parameters.hpp

#pragma once
 
#include "scippp/param.hpp"
#undef INFINITY
 
namespace scippp::params {
 
// NOLINTBEGIN(readability-identifier-naming)
 
namespace BENDERS {
    constexpr Param<double> SOLUTIONTOL { "benders/solutiontol" };
    constexpr Param<bool> CUTLPSOL { "benders/cutlpsol" };
    constexpr Param<bool> COPYBENDERS { "benders/copybenders" };
}
namespace BENDERS::DEFAULT {
    constexpr Param<int> PRIORITY { "benders/default/priority" };
    constexpr Param<bool> CUTLP { "benders/default/cutlp" };
    constexpr Param<bool> CUTPSEUDO { "benders/default/cutpseudo" };
    constexpr Param<bool> CUTRELAX { "benders/default/cutrelax" };
    constexpr Param<bool> TRANSFERCUTS { "benders/default/transfercuts" };
    constexpr Param<bool> LNSCHECK { "benders/default/lnscheck" };
    constexpr Param<int> LNSMAXDEPTH { "benders/default/lnsmaxdepth" };
    constexpr Param<int> LNSMAXCALLS { "benders/default/lnsmaxcalls" };
    constexpr Param<int> LNSMAXCALLSROOT { "benders/default/lnsmaxcallsroot" };
    constexpr Param<bool> CUTSASCONSS { "benders/default/cutsasconss" };
    constexpr Param<double> SUBPROBFRAC { "benders/default/subprobfrac" };
    constexpr Param<bool> UPDATEAUXVARBOUND { "benders/default/updateauxvarbound" };
    constexpr Param<bool> AUXVARSIMPLINT { "benders/default/auxvarsimplint" };
    constexpr Param<bool> CUTCHECK { "benders/default/cutcheck" };
    constexpr Param<double> CUTSTRENGTHENMULT { "benders/default/cutstrengthenmult" };
    constexpr Param<int> NOIMPROVELIMIT { "benders/default/noimprovelimit" };
    constexpr Param<double> COREPOINTPERTURB { "benders/default/corepointperturb" };
    constexpr Param<bool> CUTSTRENGTHENENABLED { "benders/default/cutstrengthenenabled" };
    constexpr Param<char> CUTSTRENGTHENINTPOINT { "benders/default/cutstrengthenintpoint" };
    constexpr Param<int> NUMTHREADS { "benders/default/numthreads" };
    constexpr Param<bool> EXECFEASPHASE { "benders/default/execfeasphase" };
    constexpr Param<double> SLACKVARCOEF { "benders/default/slackvarcoef" };
    constexpr Param<double> MAXSLACKVARCOEF { "benders/default/maxslackvarcoef" };
    constexpr Param<bool> CHECKCONSCONVEXITY { "benders/default/checkconsconvexity" };
}
namespace BENDERS::DEFAULT::BENDERSCUT::FEAS {
    constexpr Param<int> PRIORITY { "benders/default/benderscut/feas/priority" };
    constexpr Param<bool> ENABLED { "benders/default/benderscut/feas/enabled" };
}
namespace BENDERS::DEFAULT::BENDERSCUT::FEASALT {
    constexpr Param<int> PRIORITY { "benders/default/benderscut/feasalt/priority" };
    constexpr Param<bool> ENABLED { "benders/default/benderscut/feasalt/enabled" };
}
namespace BENDERS::DEFAULT::BENDERSCUT::INTEGER {
    constexpr Param<int> PRIORITY { "benders/default/benderscut/integer/priority" };
    constexpr Param<bool> ENABLED { "benders/default/benderscut/integer/enabled" };
    constexpr Param<double> CUTSCONSTANT { "benders/default/benderscut/integer/cutsconstant" };
    constexpr Param<bool> ADDCUTS { "benders/default/benderscut/integer/addcuts" };
}
namespace BENDERS::DEFAULT::BENDERSCUT::NOGOOD {
    constexpr Param<int> PRIORITY { "benders/default/benderscut/nogood/priority" };
    constexpr Param<bool> ENABLED { "benders/default/benderscut/nogood/enabled" };
    constexpr Param<bool> ADDCUTS { "benders/default/benderscut/nogood/addcuts" };
}
namespace BENDERS::DEFAULT::BENDERSCUT::OPTIMALITY {
    constexpr Param<int> PRIORITY { "benders/default/benderscut/optimality/priority" };
    constexpr Param<bool> ENABLED { "benders/default/benderscut/optimality/enabled" };
    constexpr Param<bool> ADDCUTS { "benders/default/benderscut/optimality/addcuts" };
    constexpr Param<bool> MIR { "benders/default/benderscut/optimality/mir" };
}
namespace BRANCHING {
    constexpr Param<char> SCOREFUNC { "branching/scorefunc" };
    constexpr Param<double> SCOREFAC { "branching/scorefac" };
    constexpr Param<bool> PREFERBINARY { "branching/preferbinary" };
    constexpr Param<double> CLAMP { "branching/clamp" };
    constexpr Param<double> MIDPULL { "branching/midpull" };
    constexpr Param<double> MIDPULLRELDOMTRIG { "branching/midpullreldomtrig" };
    constexpr Param<char> LPGAINNORMALIZE { "branching/lpgainnormalize" };
    constexpr Param<bool> DELAYPSCOSTUPDATE { "branching/delaypscostupdate" };
    constexpr Param<bool> DIVINGPSCOST { "branching/divingpscost" };
    constexpr Param<bool> FORCEALLCHILDREN { "branching/forceallchildren" };
    constexpr Param<char> FIRSTSBCHILD { "branching/firstsbchild" };
    constexpr Param<bool> CHECKSOL { "branching/checksol" };
    constexpr Param<bool> ROUNDSBSOL { "branching/roundsbsol" };
    constexpr Param<bool> SUMADJUSTSCORE { "branching/sumadjustscore" };
}
namespace BRANCHING::ALLFULLSTRONG {
    constexpr Param<int> PRIORITY { "branching/allfullstrong/priority" };
    constexpr Param<int> MAXDEPTH { "branching/allfullstrong/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/allfullstrong/maxbounddist" };
}
namespace BRANCHING::CLOUD {
    constexpr Param<int> PRIORITY { "branching/cloud/priority" };
    constexpr Param<int> MAXDEPTH { "branching/cloud/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/cloud/maxbounddist" };
    constexpr Param<bool> USECLOUD { "branching/cloud/usecloud" };
    constexpr Param<bool> ONLYF2 { "branching/cloud/onlyF2" };
    constexpr Param<bool> USEUNION { "branching/cloud/useunion" };
    constexpr Param<int> MAXPOINTS { "branching/cloud/maxpoints" };
    constexpr Param<double> MINSUCCESSRATE { "branching/cloud/minsuccessrate" };
    constexpr Param<double> MINSUCCESSUNION { "branching/cloud/minsuccessunion" };
    constexpr Param<int> MAXDEPTHUNION { "branching/cloud/maxdepthunion" };
}
namespace BRANCHING::DISTRIBUTION {
    constexpr Param<int> PRIORITY { "branching/distribution/priority" };
    constexpr Param<int> MAXDEPTH { "branching/distribution/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/distribution/maxbounddist" };
    constexpr Param<char> SCOREPARAM { "branching/distribution/scoreparam" };
    constexpr Param<bool> ONLYACTIVEROWS { "branching/distribution/onlyactiverows" };
    constexpr Param<bool> WEIGHTEDSCORE { "branching/distribution/weightedscore" };
}
namespace BRANCHING::FULLSTRONG {
    constexpr Param<int> PRIORITY { "branching/fullstrong/priority" };
    constexpr Param<int> MAXDEPTH { "branching/fullstrong/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/fullstrong/maxbounddist" };
    constexpr Param<long long> REEVALAGE { "branching/fullstrong/reevalage" };
    constexpr Param<int> MAXPROPROUNDS { "branching/fullstrong/maxproprounds" };
    constexpr Param<bool> PROBINGBOUNDS { "branching/fullstrong/probingbounds" };
    constexpr Param<bool> FORCESTRONGBRANCH { "branching/fullstrong/forcestrongbranch" };
}
namespace BRANCHING::INFERENCE {
    constexpr Param<int> PRIORITY { "branching/inference/priority" };
    constexpr Param<int> MAXDEPTH { "branching/inference/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/inference/maxbounddist" };
    constexpr Param<double> CONFLICTWEIGHT { "branching/inference/conflictweight" };
    constexpr Param<double> INFERENCEWEIGHT { "branching/inference/inferenceweight" };
    constexpr Param<double> CUTOFFWEIGHT { "branching/inference/cutoffweight" };
    constexpr Param<bool> FRACTIONALS { "branching/inference/fractionals" };
    constexpr Param<bool> USEWEIGHTEDSUM { "branching/inference/useweightedsum" };
    constexpr Param<double> RELIABLESCORE { "branching/inference/reliablescore" };
    constexpr Param<int> CONFLICTPRIO { "branching/inference/conflictprio" };
    constexpr Param<int> CUTOFFPRIO { "branching/inference/cutoffprio" };
}
namespace BRANCHING::LEASTINF {
    constexpr Param<int> PRIORITY { "branching/leastinf/priority" };
    constexpr Param<int> MAXDEPTH { "branching/leastinf/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/leastinf/maxbounddist" };
}
namespace BRANCHING::LOOKAHEAD {
    constexpr Param<int> PRIORITY { "branching/lookahead/priority" };
    constexpr Param<int> MAXDEPTH { "branching/lookahead/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/lookahead/maxbounddist" };
    constexpr Param<bool> USEIMPLIEDBINCONS { "branching/lookahead/useimpliedbincons" };
    constexpr Param<int> ADDBINCONSROW { "branching/lookahead/addbinconsrow" };
    constexpr Param<int> MAXNVIOLATEDCONS { "branching/lookahead/maxnviolatedcons" };
    constexpr Param<int> MAXNVIOLATEDBINCONS { "branching/lookahead/maxnviolatedbincons" };
    constexpr Param<int> MAXNVIOLATEDDOMREDS { "branching/lookahead/maxnviolateddomreds" };
    constexpr Param<long long> REEVALAGE { "branching/lookahead/reevalage" };
    constexpr Param<long long> REEVALAGEFSB { "branching/lookahead/reevalagefsb" };
    constexpr Param<int> RECURSIONDEPTH { "branching/lookahead/recursiondepth" };
    constexpr Param<bool> USEDOMAINREDUCTION { "branching/lookahead/usedomainreduction" };
    constexpr Param<bool> MERGEDOMAINREDUCTIONS { "branching/lookahead/mergedomainreductions" };
    constexpr Param<bool> PREFERSIMPLEBOUNDS { "branching/lookahead/prefersimplebounds" };
    constexpr Param<bool> ONLYVIOLDOMREDS { "branching/lookahead/onlyvioldomreds" };
    constexpr Param<bool> ADDNONVIOCONS { "branching/lookahead/addnonviocons" };
    constexpr Param<bool> ABBREVIATED { "branching/lookahead/abbreviated" };
    constexpr Param<int> MAXNCANDS { "branching/lookahead/maxncands" };
    constexpr Param<int> MAXNDEEPERCANDS { "branching/lookahead/maxndeepercands" };
    constexpr Param<bool> REUSEBASIS { "branching/lookahead/reusebasis" };
    constexpr Param<bool> STOREUNVIOLATEDSOL { "branching/lookahead/storeunviolatedsol" };
    constexpr Param<bool> ABBREVPSEUDO { "branching/lookahead/abbrevpseudo" };
    constexpr Param<bool> LEVEL2AVGSCORE { "branching/lookahead/level2avgscore" };
    constexpr Param<bool> LEVEL2ZEROSCORE { "branching/lookahead/level2zeroscore" };
    constexpr Param<bool> ADDCLIQUE { "branching/lookahead/addclique" };
    constexpr Param<bool> PROPAGATE { "branching/lookahead/propagate" };
    constexpr Param<bool> USELEVEL2DATA { "branching/lookahead/uselevel2data" };
    constexpr Param<bool> APPLYCHILDBOUNDS { "branching/lookahead/applychildbounds" };
    constexpr Param<bool> ENFORCEMAXDOMREDS { "branching/lookahead/enforcemaxdomreds" };
    constexpr Param<bool> UPDATEBRANCHINGRESULTS { "branching/lookahead/updatebranchingresults" };
    constexpr Param<int> MAXPROPROUNDS { "branching/lookahead/maxproprounds" };
    constexpr Param<char> SCORINGFUNCTION { "branching/lookahead/scoringfunction" };
    constexpr Param<char> DEEPERSCORINGFUNCTION { "branching/lookahead/deeperscoringfunction" };
    constexpr Param<char> SCORINGSCORINGFUNCTION { "branching/lookahead/scoringscoringfunction" };
    constexpr Param<double> MINWEIGHT { "branching/lookahead/minweight" };
    constexpr Param<double> WORSEFACTOR { "branching/lookahead/worsefactor" };
    constexpr Param<bool> FILTERBYMAXGAIN { "branching/lookahead/filterbymaxgain" };
}
namespace BRANCHING::MOSTINF {
    constexpr Param<int> PRIORITY { "branching/mostinf/priority" };
    constexpr Param<int> MAXDEPTH { "branching/mostinf/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/mostinf/maxbounddist" };
}
namespace BRANCHING::MULTAGGR {
    constexpr Param<int> PRIORITY { "branching/multaggr/priority" };
    constexpr Param<int> MAXDEPTH { "branching/multaggr/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/multaggr/maxbounddist" };
    constexpr Param<long long> REEVALAGE { "branching/multaggr/reevalage" };
    constexpr Param<int> MAXPROPROUNDS { "branching/multaggr/maxproprounds" };
    constexpr Param<bool> PROBINGBOUNDS { "branching/multaggr/probingbounds" };
}
namespace BRANCHING::NODEREOPT {
    constexpr Param<int> PRIORITY { "branching/nodereopt/priority" };
    constexpr Param<int> MAXDEPTH { "branching/nodereopt/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/nodereopt/maxbounddist" };
}
namespace BRANCHING::PSCOST {
    constexpr Param<int> PRIORITY { "branching/pscost/priority" };
    constexpr Param<int> MAXDEPTH { "branching/pscost/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/pscost/maxbounddist" };
    constexpr Param<char> STRATEGY { "branching/pscost/strategy" };
    constexpr Param<double> MINSCOREWEIGHT { "branching/pscost/minscoreweight" };
    constexpr Param<double> MAXSCOREWEIGHT { "branching/pscost/maxscoreweight" };
    constexpr Param<double> SUMSCOREWEIGHT { "branching/pscost/sumscoreweight" };
    constexpr Param<int> NCHILDREN { "branching/pscost/nchildren" };
    constexpr Param<int> NARYMAXDEPTH { "branching/pscost/narymaxdepth" };
    constexpr Param<double> NARYMINWIDTH { "branching/pscost/naryminwidth" };
    constexpr Param<double> NARYWIDTHFACTOR { "branching/pscost/narywidthfactor" };
}
namespace BRANCHING::RANDOM {
    constexpr Param<int> PRIORITY { "branching/random/priority" };
    constexpr Param<int> MAXDEPTH { "branching/random/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/random/maxbounddist" };
    constexpr Param<int> SEED { "branching/random/seed" };
}
namespace BRANCHING::RELPSCOST {
    constexpr Param<int> PRIORITY { "branching/relpscost/priority" };
    constexpr Param<int> MAXDEPTH { "branching/relpscost/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/relpscost/maxbounddist" };
    constexpr Param<double> CONFLICTWEIGHT { "branching/relpscost/conflictweight" };
    constexpr Param<double> CONFLICTLENGTHWEIGHT { "branching/relpscost/conflictlengthweight" };
    constexpr Param<double> INFERENCEWEIGHT { "branching/relpscost/inferenceweight" };
    constexpr Param<double> CUTOFFWEIGHT { "branching/relpscost/cutoffweight" };
    constexpr Param<double> PSCOSTWEIGHT { "branching/relpscost/pscostweight" };
    constexpr Param<double> NLSCOREWEIGHT { "branching/relpscost/nlscoreweight" };
    constexpr Param<double> MINRELIABLE { "branching/relpscost/minreliable" };
    constexpr Param<double> MAXRELIABLE { "branching/relpscost/maxreliable" };
    constexpr Param<double> SBITERQUOT { "branching/relpscost/sbiterquot" };
    constexpr Param<int> SBITEROFS { "branching/relpscost/sbiterofs" };
    constexpr Param<int> MAXLOOKAHEAD { "branching/relpscost/maxlookahead" };
    constexpr Param<int> INITCAND { "branching/relpscost/initcand" };
    constexpr Param<int> INITITER { "branching/relpscost/inititer" };
    constexpr Param<int> MAXBDCHGS { "branching/relpscost/maxbdchgs" };
    constexpr Param<int> MAXPROPROUNDS { "branching/relpscost/maxproprounds" };
    constexpr Param<bool> PROBINGBOUNDS { "branching/relpscost/probingbounds" };
    constexpr Param<bool> USERELERRORRELIABILITY { "branching/relpscost/userelerrorreliability" };
    constexpr Param<double> LOWERRORTOL { "branching/relpscost/lowerrortol" };
    constexpr Param<double> HIGHERRORTOL { "branching/relpscost/higherrortol" };
    constexpr Param<bool> STORESEMIINITCOSTS { "branching/relpscost/storesemiinitcosts" };
    constexpr Param<bool> USESBLOCALINFO { "branching/relpscost/usesblocalinfo" };
    constexpr Param<bool> USEHYPTESTFORRELIABILITY { "branching/relpscost/usehyptestforreliability" };
    constexpr Param<bool> USEDYNAMICCONFIDENCE { "branching/relpscost/usedynamicconfidence" };
    constexpr Param<bool> SKIPBADINITCANDS { "branching/relpscost/skipbadinitcands" };
    constexpr Param<int> CONFIDENCELEVEL { "branching/relpscost/confidencelevel" };
    constexpr Param<bool> RANDINITORDER { "branching/relpscost/randinitorder" };
    constexpr Param<bool> USESMALLWEIGHTSITLIM { "branching/relpscost/usesmallweightsitlim" };
    constexpr Param<bool> DYNAMICWEIGHTS { "branching/relpscost/dynamicweights" };
    constexpr Param<int> DEGENERACYAWARE { "branching/relpscost/degeneracyaware" };
    constexpr Param<int> STARTRANDSEED { "branching/relpscost/startrandseed" };
    constexpr Param<bool> FILTERCANDSSYM { "branching/relpscost/filtercandssym" };
    constexpr Param<bool> TRANSSYMPSCOST { "branching/relpscost/transsympscost" };
}
namespace BRANCHING::TREEMODEL {
    constexpr Param<bool> ENABLE { "branching/treemodel/enable" };
    constexpr Param<char> HIGHRULE { "branching/treemodel/highrule" };
    constexpr Param<char> LOWRULE { "branching/treemodel/lowrule" };
    constexpr Param<int> HEIGHT { "branching/treemodel/height" };
    constexpr Param<char> FILTERHIGH { "branching/treemodel/filterhigh" };
    constexpr Param<char> FILTERLOW { "branching/treemodel/filterlow" };
    constexpr Param<int> MAXFPITER { "branching/treemodel/maxfpiter" };
    constexpr Param<int> MAXSVTSHEIGHT { "branching/treemodel/maxsvtsheight" };
    constexpr Param<char> FALLBACKINF { "branching/treemodel/fallbackinf" };
    constexpr Param<char> FALLBACKNOPRIM { "branching/treemodel/fallbacknoprim" };
    constexpr Param<double> SMALLPSCOST { "branching/treemodel/smallpscost" };
}
namespace BRANCHING::VANILLAFULLSTRONG {
    constexpr Param<int> PRIORITY { "branching/vanillafullstrong/priority" };
    constexpr Param<int> MAXDEPTH { "branching/vanillafullstrong/maxdepth" };
    constexpr Param<double> MAXBOUNDDIST { "branching/vanillafullstrong/maxbounddist" };
    constexpr Param<bool> INTEGRALCANDS { "branching/vanillafullstrong/integralcands" };
    constexpr Param<bool> IDEMPOTENT { "branching/vanillafullstrong/idempotent" };
    constexpr Param<bool> SCOREALL { "branching/vanillafullstrong/scoreall" };
    constexpr Param<bool> COLLECTSCORES { "branching/vanillafullstrong/collectscores" };
    constexpr Param<bool> DONOTBRANCH { "branching/vanillafullstrong/donotbranch" };
}
namespace COMPRESSION {
    constexpr Param<bool> ENABLE { "compression/enable" };
}
namespace COMPRESSION::LARGESTREPR {
    constexpr Param<int> PRIORITY { "compression/largestrepr/priority" };
    constexpr Param<int> MINNLEAVES { "compression/largestrepr/minnleaves" };
    constexpr Param<int> ITERATIONS { "compression/largestrepr/iterations" };
    constexpr Param<int> MINCOMMONVARS { "compression/largestrepr/mincommonvars" };
}
namespace COMPRESSION::WEAKCOMPR {
    constexpr Param<int> PRIORITY { "compression/weakcompr/priority" };
    constexpr Param<int> MINNLEAVES { "compression/weakcompr/minnleaves" };
    constexpr Param<bool> CONVERTCONSS { "compression/weakcompr/convertconss" };
}
namespace CONCURRENT {
    constexpr Param<bool> CHANGESEEDS { "concurrent/changeseeds" };
    constexpr Param<bool> CHANGECHILDSEL { "concurrent/changechildsel" };
    constexpr Param<bool> COMMVARBNDS { "concurrent/commvarbnds" };
    constexpr Param<bool> PRESOLVEBEFORE { "concurrent/presolvebefore" };
    constexpr Param<int> INITSEED { "concurrent/initseed" };
    constexpr Param<std::string> PARAMSETPREFIX { "concurrent/paramsetprefix" };
}
namespace CONCURRENT::SCIP {
    constexpr Param<double> PREFPRIO { "concurrent/scip/prefprio" };
}
namespace CONCURRENT::SCIP_COUNTER {
    constexpr Param<double> PREFPRIO { "concurrent/scip-counter/prefprio" };
}
namespace CONCURRENT::SCIP_CPSOLVER {
    constexpr Param<double> PREFPRIO { "concurrent/scip-cpsolver/prefprio" };
}
namespace CONCURRENT::SCIP_DEFAULT {
    constexpr Param<double> PREFPRIO { "concurrent/scip-default/prefprio" };
}
namespace CONCURRENT::SCIP_EASYCIP {
    constexpr Param<double> PREFPRIO { "concurrent/scip-easycip/prefprio" };
}
namespace CONCURRENT::SCIP_FEAS {
    constexpr Param<double> PREFPRIO { "concurrent/scip-feas/prefprio" };
}
namespace CONCURRENT::SCIP_HARDLP {
    constexpr Param<double> PREFPRIO { "concurrent/scip-hardlp/prefprio" };
}
namespace CONCURRENT::SCIP_OPTI {
    constexpr Param<double> PREFPRIO { "concurrent/scip-opti/prefprio" };
}
namespace CONCURRENT::SYNC {
    constexpr Param<double> FREQINIT { "concurrent/sync/freqinit" };
    constexpr Param<double> FREQMAX { "concurrent/sync/freqmax" };
    constexpr Param<double> FREQFACTOR { "concurrent/sync/freqfactor" };
    constexpr Param<double> TARGETPROGRESS { "concurrent/sync/targetprogress" };
    constexpr Param<int> MAXNSOLS { "concurrent/sync/maxnsols" };
    constexpr Param<int> MAXNSYNCDELAY { "concurrent/sync/maxnsyncdelay" };
    constexpr Param<double> MINSYNCDELAY { "concurrent/sync/minsyncdelay" };
    constexpr Param<int> NBESTSOLS { "concurrent/sync/nbestsols" };
}
namespace CONFLICT {
    constexpr Param<bool> ENABLE { "conflict/enable" };
    constexpr Param<bool> CLEANBOUNDEXCEEDINGS { "conflict/cleanboundexceedings" };
    constexpr Param<bool> USELOCALROWS { "conflict/uselocalrows" };
    constexpr Param<bool> USEPROP { "conflict/useprop" };
    constexpr Param<char> USEINFLP { "conflict/useinflp" };
    constexpr Param<char> USEBOUNDLP { "conflict/useboundlp" };
    constexpr Param<bool> USESB { "conflict/usesb" };
    constexpr Param<bool> USEPSEUDO { "conflict/usepseudo" };
    constexpr Param<double> MAXVARSFAC { "conflict/maxvarsfac" };
    constexpr Param<int> MINMAXVARS { "conflict/minmaxvars" };
    constexpr Param<int> MAXLPLOOPS { "conflict/maxlploops" };
    constexpr Param<int> LPITERATIONS { "conflict/lpiterations" };
    constexpr Param<int> FUIPLEVELS { "conflict/fuiplevels" };
    constexpr Param<int> INTERCONSS { "conflict/interconss" };
    constexpr Param<int> RECONVLEVELS { "conflict/reconvlevels" };
    constexpr Param<int> MAXCONSS { "conflict/maxconss" };
    constexpr Param<int> MAXSTORESIZE { "conflict/maxstoresize" };
    constexpr Param<bool> PREFERBINARY { "conflict/preferbinary" };
    constexpr Param<bool> PREFINFPROOF { "conflict/prefinfproof" };
    constexpr Param<bool> ALLOWLOCAL { "conflict/allowlocal" };
    constexpr Param<bool> SETTLELOCAL { "conflict/settlelocal" };
    constexpr Param<bool> REPROPAGATE { "conflict/repropagate" };
    constexpr Param<bool> KEEPREPROP { "conflict/keepreprop" };
    constexpr Param<bool> SEPARATE { "conflict/separate" };
    constexpr Param<bool> DYNAMIC { "conflict/dynamic" };
    constexpr Param<bool> REMOVABLE { "conflict/removable" };
    constexpr Param<double> PROOFSCOREFAC { "conflict/proofscorefac" };
    constexpr Param<double> UPLOCKSCOREFAC { "conflict/uplockscorefac" };
    constexpr Param<double> DOWNLOCKSCOREFAC { "conflict/downlockscorefac" };
    constexpr Param<double> SCOREFAC { "conflict/scorefac" };
    constexpr Param<int> RESTARTNUM { "conflict/restartnum" };
    constexpr Param<double> RESTARTFAC { "conflict/restartfac" };
    constexpr Param<bool> IGNORERELAXEDBD { "conflict/ignorerelaxedbd" };
    constexpr Param<int> MAXVARSDETECTIMPLIEDBOUNDS { "conflict/maxvarsdetectimpliedbounds" };
    constexpr Param<bool> FULLSHORTENCONFLICT { "conflict/fullshortenconflict" };
    constexpr Param<double> CONFLICTWEIGHT { "conflict/conflictweight" };
    constexpr Param<double> CONFLICTGRAPHWEIGHT { "conflict/conflictgraphweight" };
    constexpr Param<double> MINIMPROVE { "conflict/minimprove" };
    constexpr Param<double> WEIGHTSIZE { "conflict/weightsize" };
    constexpr Param<double> WEIGHTREPROPDEPTH { "conflict/weightrepropdepth" };
    constexpr Param<double> WEIGHTVALIDDEPTH { "conflict/weightvaliddepth" };
    constexpr Param<bool> SEPAALTPROOFS { "conflict/sepaaltproofs" };
}
namespace CONFLICT::BOUNDDISJUNCTION {
    constexpr Param<double> CONTINUOUSFRAC { "conflict/bounddisjunction/continuousfrac" };
    constexpr Param<int> PRIORITY { "conflict/bounddisjunction/priority" };
}
namespace CONFLICT::GRAPH {
    constexpr Param<double> DEPTHSCOREFAC { "conflict/graph/depthscorefac" };
}
namespace CONFLICT::INDICATORCONFLICT {
    constexpr Param<int> PRIORITY { "conflict/indicatorconflict/priority" };
}
namespace CONFLICT::LINEAR {
    constexpr Param<int> PRIORITY { "conflict/linear/priority" };
}
namespace CONFLICT::LOGICOR {
    constexpr Param<int> PRIORITY { "conflict/logicor/priority" };
}
namespace CONFLICT::SETPPC {
    constexpr Param<int> PRIORITY { "conflict/setppc/priority" };
}
namespace CONSTRAINTS {
    constexpr Param<int> AGELIMIT { "constraints/agelimit" };
    constexpr Param<int> OBSOLETEAGE { "constraints/obsoleteage" };
    constexpr Param<bool> DISABLEENFOPS { "constraints/disableenfops" };
}
namespace CONSTRAINTS::AND {
    constexpr Param<int> SEPAFREQ { "constraints/and/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/and/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/and/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/and/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/and/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/and/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/and/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/and/presoltiming" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/and/presolpairwise" };
    constexpr Param<bool> PRESOLUSEHASHING { "constraints/and/presolusehashing" };
    constexpr Param<bool> LINEARIZE { "constraints/and/linearize" };
    constexpr Param<bool> ENFORCECUTS { "constraints/and/enforcecuts" };
    constexpr Param<bool> AGGRLINEARIZATION { "constraints/and/aggrlinearization" };
    constexpr Param<bool> UPGRADERESULTANT { "constraints/and/upgraderesultant" };
    constexpr Param<bool> DUALPRESOLVING { "constraints/and/dualpresolving" };
}
namespace CONSTRAINTS::BENDERS {
    constexpr Param<int> SEPAFREQ { "constraints/benders/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/benders/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/benders/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/benders/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/benders/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/benders/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/benders/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/benders/presoltiming" };
    constexpr Param<bool> ACTIVE { "constraints/benders/active" };
}
namespace CONSTRAINTS::BENDERSLP {
    constexpr Param<int> SEPAFREQ { "constraints/benderslp/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/benderslp/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/benderslp/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/benderslp/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/benderslp/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/benderslp/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/benderslp/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/benderslp/presoltiming" };
    constexpr Param<int> MAXDEPTH { "constraints/benderslp/maxdepth" };
    constexpr Param<int> DEPTHFREQ { "constraints/benderslp/depthfreq" };
    constexpr Param<int> STALLLIMIT { "constraints/benderslp/stalllimit" };
    constexpr Param<int> ITERLIMIT { "constraints/benderslp/iterlimit" };
    constexpr Param<bool> ACTIVE { "constraints/benderslp/active" };
}
namespace CONSTRAINTS::BOUNDDISJUNCTION {
    constexpr Param<int> SEPAFREQ { "constraints/bounddisjunction/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/bounddisjunction/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/bounddisjunction/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/bounddisjunction/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/bounddisjunction/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/bounddisjunction/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/bounddisjunction/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/bounddisjunction/presoltiming" };
}
namespace CONSTRAINTS::CARDINALITY {
    constexpr Param<int> SEPAFREQ { "constraints/cardinality/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/cardinality/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/cardinality/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/cardinality/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/cardinality/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/cardinality/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/cardinality/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/cardinality/presoltiming" };
    constexpr Param<bool> BRANCHBALANCED { "constraints/cardinality/branchbalanced" };
    constexpr Param<int> BALANCEDDEPTH { "constraints/cardinality/balanceddepth" };
    constexpr Param<double> BALANCEDCUTOFF { "constraints/cardinality/balancedcutoff" };
}
namespace CONSTRAINTS::COMPONENTS {
    constexpr Param<int> SEPAFREQ { "constraints/components/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/components/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/components/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/components/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/components/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/components/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/components/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/components/presoltiming" };
    constexpr Param<int> MAXDEPTH { "constraints/components/maxdepth" };
    constexpr Param<int> MAXINTVARS { "constraints/components/maxintvars" };
    constexpr Param<int> MINSIZE { "constraints/components/minsize" };
    constexpr Param<double> MINRELSIZE { "constraints/components/minrelsize" };
    constexpr Param<long long> NODELIMIT { "constraints/components/nodelimit" };
    constexpr Param<double> INTFACTOR { "constraints/components/intfactor" };
    constexpr Param<double> FEASTOLFACTOR { "constraints/components/feastolfactor" };
}
namespace CONSTRAINTS::CONJUNCTION {
    constexpr Param<int> SEPAFREQ { "constraints/conjunction/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/conjunction/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/conjunction/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/conjunction/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/conjunction/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/conjunction/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/conjunction/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/conjunction/presoltiming" };
}
namespace CONSTRAINTS::COUNTSOLS {
    constexpr Param<int> SEPAFREQ { "constraints/countsols/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/countsols/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/countsols/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/countsols/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/countsols/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/countsols/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/countsols/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/countsols/presoltiming" };
    constexpr Param<bool> ACTIVE { "constraints/countsols/active" };
    constexpr Param<bool> SPARSETEST { "constraints/countsols/sparsetest" };
    constexpr Param<bool> DISCARDSOLS { "constraints/countsols/discardsols" };
    constexpr Param<bool> COLLECT { "constraints/countsols/collect" };
    constexpr Param<long long> SOLLIMIT { "constraints/countsols/sollimit" };
}
namespace CONSTRAINTS::CUMULATIVE {
    constexpr Param<int> SEPAFREQ { "constraints/cumulative/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/cumulative/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/cumulative/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/cumulative/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/cumulative/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/cumulative/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/cumulative/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/cumulative/presoltiming" };
    constexpr Param<bool> TTINFER { "constraints/cumulative/ttinfer" };
    constexpr Param<bool> EFCHECK { "constraints/cumulative/efcheck" };
    constexpr Param<bool> EFINFER { "constraints/cumulative/efinfer" };
    constexpr Param<bool> USEADJUSTEDJOBS { "constraints/cumulative/useadjustedjobs" };
    constexpr Param<bool> TTEFCHECK { "constraints/cumulative/ttefcheck" };
    constexpr Param<bool> TTEFINFER { "constraints/cumulative/ttefinfer" };
    constexpr Param<bool> USEBINVARS { "constraints/cumulative/usebinvars" };
    constexpr Param<bool> LOCALCUTS { "constraints/cumulative/localcuts" };
    constexpr Param<bool> USECOVERCUTS { "constraints/cumulative/usecovercuts" };
    constexpr Param<bool> CUTSASCONSS { "constraints/cumulative/cutsasconss" };
    constexpr Param<bool> SEPAOLD { "constraints/cumulative/sepaold" };
    constexpr Param<bool> FILLBRANCHCANDS { "constraints/cumulative/fillbranchcands" };
    constexpr Param<bool> DUALPRESOLVE { "constraints/cumulative/dualpresolve" };
    constexpr Param<bool> COEFTIGHTENING { "constraints/cumulative/coeftightening" };
    constexpr Param<bool> NORMALIZE { "constraints/cumulative/normalize" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/cumulative/presolpairwise" };
    constexpr Param<bool> DISJUNCTIVE { "constraints/cumulative/disjunctive" };
    constexpr Param<long long> MAXNODES { "constraints/cumulative/maxnodes" };
    constexpr Param<bool> DETECTDISJUNCTIVE { "constraints/cumulative/detectdisjunctive" };
    constexpr Param<bool> DETECTVARBOUNDS { "constraints/cumulative/detectvarbounds" };
    constexpr Param<bool> USEBDWIDENING { "constraints/cumulative/usebdwidening" };
}
namespace CONSTRAINTS::DISJUNCTION {
    constexpr Param<int> SEPAFREQ { "constraints/disjunction/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/disjunction/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/disjunction/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/disjunction/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/disjunction/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/disjunction/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/disjunction/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/disjunction/presoltiming" };
    constexpr Param<bool> ALWAYSBRANCH { "constraints/disjunction/alwaysbranch" };
}
namespace CONSTRAINTS::INDICATOR {
    constexpr Param<int> SEPAFREQ { "constraints/indicator/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/indicator/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/indicator/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/indicator/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/indicator/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/indicator/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/indicator/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/indicator/presoltiming" };
    constexpr Param<bool> BRANCHINDICATORS { "constraints/indicator/branchindicators" };
    constexpr Param<bool> GENLOGICOR { "constraints/indicator/genlogicor" };
    constexpr Param<bool> ADDCOUPLING { "constraints/indicator/addcoupling" };
    constexpr Param<double> MAXCOUPLINGVALUE { "constraints/indicator/maxcouplingvalue" };
    constexpr Param<bool> ADDCOUPLINGCONS { "constraints/indicator/addcouplingcons" };
    constexpr Param<bool> SEPACOUPLINGCUTS { "constraints/indicator/sepacouplingcuts" };
    constexpr Param<bool> SEPACOUPLINGLOCAL { "constraints/indicator/sepacouplinglocal" };
    constexpr Param<double> SEPACOUPLINGVALUE { "constraints/indicator/sepacouplingvalue" };
    constexpr Param<bool> SEPAPERSPECTIVE { "constraints/indicator/sepaperspective" };
    constexpr Param<bool> SEPAPERSPLOCAL { "constraints/indicator/sepapersplocal" };
    constexpr Param<int> MAXSEPANONVIOLATED { "constraints/indicator/maxsepanonviolated" };
    constexpr Param<bool> UPDATEBOUNDS { "constraints/indicator/updatebounds" };
    constexpr Param<double> MAXCONDITIONALTLP { "constraints/indicator/maxconditionaltlp" };
    constexpr Param<int> MAXSEPACUTS { "constraints/indicator/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "constraints/indicator/maxsepacutsroot" };
    constexpr Param<bool> REMOVEINDICATORS { "constraints/indicator/removeindicators" };
    constexpr Param<bool> GENERATEBILINEAR { "constraints/indicator/generatebilinear" };
    constexpr Param<bool> SCALESLACKVAR { "constraints/indicator/scaleslackvar" };
    constexpr Param<bool> TRYSOLUTIONS { "constraints/indicator/trysolutions" };
    constexpr Param<bool> ENFORCECUTS { "constraints/indicator/enforcecuts" };
    constexpr Param<bool> DUALREDUCTIONS { "constraints/indicator/dualreductions" };
    constexpr Param<bool> ADDOPPOSITE { "constraints/indicator/addopposite" };
    constexpr Param<bool> CONFLICTSUPGRADE { "constraints/indicator/conflictsupgrade" };
    constexpr Param<double> RESTARTFRAC { "constraints/indicator/restartfrac" };
    constexpr Param<bool> USEOTHERCONSS { "constraints/indicator/useotherconss" };
    constexpr Param<bool> USEOBJECTIVECUT { "constraints/indicator/useobjectivecut" };
    constexpr Param<bool> TRYSOLFROMCOVER { "constraints/indicator/trysolfromcover" };
    constexpr Param<bool> UPGRADELINEAR { "constraints/indicator/upgradelinear" };
    constexpr Param<bool> SEPAALTERNATIVELP { "constraints/indicator/sepaalternativelp" };
    constexpr Param<bool> FORCERESTART { "constraints/indicator/forcerestart" };
    constexpr Param<bool> NOLINCONSCONT { "constraints/indicator/nolinconscont" };
}
namespace CONSTRAINTS::INTEGRAL {
    constexpr Param<int> SEPAFREQ { "constraints/integral/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/integral/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/integral/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/integral/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/integral/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/integral/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/integral/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/integral/presoltiming" };
}
namespace CONSTRAINTS::KNAPSACK {
    constexpr Param<int> SEPAFREQ { "constraints/knapsack/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/knapsack/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/knapsack/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/knapsack/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/knapsack/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/knapsack/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/knapsack/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/knapsack/presoltiming" };
    constexpr Param<int> SEPACARDFREQ { "constraints/knapsack/sepacardfreq" };
    constexpr Param<double> MAXCARDBOUNDDIST { "constraints/knapsack/maxcardbounddist" };
    constexpr Param<double> CLIQUEEXTRACTFACTOR { "constraints/knapsack/cliqueextractfactor" };
    constexpr Param<int> MAXROUNDS { "constraints/knapsack/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "constraints/knapsack/maxroundsroot" };
    constexpr Param<int> MAXSEPACUTS { "constraints/knapsack/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "constraints/knapsack/maxsepacutsroot" };
    constexpr Param<bool> DISAGGREGATION { "constraints/knapsack/disaggregation" };
    constexpr Param<bool> SIMPLIFYINEQUALITIES { "constraints/knapsack/simplifyinequalities" };
    constexpr Param<bool> NEGATEDCLIQUE { "constraints/knapsack/negatedclique" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/knapsack/presolpairwise" };
    constexpr Param<bool> PRESOLUSEHASHING { "constraints/knapsack/presolusehashing" };
    constexpr Param<bool> DUALPRESOLVING { "constraints/knapsack/dualpresolving" };
    constexpr Param<bool> USEGUBS { "constraints/knapsack/usegubs" };
    constexpr Param<bool> DETECTCUTOFFBOUND { "constraints/knapsack/detectcutoffbound" };
    constexpr Param<bool> DETECTLOWERBOUND { "constraints/knapsack/detectlowerbound" };
    constexpr Param<bool> UPDATECLIQUEPARTITIONS { "constraints/knapsack/updatecliquepartitions" };
    constexpr Param<double> CLQPARTUPDATEFAC { "constraints/knapsack/clqpartupdatefac" };
}
namespace CONSTRAINTS::LINEAR {
    constexpr Param<int> SEPAFREQ { "constraints/linear/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/linear/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/linear/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/linear/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/linear/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/linear/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/linear/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/linear/presoltiming" };
    constexpr Param<int> TIGHTENBOUNDSFREQ { "constraints/linear/tightenboundsfreq" };
    constexpr Param<int> MAXROUNDS { "constraints/linear/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "constraints/linear/maxroundsroot" };
    constexpr Param<int> MAXSEPACUTS { "constraints/linear/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "constraints/linear/maxsepacutsroot" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/linear/presolpairwise" };
    constexpr Param<bool> PRESOLUSEHASHING { "constraints/linear/presolusehashing" };
    constexpr Param<int> NMINCOMPARISONS { "constraints/linear/nmincomparisons" };
    constexpr Param<double> MINGAINPERNMINCOMPARISONS { "constraints/linear/mingainpernmincomparisons" };
    constexpr Param<double> MAXAGGRNORMSCALE { "constraints/linear/maxaggrnormscale" };
    constexpr Param<double> MAXEASYACTIVITYDELTA { "constraints/linear/maxeasyactivitydelta" };
    constexpr Param<double> MAXCARDBOUNDDIST { "constraints/linear/maxcardbounddist" };
    constexpr Param<bool> SEPARATEALL { "constraints/linear/separateall" };
    constexpr Param<bool> AGGREGATEVARIABLES { "constraints/linear/aggregatevariables" };
    constexpr Param<bool> SIMPLIFYINEQUALITIES { "constraints/linear/simplifyinequalities" };
    constexpr Param<bool> DUALPRESOLVING { "constraints/linear/dualpresolving" };
    constexpr Param<bool> SINGLETONSTUFFING { "constraints/linear/singletonstuffing" };
    constexpr Param<bool> SINGLEVARSTUFFING { "constraints/linear/singlevarstuffing" };
    constexpr Param<bool> SORTVARS { "constraints/linear/sortvars" };
    constexpr Param<bool> CHECKRELMAXABS { "constraints/linear/checkrelmaxabs" };
    constexpr Param<bool> DETECTCUTOFFBOUND { "constraints/linear/detectcutoffbound" };
    constexpr Param<bool> DETECTLOWERBOUND { "constraints/linear/detectlowerbound" };
    constexpr Param<bool> DETECTPARTIALOBJECTIVE { "constraints/linear/detectpartialobjective" };
    constexpr Param<bool> RANGEDROWPROPAGATION { "constraints/linear/rangedrowpropagation" };
    constexpr Param<bool> RANGEDROWARTCONS { "constraints/linear/rangedrowartcons" };
    constexpr Param<int> RANGEDROWMAXDEPTH { "constraints/linear/rangedrowmaxdepth" };
    constexpr Param<int> RANGEDROWFREQ { "constraints/linear/rangedrowfreq" };
    constexpr Param<bool> MULTAGGRREMOVE { "constraints/linear/multaggrremove" };
    constexpr Param<double> MAXMULTAGGRQUOT { "constraints/linear/maxmultaggrquot" };
    constexpr Param<double> MAXDUALMULTAGGRQUOT { "constraints/linear/maxdualmultaggrquot" };
    constexpr Param<bool> EXTRACTCLIQUES { "constraints/linear/extractcliques" };
}
namespace CONSTRAINTS::LINEAR::UPGRADE {
    constexpr Param<bool> INDICATOR { "constraints/linear/upgrade/indicator" };
    constexpr Param<bool> KNAPSACK { "constraints/linear/upgrade/knapsack" };
    constexpr Param<bool> LOGICOR { "constraints/linear/upgrade/logicor" };
    constexpr Param<bool> SETPPC { "constraints/linear/upgrade/setppc" };
    constexpr Param<bool> VARBOUND { "constraints/linear/upgrade/varbound" };
    constexpr Param<bool> XOR { "constraints/linear/upgrade/xor" };
}
namespace CONSTRAINTS::LINKING {
    constexpr Param<int> SEPAFREQ { "constraints/linking/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/linking/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/linking/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/linking/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/linking/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/linking/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/linking/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/linking/presoltiming" };
    constexpr Param<bool> LINEARIZE { "constraints/linking/linearize" };
}
namespace CONSTRAINTS::LOGICOR {
    constexpr Param<int> SEPAFREQ { "constraints/logicor/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/logicor/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/logicor/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/logicor/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/logicor/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/logicor/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/logicor/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/logicor/presoltiming" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/logicor/presolpairwise" };
    constexpr Param<bool> PRESOLUSEHASHING { "constraints/logicor/presolusehashing" };
    constexpr Param<bool> DUALPRESOLVING { "constraints/logicor/dualpresolving" };
    constexpr Param<bool> NEGATEDCLIQUE { "constraints/logicor/negatedclique" };
    constexpr Param<bool> IMPLICATIONS { "constraints/logicor/implications" };
    constexpr Param<bool> STRENGTHEN { "constraints/logicor/strengthen" };
}
namespace CONSTRAINTS::NONLINEAR {
    constexpr Param<int> SEPAFREQ { "constraints/nonlinear/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/nonlinear/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/nonlinear/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/nonlinear/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/nonlinear/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/nonlinear/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/nonlinear/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/nonlinear/presoltiming" };
    constexpr Param<int> MAXPROPROUNDS { "constraints/nonlinear/maxproprounds" };
    constexpr Param<bool> PROPAUXVARS { "constraints/nonlinear/propauxvars" };
    constexpr Param<char> VARBOUNDRELAX { "constraints/nonlinear/varboundrelax" };
    constexpr Param<double> VARBOUNDRELAXAMOUNT { "constraints/nonlinear/varboundrelaxamount" };
    constexpr Param<double> CONSSIDERELAXAMOUNT { "constraints/nonlinear/conssiderelaxamount" };
    constexpr Param<double> VPMAXPERTURB { "constraints/nonlinear/vpmaxperturb" };
    constexpr Param<double> VPADJFACETTHRESH { "constraints/nonlinear/vpadjfacetthresh" };
    constexpr Param<bool> VPDUALSIMPLEX { "constraints/nonlinear/vpdualsimplex" };
    constexpr Param<int> BILINMAXNAUXEXPRS { "constraints/nonlinear/bilinmaxnauxexprs" };
    constexpr Param<bool> REFORMBINPRODS { "constraints/nonlinear/reformbinprods" };
    constexpr Param<bool> REFORMBINPRODSAND { "constraints/nonlinear/reformbinprodsand" };
    constexpr Param<int> REFORMBINPRODSFAC { "constraints/nonlinear/reformbinprodsfac" };
    constexpr Param<bool> FORBIDMULTAGGRNLVAR { "constraints/nonlinear/forbidmultaggrnlvar" };
    constexpr Param<bool> TIGHTENLPFEASTOL { "constraints/nonlinear/tightenlpfeastol" };
    constexpr Param<bool> PROPINENFORCE { "constraints/nonlinear/propinenforce" };
    constexpr Param<double> WEAKCUTTHRESHOLD { "constraints/nonlinear/weakcutthreshold" };
    constexpr Param<double> STRONGCUTMAXCOEF { "constraints/nonlinear/strongcutmaxcoef" };
    constexpr Param<bool> STRONGCUTEFFICACY { "constraints/nonlinear/strongcutefficacy" };
    constexpr Param<bool> FORCESTRONGCUT { "constraints/nonlinear/forcestrongcut" };
    constexpr Param<double> ENFOAUXVIOLFACTOR { "constraints/nonlinear/enfoauxviolfactor" };
    constexpr Param<double> WEAKCUTMINVIOLFACTOR { "constraints/nonlinear/weakcutminviolfactor" };
    constexpr Param<char> ROWNOTREMOVABLE { "constraints/nonlinear/rownotremovable" };
    constexpr Param<char> VIOLSCALE { "constraints/nonlinear/violscale" };
    constexpr Param<char> CHECKVARLOCKS { "constraints/nonlinear/checkvarlocks" };
    constexpr Param<char> LINEARIZEHEURSOL { "constraints/nonlinear/linearizeheursol" };
    constexpr Param<bool> ASSUMECONVEX { "constraints/nonlinear/assumeconvex" };
}
namespace CONSTRAINTS::NONLINEAR::BRANCHING {
    constexpr Param<int> AUX { "constraints/nonlinear/branching/aux" };
    constexpr Param<bool> EXTERNAL { "constraints/nonlinear/branching/external" };
    constexpr Param<double> HIGHVIOLFACTOR { "constraints/nonlinear/branching/highviolfactor" };
    constexpr Param<double> HIGHSCOREFACTOR { "constraints/nonlinear/branching/highscorefactor" };
    constexpr Param<double> VIOLWEIGHT { "constraints/nonlinear/branching/violweight" };
    constexpr Param<double> DUALWEIGHT { "constraints/nonlinear/branching/dualweight" };
    constexpr Param<double> PSCOSTWEIGHT { "constraints/nonlinear/branching/pscostweight" };
    constexpr Param<double> DOMAINWEIGHT { "constraints/nonlinear/branching/domainweight" };
    constexpr Param<double> VARTYPEWEIGHT { "constraints/nonlinear/branching/vartypeweight" };
    constexpr Param<char> SCOREAGG { "constraints/nonlinear/branching/scoreagg" };
    constexpr Param<char> VIOLSPLIT { "constraints/nonlinear/branching/violsplit" };
    constexpr Param<double> PSCOSTRELIABLE { "constraints/nonlinear/branching/pscostreliable" };
}
namespace CONSTRAINTS::NONLINEAR::UPGRADE {
    constexpr Param<bool> LINEAR { "constraints/nonlinear/upgrade/linear" };
    constexpr Param<bool> SETPPC { "constraints/nonlinear/upgrade/setppc" };
}
namespace CONSTRAINTS::OR {
    constexpr Param<int> SEPAFREQ { "constraints/or/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/or/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/or/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/or/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/or/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/or/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/or/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/or/presoltiming" };
}
namespace CONSTRAINTS::ORBISACK {
    constexpr Param<int> SEPAFREQ { "constraints/orbisack/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/orbisack/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/orbisack/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/orbisack/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/orbisack/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/orbisack/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/orbisack/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/orbisack/presoltiming" };
    constexpr Param<bool> COVERSEPARATION { "constraints/orbisack/coverseparation" };
    constexpr Param<bool> ORBISEPARATION { "constraints/orbisack/orbiSeparation" };
    constexpr Param<double> COEFFBOUND { "constraints/orbisack/coeffbound" };
    constexpr Param<bool> CHECKPPORBISACK { "constraints/orbisack/checkpporbisack" };
    constexpr Param<bool> FORCECONSCOPY { "constraints/orbisack/forceconscopy" };
}
namespace CONSTRAINTS::ORBITOPE {
    constexpr Param<int> SEPAFREQ { "constraints/orbitope/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/orbitope/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/orbitope/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/orbitope/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/orbitope/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/orbitope/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/orbitope/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/orbitope/presoltiming" };
    constexpr Param<bool> CHECKPPORBITOPE { "constraints/orbitope/checkpporbitope" };
    constexpr Param<bool> SEPAFULLORBITOPE { "constraints/orbitope/sepafullorbitope" };
    constexpr Param<bool> FORCECONSCOPY { "constraints/orbitope/forceconscopy" };
}
namespace CONSTRAINTS::PSEUDOBOOLEAN {
    constexpr Param<int> SEPAFREQ { "constraints/pseudoboolean/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/pseudoboolean/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/pseudoboolean/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/pseudoboolean/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/pseudoboolean/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/pseudoboolean/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/pseudoboolean/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/pseudoboolean/presoltiming" };
    constexpr Param<bool> DECOMPOSENORMAL { "constraints/pseudoboolean/decomposenormal" };
    constexpr Param<bool> DECOMPOSEINDICATOR { "constraints/pseudoboolean/decomposeindicator" };
    constexpr Param<bool> NLCSEPARATE { "constraints/pseudoboolean/nlcseparate" };
    constexpr Param<bool> NLCPROPAGATE { "constraints/pseudoboolean/nlcpropagate" };
    constexpr Param<bool> NLCREMOVABLE { "constraints/pseudoboolean/nlcremovable" };
}
namespace CONSTRAINTS::SETPPC {
    constexpr Param<int> SEPAFREQ { "constraints/setppc/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/setppc/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/setppc/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/setppc/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/setppc/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/setppc/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/setppc/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/setppc/presoltiming" };
    constexpr Param<int> NPSEUDOBRANCHES { "constraints/setppc/npseudobranches" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/setppc/presolpairwise" };
    constexpr Param<bool> PRESOLUSEHASHING { "constraints/setppc/presolusehashing" };
    constexpr Param<bool> DUALPRESOLVING { "constraints/setppc/dualpresolving" };
    constexpr Param<bool> CLIQUELIFTING { "constraints/setppc/cliquelifting" };
    constexpr Param<bool> ADDVARIABLESASCLIQUES { "constraints/setppc/addvariablesascliques" };
    constexpr Param<bool> CLIQUESHRINKING { "constraints/setppc/cliqueshrinking" };
}
namespace CONSTRAINTS::SOS1 {
    constexpr Param<int> SEPAFREQ { "constraints/SOS1/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/SOS1/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/SOS1/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/SOS1/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/SOS1/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/SOS1/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/SOS1/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/SOS1/presoltiming" };
    constexpr Param<int> MAXSOSADJACENCY { "constraints/SOS1/maxsosadjacency" };
    constexpr Param<int> MAXEXTENSIONS { "constraints/SOS1/maxextensions" };
    constexpr Param<int> MAXTIGHTENBDS { "constraints/SOS1/maxtightenbds" };
    constexpr Param<bool> PERFIMPLANALYSIS { "constraints/SOS1/perfimplanalysis" };
    constexpr Param<int> DEPTHIMPLANALYSIS { "constraints/SOS1/depthimplanalysis" };
    constexpr Param<bool> CONFLICTPROP { "constraints/SOS1/conflictprop" };
    constexpr Param<bool> IMPLPROP { "constraints/SOS1/implprop" };
    constexpr Param<bool> SOSCONSPROP { "constraints/SOS1/sosconsprop" };
    constexpr Param<char> BRANCHINGRULE { "constraints/SOS1/branchingrule" };
    constexpr Param<bool> AUTOSOS1BRANCH { "constraints/SOS1/autosos1branch" };
    constexpr Param<bool> FIXNONZERO { "constraints/SOS1/fixnonzero" };
    constexpr Param<bool> ADDCOMPS { "constraints/SOS1/addcomps" };
    constexpr Param<int> MAXADDCOMPS { "constraints/SOS1/maxaddcomps" };
    constexpr Param<double> ADDCOMPSFEAS { "constraints/SOS1/addcompsfeas" };
    constexpr Param<double> ADDBDSFEAS { "constraints/SOS1/addbdsfeas" };
    constexpr Param<bool> ADDEXTENDEDBDS { "constraints/SOS1/addextendedbds" };
    constexpr Param<bool> BRANCHSOS { "constraints/SOS1/branchsos" };
    constexpr Param<bool> BRANCHNONZEROS { "constraints/SOS1/branchnonzeros" };
    constexpr Param<bool> BRANCHWEIGHT { "constraints/SOS1/branchweight" };
    constexpr Param<int> ADDCOMPSDEPTH { "constraints/SOS1/addcompsdepth" };
    constexpr Param<int> NSTRONGROUNDS { "constraints/SOS1/nstrongrounds" };
    constexpr Param<int> NSTRONGITER { "constraints/SOS1/nstrongiter" };
    constexpr Param<bool> BOUNDCUTSFROMSOS1 { "constraints/SOS1/boundcutsfromsos1" };
    constexpr Param<bool> BOUNDCUTSFROMGRAPH { "constraints/SOS1/boundcutsfromgraph" };
    constexpr Param<bool> AUTOCUTSFROMSOS1 { "constraints/SOS1/autocutsfromsos1" };
    constexpr Param<int> BOUNDCUTSFREQ { "constraints/SOS1/boundcutsfreq" };
    constexpr Param<int> BOUNDCUTSDEPTH { "constraints/SOS1/boundcutsdepth" };
    constexpr Param<int> MAXBOUNDCUTS { "constraints/SOS1/maxboundcuts" };
    constexpr Param<int> MAXBOUNDCUTSROOT { "constraints/SOS1/maxboundcutsroot" };
    constexpr Param<bool> STRTHENBOUNDCUTS { "constraints/SOS1/strthenboundcuts" };
    constexpr Param<int> IMPLCUTSFREQ { "constraints/SOS1/implcutsfreq" };
    constexpr Param<int> IMPLCUTSDEPTH { "constraints/SOS1/implcutsdepth" };
    constexpr Param<int> MAXIMPLCUTS { "constraints/SOS1/maximplcuts" };
    constexpr Param<int> MAXIMPLCUTSROOT { "constraints/SOS1/maximplcutsroot" };
}
namespace CONSTRAINTS::SOS2 {
    constexpr Param<int> SEPAFREQ { "constraints/SOS2/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/SOS2/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/SOS2/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/SOS2/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/SOS2/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/SOS2/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/SOS2/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/SOS2/presoltiming" };
}
namespace CONSTRAINTS::SUPERINDICATOR {
    constexpr Param<int> SEPAFREQ { "constraints/superindicator/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/superindicator/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/superindicator/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/superindicator/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/superindicator/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/superindicator/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/superindicator/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/superindicator/presoltiming" };
    constexpr Param<bool> CHECKSLACKTYPE { "constraints/superindicator/checkslacktype" };
    constexpr Param<double> MAXUPGDCOEFLINEAR { "constraints/superindicator/maxupgdcoeflinear" };
    constexpr Param<int> UPGDPRIOINDICATOR { "constraints/superindicator/upgdprioindicator" };
    constexpr Param<int> UPGDPRIOLINEAR { "constraints/superindicator/upgdpriolinear" };
}
namespace CONSTRAINTS::SYMRESACK {
    constexpr Param<int> SEPAFREQ { "constraints/symresack/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/symresack/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/symresack/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/symresack/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/symresack/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/symresack/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/symresack/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/symresack/presoltiming" };
    constexpr Param<bool> PPSYMRESACK { "constraints/symresack/ppsymresack" };
    constexpr Param<bool> CHECKMONOTONICITY { "constraints/symresack/checkmonotonicity" };
    constexpr Param<bool> FORCECONSCOPY { "constraints/symresack/forceconscopy" };
}
namespace CONSTRAINTS::VARBOUND {
    constexpr Param<int> SEPAFREQ { "constraints/varbound/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/varbound/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/varbound/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/varbound/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/varbound/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/varbound/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/varbound/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/varbound/presoltiming" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/varbound/presolpairwise" };
    constexpr Param<double> MAXLPCOEF { "constraints/varbound/maxlpcoef" };
    constexpr Param<bool> USEBDWIDENING { "constraints/varbound/usebdwidening" };
}
namespace CONSTRAINTS::XOR {
    constexpr Param<int> SEPAFREQ { "constraints/xor/sepafreq" };
    constexpr Param<int> PROPFREQ { "constraints/xor/propfreq" };
    constexpr Param<int> PROPTIMING { "constraints/xor/proptiming" };
    constexpr Param<int> EAGERFREQ { "constraints/xor/eagerfreq" };
    constexpr Param<int> MAXPREROUNDS { "constraints/xor/maxprerounds" };
    constexpr Param<bool> DELAYSEPA { "constraints/xor/delaysepa" };
    constexpr Param<bool> DELAYPROP { "constraints/xor/delayprop" };
    constexpr Param<int> PRESOLTIMING { "constraints/xor/presoltiming" };
    constexpr Param<bool> PRESOLPAIRWISE { "constraints/xor/presolpairwise" };
    constexpr Param<bool> PRESOLUSEHASHING { "constraints/xor/presolusehashing" };
    constexpr Param<bool> ADDEXTENDEDFORM { "constraints/xor/addextendedform" };
    constexpr Param<bool> ADDFLOWEXTENDED { "constraints/xor/addflowextended" };
    constexpr Param<bool> SEPARATEPARITY { "constraints/xor/separateparity" };
    constexpr Param<int> GAUSSPROPFREQ { "constraints/xor/gausspropfreq" };
}
namespace CUTSELECTION::HYBRID {
    constexpr Param<int> PRIORITY { "cutselection/hybrid/priority" };
    constexpr Param<double> EFFICACYWEIGHT { "cutselection/hybrid/efficacyweight" };
    constexpr Param<double> DIRCUTOFFDISTWEIGHT { "cutselection/hybrid/dircutoffdistweight" };
    constexpr Param<double> OBJPARALWEIGHT { "cutselection/hybrid/objparalweight" };
    constexpr Param<double> INTSUPPORTWEIGHT { "cutselection/hybrid/intsupportweight" };
    constexpr Param<double> MINORTHO { "cutselection/hybrid/minortho" };
    constexpr Param<double> MINORTHOROOT { "cutselection/hybrid/minorthoroot" };
}
namespace DECOMPOSITION {
    constexpr Param<bool> BENDERSLABELS { "decomposition/benderslabels" };
    constexpr Param<bool> APPLYBENDERS { "decomposition/applybenders" };
    constexpr Param<int> MAXGRAPHEDGE { "decomposition/maxgraphedge" };
    constexpr Param<bool> DISABLEMEASURES { "decomposition/disablemeasures" };
}
namespace DISPLAY {
    constexpr Param<int> VERBLEVEL { "display/verblevel" };
    constexpr Param<int> WIDTH { "display/width" };
    constexpr Param<int> FREQ { "display/freq" };
    constexpr Param<int> HEADERFREQ { "display/headerfreq" };
    constexpr Param<bool> LPINFO { "display/lpinfo" };
    constexpr Param<bool> ALLVIOLS { "display/allviols" };
    constexpr Param<bool> RELEVANTSTATS { "display/relevantstats" };
}
namespace DISPLAY::AVGDUALBOUND {
    constexpr Param<int> ACTIVE { "display/avgdualbound/active" };
}
namespace DISPLAY::COMPLETED {
    constexpr Param<int> ACTIVE { "display/completed/active" };
}
namespace DISPLAY::CONCDUALBOUND {
    constexpr Param<int> ACTIVE { "display/concdualbound/active" };
}
namespace DISPLAY::CONCGAP {
    constexpr Param<int> ACTIVE { "display/concgap/active" };
}
namespace DISPLAY::CONCMEMUSED {
    constexpr Param<int> ACTIVE { "display/concmemused/active" };
}
namespace DISPLAY::CONCPRIMALBOUND {
    constexpr Param<int> ACTIVE { "display/concprimalbound/active" };
}
namespace DISPLAY::CONCSOLFOUND {
    constexpr Param<int> ACTIVE { "display/concsolfound/active" };
}
namespace DISPLAY::CONFLICTS {
    constexpr Param<int> ACTIVE { "display/conflicts/active" };
}
namespace DISPLAY::CONSS {
    constexpr Param<int> ACTIVE { "display/conss/active" };
}
namespace DISPLAY::CURCOLS {
    constexpr Param<int> ACTIVE { "display/curcols/active" };
}
namespace DISPLAY::CURCONSS {
    constexpr Param<int> ACTIVE { "display/curconss/active" };
}
namespace DISPLAY::CURDUALBOUND {
    constexpr Param<int> ACTIVE { "display/curdualbound/active" };
}
namespace DISPLAY::CURROWS {
    constexpr Param<int> ACTIVE { "display/currows/active" };
}
namespace DISPLAY::CUTOFFBOUND {
    constexpr Param<int> ACTIVE { "display/cutoffbound/active" };
}
namespace DISPLAY::CUTS {
    constexpr Param<int> ACTIVE { "display/cuts/active" };
}
namespace DISPLAY::DEPTH {
    constexpr Param<int> ACTIVE { "display/depth/active" };
}
namespace DISPLAY::DUALBOUND {
    constexpr Param<int> ACTIVE { "display/dualbound/active" };
}
namespace DISPLAY::ESTIMATE {
    constexpr Param<int> ACTIVE { "display/estimate/active" };
}
namespace DISPLAY::FEASST {
    constexpr Param<int> ACTIVE { "display/feasST/active" };
}
namespace DISPLAY::GAP {
    constexpr Param<int> ACTIVE { "display/gap/active" };
}
namespace DISPLAY::LPAVGITERATIONS {
    constexpr Param<int> ACTIVE { "display/lpavgiterations/active" };
}
namespace DISPLAY::LPCOND {
    constexpr Param<int> ACTIVE { "display/lpcond/active" };
}
namespace DISPLAY::LPITERATIONS {
    constexpr Param<int> ACTIVE { "display/lpiterations/active" };
}
namespace DISPLAY::LPOBJ {
    constexpr Param<int> ACTIVE { "display/lpobj/active" };
}
namespace DISPLAY::MAXDEPTH {
    constexpr Param<int> ACTIVE { "display/maxdepth/active" };
}
namespace DISPLAY::MEMTOTAL {
    constexpr Param<int> ACTIVE { "display/memtotal/active" };
}
namespace DISPLAY::MEMUSED {
    constexpr Param<int> ACTIVE { "display/memused/active" };
}
namespace DISPLAY::NEXTERNBRANCHCANDS {
    constexpr Param<int> ACTIVE { "display/nexternbranchcands/active" };
}
namespace DISPLAY::NFRAC {
    constexpr Param<int> ACTIVE { "display/nfrac/active" };
}
namespace DISPLAY::NINFEASLEAVES {
    constexpr Param<int> ACTIVE { "display/ninfeasleaves/active" };
}
namespace DISPLAY::NNODES {
    constexpr Param<int> ACTIVE { "display/nnodes/active" };
}
namespace DISPLAY::NNODESBELOWINC {
    constexpr Param<int> ACTIVE { "display/nnodesbelowinc/active" };
}
namespace DISPLAY::NOBJLEAVES {
    constexpr Param<int> ACTIVE { "display/nobjleaves/active" };
}
namespace DISPLAY::NODESLEFT {
    constexpr Param<int> ACTIVE { "display/nodesleft/active" };
}
namespace DISPLAY::NRANK1NODES {
    constexpr Param<int> ACTIVE { "display/nrank1nodes/active" };
}
namespace DISPLAY::NSOLS {
    constexpr Param<int> ACTIVE { "display/nsols/active" };
}
namespace DISPLAY::PLUNGEDEPTH {
    constexpr Param<int> ACTIVE { "display/plungedepth/active" };
}
namespace DISPLAY::POOLSIZE {
    constexpr Param<int> ACTIVE { "display/poolsize/active" };
}
namespace DISPLAY::PRIMALBOUND {
    constexpr Param<int> ACTIVE { "display/primalbound/active" };
}
namespace DISPLAY::PRIMALGAP {
    constexpr Param<int> ACTIVE { "display/primalgap/active" };
}
namespace DISPLAY::PSEUDOOBJ {
    constexpr Param<int> ACTIVE { "display/pseudoobj/active" };
}
namespace DISPLAY::SEPAROUNDS {
    constexpr Param<int> ACTIVE { "display/separounds/active" };
}
namespace DISPLAY::SOLFOUND {
    constexpr Param<int> ACTIVE { "display/solfound/active" };
}
namespace DISPLAY::SOLS {
    constexpr Param<int> ACTIVE { "display/sols/active" };
}
namespace DISPLAY::STRONGBRANCHS {
    constexpr Param<int> ACTIVE { "display/strongbranchs/active" };
}
namespace DISPLAY::TIME {
    constexpr Param<int> ACTIVE { "display/time/active" };
}
namespace DISPLAY::VARS {
    constexpr Param<int> ACTIVE { "display/vars/active" };
}
namespace ESTIMATION {
    constexpr Param<char> METHOD { "estimation/method" };
    constexpr Param<double> COEFMONOWEIGHT { "estimation/coefmonoweight" };
    constexpr Param<double> COEFMONOSSG { "estimation/coefmonossg" };
    constexpr Param<int> REPORTFREQ { "estimation/reportfreq" };
    constexpr Param<std::string> REGFORESTFILENAME { "estimation/regforestfilename" };
    constexpr Param<char> COMPLETIONTYPE { "estimation/completiontype" };
    constexpr Param<bool> USELEAFTS { "estimation/useleafts" };
    constexpr Param<bool> SHOWSTATS { "estimation/showstats" };
}
namespace ESTIMATION::RESTARTS {
    constexpr Param<char> RESTARTPOLICY { "estimation/restarts/restartpolicy" };
    constexpr Param<int> RESTARTLIMIT { "estimation/restarts/restartlimit" };
    constexpr Param<long long> MINNODES { "estimation/restarts/minnodes" };
    constexpr Param<bool> COUNTONLYLEAVES { "estimation/restarts/countonlyleaves" };
    constexpr Param<double> RESTARTFACTOR { "estimation/restarts/restartfactor" };
    constexpr Param<bool> RESTARTNONLINEAR { "estimation/restarts/restartnonlinear" };
    constexpr Param<bool> RESTARTACTPRICERS { "estimation/restarts/restartactpricers" };
    constexpr Param<int> HITCOUNTERLIM { "estimation/restarts/hitcounterlim" };
}
namespace ESTIMATION::SSG {
    constexpr Param<int> NMAXSUBTREES { "estimation/ssg/nmaxsubtrees" };
    constexpr Param<long long> NMINNODESLASTSPLIT { "estimation/ssg/nminnodeslastsplit" };
}
namespace ESTIMATION::TREEPROFILE {
    constexpr Param<bool> ENABLED { "estimation/treeprofile/enabled" };
    constexpr Param<double> MINNODESPERDEPTH { "estimation/treeprofile/minnodesperdepth" };
}
namespace EXPR::LOG {
    constexpr Param<double> MINZERODISTANCE { "expr/log/minzerodistance" };
}
namespace EXPR::POW {
    constexpr Param<double> MINZERODISTANCE { "expr/pow/minzerodistance" };
}
namespace HEURISTICS {
    constexpr Param<bool> USEUCTSUBSCIP { "heuristics/useuctsubscip" };
}
namespace HEURISTICS::ACTCONSDIVING {
    constexpr Param<int> PRIORITY { "heuristics/actconsdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/actconsdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/actconsdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/actconsdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/actconsdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/actconsdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/actconsdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/actconsdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/actconsdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/actconsdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/actconsdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/actconsdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/actconsdiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/actconsdiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/actconsdiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/actconsdiving/onlylpbranchcands" };
}
namespace HEURISTICS::ADAPTIVEDIVING {
    constexpr Param<int> PRIORITY { "heuristics/adaptivediving/priority" };
    constexpr Param<int> FREQ { "heuristics/adaptivediving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/adaptivediving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/adaptivediving/maxdepth" };
    constexpr Param<double> EPSILON { "heuristics/adaptivediving/epsilon" };
    constexpr Param<char> SCORETYPE { "heuristics/adaptivediving/scoretype" };
    constexpr Param<char> SELTYPE { "heuristics/adaptivediving/seltype" };
    constexpr Param<bool> USEADAPTIVECONTEXT { "heuristics/adaptivediving/useadaptivecontext" };
    constexpr Param<double> SELCONFIDENCECOEFF { "heuristics/adaptivediving/selconfidencecoeff" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/adaptivediving/maxlpiterquot" };
    constexpr Param<long long> MAXLPITEROFS { "heuristics/adaptivediving/maxlpiterofs" };
    constexpr Param<double> BESTSOLWEIGHT { "heuristics/adaptivediving/bestsolweight" };
}
namespace HEURISTICS::ALNS {
    constexpr Param<int> PRIORITY { "heuristics/alns/priority" };
    constexpr Param<int> FREQ { "heuristics/alns/freq" };
    constexpr Param<int> FREQOFS { "heuristics/alns/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/alns/maxdepth" };
    constexpr Param<bool> SHOWNBSTATS { "heuristics/alns/shownbstats" };
    constexpr Param<long long> MAXNODES { "heuristics/alns/maxnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/alns/nodesofs" };
    constexpr Param<long long> MINNODES { "heuristics/alns/minnodes" };
    constexpr Param<long long> WAITINGNODES { "heuristics/alns/waitingnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/alns/nodesquot" };
    constexpr Param<double> NODESQUOTMIN { "heuristics/alns/nodesquotmin" };
    constexpr Param<double> STARTMINIMPROVE { "heuristics/alns/startminimprove" };
    constexpr Param<double> MINIMPROVELOW { "heuristics/alns/minimprovelow" };
    constexpr Param<double> MINIMPROVEHIGH { "heuristics/alns/minimprovehigh" };
    constexpr Param<int> NSOLSLIM { "heuristics/alns/nsolslim" };
    constexpr Param<char> BANDITALGO { "heuristics/alns/banditalgo" };
    constexpr Param<double> GAMMA { "heuristics/alns/gamma" };
    constexpr Param<double> BETA { "heuristics/alns/beta" };
    constexpr Param<double> ALPHA { "heuristics/alns/alpha" };
    constexpr Param<bool> USEDISTANCES { "heuristics/alns/usedistances" };
    constexpr Param<bool> USEREDCOST { "heuristics/alns/useredcost" };
    constexpr Param<bool> DOMOREFIXINGS { "heuristics/alns/domorefixings" };
    constexpr Param<bool> ADJUSTFIXINGRATE { "heuristics/alns/adjustfixingrate" };
    constexpr Param<bool> USESUBSCIPHEURS { "heuristics/alns/usesubscipheurs" };
    constexpr Param<double> REWARDCONTROL { "heuristics/alns/rewardcontrol" };
    constexpr Param<double> TARGETNODEFACTOR { "heuristics/alns/targetnodefactor" };
    constexpr Param<int> SEED { "heuristics/alns/seed" };
    constexpr Param<int> MAXCALLSSAMESOL { "heuristics/alns/maxcallssamesol" };
    constexpr Param<bool> ADJUSTMINIMPROVE { "heuristics/alns/adjustminimprove" };
    constexpr Param<bool> ADJUSTTARGETNODES { "heuristics/alns/adjusttargetnodes" };
    constexpr Param<double> EPS { "heuristics/alns/eps" };
    constexpr Param<double> REWARDBASELINE { "heuristics/alns/rewardbaseline" };
    constexpr Param<bool> RESETWEIGHTS { "heuristics/alns/resetweights" };
    constexpr Param<std::string> REWARDFILENAME { "heuristics/alns/rewardfilename" };
    constexpr Param<bool> SUBSCIPRANDSEEDS { "heuristics/alns/subsciprandseeds" };
    constexpr Param<bool> SCALEBYEFFORT { "heuristics/alns/scalebyeffort" };
    constexpr Param<bool> COPYCUTS { "heuristics/alns/copycuts" };
    constexpr Param<double> FIXTOL { "heuristics/alns/fixtol" };
    constexpr Param<double> UNFIXTOL { "heuristics/alns/unfixtol" };
    constexpr Param<bool> USELOCALREDCOST { "heuristics/alns/uselocalredcost" };
    constexpr Param<bool> USEPSCOST { "heuristics/alns/usepscost" };
    constexpr Param<bool> INITDURINGROOT { "heuristics/alns/initduringroot" };
}
namespace HEURISTICS::ALNS::CROSSOVER {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/crossover/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/crossover/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/crossover/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/crossover/priority" };
    constexpr Param<int> NSOLS { "heuristics/alns/crossover/nsols" };
}
namespace HEURISTICS::ALNS::DINS {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/dins/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/dins/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/dins/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/dins/priority" };
    constexpr Param<int> NPOOLSOLS { "heuristics/alns/dins/npoolsols" };
}
namespace HEURISTICS::ALNS::LOCALBRANCHING {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/localbranching/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/localbranching/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/localbranching/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/localbranching/priority" };
}
namespace HEURISTICS::ALNS::MUTATION {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/mutation/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/mutation/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/mutation/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/mutation/priority" };
}
namespace HEURISTICS::ALNS::PROXIMITY {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/proximity/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/proximity/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/proximity/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/proximity/priority" };
}
namespace HEURISTICS::ALNS::RENS {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/rens/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/rens/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/rens/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/rens/priority" };
}
namespace HEURISTICS::ALNS::RINS {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/rins/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/rins/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/rins/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/rins/priority" };
}
namespace HEURISTICS::ALNS::TRUSTREGION {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/trustregion/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/trustregion/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/trustregion/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/trustregion/priority" };
    constexpr Param<double> VIOLPENALTY { "heuristics/alns/trustregion/violpenalty" };
}
namespace HEURISTICS::ALNS::ZEROOBJECTIVE {
    constexpr Param<double> MINFIXINGRATE { "heuristics/alns/zeroobjective/minfixingrate" };
    constexpr Param<double> MAXFIXINGRATE { "heuristics/alns/zeroobjective/maxfixingrate" };
    constexpr Param<bool> ACTIVE { "heuristics/alns/zeroobjective/active" };
    constexpr Param<double> PRIORITY { "heuristics/alns/zeroobjective/priority" };
}
namespace HEURISTICS::BOUND {
    constexpr Param<int> PRIORITY { "heuristics/bound/priority" };
    constexpr Param<int> FREQ { "heuristics/bound/freq" };
    constexpr Param<int> FREQOFS { "heuristics/bound/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/bound/maxdepth" };
    constexpr Param<bool> ONLYWITHOUTSOL { "heuristics/bound/onlywithoutsol" };
    constexpr Param<int> MAXPROPROUNDS { "heuristics/bound/maxproprounds" };
    constexpr Param<char> BOUND { "heuristics/bound/bound" };
}
namespace HEURISTICS::CLIQUE {
    constexpr Param<int> PRIORITY { "heuristics/clique/priority" };
    constexpr Param<int> FREQ { "heuristics/clique/freq" };
    constexpr Param<int> FREQOFS { "heuristics/clique/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/clique/maxdepth" };
    constexpr Param<double> MININTFIXINGRATE { "heuristics/clique/minintfixingrate" };
    constexpr Param<double> MINMIPFIXINGRATE { "heuristics/clique/minmipfixingrate" };
    constexpr Param<long long> MAXNODES { "heuristics/clique/maxnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/clique/nodesofs" };
    constexpr Param<long long> MINNODES { "heuristics/clique/minnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/clique/nodesquot" };
    constexpr Param<double> MINIMPROVE { "heuristics/clique/minimprove" };
    constexpr Param<int> MAXPROPROUNDS { "heuristics/clique/maxproprounds" };
    constexpr Param<bool> COPYCUTS { "heuristics/clique/copycuts" };
    constexpr Param<bool> USELOCKFIXINGS { "heuristics/clique/uselockfixings" };
    constexpr Param<int> MAXBACKTRACKS { "heuristics/clique/maxbacktracks" };
}
namespace HEURISTICS::COEFDIVING {
    constexpr Param<int> PRIORITY { "heuristics/coefdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/coefdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/coefdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/coefdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/coefdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/coefdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/coefdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/coefdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/coefdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/coefdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/coefdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/coefdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/coefdiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/coefdiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/coefdiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/coefdiving/onlylpbranchcands" };
}
namespace HEURISTICS::COMPLETESOL {
    constexpr Param<int> PRIORITY { "heuristics/completesol/priority" };
    constexpr Param<int> FREQ { "heuristics/completesol/freq" };
    constexpr Param<int> FREQOFS { "heuristics/completesol/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/completesol/maxdepth" };
    constexpr Param<long long> MAXNODES { "heuristics/completesol/maxnodes" };
    constexpr Param<long long> MINNODES { "heuristics/completesol/minnodes" };
    constexpr Param<double> MAXUNKNOWNRATE { "heuristics/completesol/maxunknownrate" };
    constexpr Param<bool> ADDALLSOLS { "heuristics/completesol/addallsols" };
    constexpr Param<long long> NODESOFS { "heuristics/completesol/nodesofs" };
    constexpr Param<double> NODESQUOT { "heuristics/completesol/nodesquot" };
    constexpr Param<double> LPLIMFAC { "heuristics/completesol/lplimfac" };
    constexpr Param<double> OBJWEIGHT { "heuristics/completesol/objweight" };
    constexpr Param<double> BOUNDWIDENING { "heuristics/completesol/boundwidening" };
    constexpr Param<double> MINIMPROVE { "heuristics/completesol/minimprove" };
    constexpr Param<bool> IGNORECONT { "heuristics/completesol/ignorecont" };
    constexpr Param<int> SOLUTIONS { "heuristics/completesol/solutions" };
    constexpr Param<int> MAXPROPROUNDS { "heuristics/completesol/maxproprounds" };
    constexpr Param<bool> BEFOREPRESOL { "heuristics/completesol/beforepresol" };
    constexpr Param<long long> MAXLPITER { "heuristics/completesol/maxlpiter" };
    constexpr Param<int> MAXCONTVARS { "heuristics/completesol/maxcontvars" };
}
namespace HEURISTICS::CONFLICTDIVING {
    constexpr Param<int> PRIORITY { "heuristics/conflictdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/conflictdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/conflictdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/conflictdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/conflictdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/conflictdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/conflictdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/conflictdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/conflictdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/conflictdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/conflictdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/conflictdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/conflictdiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/conflictdiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/conflictdiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/conflictdiving/onlylpbranchcands" };
    constexpr Param<bool> MAXVIOL { "heuristics/conflictdiving/maxviol" };
    constexpr Param<bool> LIKECOEF { "heuristics/conflictdiving/likecoef" };
    constexpr Param<int> MINCONFLICTLOCKS { "heuristics/conflictdiving/minconflictlocks" };
    constexpr Param<double> LOCKWEIGHT { "heuristics/conflictdiving/lockweight" };
}
namespace HEURISTICS::CROSSOVER {
    constexpr Param<int> PRIORITY { "heuristics/crossover/priority" };
    constexpr Param<int> FREQ { "heuristics/crossover/freq" };
    constexpr Param<int> FREQOFS { "heuristics/crossover/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/crossover/maxdepth" };
    constexpr Param<long long> NODESOFS { "heuristics/crossover/nodesofs" };
    constexpr Param<long long> MAXNODES { "heuristics/crossover/maxnodes" };
    constexpr Param<long long> MINNODES { "heuristics/crossover/minnodes" };
    constexpr Param<int> NUSEDSOLS { "heuristics/crossover/nusedsols" };
    constexpr Param<long long> NWAITINGNODES { "heuristics/crossover/nwaitingnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/crossover/nodesquot" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/crossover/minfixingrate" };
    constexpr Param<double> MINIMPROVE { "heuristics/crossover/minimprove" };
    constexpr Param<double> LPLIMFAC { "heuristics/crossover/lplimfac" };
    constexpr Param<bool> RANDOMIZATION { "heuristics/crossover/randomization" };
    constexpr Param<bool> DONTWAITATROOT { "heuristics/crossover/dontwaitatroot" };
    constexpr Param<bool> USELPROWS { "heuristics/crossover/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/crossover/copycuts" };
    constexpr Param<bool> PERMUTE { "heuristics/crossover/permute" };
    constexpr Param<int> BESTSOLLIMIT { "heuristics/crossover/bestsollimit" };
    constexpr Param<bool> USEUCT { "heuristics/crossover/useuct" };
}
namespace HEURISTICS::DINS {
    constexpr Param<int> PRIORITY { "heuristics/dins/priority" };
    constexpr Param<int> FREQ { "heuristics/dins/freq" };
    constexpr Param<int> FREQOFS { "heuristics/dins/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/dins/maxdepth" };
    constexpr Param<long long> NODESOFS { "heuristics/dins/nodesofs" };
    constexpr Param<double> NODESQUOT { "heuristics/dins/nodesquot" };
    constexpr Param<long long> MINNODES { "heuristics/dins/minnodes" };
    constexpr Param<int> SOLNUM { "heuristics/dins/solnum" };
    constexpr Param<int> NEIGHBORHOODSIZE { "heuristics/dins/neighborhoodsize" };
    constexpr Param<long long> MAXNODES { "heuristics/dins/maxnodes" };
    constexpr Param<double> MINIMPROVE { "heuristics/dins/minimprove" };
    constexpr Param<long long> NWAITINGNODES { "heuristics/dins/nwaitingnodes" };
    constexpr Param<double> LPLIMFAC { "heuristics/dins/lplimfac" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/dins/minfixingrate" };
    constexpr Param<bool> USELPROWS { "heuristics/dins/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/dins/copycuts" };
    constexpr Param<bool> USEUCT { "heuristics/dins/useuct" };
    constexpr Param<int> BESTSOLLIMIT { "heuristics/dins/bestsollimit" };
}
namespace HEURISTICS::DISTRIBUTIONDIVING {
    constexpr Param<int> PRIORITY { "heuristics/distributiondiving/priority" };
    constexpr Param<int> FREQ { "heuristics/distributiondiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/distributiondiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/distributiondiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/distributiondiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/distributiondiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/distributiondiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/distributiondiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/distributiondiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/distributiondiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/distributiondiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/distributiondiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/distributiondiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/distributiondiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/distributiondiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/distributiondiving/onlylpbranchcands" };
    constexpr Param<char> SCOREPARAM { "heuristics/distributiondiving/scoreparam" };
}
namespace HEURISTICS::DPS {
    constexpr Param<int> PRIORITY { "heuristics/dps/priority" };
    constexpr Param<int> FREQ { "heuristics/dps/freq" };
    constexpr Param<int> FREQOFS { "heuristics/dps/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/dps/maxdepth" };
    constexpr Param<int> MAXITERATIONS { "heuristics/dps/maxiterations" };
    constexpr Param<double> MAXLINKSCORE { "heuristics/dps/maxlinkscore" };
    constexpr Param<double> PENALTY { "heuristics/dps/penalty" };
    constexpr Param<bool> REOPTIMIZE { "heuristics/dps/reoptimize" };
    constexpr Param<bool> REUSE { "heuristics/dps/reuse" };
}
namespace HEURISTICS::DUALVAL {
    constexpr Param<int> PRIORITY { "heuristics/dualval/priority" };
    constexpr Param<int> FREQ { "heuristics/dualval/freq" };
    constexpr Param<int> FREQOFS { "heuristics/dualval/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/dualval/maxdepth" };
    constexpr Param<bool> FORCEIMPROVEMENTS { "heuristics/dualval/forceimprovements" };
    constexpr Param<bool> ONLYCHEAPER { "heuristics/dualval/onlycheaper" };
    constexpr Param<bool> ONLYLEAVES { "heuristics/dualval/onlyleaves" };
    constexpr Param<bool> RELAXINDICATORS { "heuristics/dualval/relaxindicators" };
    constexpr Param<bool> RELAXCONTVARS { "heuristics/dualval/relaxcontvars" };
    constexpr Param<int> HEURVERBLEVEL { "heuristics/dualval/heurverblevel" };
    constexpr Param<int> NLPVERBLEVEL { "heuristics/dualval/nlpverblevel" };
    constexpr Param<int> RANKVALUE { "heuristics/dualval/rankvalue" };
    constexpr Param<int> MAXCALLS { "heuristics/dualval/maxcalls" };
    constexpr Param<int> DYNAMICDEPTH { "heuristics/dualval/dynamicdepth" };
    constexpr Param<int> MAXEQUALRANKS { "heuristics/dualval/maxequalranks" };
    constexpr Param<double> MINGAP { "heuristics/dualval/mingap" };
    constexpr Param<double> LAMBDASLACK { "heuristics/dualval/lambdaslack" };
    constexpr Param<double> LAMBDAOBJ { "heuristics/dualval/lambdaobj" };
}
namespace HEURISTICS::FARKASDIVING {
    constexpr Param<int> PRIORITY { "heuristics/farkasdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/farkasdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/farkasdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/farkasdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/farkasdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/farkasdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/farkasdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/farkasdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/farkasdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/farkasdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/farkasdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/farkasdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/farkasdiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/farkasdiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/farkasdiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/farkasdiving/onlylpbranchcands" };
    constexpr Param<bool> CHECKCANDS { "heuristics/farkasdiving/checkcands" };
    constexpr Param<bool> SCALESCORE { "heuristics/farkasdiving/scalescore" };
    constexpr Param<bool> ROOTSUCCESS { "heuristics/farkasdiving/rootsuccess" };
    constexpr Param<double> MAXOBJOCC { "heuristics/farkasdiving/maxobjocc" };
    constexpr Param<double> OBJDYNAMISM { "heuristics/farkasdiving/objdynamism" };
    constexpr Param<char> SCALETYPE { "heuristics/farkasdiving/scaletype" };
}
namespace HEURISTICS::FEASPUMP {
    constexpr Param<int> PRIORITY { "heuristics/feaspump/priority" };
    constexpr Param<int> FREQ { "heuristics/feaspump/freq" };
    constexpr Param<int> FREQOFS { "heuristics/feaspump/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/feaspump/maxdepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/feaspump/maxlpiterquot" };
    constexpr Param<double> OBJFACTOR { "heuristics/feaspump/objfactor" };
    constexpr Param<double> ALPHA { "heuristics/feaspump/alpha" };
    constexpr Param<double> ALPHADIFF { "heuristics/feaspump/alphadiff" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/feaspump/maxlpiterofs" };
    constexpr Param<int> MAXSOLS { "heuristics/feaspump/maxsols" };
    constexpr Param<int> MAXLOOPS { "heuristics/feaspump/maxloops" };
    constexpr Param<int> MAXSTALLLOOPS { "heuristics/feaspump/maxstallloops" };
    constexpr Param<int> MINFLIPS { "heuristics/feaspump/minflips" };
    constexpr Param<int> CYCLELENGTH { "heuristics/feaspump/cyclelength" };
    constexpr Param<int> PERTURBFREQ { "heuristics/feaspump/perturbfreq" };
    constexpr Param<int> NEIGHBORHOODSIZE { "heuristics/feaspump/neighborhoodsize" };
    constexpr Param<bool> BEFORECUTS { "heuristics/feaspump/beforecuts" };
    constexpr Param<bool> USEFP20 { "heuristics/feaspump/usefp20" };
    constexpr Param<bool> PERTSOLFOUND { "heuristics/feaspump/pertsolfound" };
    constexpr Param<bool> STAGE3 { "heuristics/feaspump/stage3" };
    constexpr Param<bool> COPYCUTS { "heuristics/feaspump/copycuts" };
}
namespace HEURISTICS::FIXANDINFER {
    constexpr Param<int> PRIORITY { "heuristics/fixandinfer/priority" };
    constexpr Param<int> FREQ { "heuristics/fixandinfer/freq" };
    constexpr Param<int> FREQOFS { "heuristics/fixandinfer/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/fixandinfer/maxdepth" };
    constexpr Param<int> PROPROUNDS { "heuristics/fixandinfer/proprounds" };
    constexpr Param<int> MINFIXINGS { "heuristics/fixandinfer/minfixings" };
}
namespace HEURISTICS::FRACDIVING {
    constexpr Param<int> PRIORITY { "heuristics/fracdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/fracdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/fracdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/fracdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/fracdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/fracdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/fracdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/fracdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/fracdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/fracdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/fracdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/fracdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/fracdiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/fracdiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/fracdiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/fracdiving/onlylpbranchcands" };
}
namespace HEURISTICS::GINS {
    constexpr Param<int> PRIORITY { "heuristics/gins/priority" };
    constexpr Param<int> FREQ { "heuristics/gins/freq" };
    constexpr Param<int> FREQOFS { "heuristics/gins/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/gins/maxdepth" };
    constexpr Param<int> NODESOFS { "heuristics/gins/nodesofs" };
    constexpr Param<int> MAXNODES { "heuristics/gins/maxnodes" };
    constexpr Param<int> MINNODES { "heuristics/gins/minnodes" };
    constexpr Param<int> NWAITINGNODES { "heuristics/gins/nwaitingnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/gins/nodesquot" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/gins/minfixingrate" };
    constexpr Param<double> MINIMPROVE { "heuristics/gins/minimprove" };
    constexpr Param<bool> USELPROWS { "heuristics/gins/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/gins/copycuts" };
    constexpr Param<bool> FIXCONTVARS { "heuristics/gins/fixcontvars" };
    constexpr Param<int> BESTSOLLIMIT { "heuristics/gins/bestsollimit" };
    constexpr Param<int> MAXDISTANCE { "heuristics/gins/maxdistance" };
    constexpr Param<char> POTENTIAL { "heuristics/gins/potential" };
    constexpr Param<bool> USEROLLINGHORIZON { "heuristics/gins/userollinghorizon" };
    constexpr Param<bool> RELAXDENSECONSS { "heuristics/gins/relaxdenseconss" };
    constexpr Param<double> ROLLHORIZONLIMFAC { "heuristics/gins/rollhorizonlimfac" };
    constexpr Param<double> OVERLAP { "heuristics/gins/overlap" };
    constexpr Param<bool> USEDECOMP { "heuristics/gins/usedecomp" };
    constexpr Param<bool> USEDECOMPROLLHORIZON { "heuristics/gins/usedecomprollhorizon" };
    constexpr Param<bool> USESELFALLBACK { "heuristics/gins/useselfallback" };
    constexpr Param<bool> CONSECUTIVEBLOCKS { "heuristics/gins/consecutiveblocks" };
}
namespace HEURISTICS::GUIDEDDIVING {
    constexpr Param<int> PRIORITY { "heuristics/guideddiving/priority" };
    constexpr Param<int> FREQ { "heuristics/guideddiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/guideddiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/guideddiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/guideddiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/guideddiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/guideddiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/guideddiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/guideddiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/guideddiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/guideddiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/guideddiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/guideddiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/guideddiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/guideddiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/guideddiving/onlylpbranchcands" };
}
namespace HEURISTICS::INDICATOR {
    constexpr Param<int> PRIORITY { "heuristics/indicator/priority" };
    constexpr Param<int> FREQ { "heuristics/indicator/freq" };
    constexpr Param<int> FREQOFS { "heuristics/indicator/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/indicator/maxdepth" };
    constexpr Param<bool> ONEOPT { "heuristics/indicator/oneopt" };
    constexpr Param<bool> IMPROVESOLS { "heuristics/indicator/improvesols" };
}
namespace HEURISTICS::INTDIVING {
    constexpr Param<int> PRIORITY { "heuristics/intdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/intdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/intdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/intdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/intdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/intdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/intdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/intdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/intdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/intdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/intdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/intdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/intdiving/backtrack" };
}
namespace HEURISTICS::INTSHIFTING {
    constexpr Param<int> PRIORITY { "heuristics/intshifting/priority" };
    constexpr Param<int> FREQ { "heuristics/intshifting/freq" };
    constexpr Param<int> FREQOFS { "heuristics/intshifting/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/intshifting/maxdepth" };
}
namespace HEURISTICS::LINESEARCHDIVING {
    constexpr Param<int> PRIORITY { "heuristics/linesearchdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/linesearchdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/linesearchdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/linesearchdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/linesearchdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/linesearchdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/linesearchdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/linesearchdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/linesearchdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/linesearchdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/linesearchdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/linesearchdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/linesearchdiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/linesearchdiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/linesearchdiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/linesearchdiving/onlylpbranchcands" };
}
namespace HEURISTICS::LOCALBRANCHING {
    constexpr Param<int> PRIORITY { "heuristics/localbranching/priority" };
    constexpr Param<int> FREQ { "heuristics/localbranching/freq" };
    constexpr Param<int> FREQOFS { "heuristics/localbranching/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/localbranching/maxdepth" };
    constexpr Param<int> NODESOFS { "heuristics/localbranching/nodesofs" };
    constexpr Param<int> NEIGHBORHOODSIZE { "heuristics/localbranching/neighborhoodsize" };
    constexpr Param<double> NODESQUOT { "heuristics/localbranching/nodesquot" };
    constexpr Param<double> LPLIMFAC { "heuristics/localbranching/lplimfac" };
    constexpr Param<int> MINNODES { "heuristics/localbranching/minnodes" };
    constexpr Param<int> MAXNODES { "heuristics/localbranching/maxnodes" };
    constexpr Param<int> NWAITINGNODES { "heuristics/localbranching/nwaitingnodes" };
    constexpr Param<double> MINIMPROVE { "heuristics/localbranching/minimprove" };
    constexpr Param<bool> USELPROWS { "heuristics/localbranching/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/localbranching/copycuts" };
    constexpr Param<int> BESTSOLLIMIT { "heuristics/localbranching/bestsollimit" };
}
namespace HEURISTICS::LOCKS {
    constexpr Param<int> PRIORITY { "heuristics/locks/priority" };
    constexpr Param<int> FREQ { "heuristics/locks/freq" };
    constexpr Param<int> FREQOFS { "heuristics/locks/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/locks/maxdepth" };
    constexpr Param<int> MAXPROPROUNDS { "heuristics/locks/maxproprounds" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/locks/minfixingrate" };
    constexpr Param<double> ROUNDUPPROBABILITY { "heuristics/locks/roundupprobability" };
    constexpr Param<bool> USEFINALSUBMIP { "heuristics/locks/usefinalsubmip" };
    constexpr Param<long long> MAXNODES { "heuristics/locks/maxnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/locks/nodesofs" };
    constexpr Param<long long> MINNODES { "heuristics/locks/minnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/locks/nodesquot" };
    constexpr Param<double> MINIMPROVE { "heuristics/locks/minimprove" };
    constexpr Param<bool> COPYCUTS { "heuristics/locks/copycuts" };
    constexpr Param<bool> UPDATELOCKS { "heuristics/locks/updatelocks" };
    constexpr Param<double> MINFIXINGRATELP { "heuristics/locks/minfixingratelp" };
}
namespace HEURISTICS::LPFACE {
    constexpr Param<int> PRIORITY { "heuristics/lpface/priority" };
    constexpr Param<int> FREQ { "heuristics/lpface/freq" };
    constexpr Param<int> FREQOFS { "heuristics/lpface/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/lpface/maxdepth" };
    constexpr Param<long long> NODESOFS { "heuristics/lpface/nodesofs" };
    constexpr Param<long long> MAXNODES { "heuristics/lpface/maxnodes" };
    constexpr Param<long long> MINNODES { "heuristics/lpface/minnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/lpface/nodesquot" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/lpface/minfixingrate" };
    constexpr Param<double> LPLIMFAC { "heuristics/lpface/lplimfac" };
    constexpr Param<bool> USELPROWS { "heuristics/lpface/uselprows" };
    constexpr Param<bool> DUALBASISEQUATIONS { "heuristics/lpface/dualbasisequations" };
    constexpr Param<bool> KEEPSUBSCIP { "heuristics/lpface/keepsubscip" };
    constexpr Param<bool> COPYCUTS { "heuristics/lpface/copycuts" };
    constexpr Param<char> SUBSCIPOBJECTIVE { "heuristics/lpface/subscipobjective" };
    constexpr Param<int> MINPATHLEN { "heuristics/lpface/minpathlen" };
}
namespace HEURISTICS::MPEC {
    constexpr Param<int> PRIORITY { "heuristics/mpec/priority" };
    constexpr Param<int> FREQ { "heuristics/mpec/freq" };
    constexpr Param<int> FREQOFS { "heuristics/mpec/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/mpec/maxdepth" };
    constexpr Param<double> INITTHETA { "heuristics/mpec/inittheta" };
    constexpr Param<double> SIGMA { "heuristics/mpec/sigma" };
    constexpr Param<double> SUBNLPTRIGGER { "heuristics/mpec/subnlptrigger" };
    constexpr Param<double> MAXNLPCOST { "heuristics/mpec/maxnlpcost" };
    constexpr Param<double> MINIMPROVE { "heuristics/mpec/minimprove" };
    constexpr Param<double> MINGAPLEFT { "heuristics/mpec/mingapleft" };
    constexpr Param<int> MAXITER { "heuristics/mpec/maxiter" };
    constexpr Param<int> MAXNLPITER { "heuristics/mpec/maxnlpiter" };
    constexpr Param<int> MAXNUNSUCC { "heuristics/mpec/maxnunsucc" };
}
namespace HEURISTICS::MULTISTART {
    constexpr Param<int> PRIORITY { "heuristics/multistart/priority" };
    constexpr Param<int> FREQ { "heuristics/multistart/freq" };
    constexpr Param<int> FREQOFS { "heuristics/multistart/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/multistart/maxdepth" };
    constexpr Param<int> NRNDPOINTS { "heuristics/multistart/nrndpoints" };
    constexpr Param<double> MAXBOUNDSIZE { "heuristics/multistart/maxboundsize" };
    constexpr Param<int> MAXITER { "heuristics/multistart/maxiter" };
    constexpr Param<double> MINIMPRFAC { "heuristics/multistart/minimprfac" };
    constexpr Param<int> MINIMPRITER { "heuristics/multistart/minimpriter" };
    constexpr Param<double> MAXRELDIST { "heuristics/multistart/maxreldist" };
    constexpr Param<double> GRADLIMIT { "heuristics/multistart/gradlimit" };
    constexpr Param<int> MAXNCLUSTER { "heuristics/multistart/maxncluster" };
    constexpr Param<bool> ONLYNLPS { "heuristics/multistart/onlynlps" };
}
namespace HEURISTICS::MUTATION {
    constexpr Param<int> PRIORITY { "heuristics/mutation/priority" };
    constexpr Param<int> FREQ { "heuristics/mutation/freq" };
    constexpr Param<int> FREQOFS { "heuristics/mutation/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/mutation/maxdepth" };
    constexpr Param<int> NODESOFS { "heuristics/mutation/nodesofs" };
    constexpr Param<int> MAXNODES { "heuristics/mutation/maxnodes" };
    constexpr Param<int> MINNODES { "heuristics/mutation/minnodes" };
    constexpr Param<int> NWAITINGNODES { "heuristics/mutation/nwaitingnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/mutation/nodesquot" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/mutation/minfixingrate" };
    constexpr Param<double> MINIMPROVE { "heuristics/mutation/minimprove" };
    constexpr Param<bool> USELPROWS { "heuristics/mutation/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/mutation/copycuts" };
    constexpr Param<int> BESTSOLLIMIT { "heuristics/mutation/bestsollimit" };
    constexpr Param<bool> USEUCT { "heuristics/mutation/useuct" };
}
namespace HEURISTICS::NLPDIVING {
    constexpr Param<int> PRIORITY { "heuristics/nlpdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/nlpdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/nlpdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/nlpdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/nlpdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/nlpdiving/maxreldepth" };
    constexpr Param<int> MAXNLPITERABS { "heuristics/nlpdiving/maxnlpiterabs" };
    constexpr Param<int> MAXNLPITERREL { "heuristics/nlpdiving/maxnlpiterrel" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/nlpdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/nlpdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/nlpdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/nlpdiving/maxdiveavgquotnosol" };
    constexpr Param<int> MAXFEASNLPS { "heuristics/nlpdiving/maxfeasnlps" };
    constexpr Param<bool> BACKTRACK { "heuristics/nlpdiving/backtrack" };
    constexpr Param<bool> LP { "heuristics/nlpdiving/lp" };
    constexpr Param<bool> PREFERLPFRACS { "heuristics/nlpdiving/preferlpfracs" };
    constexpr Param<double> MINSUCCQUOT { "heuristics/nlpdiving/minsuccquot" };
    constexpr Param<double> FIXQUOT { "heuristics/nlpdiving/fixquot" };
    constexpr Param<bool> PREFERCOVER { "heuristics/nlpdiving/prefercover" };
    constexpr Param<bool> SOLVESUBMIP { "heuristics/nlpdiving/solvesubmip" };
    constexpr Param<bool> NLPFASTFAIL { "heuristics/nlpdiving/nlpfastfail" };
    constexpr Param<char> NLPSTART { "heuristics/nlpdiving/nlpstart" };
    constexpr Param<char> VARSELRULE { "heuristics/nlpdiving/varselrule" };
}
namespace HEURISTICS::OBJPSCOSTDIVING {
    constexpr Param<int> PRIORITY { "heuristics/objpscostdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/objpscostdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/objpscostdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/objpscostdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/objpscostdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/objpscostdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/objpscostdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/objpscostdiving/maxlpiterofs" };
    constexpr Param<int> MAXSOLS { "heuristics/objpscostdiving/maxsols" };
    constexpr Param<double> DEPTHFAC { "heuristics/objpscostdiving/depthfac" };
    constexpr Param<double> DEPTHFACNOSOL { "heuristics/objpscostdiving/depthfacnosol" };
}
namespace HEURISTICS::OCTANE {
    constexpr Param<int> PRIORITY { "heuristics/octane/priority" };
    constexpr Param<int> FREQ { "heuristics/octane/freq" };
    constexpr Param<int> FREQOFS { "heuristics/octane/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/octane/maxdepth" };
    constexpr Param<int> FMAX { "heuristics/octane/fmax" };
    constexpr Param<int> FFIRST { "heuristics/octane/ffirst" };
    constexpr Param<bool> USEFRACSPACE { "heuristics/octane/usefracspace" };
    constexpr Param<bool> USEOBJRAY { "heuristics/octane/useobjray" };
    constexpr Param<bool> USEAVGRAY { "heuristics/octane/useavgray" };
    constexpr Param<bool> USEDIFFRAY { "heuristics/octane/usediffray" };
    constexpr Param<bool> USEAVGWGTRAY { "heuristics/octane/useavgwgtray" };
    constexpr Param<bool> USEAVGNBRAY { "heuristics/octane/useavgnbray" };
}
namespace HEURISTICS::OFINS {
    constexpr Param<int> PRIORITY { "heuristics/ofins/priority" };
    constexpr Param<int> FREQ { "heuristics/ofins/freq" };
    constexpr Param<int> FREQOFS { "heuristics/ofins/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/ofins/maxdepth" };
    constexpr Param<long long> MAXNODES { "heuristics/ofins/maxnodes" };
    constexpr Param<long long> MINNODES { "heuristics/ofins/minnodes" };
    constexpr Param<double> MAXCHANGERATE { "heuristics/ofins/maxchangerate" };
    constexpr Param<double> MAXCHANGE { "heuristics/ofins/maxchange" };
    constexpr Param<bool> COPYCUTS { "heuristics/ofins/copycuts" };
    constexpr Param<bool> ADDALLSOLS { "heuristics/ofins/addallsols" };
    constexpr Param<long long> NODESOFS { "heuristics/ofins/nodesofs" };
    constexpr Param<double> NODESQUOT { "heuristics/ofins/nodesquot" };
    constexpr Param<double> MINIMPROVE { "heuristics/ofins/minimprove" };
    constexpr Param<double> LPLIMFAC { "heuristics/ofins/lplimfac" };
}
namespace HEURISTICS::ONEOPT {
    constexpr Param<int> PRIORITY { "heuristics/oneopt/priority" };
    constexpr Param<int> FREQ { "heuristics/oneopt/freq" };
    constexpr Param<int> FREQOFS { "heuristics/oneopt/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/oneopt/maxdepth" };
    constexpr Param<bool> WEIGHTEDOBJ { "heuristics/oneopt/weightedobj" };
    constexpr Param<bool> DURINGROOT { "heuristics/oneopt/duringroot" };
    constexpr Param<bool> FORCELPCONSTRUCTION { "heuristics/oneopt/forcelpconstruction" };
    constexpr Param<bool> BEFOREPRESOL { "heuristics/oneopt/beforepresol" };
    constexpr Param<bool> USELOOP { "heuristics/oneopt/useloop" };
}
namespace HEURISTICS::PADM {
    constexpr Param<int> PRIORITY { "heuristics/padm/priority" };
    constexpr Param<int> FREQ { "heuristics/padm/freq" };
    constexpr Param<int> FREQOFS { "heuristics/padm/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/padm/maxdepth" };
    constexpr Param<long long> MAXNODES { "heuristics/padm/maxnodes" };
    constexpr Param<long long> MINNODES { "heuristics/padm/minnodes" };
    constexpr Param<double> NODEFAC { "heuristics/padm/nodefac" };
    constexpr Param<int> ADMITERATIONS { "heuristics/padm/admiterations" };
    constexpr Param<int> PENALTYITERATIONS { "heuristics/padm/penaltyiterations" };
    constexpr Param<double> GAP { "heuristics/padm/gap" };
    constexpr Param<bool> REOPTIMIZE { "heuristics/padm/reoptimize" };
    constexpr Param<bool> SCALING { "heuristics/padm/scaling" };
    constexpr Param<bool> ASSIGNLINKING { "heuristics/padm/assignlinking" };
    constexpr Param<bool> ORIGINAL { "heuristics/padm/original" };
    constexpr Param<int> TIMING { "heuristics/padm/timing" };
}
namespace HEURISTICS::PROXIMITY {
    constexpr Param<int> PRIORITY { "heuristics/proximity/priority" };
    constexpr Param<int> FREQ { "heuristics/proximity/freq" };
    constexpr Param<int> FREQOFS { "heuristics/proximity/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/proximity/maxdepth" };
    constexpr Param<bool> USELPROWS { "heuristics/proximity/uselprows" };
    constexpr Param<bool> RESTART { "heuristics/proximity/restart" };
    constexpr Param<bool> USEFINALLP { "heuristics/proximity/usefinallp" };
    constexpr Param<long long> MAXNODES { "heuristics/proximity/maxnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/proximity/nodesofs" };
    constexpr Param<long long> MINNODES { "heuristics/proximity/minnodes" };
    constexpr Param<long long> MAXLPITERS { "heuristics/proximity/maxlpiters" };
    constexpr Param<long long> MINLPITERS { "heuristics/proximity/minlpiters" };
    constexpr Param<long long> WAITINGNODES { "heuristics/proximity/waitingnodes" };
    constexpr Param<double> MINIMPROVE { "heuristics/proximity/minimprove" };
    constexpr Param<double> NODESQUOT { "heuristics/proximity/nodesquot" };
    constexpr Param<double> BINVARQUOT { "heuristics/proximity/binvarquot" };
    constexpr Param<double> LPITERSQUOT { "heuristics/proximity/lpitersquot" };
    constexpr Param<double> MINGAP { "heuristics/proximity/mingap" };
    constexpr Param<bool> USEUCT { "heuristics/proximity/useuct" };
}
namespace HEURISTICS::PSCOSTDIVING {
    constexpr Param<int> PRIORITY { "heuristics/pscostdiving/priority" };
    constexpr Param<int> FREQ { "heuristics/pscostdiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/pscostdiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/pscostdiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/pscostdiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/pscostdiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/pscostdiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/pscostdiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/pscostdiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/pscostdiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/pscostdiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/pscostdiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/pscostdiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/pscostdiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/pscostdiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/pscostdiving/onlylpbranchcands" };
}
namespace HEURISTICS::RANDROUNDING {
    constexpr Param<int> PRIORITY { "heuristics/randrounding/priority" };
    constexpr Param<int> FREQ { "heuristics/randrounding/freq" };
    constexpr Param<int> FREQOFS { "heuristics/randrounding/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/randrounding/maxdepth" };
    constexpr Param<bool> ONCEPERNODE { "heuristics/randrounding/oncepernode" };
    constexpr Param<bool> USESIMPLEROUNDING { "heuristics/randrounding/usesimplerounding" };
    constexpr Param<bool> PROPAGATEONLYROOT { "heuristics/randrounding/propagateonlyroot" };
    constexpr Param<int> MAXPROPROUNDS { "heuristics/randrounding/maxproprounds" };
}
namespace HEURISTICS::RENS {
    constexpr Param<int> PRIORITY { "heuristics/rens/priority" };
    constexpr Param<int> FREQ { "heuristics/rens/freq" };
    constexpr Param<int> FREQOFS { "heuristics/rens/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/rens/maxdepth" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/rens/minfixingrate" };
    constexpr Param<long long> MAXNODES { "heuristics/rens/maxnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/rens/nodesofs" };
    constexpr Param<long long> MINNODES { "heuristics/rens/minnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/rens/nodesquot" };
    constexpr Param<double> MINIMPROVE { "heuristics/rens/minimprove" };
    constexpr Param<double> LPLIMFAC { "heuristics/rens/lplimfac" };
    constexpr Param<char> STARTSOL { "heuristics/rens/startsol" };
    constexpr Param<bool> BINARYBOUNDS { "heuristics/rens/binarybounds" };
    constexpr Param<bool> USELPROWS { "heuristics/rens/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/rens/copycuts" };
    constexpr Param<bool> EXTRATIME { "heuristics/rens/extratime" };
    constexpr Param<bool> ADDALLSOLS { "heuristics/rens/addallsols" };
    constexpr Param<bool> FULLSCALE { "heuristics/rens/fullscale" };
    constexpr Param<int> BESTSOLLIMIT { "heuristics/rens/bestsollimit" };
    constexpr Param<bool> USEUCT { "heuristics/rens/useuct" };
}
namespace HEURISTICS::REOPTSOLS {
    constexpr Param<int> PRIORITY { "heuristics/reoptsols/priority" };
    constexpr Param<int> FREQ { "heuristics/reoptsols/freq" };
    constexpr Param<int> FREQOFS { "heuristics/reoptsols/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/reoptsols/maxdepth" };
    constexpr Param<int> MAXSOLS { "heuristics/reoptsols/maxsols" };
    constexpr Param<int> MAXRUNS { "heuristics/reoptsols/maxruns" };
}
namespace HEURISTICS::REPAIR {
    constexpr Param<int> PRIORITY { "heuristics/repair/priority" };
    constexpr Param<int> FREQ { "heuristics/repair/freq" };
    constexpr Param<int> FREQOFS { "heuristics/repair/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/repair/maxdepth" };
    constexpr Param<std::string> FILENAME { "heuristics/repair/filename" };
    constexpr Param<bool> ROUNDIT { "heuristics/repair/roundit" };
    constexpr Param<bool> USEOBJFACTOR { "heuristics/repair/useobjfactor" };
    constexpr Param<bool> USEVARFIX { "heuristics/repair/usevarfix" };
    constexpr Param<bool> USESLACKVARS { "heuristics/repair/useslackvars" };
    constexpr Param<double> ALPHA { "heuristics/repair/alpha" };
    constexpr Param<int> NODESOFS { "heuristics/repair/nodesofs" };
    constexpr Param<int> MAXNODES { "heuristics/repair/maxnodes" };
    constexpr Param<int> MINNODES { "heuristics/repair/minnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/repair/nodesquot" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/repair/minfixingrate" };
}
namespace HEURISTICS::RINS {
    constexpr Param<int> PRIORITY { "heuristics/rins/priority" };
    constexpr Param<int> FREQ { "heuristics/rins/freq" };
    constexpr Param<int> FREQOFS { "heuristics/rins/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/rins/maxdepth" };
    constexpr Param<int> NODESOFS { "heuristics/rins/nodesofs" };
    constexpr Param<int> MAXNODES { "heuristics/rins/maxnodes" };
    constexpr Param<int> MINNODES { "heuristics/rins/minnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/rins/nodesquot" };
    constexpr Param<int> NWAITINGNODES { "heuristics/rins/nwaitingnodes" };
    constexpr Param<double> MINIMPROVE { "heuristics/rins/minimprove" };
    constexpr Param<double> MINFIXINGRATE { "heuristics/rins/minfixingrate" };
    constexpr Param<double> LPLIMFAC { "heuristics/rins/lplimfac" };
    constexpr Param<bool> USELPROWS { "heuristics/rins/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/rins/copycuts" };
    constexpr Param<bool> USEUCT { "heuristics/rins/useuct" };
}
namespace HEURISTICS::ROOTSOLDIVING {
    constexpr Param<int> PRIORITY { "heuristics/rootsoldiving/priority" };
    constexpr Param<int> FREQ { "heuristics/rootsoldiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/rootsoldiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/rootsoldiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/rootsoldiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/rootsoldiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/rootsoldiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/rootsoldiving/maxlpiterofs" };
    constexpr Param<int> MAXSOLS { "heuristics/rootsoldiving/maxsols" };
    constexpr Param<double> DEPTHFAC { "heuristics/rootsoldiving/depthfac" };
    constexpr Param<double> DEPTHFACNOSOL { "heuristics/rootsoldiving/depthfacnosol" };
    constexpr Param<double> ALPHA { "heuristics/rootsoldiving/alpha" };
}
namespace HEURISTICS::ROUNDING {
    constexpr Param<int> PRIORITY { "heuristics/rounding/priority" };
    constexpr Param<int> FREQ { "heuristics/rounding/freq" };
    constexpr Param<int> FREQOFS { "heuristics/rounding/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/rounding/maxdepth" };
    constexpr Param<int> SUCCESSFACTOR { "heuristics/rounding/successfactor" };
    constexpr Param<bool> ONCEPERNODE { "heuristics/rounding/oncepernode" };
}
namespace HEURISTICS::SHIFTANDPROPAGATE {
    constexpr Param<int> PRIORITY { "heuristics/shiftandpropagate/priority" };
    constexpr Param<int> FREQ { "heuristics/shiftandpropagate/freq" };
    constexpr Param<int> FREQOFS { "heuristics/shiftandpropagate/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/shiftandpropagate/maxdepth" };
    constexpr Param<int> NPROPROUNDS { "heuristics/shiftandpropagate/nproprounds" };
    constexpr Param<bool> RELAX { "heuristics/shiftandpropagate/relax" };
    constexpr Param<bool> PROBING { "heuristics/shiftandpropagate/probing" };
    constexpr Param<bool> ONLYWITHOUTSOL { "heuristics/shiftandpropagate/onlywithoutsol" };
    constexpr Param<int> CUTOFFBREAKER { "heuristics/shiftandpropagate/cutoffbreaker" };
    constexpr Param<char> SORTKEY { "heuristics/shiftandpropagate/sortkey" };
    constexpr Param<bool> SORTVARS { "heuristics/shiftandpropagate/sortvars" };
    constexpr Param<bool> COLLECTSTATS { "heuristics/shiftandpropagate/collectstats" };
    constexpr Param<bool> STOPAFTERFEASIBLE { "heuristics/shiftandpropagate/stopafterfeasible" };
    constexpr Param<bool> PREFERBINARIES { "heuristics/shiftandpropagate/preferbinaries" };
    constexpr Param<bool> NOZEROFIXING { "heuristics/shiftandpropagate/nozerofixing" };
    constexpr Param<bool> FIXBINLOCKS { "heuristics/shiftandpropagate/fixbinlocks" };
    constexpr Param<bool> BINLOCKSFIRST { "heuristics/shiftandpropagate/binlocksfirst" };
    constexpr Param<bool> NORMALIZE { "heuristics/shiftandpropagate/normalize" };
    constexpr Param<bool> UPDATEWEIGHTS { "heuristics/shiftandpropagate/updateweights" };
    constexpr Param<bool> IMPLISCONTINUOUS { "heuristics/shiftandpropagate/impliscontinuous" };
    constexpr Param<bool> SELECTBEST { "heuristics/shiftandpropagate/selectbest" };
    constexpr Param<double> MAXCUTOFFQUOT { "heuristics/shiftandpropagate/maxcutoffquot" };
    constexpr Param<double> MINFIXINGRATELP { "heuristics/shiftandpropagate/minfixingratelp" };
}
namespace HEURISTICS::SHIFTING {
    constexpr Param<int> PRIORITY { "heuristics/shifting/priority" };
    constexpr Param<int> FREQ { "heuristics/shifting/freq" };
    constexpr Param<int> FREQOFS { "heuristics/shifting/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/shifting/maxdepth" };
}
namespace HEURISTICS::SIMPLEROUNDING {
    constexpr Param<int> PRIORITY { "heuristics/simplerounding/priority" };
    constexpr Param<int> FREQ { "heuristics/simplerounding/freq" };
    constexpr Param<int> FREQOFS { "heuristics/simplerounding/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/simplerounding/maxdepth" };
    constexpr Param<bool> ONCEPERNODE { "heuristics/simplerounding/oncepernode" };
}
namespace HEURISTICS::SUBNLP {
    constexpr Param<int> PRIORITY { "heuristics/subnlp/priority" };
    constexpr Param<int> FREQ { "heuristics/subnlp/freq" };
    constexpr Param<int> FREQOFS { "heuristics/subnlp/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/subnlp/maxdepth" };
    constexpr Param<int> NLPVERBLEVEL { "heuristics/subnlp/nlpverblevel" };
    constexpr Param<int> NODESOFFSET { "heuristics/subnlp/nodesoffset" };
    constexpr Param<double> NODESFACTOR { "heuristics/subnlp/nodesfactor" };
    constexpr Param<double> SUCCESSRATEEXP { "heuristics/subnlp/successrateexp" };
    constexpr Param<int> ITERINIT { "heuristics/subnlp/iterinit" };
    constexpr Param<int> NINITSOLVES { "heuristics/subnlp/ninitsolves" };
    constexpr Param<int> ITERMIN { "heuristics/subnlp/itermin" };
    constexpr Param<double> OPTTOL { "heuristics/subnlp/opttol" };
    constexpr Param<double> FEASTOLFACTOR { "heuristics/subnlp/feastolfactor" };
    constexpr Param<int> MAXPRESOLVEROUNDS { "heuristics/subnlp/maxpresolverounds" };
    constexpr Param<int> PRESOLVEEMPHASIS { "heuristics/subnlp/presolveemphasis" };
    constexpr Param<bool> SETCUTOFF { "heuristics/subnlp/setcutoff" };
    constexpr Param<bool> FORBIDFIXINGS { "heuristics/subnlp/forbidfixings" };
    constexpr Param<bool> KEEPCOPY { "heuristics/subnlp/keepcopy" };
    constexpr Param<double> EXPECTINFEAS { "heuristics/subnlp/expectinfeas" };
}
namespace HEURISTICS::TRIVIAL {
    constexpr Param<int> PRIORITY { "heuristics/trivial/priority" };
    constexpr Param<int> FREQ { "heuristics/trivial/freq" };
    constexpr Param<int> FREQOFS { "heuristics/trivial/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/trivial/maxdepth" };
}
namespace HEURISTICS::TRIVIALNEGATION {
    constexpr Param<int> PRIORITY { "heuristics/trivialnegation/priority" };
    constexpr Param<int> FREQ { "heuristics/trivialnegation/freq" };
    constexpr Param<int> FREQOFS { "heuristics/trivialnegation/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/trivialnegation/maxdepth" };
}
namespace HEURISTICS::TRUSTREGION {
    constexpr Param<int> PRIORITY { "heuristics/trustregion/priority" };
    constexpr Param<int> FREQ { "heuristics/trustregion/freq" };
    constexpr Param<int> FREQOFS { "heuristics/trustregion/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/trustregion/maxdepth" };
    constexpr Param<int> NODESOFS { "heuristics/trustregion/nodesofs" };
    constexpr Param<int> MINBINVARS { "heuristics/trustregion/minbinvars" };
    constexpr Param<double> NODESQUOT { "heuristics/trustregion/nodesquot" };
    constexpr Param<double> LPLIMFAC { "heuristics/trustregion/lplimfac" };
    constexpr Param<int> MINNODES { "heuristics/trustregion/minnodes" };
    constexpr Param<int> MAXNODES { "heuristics/trustregion/maxnodes" };
    constexpr Param<int> NWAITINGNODES { "heuristics/trustregion/nwaitingnodes" };
    constexpr Param<bool> USELPROWS { "heuristics/trustregion/uselprows" };
    constexpr Param<bool> COPYCUTS { "heuristics/trustregion/copycuts" };
    constexpr Param<int> BESTSOLLIMIT { "heuristics/trustregion/bestsollimit" };
    constexpr Param<double> VIOLPENALTY { "heuristics/trustregion/violpenalty" };
    constexpr Param<double> OBJMINIMPROVE { "heuristics/trustregion/objminimprove" };
}
namespace HEURISTICS::TRYSOL {
    constexpr Param<int> PRIORITY { "heuristics/trysol/priority" };
    constexpr Param<int> FREQ { "heuristics/trysol/freq" };
    constexpr Param<int> FREQOFS { "heuristics/trysol/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/trysol/maxdepth" };
}
namespace HEURISTICS::TWOOPT {
    constexpr Param<int> PRIORITY { "heuristics/twoopt/priority" };
    constexpr Param<int> FREQ { "heuristics/twoopt/freq" };
    constexpr Param<int> FREQOFS { "heuristics/twoopt/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/twoopt/maxdepth" };
    constexpr Param<bool> INTOPT { "heuristics/twoopt/intopt" };
    constexpr Param<int> WAITINGNODES { "heuristics/twoopt/waitingnodes" };
    constexpr Param<int> MAXNSLAVES { "heuristics/twoopt/maxnslaves" };
    constexpr Param<double> MATCHINGRATE { "heuristics/twoopt/matchingrate" };
}
namespace HEURISTICS::UNDERCOVER {
    constexpr Param<int> PRIORITY { "heuristics/undercover/priority" };
    constexpr Param<int> FREQ { "heuristics/undercover/freq" };
    constexpr Param<int> FREQOFS { "heuristics/undercover/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/undercover/maxdepth" };
    constexpr Param<std::string> FIXINGALTS { "heuristics/undercover/fixingalts" };
    constexpr Param<long long> MAXNODES { "heuristics/undercover/maxnodes" };
    constexpr Param<long long> MINNODES { "heuristics/undercover/minnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/undercover/nodesofs" };
    constexpr Param<double> CONFLICTWEIGHT { "heuristics/undercover/conflictweight" };
    constexpr Param<double> CUTOFFWEIGHT { "heuristics/undercover/cutoffweight" };
    constexpr Param<double> INFERENCEWEIGHT { "heuristics/undercover/inferenceweight" };
    constexpr Param<double> MAXCOVERSIZEVARS { "heuristics/undercover/maxcoversizevars" };
    constexpr Param<double> MAXCOVERSIZECONSS { "heuristics/undercover/maxcoversizeconss" };
    constexpr Param<double> MINCOVEREDREL { "heuristics/undercover/mincoveredrel" };
    constexpr Param<double> MINIMPROVE { "heuristics/undercover/minimprove" };
    constexpr Param<double> NODESQUOT { "heuristics/undercover/nodesquot" };
    constexpr Param<double> RECOVERDIV { "heuristics/undercover/recoverdiv" };
    constexpr Param<int> MINCOVEREDABS { "heuristics/undercover/mincoveredabs" };
    constexpr Param<int> MAXBACKTRACKS { "heuristics/undercover/maxbacktracks" };
    constexpr Param<int> MAXRECOVERS { "heuristics/undercover/maxrecovers" };
    constexpr Param<int> MAXREORDERS { "heuristics/undercover/maxreorders" };
    constexpr Param<char> COVERINGOBJ { "heuristics/undercover/coveringobj" };
    constexpr Param<char> FIXINGORDER { "heuristics/undercover/fixingorder" };
    constexpr Param<bool> BEFORECUTS { "heuristics/undercover/beforecuts" };
    constexpr Param<bool> FIXINTFIRST { "heuristics/undercover/fixintfirst" };
    constexpr Param<bool> LOCKSROUNDING { "heuristics/undercover/locksrounding" };
    constexpr Param<bool> ONLYCONVEXIFY { "heuristics/undercover/onlyconvexify" };
    constexpr Param<bool> POSTNLP { "heuristics/undercover/postnlp" };
    constexpr Param<bool> COVERBD { "heuristics/undercover/coverbd" };
    constexpr Param<bool> COPYCUTS { "heuristics/undercover/copycuts" };
    constexpr Param<bool> REUSECOVER { "heuristics/undercover/reusecover" };
}
namespace HEURISTICS::VBOUNDS {
    constexpr Param<int> PRIORITY { "heuristics/vbounds/priority" };
    constexpr Param<int> FREQ { "heuristics/vbounds/freq" };
    constexpr Param<int> FREQOFS { "heuristics/vbounds/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/vbounds/maxdepth" };
    constexpr Param<double> MININTFIXINGRATE { "heuristics/vbounds/minintfixingrate" };
    constexpr Param<double> MINMIPFIXINGRATE { "heuristics/vbounds/minmipfixingrate" };
    constexpr Param<long long> MAXNODES { "heuristics/vbounds/maxnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/vbounds/nodesofs" };
    constexpr Param<long long> MINNODES { "heuristics/vbounds/minnodes" };
    constexpr Param<double> NODESQUOT { "heuristics/vbounds/nodesquot" };
    constexpr Param<double> MINIMPROVE { "heuristics/vbounds/minimprove" };
    constexpr Param<int> MAXPROPROUNDS { "heuristics/vbounds/maxproprounds" };
    constexpr Param<bool> COPYCUTS { "heuristics/vbounds/copycuts" };
    constexpr Param<bool> USELOCKFIXINGS { "heuristics/vbounds/uselockfixings" };
    constexpr Param<int> MAXBACKTRACKS { "heuristics/vbounds/maxbacktracks" };
    constexpr Param<int> FEASVARIANT { "heuristics/vbounds/feasvariant" };
    constexpr Param<int> TIGHTENVARIANT { "heuristics/vbounds/tightenvariant" };
}
namespace HEURISTICS::VECLENDIVING {
    constexpr Param<int> PRIORITY { "heuristics/veclendiving/priority" };
    constexpr Param<int> FREQ { "heuristics/veclendiving/freq" };
    constexpr Param<int> FREQOFS { "heuristics/veclendiving/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/veclendiving/maxdepth" };
    constexpr Param<double> MINRELDEPTH { "heuristics/veclendiving/minreldepth" };
    constexpr Param<double> MAXRELDEPTH { "heuristics/veclendiving/maxreldepth" };
    constexpr Param<double> MAXLPITERQUOT { "heuristics/veclendiving/maxlpiterquot" };
    constexpr Param<int> MAXLPITEROFS { "heuristics/veclendiving/maxlpiterofs" };
    constexpr Param<double> MAXDIVEUBQUOT { "heuristics/veclendiving/maxdiveubquot" };
    constexpr Param<double> MAXDIVEAVGQUOT { "heuristics/veclendiving/maxdiveavgquot" };
    constexpr Param<double> MAXDIVEUBQUOTNOSOL { "heuristics/veclendiving/maxdiveubquotnosol" };
    constexpr Param<double> MAXDIVEAVGQUOTNOSOL { "heuristics/veclendiving/maxdiveavgquotnosol" };
    constexpr Param<bool> BACKTRACK { "heuristics/veclendiving/backtrack" };
    constexpr Param<double> LPRESOLVEDOMCHGQUOT { "heuristics/veclendiving/lpresolvedomchgquot" };
    constexpr Param<int> LPSOLVEFREQ { "heuristics/veclendiving/lpsolvefreq" };
    constexpr Param<bool> ONLYLPBRANCHCANDS { "heuristics/veclendiving/onlylpbranchcands" };
}
namespace HEURISTICS::ZEROOBJ {
    constexpr Param<int> PRIORITY { "heuristics/zeroobj/priority" };
    constexpr Param<int> FREQ { "heuristics/zeroobj/freq" };
    constexpr Param<int> FREQOFS { "heuristics/zeroobj/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/zeroobj/maxdepth" };
    constexpr Param<long long> MAXNODES { "heuristics/zeroobj/maxnodes" };
    constexpr Param<long long> NODESOFS { "heuristics/zeroobj/nodesofs" };
    constexpr Param<long long> MINNODES { "heuristics/zeroobj/minnodes" };
    constexpr Param<long long> MAXLPITERS { "heuristics/zeroobj/maxlpiters" };
    constexpr Param<double> NODESQUOT { "heuristics/zeroobj/nodesquot" };
    constexpr Param<double> MINIMPROVE { "heuristics/zeroobj/minimprove" };
    constexpr Param<bool> ADDALLSOLS { "heuristics/zeroobj/addallsols" };
    constexpr Param<bool> ONLYWITHOUTSOL { "heuristics/zeroobj/onlywithoutsol" };
    constexpr Param<bool> USEUCT { "heuristics/zeroobj/useuct" };
}
namespace HEURISTICS::ZIROUNDING {
    constexpr Param<int> PRIORITY { "heuristics/zirounding/priority" };
    constexpr Param<int> FREQ { "heuristics/zirounding/freq" };
    constexpr Param<int> FREQOFS { "heuristics/zirounding/freqofs" };
    constexpr Param<int> MAXDEPTH { "heuristics/zirounding/maxdepth" };
    constexpr Param<int> MAXROUNDINGLOOPS { "heuristics/zirounding/maxroundingloops" };
    constexpr Param<bool> STOPZIROUND { "heuristics/zirounding/stopziround" };
    constexpr Param<double> STOPPERCENTAGE { "heuristics/zirounding/stoppercentage" };
    constexpr Param<int> MINSTOPNCALLS { "heuristics/zirounding/minstopncalls" };
}
namespace HISTORY {
    constexpr Param<bool> VALUEBASED { "history/valuebased" };
    constexpr Param<bool> ALLOWMERGE { "history/allowmerge" };
    constexpr Param<bool> ALLOWTRANSFER { "history/allowtransfer" };
}
namespace LIMITS {
    constexpr Param<double> TIME { "limits/time" };
    constexpr Param<long long> NODES { "limits/nodes" };
    constexpr Param<long long> TOTALNODES { "limits/totalnodes" };
    constexpr Param<long long> STALLNODES { "limits/stallnodes" };
    constexpr Param<double> MEMORY { "limits/memory" };
    constexpr Param<double> GAP { "limits/gap" };
    constexpr Param<double> ABSGAP { "limits/absgap" };
    constexpr Param<int> SOLUTIONS { "limits/solutions" };
    constexpr Param<int> BESTSOL { "limits/bestsol" };
    constexpr Param<int> MAXSOL { "limits/maxsol" };
    constexpr Param<int> MAXORIGSOL { "limits/maxorigsol" };
    constexpr Param<int> RESTARTS { "limits/restarts" };
    constexpr Param<int> AUTORESTARTNODES { "limits/autorestartnodes" };
    constexpr Param<double> SOFTTIME { "limits/softtime" };
}
namespace LP {
    constexpr Param<int> SOLVEFREQ { "lp/solvefreq" };
    constexpr Param<long long> ITERLIM { "lp/iterlim" };
    constexpr Param<long long> ROOTITERLIM { "lp/rootiterlim" };
    constexpr Param<int> SOLVEDEPTH { "lp/solvedepth" };
    constexpr Param<char> INITALGORITHM { "lp/initalgorithm" };
    constexpr Param<char> RESOLVEALGORITHM { "lp/resolvealgorithm" };
    constexpr Param<char> PRICING { "lp/pricing" };
    constexpr Param<bool> CLEARINITIALPROBINGLP { "lp/clearinitialprobinglp" };
    constexpr Param<bool> RESOLVERESTORE { "lp/resolverestore" };
    constexpr Param<bool> FREESOLVALBUFFERS { "lp/freesolvalbuffers" };
    constexpr Param<int> COLAGELIMIT { "lp/colagelimit" };
    constexpr Param<int> ROWAGELIMIT { "lp/rowagelimit" };
    constexpr Param<bool> CLEANUPCOLS { "lp/cleanupcols" };
    constexpr Param<bool> CLEANUPCOLSROOT { "lp/cleanupcolsroot" };
    constexpr Param<bool> CLEANUPROWS { "lp/cleanuprows" };
    constexpr Param<bool> CLEANUPROWSROOT { "lp/cleanuprowsroot" };
    constexpr Param<bool> CHECKSTABILITY { "lp/checkstability" };
    constexpr Param<double> CONDITIONLIMIT { "lp/conditionlimit" };
    constexpr Param<double> MINMARKOWITZ { "lp/minmarkowitz" };
    constexpr Param<bool> CHECKPRIMFEAS { "lp/checkprimfeas" };
    constexpr Param<bool> CHECKDUALFEAS { "lp/checkdualfeas" };
    constexpr Param<bool> CHECKFARKAS { "lp/checkfarkas" };
    constexpr Param<int> FASTMIP { "lp/fastmip" };
    constexpr Param<int> SCALING { "lp/scaling" };
    constexpr Param<bool> PRESOLVING { "lp/presolving" };
    constexpr Param<bool> LEXDUALALGO { "lp/lexdualalgo" };
    constexpr Param<bool> LEXDUALROOTONLY { "lp/lexdualrootonly" };
    constexpr Param<int> LEXDUALMAXROUNDS { "lp/lexdualmaxrounds" };
    constexpr Param<bool> LEXDUALBASIC { "lp/lexdualbasic" };
    constexpr Param<bool> LEXDUALSTALLING { "lp/lexdualstalling" };
    constexpr Param<int> DISABLECUTOFF { "lp/disablecutoff" };
    constexpr Param<double> ROWREPSWITCH { "lp/rowrepswitch" };
    constexpr Param<int> THREADS { "lp/threads" };
    constexpr Param<double> RESOLVEITERFAC { "lp/resolveiterfac" };
    constexpr Param<int> RESOLVEITERMIN { "lp/resolveitermin" };
    constexpr Param<int> SOLUTIONPOLISHING { "lp/solutionpolishing" };
    constexpr Param<int> REFACTORINTERVAL { "lp/refactorinterval" };
    constexpr Param<bool> ALWAYSGETDUALS { "lp/alwaysgetduals" };
}
namespace MEMORY {
    constexpr Param<double> SAVEFAC { "memory/savefac" };
    constexpr Param<double> ARRAYGROWFAC { "memory/arraygrowfac" };
    constexpr Param<int> ARRAYGROWINIT { "memory/arraygrowinit" };
    constexpr Param<double> TREEGROWFAC { "memory/treegrowfac" };
    constexpr Param<int> TREEGROWINIT { "memory/treegrowinit" };
    constexpr Param<double> PATHGROWFAC { "memory/pathgrowfac" };
    constexpr Param<int> PATHGROWINIT { "memory/pathgrowinit" };
}
namespace MISC {
    constexpr Param<bool> CATCHCTRLC { "misc/catchctrlc" };
    constexpr Param<bool> USEVARTABLE { "misc/usevartable" };
    constexpr Param<bool> USECONSTABLE { "misc/useconstable" };
    constexpr Param<bool> USESMALLTABLES { "misc/usesmalltables" };
    constexpr Param<bool> RESETSTAT { "misc/resetstat" };
    constexpr Param<bool> IMPROVINGSOLS { "misc/improvingsols" };
    constexpr Param<bool> PRINTREASON { "misc/printreason" };
    constexpr Param<bool> ESTIMEXTERNMEM { "misc/estimexternmem" };
    constexpr Param<bool> AVOIDMEMOUT { "misc/avoidmemout" };
    constexpr Param<bool> TRANSORIGSOLS { "misc/transorigsols" };
    constexpr Param<bool> TRANSSOLSORIG { "misc/transsolsorig" };
    constexpr Param<bool> CALCINTEGRAL { "misc/calcintegral" };
    constexpr Param<bool> FINITESOLUTIONSTORE { "misc/finitesolutionstore" };
    constexpr Param<bool> OUTPUTORIGSOL { "misc/outputorigsol" };
    constexpr Param<bool> ALLOWSTRONGDUALREDS { "misc/allowstrongdualreds" };
    constexpr Param<bool> ALLOWWEAKDUALREDS { "misc/allowweakdualreds" };
    constexpr Param<bool> SCALEOBJ { "misc/scaleobj" };
    constexpr Param<bool> SHOWDIVINGSTATS { "misc/showdivingstats" };
    constexpr Param<double> REFERENCEVALUE { "misc/referencevalue" };
    constexpr Param<int> USESYMMETRY { "misc/usesymmetry" };
}
namespace NLHDLR::BILINEAR {
    constexpr Param<bool> ENABLED { "nlhdlr/bilinear/enabled" };
    constexpr Param<bool> USEINTEVAL { "nlhdlr/bilinear/useinteval" };
    constexpr Param<bool> USEREVERSEPROP { "nlhdlr/bilinear/usereverseprop" };
    constexpr Param<int> MAXSEPAROUNDSROOT { "nlhdlr/bilinear/maxseparoundsroot" };
    constexpr Param<int> MAXSEPAROUNDS { "nlhdlr/bilinear/maxseparounds" };
    constexpr Param<int> MAXSEPADEPTH { "nlhdlr/bilinear/maxsepadepth" };
}
namespace NLHDLR::CONCAVE {
    constexpr Param<bool> ENABLED { "nlhdlr/concave/enabled" };
    constexpr Param<bool> DETECTSUM { "nlhdlr/concave/detectsum" };
    constexpr Param<bool> CVXQUADRATIC { "nlhdlr/concave/cvxquadratic" };
    constexpr Param<bool> CVXSIGNOMIAL { "nlhdlr/concave/cvxsignomial" };
    constexpr Param<bool> CVXPRODCOMP { "nlhdlr/concave/cvxprodcomp" };
    constexpr Param<bool> HANDLETRIVIAL { "nlhdlr/concave/handletrivial" };
}
namespace NLHDLR::CONVEX {
    constexpr Param<bool> ENABLED { "nlhdlr/convex/enabled" };
    constexpr Param<bool> DETECTSUM { "nlhdlr/convex/detectsum" };
    constexpr Param<bool> EXTENDEDFORM { "nlhdlr/convex/extendedform" };
    constexpr Param<bool> CVXQUADRATIC { "nlhdlr/convex/cvxquadratic" };
    constexpr Param<bool> CVXSIGNOMIAL { "nlhdlr/convex/cvxsignomial" };
    constexpr Param<bool> CVXPRODCOMP { "nlhdlr/convex/cvxprodcomp" };
    constexpr Param<bool> HANDLETRIVIAL { "nlhdlr/convex/handletrivial" };
}
namespace NLHDLR::DEFAULT {
    constexpr Param<bool> ENABLED { "nlhdlr/default/enabled" };
}
namespace NLHDLR::PERSPECTIVE {
    constexpr Param<bool> ENABLED { "nlhdlr/perspective/enabled" };
    constexpr Param<int> MAXPROPROUNDS { "nlhdlr/perspective/maxproprounds" };
    constexpr Param<double> MINDOMREDUCTION { "nlhdlr/perspective/mindomreduction" };
    constexpr Param<double> MINVIOLPROBING { "nlhdlr/perspective/minviolprobing" };
    constexpr Param<bool> PROBINGONLYINSEPA { "nlhdlr/perspective/probingonlyinsepa" };
    constexpr Param<int> PROBINGFREQ { "nlhdlr/perspective/probingfreq" };
    constexpr Param<bool> CONVEXONLY { "nlhdlr/perspective/convexonly" };
    constexpr Param<bool> TIGHTENBOUNDS { "nlhdlr/perspective/tightenbounds" };
    constexpr Param<bool> ADJREFPOINT { "nlhdlr/perspective/adjrefpoint" };
}
namespace NLHDLR::QUADRATIC {
    constexpr Param<bool> ENABLED { "nlhdlr/quadratic/enabled" };
    constexpr Param<bool> USEINTERSECTIONCUTS { "nlhdlr/quadratic/useintersectioncuts" };
    constexpr Param<bool> USESTRENGTHENING { "nlhdlr/quadratic/usestrengthening" };
    constexpr Param<bool> USEBOUNDSASRAYS { "nlhdlr/quadratic/useboundsasrays" };
    constexpr Param<int> NCUTSLIMIT { "nlhdlr/quadratic/ncutslimit" };
    constexpr Param<int> NCUTSLIMITROOT { "nlhdlr/quadratic/ncutslimitroot" };
    constexpr Param<int> MAXRANK { "nlhdlr/quadratic/maxrank" };
    constexpr Param<double> MINCUTVIOLATION { "nlhdlr/quadratic/mincutviolation" };
    constexpr Param<double> MINVIOLATION { "nlhdlr/quadratic/minviolation" };
    constexpr Param<int> ATWHICHNODES { "nlhdlr/quadratic/atwhichnodes" };
    constexpr Param<int> NSTRENGTHLIMIT { "nlhdlr/quadratic/nstrengthlimit" };
    constexpr Param<bool> IGNOREBADRAYRESTRICTION { "nlhdlr/quadratic/ignorebadrayrestriction" };
    constexpr Param<bool> IGNORENHIGHRE { "nlhdlr/quadratic/ignorenhighre" };
}
namespace NLHDLR::QUOTIENT {
    constexpr Param<bool> ENABLED { "nlhdlr/quotient/enabled" };
}
namespace NLHDLR::SOC {
    constexpr Param<bool> ENABLED { "nlhdlr/soc/enabled" };
    constexpr Param<double> MINCUTEFFICACY { "nlhdlr/soc/mincutefficacy" };
    constexpr Param<bool> COMPEIGENVALUES { "nlhdlr/soc/compeigenvalues" };
}
namespace NLP {
    constexpr Param<std::string> SOLVER { "nlp/solver" };
    constexpr Param<bool> DISABLE { "nlp/disable" };
}
namespace NODESELECTION {
    constexpr Param<char> CHILDSEL { "nodeselection/childsel" };
}
namespace NODESELECTION::BFS {
    constexpr Param<int> STDPRIORITY { "nodeselection/bfs/stdpriority" };
    constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/bfs/memsavepriority" };
    constexpr Param<int> MINPLUNGEDEPTH { "nodeselection/bfs/minplungedepth" };
    constexpr Param<int> MAXPLUNGEDEPTH { "nodeselection/bfs/maxplungedepth" };
    constexpr Param<double> MAXPLUNGEQUOT { "nodeselection/bfs/maxplungequot" };
}
namespace NODESELECTION::BREADTHFIRST {
    constexpr Param<int> STDPRIORITY { "nodeselection/breadthfirst/stdpriority" };
    constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/breadthfirst/memsavepriority" };
}
namespace NODESELECTION::DFS {
    constexpr Param<int> STDPRIORITY { "nodeselection/dfs/stdpriority" };
    constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/dfs/memsavepriority" };
}
namespace NODESELECTION::ESTIMATE {
    constexpr Param<int> STDPRIORITY { "nodeselection/estimate/stdpriority" };
    constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/estimate/memsavepriority" };
    constexpr Param<int> MINPLUNGEDEPTH { "nodeselection/estimate/minplungedepth" };
    constexpr Param<int> MAXPLUNGEDEPTH { "nodeselection/estimate/maxplungedepth" };
    constexpr Param<double> MAXPLUNGEQUOT { "nodeselection/estimate/maxplungequot" };
    constexpr Param<int> BESTNODEFREQ { "nodeselection/estimate/bestnodefreq" };
    constexpr Param<int> BREADTHFIRSTDEPTH { "nodeselection/estimate/breadthfirstdepth" };
    constexpr Param<int> PLUNGEOFFSET { "nodeselection/estimate/plungeoffset" };
}
namespace NODESELECTION::HYBRIDESTIM {
    constexpr Param<int> STDPRIORITY { "nodeselection/hybridestim/stdpriority" };
    constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/hybridestim/memsavepriority" };
    constexpr Param<int> MINPLUNGEDEPTH { "nodeselection/hybridestim/minplungedepth" };
    constexpr Param<int> MAXPLUNGEDEPTH { "nodeselection/hybridestim/maxplungedepth" };
    constexpr Param<double> MAXPLUNGEQUOT { "nodeselection/hybridestim/maxplungequot" };
    constexpr Param<int> BESTNODEFREQ { "nodeselection/hybridestim/bestnodefreq" };
    constexpr Param<double> ESTIMWEIGHT { "nodeselection/hybridestim/estimweight" };
}
namespace NODESELECTION::RESTARTDFS {
    constexpr Param<int> STDPRIORITY { "nodeselection/restartdfs/stdpriority" };
    constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/restartdfs/memsavepriority" };
    constexpr Param<int> SELECTBESTFREQ { "nodeselection/restartdfs/selectbestfreq" };
    constexpr Param<bool> COUNTONLYLEAVES { "nodeselection/restartdfs/countonlyleaves" };
}
namespace NODESELECTION::UCT {
    constexpr Param<int> STDPRIORITY { "nodeselection/uct/stdpriority" };
    constexpr Param<int> MEMSAVEPRIORITY { "nodeselection/uct/memsavepriority" };
    constexpr Param<int> NODELIMIT { "nodeselection/uct/nodelimit" };
    constexpr Param<double> WEIGHT { "nodeselection/uct/weight" };
    constexpr Param<bool> USEESTIMATE { "nodeselection/uct/useestimate" };
}
namespace NUMERICS {
    constexpr Param<double> INFINITY { "numerics/infinity" };
    constexpr Param<double> EPSILON { "numerics/epsilon" };
    constexpr Param<double> SUMEPSILON { "numerics/sumepsilon" };
    constexpr Param<double> FEASTOL { "numerics/feastol" };
    constexpr Param<double> CHECKFEASTOLFAC { "numerics/checkfeastolfac" };
    constexpr Param<double> LPFEASTOLFACTOR { "numerics/lpfeastolfactor" };
    constexpr Param<double> DUALFEASTOL { "numerics/dualfeastol" };
    constexpr Param<double> BARRIERCONVTOL { "numerics/barrierconvtol" };
    constexpr Param<double> BOUNDSTREPS { "numerics/boundstreps" };
    constexpr Param<double> PSEUDOCOSTEPS { "numerics/pseudocosteps" };
    constexpr Param<double> PSEUDOCOSTDELTA { "numerics/pseudocostdelta" };
    constexpr Param<double> RECOMPUTEFAC { "numerics/recomputefac" };
    constexpr Param<double> HUGEVAL { "numerics/hugeval" };
}
namespace PARALLEL {
    constexpr Param<int> MODE { "parallel/mode" };
    constexpr Param<int> MINNTHREADS { "parallel/minnthreads" };
    constexpr Param<int> MAXNTHREADS { "parallel/maxnthreads" };
}
namespace PRESOLVING {
    constexpr Param<int> MAXROUNDS { "presolving/maxrounds" };
    constexpr Param<double> ABORTFAC { "presolving/abortfac" };
    constexpr Param<int> MAXRESTARTS { "presolving/maxrestarts" };
    constexpr Param<double> RESTARTFAC { "presolving/restartfac" };
    constexpr Param<double> CLQTABLEFAC { "presolving/clqtablefac" };
    constexpr Param<double> IMMRESTARTFAC { "presolving/immrestartfac" };
    constexpr Param<double> SUBRESTARTFAC { "presolving/subrestartfac" };
    constexpr Param<double> RESTARTMINRED { "presolving/restartminred" };
    constexpr Param<bool> DONOTMULTAGGR { "presolving/donotmultaggr" };
    constexpr Param<bool> DONOTAGGR { "presolving/donotaggr" };
}
namespace PRESOLVING::BOUNDSHIFT {
    constexpr Param<int> PRIORITY { "presolving/boundshift/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/boundshift/maxrounds" };
    constexpr Param<int> TIMING { "presolving/boundshift/timing" };
    constexpr Param<long long> MAXSHIFT { "presolving/boundshift/maxshift" };
    constexpr Param<bool> FLIPPING { "presolving/boundshift/flipping" };
    constexpr Param<bool> INTEGER { "presolving/boundshift/integer" };
}
namespace PRESOLVING::CONVERTINTTOBIN {
    constexpr Param<int> PRIORITY { "presolving/convertinttobin/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/convertinttobin/maxrounds" };
    constexpr Param<int> TIMING { "presolving/convertinttobin/timing" };
    constexpr Param<long long> MAXDOMAINSIZE { "presolving/convertinttobin/maxdomainsize" };
    constexpr Param<bool> ONLYPOWEROFTWO { "presolving/convertinttobin/onlypoweroftwo" };
    constexpr Param<bool> SAMELOCKSINBOTHDIRECTIONS { "presolving/convertinttobin/samelocksinbothdirections" };
}
namespace PRESOLVING::DOMCOL {
    constexpr Param<int> PRIORITY { "presolving/domcol/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/domcol/maxrounds" };
    constexpr Param<int> TIMING { "presolving/domcol/timing" };
    constexpr Param<int> NUMMINPAIRS { "presolving/domcol/numminpairs" };
    constexpr Param<int> NUMMAXPAIRS { "presolving/domcol/nummaxpairs" };
    constexpr Param<bool> PREDBNDSTR { "presolving/domcol/predbndstr" };
    constexpr Param<bool> CONTINUOUSRED { "presolving/domcol/continuousred" };
}
namespace PRESOLVING::DUALAGG {
    constexpr Param<int> PRIORITY { "presolving/dualagg/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/dualagg/maxrounds" };
    constexpr Param<int> TIMING { "presolving/dualagg/timing" };
}
namespace PRESOLVING::DUALCOMP {
    constexpr Param<int> PRIORITY { "presolving/dualcomp/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/dualcomp/maxrounds" };
    constexpr Param<int> TIMING { "presolving/dualcomp/timing" };
    constexpr Param<bool> COMPONLYDISVARS { "presolving/dualcomp/componlydisvars" };
}
namespace PRESOLVING::DUALINFER {
    constexpr Param<int> PRIORITY { "presolving/dualinfer/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/dualinfer/maxrounds" };
    constexpr Param<int> TIMING { "presolving/dualinfer/timing" };
    constexpr Param<bool> TWOCOLCOMBINE { "presolving/dualinfer/twocolcombine" };
    constexpr Param<int> MAXDUALBNDLOOPS { "presolving/dualinfer/maxdualbndloops" };
    constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/dualinfer/maxconsiderednonzeros" };
    constexpr Param<int> MAXRETRIEVEFAILS { "presolving/dualinfer/maxretrievefails" };
    constexpr Param<int> MAXCOMBINEFAILS { "presolving/dualinfer/maxcombinefails" };
    constexpr Param<int> MAXHASHFAC { "presolving/dualinfer/maxhashfac" };
    constexpr Param<int> MAXPAIRFAC { "presolving/dualinfer/maxpairfac" };
    constexpr Param<int> MAXROWSUPPORT { "presolving/dualinfer/maxrowsupport" };
}
namespace PRESOLVING::DUALSPARSIFY {
    constexpr Param<int> PRIORITY { "presolving/dualsparsify/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/dualsparsify/maxrounds" };
    constexpr Param<int> TIMING { "presolving/dualsparsify/timing" };
    constexpr Param<bool> ENABLECOPY { "presolving/dualsparsify/enablecopy" };
    constexpr Param<bool> PRESERVEINTCOEFS { "presolving/dualsparsify/preserveintcoefs" };
    constexpr Param<bool> PRESERVEGOODLOCKS { "presolving/dualsparsify/preservegoodlocks" };
    constexpr Param<int> MAXCONTFILLIN { "presolving/dualsparsify/maxcontfillin" };
    constexpr Param<int> MAXBINFILLIN { "presolving/dualsparsify/maxbinfillin" };
    constexpr Param<int> MAXINTFILLIN { "presolving/dualsparsify/maxintfillin" };
    constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/dualsparsify/maxconsiderednonzeros" };
    constexpr Param<int> MINELIMINATEDNONZEROS { "presolving/dualsparsify/mineliminatednonzeros" };
    constexpr Param<double> MAXRETRIEVEFAC { "presolving/dualsparsify/maxretrievefac" };
    constexpr Param<double> WAITINGFAC { "presolving/dualsparsify/waitingfac" };
}
namespace PRESOLVING::GATEEXTRACTION {
    constexpr Param<int> PRIORITY { "presolving/gateextraction/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/gateextraction/maxrounds" };
    constexpr Param<int> TIMING { "presolving/gateextraction/timing" };
    constexpr Param<bool> ONLYSETPART { "presolving/gateextraction/onlysetpart" };
    constexpr Param<bool> SEARCHEQUATIONS { "presolving/gateextraction/searchequations" };
    constexpr Param<int> SORTING { "presolving/gateextraction/sorting" };
}
namespace PRESOLVING::IMPLICS {
    constexpr Param<int> PRIORITY { "presolving/implics/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/implics/maxrounds" };
    constexpr Param<int> TIMING { "presolving/implics/timing" };
}
namespace PRESOLVING::INTTOBINARY {
    constexpr Param<int> PRIORITY { "presolving/inttobinary/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/inttobinary/maxrounds" };
    constexpr Param<int> TIMING { "presolving/inttobinary/timing" };
}
namespace PRESOLVING::QPKKTREF {
    constexpr Param<int> PRIORITY { "presolving/qpkktref/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/qpkktref/maxrounds" };
    constexpr Param<int> TIMING { "presolving/qpkktref/timing" };
    constexpr Param<bool> ADDKKTBINARY { "presolving/qpkktref/addkktbinary" };
    constexpr Param<bool> UPDATEQUADBOUNDED { "presolving/qpkktref/updatequadbounded" };
    constexpr Param<bool> UPDATEQUADINDEF { "presolving/qpkktref/updatequadindef" };
}
namespace PRESOLVING::REDVUB {
    constexpr Param<int> PRIORITY { "presolving/redvub/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/redvub/maxrounds" };
    constexpr Param<int> TIMING { "presolving/redvub/timing" };
}
namespace PRESOLVING::SPARSIFY {
    constexpr Param<int> PRIORITY { "presolving/sparsify/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/sparsify/maxrounds" };
    constexpr Param<int> TIMING { "presolving/sparsify/timing" };
    constexpr Param<bool> ENABLECOPY { "presolving/sparsify/enablecopy" };
    constexpr Param<bool> CANCELLINEAR { "presolving/sparsify/cancellinear" };
    constexpr Param<bool> PRESERVEINTCOEFS { "presolving/sparsify/preserveintcoefs" };
    constexpr Param<int> MAXCONTFILLIN { "presolving/sparsify/maxcontfillin" };
    constexpr Param<int> MAXBINFILLIN { "presolving/sparsify/maxbinfillin" };
    constexpr Param<int> MAXINTFILLIN { "presolving/sparsify/maxintfillin" };
    constexpr Param<int> MAXNONZEROS { "presolving/sparsify/maxnonzeros" };
    constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/sparsify/maxconsiderednonzeros" };
    constexpr Param<char> ROWSORT { "presolving/sparsify/rowsort" };
    constexpr Param<double> MAXRETRIEVEFAC { "presolving/sparsify/maxretrievefac" };
    constexpr Param<double> WAITINGFAC { "presolving/sparsify/waitingfac" };
}
namespace PRESOLVING::STUFFING {
    constexpr Param<int> PRIORITY { "presolving/stuffing/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/stuffing/maxrounds" };
    constexpr Param<int> TIMING { "presolving/stuffing/timing" };
}
namespace PRESOLVING::TRIVIAL {
    constexpr Param<int> PRIORITY { "presolving/trivial/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/trivial/maxrounds" };
    constexpr Param<int> TIMING { "presolving/trivial/timing" };
}
namespace PRESOLVING::TWOROWBND {
    constexpr Param<int> PRIORITY { "presolving/tworowbnd/priority" };
    constexpr Param<int> MAXROUNDS { "presolving/tworowbnd/maxrounds" };
    constexpr Param<int> TIMING { "presolving/tworowbnd/timing" };
    constexpr Param<bool> ENABLECOPY { "presolving/tworowbnd/enablecopy" };
    constexpr Param<int> MAXCONSIDEREDNONZEROS { "presolving/tworowbnd/maxconsiderednonzeros" };
    constexpr Param<int> MAXRETRIEVEFAILS { "presolving/tworowbnd/maxretrievefails" };
    constexpr Param<int> MAXCOMBINEFAILS { "presolving/tworowbnd/maxcombinefails" };
    constexpr Param<int> MAXHASHFAC { "presolving/tworowbnd/maxhashfac" };
    constexpr Param<int> MAXPAIRFAC { "presolving/tworowbnd/maxpairfac" };
}
namespace PRICING {
    constexpr Param<int> MAXVARS { "pricing/maxvars" };
    constexpr Param<int> MAXVARSROOT { "pricing/maxvarsroot" };
    constexpr Param<double> ABORTFAC { "pricing/abortfac" };
    constexpr Param<bool> DELVARS { "pricing/delvars" };
    constexpr Param<bool> DELVARSROOT { "pricing/delvarsroot" };
}
namespace PROPAGATING {
    constexpr Param<int> MAXROUNDS { "propagating/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "propagating/maxroundsroot" };
    constexpr Param<bool> ABORTONCUTOFF { "propagating/abortoncutoff" };
}
namespace PROPAGATING::DUALFIX {
    constexpr Param<int> PRIORITY { "propagating/dualfix/priority" };
    constexpr Param<int> FREQ { "propagating/dualfix/freq" };
    constexpr Param<bool> DELAY { "propagating/dualfix/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/dualfix/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/dualfix/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/dualfix/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/dualfix/presoltiming" };
}
namespace PROPAGATING::GENVBOUNDS {
    constexpr Param<int> PRIORITY { "propagating/genvbounds/priority" };
    constexpr Param<int> FREQ { "propagating/genvbounds/freq" };
    constexpr Param<bool> DELAY { "propagating/genvbounds/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/genvbounds/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/genvbounds/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/genvbounds/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/genvbounds/presoltiming" };
    constexpr Param<bool> GLOBAL { "propagating/genvbounds/global" };
    constexpr Param<bool> PROPINROOTNODE { "propagating/genvbounds/propinrootnode" };
    constexpr Param<bool> SORT { "propagating/genvbounds/sort" };
    constexpr Param<bool> PROPASCONSS { "propagating/genvbounds/propasconss" };
}
namespace PROPAGATING::NLOBBT {
    constexpr Param<int> PRIORITY { "propagating/nlobbt/priority" };
    constexpr Param<int> FREQ { "propagating/nlobbt/freq" };
    constexpr Param<bool> DELAY { "propagating/nlobbt/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/nlobbt/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/nlobbt/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/nlobbt/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/nlobbt/presoltiming" };
    constexpr Param<double> FEASTOLFAC { "propagating/nlobbt/feastolfac" };
    constexpr Param<double> RELOBJTOLFAC { "propagating/nlobbt/relobjtolfac" };
    constexpr Param<double> MINNONCONVEXFRAC { "propagating/nlobbt/minnonconvexfrac" };
    constexpr Param<double> MINLINEARFRAC { "propagating/nlobbt/minlinearfrac" };
    constexpr Param<bool> ADDLPROWS { "propagating/nlobbt/addlprows" };
    constexpr Param<int> NLPITERLIMIT { "propagating/nlobbt/nlpiterlimit" };
    constexpr Param<double> NLPTIMELIMIT { "propagating/nlobbt/nlptimelimit" };
    constexpr Param<int> NLPVERBLEVEL { "propagating/nlobbt/nlpverblevel" };
    constexpr Param<double> ITLIMITFACTOR { "propagating/nlobbt/itlimitfactor" };
}
namespace PROPAGATING::OBBT {
    constexpr Param<int> PRIORITY { "propagating/obbt/priority" };
    constexpr Param<int> FREQ { "propagating/obbt/freq" };
    constexpr Param<bool> DELAY { "propagating/obbt/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/obbt/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/obbt/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/obbt/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/obbt/presoltiming" };
    constexpr Param<bool> CREATEGENVBOUNDS { "propagating/obbt/creategenvbounds" };
    constexpr Param<bool> NORMALIZE { "propagating/obbt/normalize" };
    constexpr Param<bool> APPLYFILTERROUNDS { "propagating/obbt/applyfilterrounds" };
    constexpr Param<bool> APPLYTRIVIALFILTER { "propagating/obbt/applytrivialfilter" };
    constexpr Param<bool> GENVBDSDURINGFILTER { "propagating/obbt/genvbdsduringfilter" };
    constexpr Param<bool> GENVBDSDURINGSEPA { "propagating/obbt/genvbdsduringsepa" };
    constexpr Param<int> MINFILTER { "propagating/obbt/minfilter" };
    constexpr Param<double> ITLIMITFACTOR { "propagating/obbt/itlimitfactor" };
    constexpr Param<double> ITLIMITFACTORBILIN { "propagating/obbt/itlimitfactorbilin" };
    constexpr Param<double> MINNONCONVEXITY { "propagating/obbt/minnonconvexity" };
    constexpr Param<long long> MINITLIMIT { "propagating/obbt/minitlimit" };
    constexpr Param<double> DUALFEASTOL { "propagating/obbt/dualfeastol" };
    constexpr Param<double> CONDITIONLIMIT { "propagating/obbt/conditionlimit" };
    constexpr Param<double> BOUNDSTREPS { "propagating/obbt/boundstreps" };
    constexpr Param<bool> ONLYNONCONVEXVARS { "propagating/obbt/onlynonconvexvars" };
    constexpr Param<bool> TIGHTINTBOUNDSPROBING { "propagating/obbt/tightintboundsprobing" };
    constexpr Param<bool> TIGHTCONTBOUNDSPROBING { "propagating/obbt/tightcontboundsprobing" };
    constexpr Param<bool> CREATEBILININEQS { "propagating/obbt/createbilinineqs" };
    constexpr Param<bool> CREATELINCONS { "propagating/obbt/createlincons" };
    constexpr Param<int> ORDERINGALGO { "propagating/obbt/orderingalgo" };
    constexpr Param<bool> SEPARATESOL { "propagating/obbt/separatesol" };
    constexpr Param<int> SEPAMINITER { "propagating/obbt/sepaminiter" };
    constexpr Param<int> SEPAMAXITER { "propagating/obbt/sepamaxiter" };
    constexpr Param<int> PROPAGATEFREQ { "propagating/obbt/propagatefreq" };
}
namespace PROPAGATING::PROBING {
    constexpr Param<int> PRIORITY { "propagating/probing/priority" };
    constexpr Param<int> FREQ { "propagating/probing/freq" };
    constexpr Param<bool> DELAY { "propagating/probing/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/probing/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/probing/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/probing/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/probing/presoltiming" };
    constexpr Param<int> MAXRUNS { "propagating/probing/maxruns" };
    constexpr Param<int> PROPROUNDS { "propagating/probing/proprounds" };
    constexpr Param<int> MAXFIXINGS { "propagating/probing/maxfixings" };
    constexpr Param<int> MAXUSELESS { "propagating/probing/maxuseless" };
    constexpr Param<int> MAXTOTALUSELESS { "propagating/probing/maxtotaluseless" };
    constexpr Param<int> MAXSUMUSELESS { "propagating/probing/maxsumuseless" };
    constexpr Param<int> MAXDEPTH { "propagating/probing/maxdepth" };
}
namespace PROPAGATING::PSEUDOOBJ {
    constexpr Param<int> PRIORITY { "propagating/pseudoobj/priority" };
    constexpr Param<int> FREQ { "propagating/pseudoobj/freq" };
    constexpr Param<bool> DELAY { "propagating/pseudoobj/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/pseudoobj/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/pseudoobj/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/pseudoobj/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/pseudoobj/presoltiming" };
    constexpr Param<int> MINUSELESS { "propagating/pseudoobj/minuseless" };
    constexpr Param<double> MAXVARSFRAC { "propagating/pseudoobj/maxvarsfrac" };
    constexpr Param<bool> PROPFULLINROOT { "propagating/pseudoobj/propfullinroot" };
    constexpr Param<bool> PROPCUTOFFBOUND { "propagating/pseudoobj/propcutoffbound" };
    constexpr Param<bool> FORCE { "propagating/pseudoobj/force" };
    constexpr Param<int> MAXNEWVARS { "propagating/pseudoobj/maxnewvars" };
    constexpr Param<bool> PROPUSEIMPLICS { "propagating/pseudoobj/propuseimplics" };
    constexpr Param<bool> RESPROPUSEIMPLICS { "propagating/pseudoobj/respropuseimplics" };
    constexpr Param<int> MAXIMPLVARS { "propagating/pseudoobj/maximplvars" };
}
namespace PROPAGATING::REDCOST {
    constexpr Param<int> PRIORITY { "propagating/redcost/priority" };
    constexpr Param<int> FREQ { "propagating/redcost/freq" };
    constexpr Param<bool> DELAY { "propagating/redcost/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/redcost/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/redcost/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/redcost/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/redcost/presoltiming" };
    constexpr Param<bool> CONTINUOUS { "propagating/redcost/continuous" };
    constexpr Param<bool> USEIMPLICS { "propagating/redcost/useimplics" };
    constexpr Param<bool> FORCE { "propagating/redcost/force" };
}
namespace PROPAGATING::ROOTREDCOST {
    constexpr Param<int> PRIORITY { "propagating/rootredcost/priority" };
    constexpr Param<int> FREQ { "propagating/rootredcost/freq" };
    constexpr Param<bool> DELAY { "propagating/rootredcost/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/rootredcost/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/rootredcost/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/rootredcost/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/rootredcost/presoltiming" };
    constexpr Param<bool> ONLYBINARY { "propagating/rootredcost/onlybinary" };
    constexpr Param<bool> FORCE { "propagating/rootredcost/force" };
}
namespace PROPAGATING::SYMMETRY {
    constexpr Param<int> PRIORITY { "propagating/symmetry/priority" };
    constexpr Param<int> FREQ { "propagating/symmetry/freq" };
    constexpr Param<bool> DELAY { "propagating/symmetry/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/symmetry/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/symmetry/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/symmetry/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/symmetry/presoltiming" };
    constexpr Param<int> MAXGENERATORS { "propagating/symmetry/maxgenerators" };
    constexpr Param<bool> CHECKSYMMETRIES { "propagating/symmetry/checksymmetries" };
    constexpr Param<bool> DISPLAYNORBITVARS { "propagating/symmetry/displaynorbitvars" };
    constexpr Param<bool> DOUBLEEQUATIONS { "propagating/symmetry/doubleequations" };
    constexpr Param<bool> CONSSADDLP { "propagating/symmetry/conssaddlp" };
    constexpr Param<bool> ADDSYMRESACKS { "propagating/symmetry/addsymresacks" };
    constexpr Param<bool> DETECTORBITOPES { "propagating/symmetry/detectorbitopes" };
    constexpr Param<bool> DETECTSUBGROUPS { "propagating/symmetry/detectsubgroups" };
    constexpr Param<bool> ADDWEAKSBCS { "propagating/symmetry/addweaksbcs" };
    constexpr Param<int> ADDCONSSTIMING { "propagating/symmetry/addconsstiming" };
    constexpr Param<int> OFSYMCOMPTIMING { "propagating/symmetry/ofsymcomptiming" };
    constexpr Param<bool> PERFORMPRESOLVING { "propagating/symmetry/performpresolving" };
    constexpr Param<int> RECOMPUTERESTART { "propagating/symmetry/recomputerestart" };
    constexpr Param<bool> COMPRESSSYMMETRIES { "propagating/symmetry/compresssymmetries" };
    constexpr Param<double> COMPRESSTHRESHOLD { "propagating/symmetry/compressthreshold" };
    constexpr Param<bool> USECOLUMNSPARSITY { "propagating/symmetry/usecolumnsparsity" };
    constexpr Param<int> MAXNCONSSSUBGROUP { "propagating/symmetry/maxnconsssubgroup" };
    constexpr Param<bool> USEDYNAMICPROP { "propagating/symmetry/usedynamicprop" };
    constexpr Param<bool> ADDSTRONGSBCS { "propagating/symmetry/addstrongsbcs" };
    constexpr Param<int> SSTTIEBREAKRULE { "propagating/symmetry/ssttiebreakrule" };
    constexpr Param<int> SSTLEADERRULE { "propagating/symmetry/sstleaderrule" };
    constexpr Param<int> SSTLEADERVARTYPE { "propagating/symmetry/sstleadervartype" };
    constexpr Param<bool> ADDCONFLICTCUTS { "propagating/symmetry/addconflictcuts" };
    constexpr Param<bool> SSTADDCUTS { "propagating/symmetry/sstaddcuts" };
    constexpr Param<bool> SSTMIXEDCOMPONENTS { "propagating/symmetry/sstmixedcomponents" };
    constexpr Param<bool> SYMFIXNONBINARYVARS { "propagating/symmetry/symfixnonbinaryvars" };
    constexpr Param<bool> ONLYBINARYSYMMETRY { "propagating/symmetry/onlybinarysymmetry" };
    constexpr Param<bool> PREFERLESSROWS { "propagating/symmetry/preferlessrows" };
}
namespace PROPAGATING::VBOUNDS {
    constexpr Param<int> PRIORITY { "propagating/vbounds/priority" };
    constexpr Param<int> FREQ { "propagating/vbounds/freq" };
    constexpr Param<bool> DELAY { "propagating/vbounds/delay" };
    constexpr Param<int> TIMINGMASK { "propagating/vbounds/timingmask" };
    constexpr Param<int> PRESOLPRIORITY { "propagating/vbounds/presolpriority" };
    constexpr Param<int> MAXPREROUNDS { "propagating/vbounds/maxprerounds" };
    constexpr Param<int> PRESOLTIMING { "propagating/vbounds/presoltiming" };
    constexpr Param<bool> USEBDWIDENING { "propagating/vbounds/usebdwidening" };
    constexpr Param<bool> USEIMPLICS { "propagating/vbounds/useimplics" };
    constexpr Param<bool> USECLIQUES { "propagating/vbounds/usecliques" };
    constexpr Param<bool> USEVBOUNDS { "propagating/vbounds/usevbounds" };
    constexpr Param<bool> DOTOPOSORT { "propagating/vbounds/dotoposort" };
    constexpr Param<bool> SORTCLIQUES { "propagating/vbounds/sortcliques" };
    constexpr Param<bool> DETECTCYCLES { "propagating/vbounds/detectcycles" };
    constexpr Param<double> MINNEWCLIQUES { "propagating/vbounds/minnewcliques" };
    constexpr Param<double> MAXCLIQUESMEDIUM { "propagating/vbounds/maxcliquesmedium" };
    constexpr Param<double> MAXCLIQUESEXHAUSTIVE { "propagating/vbounds/maxcliquesexhaustive" };
}
namespace RANDOMIZATION {
    constexpr Param<int> RANDOMSEEDSHIFT { "randomization/randomseedshift" };
    constexpr Param<int> PERMUTATIONSEED { "randomization/permutationseed" };
    constexpr Param<bool> PERMUTECONSS { "randomization/permuteconss" };
    constexpr Param<bool> PERMUTEVARS { "randomization/permutevars" };
    constexpr Param<int> LPSEED { "randomization/lpseed" };
}
namespace READING {
    constexpr Param<bool> INITIALCONSS { "reading/initialconss" };
    constexpr Param<bool> DYNAMICCONSS { "reading/dynamicconss" };
    constexpr Param<bool> DYNAMICCOLS { "reading/dynamiccols" };
    constexpr Param<bool> DYNAMICROWS { "reading/dynamicrows" };
}
namespace READING::BNDREADER {
    constexpr Param<bool> IMPROVEONLY { "reading/bndreader/improveonly" };
}
namespace READING::CIPREADER {
    constexpr Param<bool> WRITEFIXEDVARS { "reading/cipreader/writefixedvars" };
}
namespace READING::CNFREADER {
    constexpr Param<bool> USEOBJ { "reading/cnfreader/useobj" };
}
namespace READING::GMSREADER {
    constexpr Param<bool> FREEINTS { "reading/gmsreader/freeints" };
    constexpr Param<bool> REPLACEFORBIDDENCHARS { "reading/gmsreader/replaceforbiddenchars" };
    constexpr Param<double> BIGMDEFAULT { "reading/gmsreader/bigmdefault" };
    constexpr Param<char> INDICATORREFORM { "reading/gmsreader/indicatorreform" };
    constexpr Param<bool> SIGNPOWER { "reading/gmsreader/signpower" };
}
namespace READING::LPREADER {
    constexpr Param<bool> LINEARIZE_AND_CONSTRAINTS { "reading/lpreader/linearize-and-constraints" };
    constexpr Param<bool> AGGRLINEARIZATION_ANDS { "reading/lpreader/aggrlinearization-ands" };
}
namespace READING::MPSREADER {
    constexpr Param<bool> LINEARIZE_AND_CONSTRAINTS { "reading/mpsreader/linearize-and-constraints" };
    constexpr Param<bool> AGGRLINEARIZATION_ANDS { "reading/mpsreader/aggrlinearization-ands" };
}
namespace READING::OPBREADER {
    constexpr Param<bool> DYNAMICCONSS { "reading/opbreader/dynamicconss" };
    constexpr Param<bool> MULTISYMBOL { "reading/opbreader/multisymbol" };
}
namespace READING::PBMREADER {
    constexpr Param<bool> BINARY { "reading/pbmreader/binary" };
    constexpr Param<int> MAXROWS { "reading/pbmreader/maxrows" };
    constexpr Param<int> MAXCOLS { "reading/pbmreader/maxcols" };
}
namespace READING::PPMREADER {
    constexpr Param<bool> RGBRELATIV { "reading/ppmreader/rgbrelativ" };
    constexpr Param<bool> RGBASCII { "reading/ppmreader/rgbascii" };
    constexpr Param<int> COEFFICIENTLIMIT { "reading/ppmreader/coefficientlimit" };
    constexpr Param<int> RGBLIMIT { "reading/ppmreader/rgblimit" };
}
namespace READING::STOREADER {
    constexpr Param<bool> USEBENDERS { "reading/storeader/usebenders" };
}
namespace REOPTIMIZATION {
    constexpr Param<bool> ENABLE { "reoptimization/enable" };
    constexpr Param<int> MAXSAVEDNODES { "reoptimization/maxsavednodes" };
    constexpr Param<int> MAXDIFFOFNODES { "reoptimization/maxdiffofnodes" };
    constexpr Param<bool> SEPABESTSOL { "reoptimization/sepabestsol" };
    constexpr Param<bool> STOREVARHISTORY { "reoptimization/storevarhistory" };
    constexpr Param<bool> USEPSCOST { "reoptimization/usepscost" };
    constexpr Param<int> SOLVELP { "reoptimization/solvelp" };
    constexpr Param<int> SOLVELPDIFF { "reoptimization/solvelpdiff" };
    constexpr Param<int> SAVESOLS { "reoptimization/savesols" };
    constexpr Param<double> OBJSIMROOTLP { "reoptimization/objsimrootLP" };
    constexpr Param<double> OBJSIMSOL { "reoptimization/objsimsol" };
    constexpr Param<double> DELAY { "reoptimization/delay" };
    constexpr Param<bool> COMMONTIMELIMIT { "reoptimization/commontimelimit" };
    constexpr Param<bool> SHRINKINNER { "reoptimization/shrinkinner" };
    constexpr Param<bool> STRONGBRANCHINGINIT { "reoptimization/strongbranchinginit" };
    constexpr Param<bool> REDUCETOFRONTIER { "reoptimization/reducetofrontier" };
    constexpr Param<int> FORCEHEURRESTART { "reoptimization/forceheurrestart" };
    constexpr Param<bool> SAVECONSPROP { "reoptimization/saveconsprop" };
    constexpr Param<bool> USESPLITCONS { "reoptimization/usesplitcons" };
    constexpr Param<char> VARORDERINTERDICTION { "reoptimization/varorderinterdiction" };
    constexpr Param<bool> USECUTS { "reoptimization/usecuts" };
    constexpr Param<int> MAXCUTAGE { "reoptimization/maxcutage" };
}
namespace REOPTIMIZATION::GLOBALCONS {
    constexpr Param<bool> SEPAINFSUBTREES { "reoptimization/globalcons/sepainfsubtrees" };
}
namespace SEPARATING {
    constexpr Param<double> MAXBOUNDDIST { "separating/maxbounddist" };
    constexpr Param<double> MAXLOCALBOUNDDIST { "separating/maxlocalbounddist" };
    constexpr Param<double> MAXCOEFRATIO { "separating/maxcoefratio" };
    constexpr Param<double> MAXCOEFRATIOFACROWPREP { "separating/maxcoefratiofacrowprep" };
    constexpr Param<double> MINEFFICACY { "separating/minefficacy" };
    constexpr Param<double> MINEFFICACYROOT { "separating/minefficacyroot" };
    constexpr Param<double> MINACTIVITYQUOT { "separating/minactivityquot" };
    constexpr Param<char> ORTHOFUNC { "separating/orthofunc" };
    constexpr Param<char> EFFICACYNORM { "separating/efficacynorm" };
    constexpr Param<char> CUTSELRESTART { "separating/cutselrestart" };
    constexpr Param<char> CUTSELSUBSCIP { "separating/cutselsubscip" };
    constexpr Param<bool> FILTERCUTPOOLREL { "separating/filtercutpoolrel" };
    constexpr Param<int> MAXRUNS { "separating/maxruns" };
    constexpr Param<int> MAXROUNDS { "separating/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/maxroundsroot" };
    constexpr Param<int> MAXROUNDSROOTSUBRUN { "separating/maxroundsrootsubrun" };
    constexpr Param<int> MAXADDROUNDS { "separating/maxaddrounds" };
    constexpr Param<int> MAXSTALLROUNDS { "separating/maxstallrounds" };
    constexpr Param<int> MAXSTALLROUNDSROOT { "separating/maxstallroundsroot" };
    constexpr Param<int> MAXCUTS { "separating/maxcuts" };
    constexpr Param<int> MAXCUTSROOT { "separating/maxcutsroot" };
    constexpr Param<int> CUTAGELIMIT { "separating/cutagelimit" };
    constexpr Param<int> POOLFREQ { "separating/poolfreq" };
}
namespace SEPARATING::AGGREGATION {
    constexpr Param<int> PRIORITY { "separating/aggregation/priority" };
    constexpr Param<int> FREQ { "separating/aggregation/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/aggregation/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/aggregation/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/aggregation/expbackoff" };
    constexpr Param<int> MAXROUNDS { "separating/aggregation/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/aggregation/maxroundsroot" };
    constexpr Param<int> MAXTRIES { "separating/aggregation/maxtries" };
    constexpr Param<int> MAXTRIESROOT { "separating/aggregation/maxtriesroot" };
    constexpr Param<int> MAXFAILS { "separating/aggregation/maxfails" };
    constexpr Param<int> MAXFAILSROOT { "separating/aggregation/maxfailsroot" };
    constexpr Param<int> MAXAGGRS { "separating/aggregation/maxaggrs" };
    constexpr Param<int> MAXAGGRSROOT { "separating/aggregation/maxaggrsroot" };
    constexpr Param<int> MAXSEPACUTS { "separating/aggregation/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "separating/aggregation/maxsepacutsroot" };
    constexpr Param<double> MAXSLACK { "separating/aggregation/maxslack" };
    constexpr Param<double> MAXSLACKROOT { "separating/aggregation/maxslackroot" };
    constexpr Param<double> DENSITYSCORE { "separating/aggregation/densityscore" };
    constexpr Param<double> SLACKSCORE { "separating/aggregation/slackscore" };
    constexpr Param<double> MAXAGGDENSITY { "separating/aggregation/maxaggdensity" };
    constexpr Param<double> MAXROWDENSITY { "separating/aggregation/maxrowdensity" };
    constexpr Param<int> DENSITYOFFSET { "separating/aggregation/densityoffset" };
    constexpr Param<double> MAXROWFAC { "separating/aggregation/maxrowfac" };
    constexpr Param<int> MAXTESTDELTA { "separating/aggregation/maxtestdelta" };
    constexpr Param<double> AGGRTOL { "separating/aggregation/aggrtol" };
    constexpr Param<bool> TRYNEGSCALING { "separating/aggregation/trynegscaling" };
    constexpr Param<bool> FIXINTEGRALRHS { "separating/aggregation/fixintegralrhs" };
    constexpr Param<bool> DYNAMICCUTS { "separating/aggregation/dynamiccuts" };
}
namespace SEPARATING::CGMIP {
    constexpr Param<int> PRIORITY { "separating/cgmip/priority" };
    constexpr Param<int> FREQ { "separating/cgmip/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/cgmip/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/cgmip/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/cgmip/expbackoff" };
    constexpr Param<int> MAXROUNDS { "separating/cgmip/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/cgmip/maxroundsroot" };
    constexpr Param<int> MAXDEPTH { "separating/cgmip/maxdepth" };
    constexpr Param<bool> DECISIONTREE { "separating/cgmip/decisiontree" };
    constexpr Param<double> TIMELIMIT { "separating/cgmip/timelimit" };
    constexpr Param<double> MEMORYLIMIT { "separating/cgmip/memorylimit" };
    constexpr Param<long long> MINNODELIMIT { "separating/cgmip/minnodelimit" };
    constexpr Param<long long> MAXNODELIMIT { "separating/cgmip/maxnodelimit" };
    constexpr Param<double> CUTCOEFBND { "separating/cgmip/cutcoefbnd" };
    constexpr Param<bool> ONLYACTIVEROWS { "separating/cgmip/onlyactiverows" };
    constexpr Param<int> MAXROWAGE { "separating/cgmip/maxrowage" };
    constexpr Param<bool> ONLYRANKONE { "separating/cgmip/onlyrankone" };
    constexpr Param<bool> ONLYINTVARS { "separating/cgmip/onlyintvars" };
    constexpr Param<bool> CONTCONVERT { "separating/cgmip/contconvert" };
    constexpr Param<double> CONTCONVFRAC { "separating/cgmip/contconvfrac" };
    constexpr Param<int> CONTCONVMIN { "separating/cgmip/contconvmin" };
    constexpr Param<bool> INTCONVERT { "separating/cgmip/intconvert" };
    constexpr Param<double> INTCONVFRAC { "separating/cgmip/intconvfrac" };
    constexpr Param<int> INTCONVMIN { "separating/cgmip/intconvmin" };
    constexpr Param<bool> SKIPMULTBOUNDS { "separating/cgmip/skipmultbounds" };
    constexpr Param<bool> OBJLONE { "separating/cgmip/objlone" };
    constexpr Param<double> OBJWEIGHT { "separating/cgmip/objweight" };
    constexpr Param<bool> OBJWEIGHTSIZE { "separating/cgmip/objweightsize" };
    constexpr Param<bool> DYNAMICCUTS { "separating/cgmip/dynamiccuts" };
    constexpr Param<bool> USECMIR { "separating/cgmip/usecmir" };
    constexpr Param<bool> USESTRONGCG { "separating/cgmip/usestrongcg" };
    constexpr Param<bool> CMIROWNBOUNDS { "separating/cgmip/cmirownbounds" };
    constexpr Param<bool> USECUTPOOL { "separating/cgmip/usecutpool" };
    constexpr Param<bool> PRIMALSEPARATION { "separating/cgmip/primalseparation" };
    constexpr Param<bool> EARLYTERM { "separating/cgmip/earlyterm" };
    constexpr Param<bool> ADDVIOLATIONCONS { "separating/cgmip/addviolationcons" };
    constexpr Param<bool> ADDVIOLCONSHDLR { "separating/cgmip/addviolconshdlr" };
    constexpr Param<bool> CONSHDLRUSENORM { "separating/cgmip/conshdlrusenorm" };
    constexpr Param<bool> USEOBJUB { "separating/cgmip/useobjub" };
    constexpr Param<bool> USEOBJLB { "separating/cgmip/useobjlb" };
    constexpr Param<bool> SUBSCIPFAST { "separating/cgmip/subscipfast" };
    constexpr Param<bool> OUTPUT { "separating/cgmip/output" };
    constexpr Param<bool> GENPRIMALSOLS { "separating/cgmip/genprimalsols" };
}
namespace SEPARATING::CLIQUE {
    constexpr Param<int> PRIORITY { "separating/clique/priority" };
    constexpr Param<int> FREQ { "separating/clique/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/clique/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/clique/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/clique/expbackoff" };
    constexpr Param<double> SCALEVAL { "separating/clique/scaleval" };
    constexpr Param<int> MAXTREENODES { "separating/clique/maxtreenodes" };
    constexpr Param<int> BACKTRACKFREQ { "separating/clique/backtrackfreq" };
    constexpr Param<int> MAXSEPACUTS { "separating/clique/maxsepacuts" };
    constexpr Param<int> MAXZEROEXTENSIONS { "separating/clique/maxzeroextensions" };
    constexpr Param<double> CLIQUETABLEMEM { "separating/clique/cliquetablemem" };
    constexpr Param<double> CLIQUEDENSITY { "separating/clique/cliquedensity" };
}
namespace SEPARATING::CLOSECUTS {
    constexpr Param<int> PRIORITY { "separating/closecuts/priority" };
    constexpr Param<int> FREQ { "separating/closecuts/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/closecuts/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/closecuts/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/closecuts/expbackoff" };
    constexpr Param<bool> SEPARELINT { "separating/closecuts/separelint" };
    constexpr Param<double> SEPACOMBVALUE { "separating/closecuts/sepacombvalue" };
    constexpr Param<int> CLOSETHRES { "separating/closecuts/closethres" };
    constexpr Param<bool> INCLOBJCUTOFF { "separating/closecuts/inclobjcutoff" };
    constexpr Param<bool> RECOMPUTERELINT { "separating/closecuts/recomputerelint" };
    constexpr Param<int> MAXUNSUCCESSFUL { "separating/closecuts/maxunsuccessful" };
    constexpr Param<double> MAXLPITERFACTOR { "separating/closecuts/maxlpiterfactor" };
}
namespace SEPARATING::CMIR {
    constexpr Param<int> PRIORITY { "separating/cmir/priority" };
    constexpr Param<int> FREQ { "separating/cmir/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/cmir/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/cmir/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/cmir/expbackoff" };
}
namespace SEPARATING::CONVEXPROJ {
    constexpr Param<int> PRIORITY { "separating/convexproj/priority" };
    constexpr Param<int> FREQ { "separating/convexproj/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/convexproj/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/convexproj/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/convexproj/expbackoff" };
    constexpr Param<int> MAXDEPTH { "separating/convexproj/maxdepth" };
    constexpr Param<int> NLPITERLIMIT { "separating/convexproj/nlpiterlimit" };
}
namespace SEPARATING::DISJUNCTIVE {
    constexpr Param<int> PRIORITY { "separating/disjunctive/priority" };
    constexpr Param<int> FREQ { "separating/disjunctive/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/disjunctive/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/disjunctive/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/disjunctive/expbackoff" };
    constexpr Param<bool> STRENGTHEN { "separating/disjunctive/strengthen" };
    constexpr Param<int> MAXDEPTH { "separating/disjunctive/maxdepth" };
    constexpr Param<int> MAXROUNDS { "separating/disjunctive/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/disjunctive/maxroundsroot" };
    constexpr Param<int> MAXINVCUTS { "separating/disjunctive/maxinvcuts" };
    constexpr Param<int> MAXINVCUTSROOT { "separating/disjunctive/maxinvcutsroot" };
    constexpr Param<int> MAXCONFSDELAY { "separating/disjunctive/maxconfsdelay" };
    constexpr Param<int> MAXRANK { "separating/disjunctive/maxrank" };
    constexpr Param<int> MAXRANKINTEGRAL { "separating/disjunctive/maxrankintegral" };
    constexpr Param<double> MAXWEIGHTRANGE { "separating/disjunctive/maxweightrange" };
}
namespace SEPARATING::ECCUTS {
    constexpr Param<int> PRIORITY { "separating/eccuts/priority" };
    constexpr Param<int> FREQ { "separating/eccuts/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/eccuts/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/eccuts/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/eccuts/expbackoff" };
    constexpr Param<bool> DYNAMICCUTS { "separating/eccuts/dynamiccuts" };
    constexpr Param<int> MAXROUNDS { "separating/eccuts/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/eccuts/maxroundsroot" };
    constexpr Param<int> MAXDEPTH { "separating/eccuts/maxdepth" };
    constexpr Param<int> MAXSEPACUTS { "separating/eccuts/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "separating/eccuts/maxsepacutsroot" };
    constexpr Param<double> CUTMAXRANGE { "separating/eccuts/cutmaxrange" };
    constexpr Param<double> MINVIOLATION { "separating/eccuts/minviolation" };
    constexpr Param<int> MINAGGRSIZE { "separating/eccuts/minaggrsize" };
    constexpr Param<int> MAXAGGRSIZE { "separating/eccuts/maxaggrsize" };
    constexpr Param<int> MAXBILINTERMS { "separating/eccuts/maxbilinterms" };
    constexpr Param<int> MAXSTALLROUNDS { "separating/eccuts/maxstallrounds" };
}
namespace SEPARATING::FLOWCOVER {
    constexpr Param<int> PRIORITY { "separating/flowcover/priority" };
    constexpr Param<int> FREQ { "separating/flowcover/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/flowcover/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/flowcover/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/flowcover/expbackoff" };
}
namespace SEPARATING::GAUGE {
    constexpr Param<int> PRIORITY { "separating/gauge/priority" };
    constexpr Param<int> FREQ { "separating/gauge/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/gauge/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/gauge/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/gauge/expbackoff" };
    constexpr Param<int> NLPITERLIMIT { "separating/gauge/nlpiterlimit" };
}
namespace SEPARATING::GOMORY {
    constexpr Param<int> PRIORITY { "separating/gomory/priority" };
    constexpr Param<int> FREQ { "separating/gomory/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/gomory/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/gomory/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/gomory/expbackoff" };
    constexpr Param<int> MAXROUNDS { "separating/gomory/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/gomory/maxroundsroot" };
    constexpr Param<int> MAXSEPACUTS { "separating/gomory/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "separating/gomory/maxsepacutsroot" };
    constexpr Param<int> MAXRANK { "separating/gomory/maxrank" };
    constexpr Param<int> MAXRANKINTEGRAL { "separating/gomory/maxrankintegral" };
    constexpr Param<double> AWAY { "separating/gomory/away" };
    constexpr Param<bool> DYNAMICCUTS { "separating/gomory/dynamiccuts" };
    constexpr Param<bool> MAKEINTEGRAL { "separating/gomory/makeintegral" };
    constexpr Param<bool> FORCECUTS { "separating/gomory/forcecuts" };
    constexpr Param<bool> SEPARATEROWS { "separating/gomory/separaterows" };
    constexpr Param<bool> DELAYEDCUTS { "separating/gomory/delayedcuts" };
    constexpr Param<bool> SIDETYPEBASIS { "separating/gomory/sidetypebasis" };
    constexpr Param<bool> TRYSTRONGCG { "separating/gomory/trystrongcg" };
    constexpr Param<bool> GENBOTHGOMSCG { "separating/gomory/genbothgomscg" };
}
namespace SEPARATING::GOMORYMI {
    constexpr Param<int> PRIORITY { "separating/gomorymi/priority" };
    constexpr Param<int> FREQ { "separating/gomorymi/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/gomorymi/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/gomorymi/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/gomorymi/expbackoff" };
}
namespace SEPARATING::IMPLIEDBOUNDS {
    constexpr Param<int> PRIORITY { "separating/impliedbounds/priority" };
    constexpr Param<int> FREQ { "separating/impliedbounds/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/impliedbounds/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/impliedbounds/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/impliedbounds/expbackoff" };
    constexpr Param<bool> USETWOSIZECLIQUES { "separating/impliedbounds/usetwosizecliques" };
}
namespace SEPARATING::INTERMINOR {
    constexpr Param<int> PRIORITY { "separating/interminor/priority" };
    constexpr Param<int> FREQ { "separating/interminor/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/interminor/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/interminor/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/interminor/expbackoff" };
    constexpr Param<bool> USESTRENGTHENING { "separating/interminor/usestrengthening" };
    constexpr Param<bool> USEBOUNDS { "separating/interminor/usebounds" };
    constexpr Param<double> MINCUTVIOL { "separating/interminor/mincutviol" };
    constexpr Param<int> MAXROUNDS { "separating/interminor/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/interminor/maxroundsroot" };
}
namespace SEPARATING::INTOBJ {
    constexpr Param<int> PRIORITY { "separating/intobj/priority" };
    constexpr Param<int> FREQ { "separating/intobj/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/intobj/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/intobj/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/intobj/expbackoff" };
}
namespace SEPARATING::KNAPSACKCOVER {
    constexpr Param<int> PRIORITY { "separating/knapsackcover/priority" };
    constexpr Param<int> FREQ { "separating/knapsackcover/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/knapsackcover/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/knapsackcover/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/knapsackcover/expbackoff" };
}
namespace SEPARATING::MCF {
    constexpr Param<int> PRIORITY { "separating/mcf/priority" };
    constexpr Param<int> FREQ { "separating/mcf/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/mcf/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/mcf/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/mcf/expbackoff" };
    constexpr Param<int> NCLUSTERS { "separating/mcf/nclusters" };
    constexpr Param<double> MAXWEIGHTRANGE { "separating/mcf/maxweightrange" };
    constexpr Param<int> MAXTESTDELTA { "separating/mcf/maxtestdelta" };
    constexpr Param<bool> TRYNEGSCALING { "separating/mcf/trynegscaling" };
    constexpr Param<bool> FIXINTEGRALRHS { "separating/mcf/fixintegralrhs" };
    constexpr Param<bool> DYNAMICCUTS { "separating/mcf/dynamiccuts" };
    constexpr Param<int> MODELTYPE { "separating/mcf/modeltype" };
    constexpr Param<int> MAXSEPACUTS { "separating/mcf/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "separating/mcf/maxsepacutsroot" };
    constexpr Param<double> MAXINCONSISTENCYRATIO { "separating/mcf/maxinconsistencyratio" };
    constexpr Param<double> MAXARCINCONSISTENCYRATIO { "separating/mcf/maxarcinconsistencyratio" };
    constexpr Param<bool> CHECKCUTSHORECONNECTIVITY { "separating/mcf/checkcutshoreconnectivity" };
    constexpr Param<bool> SEPARATESINGLENODECUTS { "separating/mcf/separatesinglenodecuts" };
    constexpr Param<bool> SEPARATEFLOWCUTSET { "separating/mcf/separateflowcutset" };
    constexpr Param<bool> SEPARATEKNAPSACK { "separating/mcf/separateknapsack" };
}
namespace SEPARATING::MINOR {
    constexpr Param<int> PRIORITY { "separating/minor/priority" };
    constexpr Param<int> FREQ { "separating/minor/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/minor/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/minor/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/minor/expbackoff" };
    constexpr Param<int> MAXMINORSCONST { "separating/minor/maxminorsconst" };
    constexpr Param<double> MAXMINORSFAC { "separating/minor/maxminorsfac" };
    constexpr Param<double> MINCUTVIOL { "separating/minor/mincutviol" };
    constexpr Param<int> MAXROUNDS { "separating/minor/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/minor/maxroundsroot" };
    constexpr Param<bool> IGNOREPACKINGCONSS { "separating/minor/ignorepackingconss" };
}
namespace SEPARATING::MIXING {
    constexpr Param<int> PRIORITY { "separating/mixing/priority" };
    constexpr Param<int> FREQ { "separating/mixing/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/mixing/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/mixing/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/mixing/expbackoff" };
    constexpr Param<bool> USELOCALBOUNDS { "separating/mixing/uselocalbounds" };
    constexpr Param<bool> ISCUTSONINTS { "separating/mixing/iscutsonints" };
    constexpr Param<int> MAXROUNDS { "separating/mixing/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/mixing/maxroundsroot" };
    constexpr Param<int> MAXNUNSUCCESSFUL { "separating/mixing/maxnunsuccessful" };
}
namespace SEPARATING::ODDCYCLE {
    constexpr Param<int> PRIORITY { "separating/oddcycle/priority" };
    constexpr Param<int> FREQ { "separating/oddcycle/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/oddcycle/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/oddcycle/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/oddcycle/expbackoff" };
    constexpr Param<bool> USEGLS { "separating/oddcycle/usegls" };
    constexpr Param<bool> LIFTODDCYCLES { "separating/oddcycle/liftoddcycles" };
    constexpr Param<int> MAXSEPACUTS { "separating/oddcycle/maxsepacuts" };
    constexpr Param<int> MAXSEPACUTSROOT { "separating/oddcycle/maxsepacutsroot" };
    constexpr Param<int> MAXROUNDS { "separating/oddcycle/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/oddcycle/maxroundsroot" };
    constexpr Param<int> SCALINGFACTOR { "separating/oddcycle/scalingfactor" };
    constexpr Param<bool> ADDSELFARCS { "separating/oddcycle/addselfarcs" };
    constexpr Param<bool> REPAIRCYCLES { "separating/oddcycle/repaircycles" };
    constexpr Param<bool> INCLUDETRIANGLES { "separating/oddcycle/includetriangles" };
    constexpr Param<bool> MULTIPLECUTS { "separating/oddcycle/multiplecuts" };
    constexpr Param<bool> ALLOWMULTIPLECUTS { "separating/oddcycle/allowmultiplecuts" };
    constexpr Param<bool> LPLIFTCOEF { "separating/oddcycle/lpliftcoef" };
    constexpr Param<bool> RECALCLIFTCOEF { "separating/oddcycle/recalcliftcoef" };
    constexpr Param<int> SORTSWITCH { "separating/oddcycle/sortswitch" };
    constexpr Param<bool> SORTROOTNEIGHBORS { "separating/oddcycle/sortrootneighbors" };
    constexpr Param<int> PERCENTTESTVARS { "separating/oddcycle/percenttestvars" };
    constexpr Param<int> OFFSETTESTVARS { "separating/oddcycle/offsettestvars" };
    constexpr Param<int> MAXPERNODESLEVEL { "separating/oddcycle/maxpernodeslevel" };
    constexpr Param<int> OFFSETNODESLEVEL { "separating/oddcycle/offsetnodeslevel" };
    constexpr Param<int> MAXNLEVELS { "separating/oddcycle/maxnlevels" };
    constexpr Param<int> MAXCUTSROOT { "separating/oddcycle/maxcutsroot" };
    constexpr Param<int> MAXCUTSLEVEL { "separating/oddcycle/maxcutslevel" };
    constexpr Param<int> MAXREFERENCE { "separating/oddcycle/maxreference" };
    constexpr Param<int> MAXUNSUCESSFULL { "separating/oddcycle/maxunsucessfull" };
    constexpr Param<int> CUTTHRESHOLD { "separating/oddcycle/cutthreshold" };
}
namespace SEPARATING::RAPIDLEARNING {
    constexpr Param<int> PRIORITY { "separating/rapidlearning/priority" };
    constexpr Param<int> FREQ { "separating/rapidlearning/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/rapidlearning/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/rapidlearning/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/rapidlearning/expbackoff" };
    constexpr Param<bool> APPLYCONFLICTS { "separating/rapidlearning/applyconflicts" };
    constexpr Param<bool> APPLYBDCHGS { "separating/rapidlearning/applybdchgs" };
    constexpr Param<bool> APPLYINFERVALS { "separating/rapidlearning/applyinfervals" };
    constexpr Param<bool> REDUCEDINFER { "separating/rapidlearning/reducedinfer" };
    constexpr Param<bool> APPLYPRIMALSOL { "separating/rapidlearning/applyprimalsol" };
    constexpr Param<bool> APPLYSOLVED { "separating/rapidlearning/applysolved" };
    constexpr Param<bool> CHECKDEGENERACY { "separating/rapidlearning/checkdegeneracy" };
    constexpr Param<bool> CHECKDUALBOUND { "separating/rapidlearning/checkdualbound" };
    constexpr Param<bool> CHECKLEAVES { "separating/rapidlearning/checkleaves" };
    constexpr Param<bool> CHECKEXEC { "separating/rapidlearning/checkexec" };
    constexpr Param<bool> CHECKOBJ { "separating/rapidlearning/checkobj" };
    constexpr Param<bool> CHECKNSOLS { "separating/rapidlearning/checknsols" };
    constexpr Param<bool> CONTVARS { "separating/rapidlearning/contvars" };
    constexpr Param<double> CONTVARSQUOT { "separating/rapidlearning/contvarsquot" };
    constexpr Param<double> LPITERQUOT { "separating/rapidlearning/lpiterquot" };
    constexpr Param<double> MINDEGENERACY { "separating/rapidlearning/mindegeneracy" };
    constexpr Param<double> MININFLPRATIO { "separating/rapidlearning/mininflpratio" };
    constexpr Param<double> MINVARCONSRATIO { "separating/rapidlearning/minvarconsratio" };
    constexpr Param<int> MAXNVARS { "separating/rapidlearning/maxnvars" };
    constexpr Param<int> MAXNCONSS { "separating/rapidlearning/maxnconss" };
    constexpr Param<int> MAXCALLS { "separating/rapidlearning/maxcalls" };
    constexpr Param<int> MAXNODES { "separating/rapidlearning/maxnodes" };
    constexpr Param<int> MINNODES { "separating/rapidlearning/minnodes" };
    constexpr Param<long long> NWAITINGNODES { "separating/rapidlearning/nwaitingnodes" };
    constexpr Param<bool> COPYCUTS { "separating/rapidlearning/copycuts" };
}
namespace SEPARATING::RLT {
    constexpr Param<int> PRIORITY { "separating/rlt/priority" };
    constexpr Param<int> FREQ { "separating/rlt/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/rlt/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/rlt/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/rlt/expbackoff" };
    constexpr Param<int> MAXNCUTS { "separating/rlt/maxncuts" };
    constexpr Param<int> MAXUNKNOWNTERMS { "separating/rlt/maxunknownterms" };
    constexpr Param<int> MAXUSEDVARS { "separating/rlt/maxusedvars" };
    constexpr Param<int> MAXROUNDS { "separating/rlt/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/rlt/maxroundsroot" };
    constexpr Param<bool> ONLYEQROWS { "separating/rlt/onlyeqrows" };
    constexpr Param<bool> ONLYCONTROWS { "separating/rlt/onlycontrows" };
    constexpr Param<bool> ONLYORIGINAL { "separating/rlt/onlyoriginal" };
    constexpr Param<bool> USEINSUBSCIP { "separating/rlt/useinsubscip" };
    constexpr Param<bool> USEPROJECTION { "separating/rlt/useprojection" };
    constexpr Param<bool> DETECTHIDDEN { "separating/rlt/detecthidden" };
    constexpr Param<bool> HIDDENRLT { "separating/rlt/hiddenrlt" };
    constexpr Param<bool> ADDTOPOOL { "separating/rlt/addtopool" };
    constexpr Param<double> GOODSCORE { "separating/rlt/goodscore" };
    constexpr Param<double> BADSCORE { "separating/rlt/badscore" };
    constexpr Param<double> OBJPARALWEIGHT { "separating/rlt/objparalweight" };
    constexpr Param<double> EFFICACYWEIGHT { "separating/rlt/efficacyweight" };
    constexpr Param<double> DIRCUTOFFDISTWEIGHT { "separating/rlt/dircutoffdistweight" };
    constexpr Param<double> GOODMAXPARALL { "separating/rlt/goodmaxparall" };
    constexpr Param<double> MAXPARALL { "separating/rlt/maxparall" };
}
namespace SEPARATING::STRONGCG {
    constexpr Param<int> PRIORITY { "separating/strongcg/priority" };
    constexpr Param<int> FREQ { "separating/strongcg/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/strongcg/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/strongcg/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/strongcg/expbackoff" };
}
namespace SEPARATING::ZEROHALF {
    constexpr Param<int> PRIORITY { "separating/zerohalf/priority" };
    constexpr Param<int> FREQ { "separating/zerohalf/freq" };
    constexpr Param<double> MAXBOUNDDIST { "separating/zerohalf/maxbounddist" };
    constexpr Param<bool> DELAY { "separating/zerohalf/delay" };
    constexpr Param<int> EXPBACKOFF { "separating/zerohalf/expbackoff" };
    constexpr Param<int> MAXROUNDS { "separating/zerohalf/maxrounds" };
    constexpr Param<int> MAXROUNDSROOT { "separating/zerohalf/maxroundsroot" };
    constexpr Param<int> MAXSEPACUTS { "separating/zerohalf/maxsepacuts" };
    constexpr Param<int> INITSEED { "separating/zerohalf/initseed" };
    constexpr Param<int> MAXSEPACUTSROOT { "separating/zerohalf/maxsepacutsroot" };
    constexpr Param<int> MAXCUTCANDS { "separating/zerohalf/maxcutcands" };
    constexpr Param<double> MAXSLACK { "separating/zerohalf/maxslack" };
    constexpr Param<double> MAXSLACKROOT { "separating/zerohalf/maxslackroot" };
    constexpr Param<double> GOODSCORE { "separating/zerohalf/goodscore" };
    constexpr Param<double> BADSCORE { "separating/zerohalf/badscore" };
    constexpr Param<double> OBJPARALWEIGHT { "separating/zerohalf/objparalweight" };
    constexpr Param<double> EFFICACYWEIGHT { "separating/zerohalf/efficacyweight" };
    constexpr Param<double> DIRCUTOFFDISTWEIGHT { "separating/zerohalf/dircutoffdistweight" };
    constexpr Param<double> GOODMAXPARALL { "separating/zerohalf/goodmaxparall" };
    constexpr Param<double> MAXPARALL { "separating/zerohalf/maxparall" };
    constexpr Param<double> MINVIOL { "separating/zerohalf/minviol" };
    constexpr Param<bool> DYNAMICCUTS { "separating/zerohalf/dynamiccuts" };
    constexpr Param<double> MAXROWDENSITY { "separating/zerohalf/maxrowdensity" };
    constexpr Param<int> DENSITYOFFSET { "separating/zerohalf/densityoffset" };
}
namespace SOLVINGPHASES {
    constexpr Param<bool> ENABLED { "solvingphases/enabled" };
    constexpr Param<bool> TESTMODE { "solvingphases/testmode" };
    constexpr Param<std::string> FEASSETNAME { "solvingphases/feassetname" };
    constexpr Param<std::string> IMPROVESETNAME { "solvingphases/improvesetname" };
    constexpr Param<std::string> PROOFSETNAME { "solvingphases/proofsetname" };
    constexpr Param<long long> NODEOFFSET { "solvingphases/nodeoffset" };
    constexpr Param<bool> FALLBACK { "solvingphases/fallback" };
    constexpr Param<char> TRANSITIONMETHOD { "solvingphases/transitionmethod" };
    constexpr Param<bool> INTERRUPTOPTIMAL { "solvingphases/interruptoptimal" };
    constexpr Param<bool> USERESTART1TO2 { "solvingphases/userestart1to2" };
    constexpr Param<bool> USERESTART2TO3 { "solvingphases/userestart2to3" };
    constexpr Param<double> OPTIMALVALUE { "solvingphases/optimalvalue" };
    constexpr Param<char> XTYPE { "solvingphases/xtype" };
    constexpr Param<bool> USEEMPHSETTINGS { "solvingphases/useemphsettings" };
}
namespace TABLE::BENDERS {
    constexpr Param<bool> ACTIVE { "table/benders/active" };
}
namespace TABLE::BRANCHRULES {
    constexpr Param<bool> ACTIVE { "table/branchrules/active" };
}
namespace TABLE::COMPRESSION {
    constexpr Param<bool> ACTIVE { "table/compression/active" };
}
namespace TABLE::CONCURRENTSOLVER {
    constexpr Param<bool> ACTIVE { "table/concurrentsolver/active" };
}
namespace TABLE::CONFLICT {
    constexpr Param<bool> ACTIVE { "table/conflict/active" };
}
namespace TABLE::CONSTIMING {
    constexpr Param<bool> ACTIVE { "table/constiming/active" };
}
namespace TABLE::CONSTRAINT {
    constexpr Param<bool> ACTIVE { "table/constraint/active" };
}
namespace TABLE::CONS_NONLINEAR {
    constexpr Param<bool> ACTIVE { "table/cons_nonlinear/active" };
}
namespace TABLE::CUTSEL {
    constexpr Param<bool> ACTIVE { "table/cutsel/active" };
}
namespace TABLE::ESTIM {
    constexpr Param<bool> ACTIVE { "table/estim/active" };
}
namespace TABLE::EXPRHDLR {
    constexpr Param<bool> ACTIVE { "table/exprhdlr/active" };
}
namespace TABLE::HEURISTICS {
    constexpr Param<bool> ACTIVE { "table/heuristics/active" };
}
namespace TABLE::LP {
    constexpr Param<bool> ACTIVE { "table/lp/active" };
}
namespace TABLE::NEIGHBORHOOD {
    constexpr Param<bool> ACTIVE { "table/neighborhood/active" };
}
namespace TABLE::NLHDLR {
    constexpr Param<bool> ACTIVE { "table/nlhdlr/active" };
}
namespace TABLE::NLHDLR_BILINEAR {
    constexpr Param<bool> ACTIVE { "table/nlhdlr_bilinear/active" };
}
namespace TABLE::NLHDLR_QUADRATIC {
    constexpr Param<bool> ACTIVE { "table/nlhdlr_quadratic/active" };
}
namespace TABLE::NLP {
    constexpr Param<bool> ACTIVE { "table/nlp/active" };
}
namespace TABLE::NLPI {
    constexpr Param<bool> ACTIVE { "table/nlpi/active" };
}
namespace TABLE::ORBITALFIXING {
    constexpr Param<bool> ACTIVE { "table/orbitalfixing/active" };
}
namespace TABLE::ORIGPROB {
    constexpr Param<bool> ACTIVE { "table/origprob/active" };
}
namespace TABLE::PRESOLVEDPROB {
    constexpr Param<bool> ACTIVE { "table/presolvedprob/active" };
}
namespace TABLE::PRESOLVER {
    constexpr Param<bool> ACTIVE { "table/presolver/active" };
}
namespace TABLE::PRICER {
    constexpr Param<bool> ACTIVE { "table/pricer/active" };
}
namespace TABLE::PROPAGATOR {
    constexpr Param<bool> ACTIVE { "table/propagator/active" };
}
namespace TABLE::RELAXATOR {
    constexpr Param<bool> ACTIVE { "table/relaxator/active" };
}
namespace TABLE::ROOT {
    constexpr Param<bool> ACTIVE { "table/root/active" };
}
namespace TABLE::SEPARATOR {
    constexpr Param<bool> ACTIVE { "table/separator/active" };
}
namespace TABLE::SOLUTION {
    constexpr Param<bool> ACTIVE { "table/solution/active" };
}
namespace TABLE::STATUS {
    constexpr Param<bool> ACTIVE { "table/status/active" };
}
namespace TABLE::TIMING {
    constexpr Param<bool> ACTIVE { "table/timing/active" };
}
namespace TABLE::TREE {
    constexpr Param<bool> ACTIVE { "table/tree/active" };
}
namespace TIMING {
    constexpr Param<int> CLOCKTYPE { "timing/clocktype" };
    constexpr Param<bool> ENABLED { "timing/enabled" };
    constexpr Param<bool> READING { "timing/reading" };
    constexpr Param<bool> RARECLOCKCHECK { "timing/rareclockcheck" };
    constexpr Param<bool> STATISTICTIMING { "timing/statistictiming" };
    constexpr Param<bool> NLPIEVAL { "timing/nlpieval" };
}
namespace VISUAL {
    constexpr Param<std::string> VBCFILENAME { "visual/vbcfilename" };
    constexpr Param<std::string> BAKFILENAME { "visual/bakfilename" };
    constexpr Param<bool> REALTIME { "visual/realtime" };
    constexpr Param<bool> DISPSOLS { "visual/dispsols" };
    constexpr Param<bool> DISPLB { "visual/displb" };
    constexpr Param<bool> OBJEXTERN { "visual/objextern" };
}
namespace WRITE {
    constexpr Param<bool> ALLCONSS { "write/allconss" };
    constexpr Param<bool> PRINTZEROS { "write/printzeros" };
    constexpr Param<int> GENERICNAMESOFFSET { "write/genericnamesoffset" };
}
 
// NOLINTEND(readability-identifier-naming)
 
}