Once you started GCG, you can navigate through the menu. All expandable points of the menu are written inside brackets (<display>
, <set>
, ...) and everything else is just a keyword (read
, quit
, ...). Switching back to a higher level inside the menu can be done by simply typing ..
, going to the top level by just pressing enter. Finally, there are also real submenus (the master menu, the explore menu), which you have to leave with quit
.
Most often, you will need to change settings. This can be done using set
or fix
(parameters for fix
are the same as for set
, thus they are omitted in the list below). If you use fix
, the parameters will not be changeable throughout the execution of GCG. If you use set
, GCG will sometimes modify some parameters (e.g. for the The GCG Presolving). This also results in the set diffsave
command to not only write the parameters you changed (they appear at the bottom), but also some that GCG will always change by default.
You can click on an item to show its description. When searching, the command as well as its description will be searched for.

<change>
change the problem

change add
add constraint

change bounds
change bounds of a variable

change freetransproblem
free transformed problem

change objsense
change objective sense

<display>
display information

display additionalstatistics
display additional solving statistics

display benders
display Benders' decomposition

display blocknumbercandidates
display number of blocks candidates

display branching
display branching rules

display compression
display compression techniques

display conflict
display conflict handlers

display conshdlrs
display constraint handlers

display cutselectors
display cut selectors

display decomposition
display decomposition

display detectionstatistics
display complete detection information

display displaycols
display display columns

display dualsolution
display dual solution vector (LP only, without presolving)

display exprhdlrs
display expression handlers

display finitesolution
display best primal solution (try to make solution values finite, first)

display heuristics
display primal heuristics

display linclass
linear constraint classification as used for MIPLIB

display lpsolquality
display quality of the current LP solution, if available

display memory
display memory diagnostics

display nlpis
display NLP solver interfaces

display nodeselectors
display node selectors

display parameters
display nondefault parameter settings

display presolvers
display presolvers

display pricers
display pricers

display problem
display original problem

display propagators
display propagators

display readers
display file readers

display relaxators
display relaxators

display reoptstatistics
display reoptimization statistics

display separators
display cut separators

display sols
display solutions from pool

display solution
display best primal solution

display solvers
display available pricing problem solvers

display statistics
display problem and optimization statistics

display subproblem
display subproblem of a Benders' decomposition

display subsolution
display solution to the Benders' decomposition subproblems given the best master problem solution

display transproblem
display current node transformed problem

display transsolution
display best primal solution in transformed variables

display value
display value of single variable in best primal solution

display varbranchstatistics
display statistics for branching on variables

<graph>
graph submenu to read and write graph

graph <read>
read partition from file

graph read rowgraph
reads graph of given type

graph <write>
write graph to file

graph write rowgraph
writes graph of given type

<set>
load/save/change parameters

set <benders>
parameters for <benders>

set benders copybenders
should Benders' decomposition be copied for use in subSCIPs? [TRUE]

set benders cutlpsol
should Benders' cuts be generated from the solution to the LP relaxation? [TRUE]

set benders solutiontol
the tolerance used for checking optimality in Benders' decomposition. tol where optimality is given by LB + tol > UB. [1e06]

set <branching>
change parameters for branching rules

set branching <advanced>
advanced parameters

set branching advanced checksol
should LP solutions during strong branching with propagation be checked for feasibility? [TRUE]

set branching advanced firstsbchild
child node to be regarded first during strong branching (only with propagation): 'u'p child, 'd'own child, 'h'istorybased, or 'a'utomatic [a]

set branching advanced forceallchildren
should all strong branching children be regarded even if one is detected to be infeasible? (only with propagation) [FALSE]

set branching advanced roundsbsol
should LP solutions during strong branching with propagation be rounded? (only when checksbsol=TRUE) [TRUE]

set branching advanced scorefac
branching score factor to weigh downward and upward gain prediction in sum score function [0.167]

set branching advanced scorefunc
branching score function ('s'um, 'p'roduct, 'q'uotient) [p]

set branching advanced sumadjustscore
score adjustment near zero by adding epsilon (TRUE) or using maximum (FALSE) [FALSE]

set branching <bp_strong>
parameters for <bp_strong>

set branching bp_strong <ryanfoster>
parameters for <ryanfoster>

set branching bp_strong ryanfoster usemostfrac
should singlevariablefractionality be used as a heuristic for strong branching for RyanFoster branching? [FALSE]

set branching bp_strong ryanfoster usepseudocosts
should singlevariablepseudocosts be used as a heuristic for strong branching for RyanFoster branching? [TRUE]

set branching bp_strong closepercentage
what percentage of the strong branching score of the candidate that was selected does the heuristic's incumbent need to be considered close (e.g. 0.5 = 50%)? [0.9]

set branching bp_strong depthlogbase
what should be the base of the logarithm that is used to compute the depth of hybrid branching? [3.5]

set branching bp_strong depthlogphase0frac
if using a logarithm to compute the depth of hybrid branching, what should be the fraction of the depth assigned to phase 1 that is assigned to phase 0? [0.0]

set branching bp_strong depthlogphase2frac
if using a logarithm to compute the depth of hybrid branching, what should be the fraction of the depth assigned to phase 1 that is assigned to phase 2? [0.75]

set branching bp_strong depthlogweight
how much should the logarithm of the number of variables influence the depth for hybrid branching? (0 = not at all, 1 = fully) [0.5]

set branching bp_strong forcep0
should phase 0 be performed even if the number of input candidates is already lower or equal to the number of output candidates? [FALSE]

set branching bp_strong histweight
how many candidates should be chosen based on historical strong branching scores as opposed to current heuristic scores in phase 0 (e.g. 0.5 = 50%)? [0.5]

set branching bp_strong immediateinf
should infeasibility detected during strong branching be handled immediately, or only if the candidate is selected? [TRUE]

set branching bp_strong lookaheadscales
how much should the lookahead scale with the overall evaluation effort? (0 = not at all, 1 = fully) [0.5]

set branching bp_strong maxconsecheurclose
how many times in a row can the heuristic be close before strong branching is stopped? [4]

set branching bp_strong maxlookahead
maximum number of nonimproving candidates until phase 2 is stopped [8]

set branching bp_strong maxphase1depth
maximum tree depth up to which phase 1 is performed (intended for heuristics like pseudocost branching) [4]

set branching bp_strong maxphase2depth
maximum tree depth up to which phase 2 is performed (intended for heuristics like pseudocost branching) [3]

set branching bp_strong maxsblpiters
maximum number of strong branching lp iterations, set to 2*avg lp iterations if <= 0 [2147483647]

set branching bp_strong maxsbpricerounds
maximum number of strong branching price rounds, set to 2*avg lp iterations if <= 0 [2147483647]

set branching bp_strong mincolgencands
minimum number of variables for phase 2 to be executed, otherwise the best candidate from phase 1 will be chosen [4]

set branching bp_strong minphase0depth
minimum tree depth from which on phase 0 is performed (intended for heuristics like pseudocost branching) [0]

set branching bp_strong phase1reliable
min count of pseudocost scores for a variable to be considered reliable in phase 1 [2147483647]

set branching bp_strong phase2reliable
min count of pseudocost scores for a variable to be considered reliable in phase 2 [2147483647]

set branching bp_strong reevalage
how many times can bounds be changed due to infeasibility during strong branching until an already evaluated variable needs to be reevaluated? [1]

set branching bp_strong sbpseudocostweight
with how much weight should strong branching scores be considered for pseudocost scores? [1.0]

set branching bp_strong stronglite
should strong branching use column generation during variable evaluation? [FALSE]

set branching bp_strong strongtraining
should strong branching run as precise as possible (to generate more valuable training data)? [FALSE]

set branching <empty>
branching rule for the original problem while real branching is applied in the master

set branching empty maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes) [1.0]

set branching empty maxdepth
maximal depth level, up to which branching rule <empty> should be used (1 for no limit) [1]

set branching empty priority
priority of branching rule <empty> [1000000]

set branching <orig>
parameters for <orig>

set branching orig enforcebycons
should bounds on variables be enforced by constraints(TRUE) or by bounds(FALSE) [FALSE]

set branching orig maxphase0outcands
maximum number of output candidates from phase 0 during strong branching [50]

set branching orig maxphase0outcandsfrac
maximum number of output candidates from phase 0 as fraction of total cands during strong branching [0.7]

set branching orig maxphase1outcands
maximum number of output candidates from phase 1 during strong branching [20]

set branching orig maxphase1outcandsfrac
maximum number of output candidates from phase 1 as fraction of phase 1 cands during strong branching [0.7]

set branching orig minphase0outcands
minimum number of output candidates from phase 0 during strong branching [10]

set branching orig minphase1outcands
minimum number of output candidates from phase 1 during strong branching [3]

set branching orig mostfrac
should branching be performed on the most fractional variable? (only if usepseudocosts = FALSE) [FALSE]

set branching orig phase1gapweight
how much impact should the node gap have on the number of precisely evaluated candidates in phase 1 during strong branching? [0.25]

set branching orig phase2gapweight
how much impact should the node gap have on the number of precisely evaluated candidates in phase 2 during strong branching? [1.0]

set branching orig usepseudocosts
should pseudocosts be used to determine the variable on which the branching is performed? [TRUE]

set branching orig usepsstrong
should strong branching with propagation be used to determine the variable on which the branching is performed? (only if usepseudocosts = mostfrac = random = FALSE) [FALSE]

set branching orig userandom
should the variable on which the branching is performed be selected randomly? (only if usepseudocosts = mostfrac = FALSE) [TRUE]

set branching orig usestrong
should strong branching be used to determine the variable on which the branching is performed? [FALSE]

set branching <relpsprob>
parameters for <relpsprob>

set branching relpsprob <advanced>
advanced parameters

set branching relpsprob advanced conflictlengthweight
weight in score calculations for conflict length score [0.0001]

set branching relpsprob advanced conflictweight
weight in score calculations for conflict score [0.01]

set branching relpsprob advanced cutoffweight
weight in score calculations for cutoff score [0.0001]

set branching relpsprob advanced inferenceweight
weight in score calculations for inference score [0.1]

set branching relpsprob advanced maxbdchgs
maximal number of bound tightenings before the node is immediately reevaluated (1: unlimited) [20]

set branching relpsprob advanced maxlookahead
maximal number of further variables evaluated without better score [8]

set branching relpsprob advanced maxreliable
maximal value for minimum pseudo cost size to regard pseudo cost value as reliable [8.0]

set branching relpsprob advanced minbdchgs
minimal number of bound tightenings before bound changes are applied [1]

set branching relpsprob advanced minreliable
minimal value for minimum pseudo cost size to regard pseudo cost value as reliable [1.0]

set branching relpsprob advanced pscostweight
weight in score calculations for pseudo cost score [1.0]

set branching relpsprob initcand
maximal number of candidates initialized with strong branching per node [100]

set branching relpsprob iterofs
additional number of allowed LP iterations [100000]

set branching relpsprob iterquot
maximal fraction of branching LP iterations compared to node relaxation LP iterations [0.5]

set branching relpsprob reliability
reliability value for probing [0.8]

set branching relpsprob uselp
shall the LP be solved during probing? (TRUE) [TRUE]

set branching <ryanfoster>
parameters for <ryanfoster>

set branching ryanfoster maxphase0outcands
maximum number of output candidates from phase 0 during strong branching [50]

set branching ryanfoster maxphase0outcandsfrac
maximum number of output candidates from phase 0 as fraction of total cands during strong branching [0.7]

set branching ryanfoster maxphase1outcands
maximum number of output candidates from phase 1 during strong branching [20]

set branching ryanfoster maxphase1outcandsfrac
maximum number of output candidates from phase 1 as fraction of phase 1 cands during strong branching [0.7]

set branching ryanfoster minphase0outcands
minimum number of output candidates from phase 0 during strong branching [10]

set branching ryanfoster minphase1outcands
minimum number of output candidates from phase 1 during strong branching [3]

set branching ryanfoster phase1gapweight
how much impact should the node gap have on the number of precisely evaluated candidates in phase 1 during strong branching? [0.25]

set branching ryanfoster phase2gapweight
how much impact should the node gap have on the number of precisely evaluated candidates in phase 2 during strong branching? [1.0]

set branching ryanfoster usestrong
should strong branching be used to determine the variables on which the branching is performed? [FALSE]

set branching clamp
minimal relative distance of branching point to bounds when branching on a continuous variable [0.2]

set branching delaypscostupdate
should updating pseudo costs for continuous variables be delayed to the time after separation? [TRUE]

set branching direction
change preferred branching direction of a single variable (1:down, 0:auto, +1:up)

set branching divingpscost
should pseudo costs be updated also in diving and probing mode? [TRUE]

set branching lpgainnormalize
strategy for normalization of LP gain when updating pseudocosts of continuous variables (divide by movement of 'l'p value, reduction in 'd'omain width, or reduction in domain width of 's'ibling) [s]

set branching midpull
fraction by which to move branching point of a continuous variable towards the middle of the domain; a value of 1.0 leads to branching always in the middle of the domain [0.75]

set branching midpullreldomtrig
multiply midpull by relative domain width if the latter is below this value [0.5]

set branching preferbinary
should branching on binary variables be preferred? [FALSE]

set branching priority
change branching priority of a single variable

set <compression>
parameters for <compression>

set compression <advanced>
advanced parameters

set compression advanced enable
should automatic tree compression after the presolving be enabled? [FALSE]

set <concurrent>
parameters for <concurrent>

set concurrent <sync>
parameters for <sync>

set concurrent sync <advanced>
advanced parameters

set concurrent sync advanced maxnsyncdelay
maximum number of synchronizations before reading is enforced regardless of delay [7]

set concurrent sync freqfactor
factor by which the frequency of synchronization is changed [1.5]

set concurrent sync freqinit
initial frequency of synchronization with other threads [10.0]

set concurrent sync freqmax
maximal frequency of synchronization with other threads [10.0]

set concurrent sync maxnsols
maximum number of solutions that will be shared in a single synchronization [3]

set concurrent sync minsyncdelay
minimum delay before synchronization data is read [10.0]

set concurrent sync nbestsols
how many of the N best solutions should be considered for synchronization? [10]

set concurrent sync targetprogress
when adapting the synchronization frequency this value is the targeted relative difference by which the absolute gap decreases per synchronization [0.001]

set concurrent changechildsel
use different child selection rules in each concurrent solver? [TRUE]

set concurrent changeseeds
set different random seeds in each concurrent solver? [TRUE]

set concurrent commvarbnds
should the concurrent solvers communicate global variable bound changes? [TRUE]

set concurrent initseed
maximum number of solutions that will be shared in a one synchronization [5131912]

set concurrent paramsetprefix
path prefix for parameter setting files of concurrent solvers []

set concurrent presolvebefore
should the problem be presolved before it is copied to the concurrent solvers? [TRUE]

set <conflict>
change parameters for conflict handlers

set conflict <advanced>
advanced parameters

set conflict advanced allowlocal
should conflict constraints be generated that are only valid locally? [TRUE]

set conflict advanced cleanboundexceedings
should conflicts based on an old cutoff bound be removed from the conflict pool after improving the primal bound? [TRUE]

set conflict advanced downlockscorefac
score factor for down locks in bound relaxation heuristic [0.0]

set conflict advanced dynamic
should the conflict constraints be subject to aging? [TRUE]

set conflict advanced fuiplevels
number of depth levels up to which first UIP's are used in conflict analysis (1: use AllFirstUIP rule) [1]

set conflict advanced fullshortenconflict
try to shorten the whole conflict set or terminate early (depending on the 'maxvarsdetectimpliedbounds' parameter) [TRUE]

set conflict advanced ignorerelaxedbd
should relaxed bounds be ignored? [FALSE]

set conflict advanced interconss
maximal number of intermediate conflict constraints generated in conflict graph (1: use every intermediate constraint) [1]

set conflict advanced keepreprop
should constraints be kept for repropagation even if they are too long? [TRUE]

set conflict advanced lpiterations
maximal number of LP iterations in each LP resolving loop (1: no limit) [10]

set conflict advanced maxconss
maximal number of conflict constraints accepted at an infeasible node (1: use all generated conflict constraints) [10]

set conflict advanced maxlploops
maximal number of LP resolving loops during conflict analysis (1: no limit) [2]

set conflict advanced maxstoresize
maximal size of conflict store (1: auto, 0: disable storage) [10000]

set conflict advanced cleanboundexceedings
should conflicts based on an old cutoff bound be removed from the conflict pool after improving the primal bound? [TRUE]

set conflict advanced maxvarsfac
maximal fraction of variables involved in a conflict constraint [0.15]

set conflict advanced minimprove
minimal improvement of primal bound to remove conflicts based on a previous incumbent [0.05]

set conflict advanced minmaxvars
minimal absolute maximum of variables involved in a conflict constraint [0]

set conflict advanced prefinfproof
prefer infeasibility proof to boundexceeding proof [TRUE]

set conflict advanced proofscorefac
score factor for impact on acticity in bound relaxation heuristic [1.0]

set conflict advanced reconvlevels
number of depth levels up to which UIP reconvergence constraints are generated (1: generate reconvergence constraints in all depth levels) [1]

set conflict advanced removable
should the conflict's relaxations be subject to LP aging and cleanup? [TRUE]

set conflict advanced repropagate
should earlier nodes be repropagated in order to replace branching decisions by deductions? [TRUE]

set conflict advanced scorefac
factor to decrease importance of variables' earlier conflict scores [0.98]

set conflict advanced separate
should the conflict constraints be separated? [TRUE]

set conflict advanced settlelocal
should conflict constraints be attached only to the local subtree where they can be useful? [FALSE]

set conflict advanced uplockscorefac
score factor for up locks in bound relaxation heuristic [0.0]

set conflict advanced uselocalrows
use local rows to construct infeasibility proofs [TRUE]

set conflict advanced weightrepropdepth
weight of the repropagation depth of a conflict used in score calculation [0.1]

set conflict advanced weightsize
weight of the size of a conflict used in score calculation [0.001]

set conflict advanced weightvaliddepth
weight of the valid depth of a conflict used in score calculation [1.0]

set conflict <bounddisjunction>
conflict handler creating bound disjunction constraints

set conflict bounddisjunction <advanced>
advanced parameters

set conflict bounddisjunction advanced priority
priority of conflict handler <bounddisjunction> [3000000]

set conflict bounddisjunction continuousfrac
maximal percantage of continuous variables within a conflict [0.4]

set conflict <graph>
parameters for <graph>

set conflict graph <advanced>
advanced parameters

set conflict graph advanced depthscorefac
score factor for depth level in bound relaxation heuristic [1.0]

set conflict <indicatorconflict>
replace slack variables and generate logicor constraints

set conflict indicatorconflict <advanced>
advanced parameters

set conflict indicatorconflict advanced priority
priority of conflict handler <indicatorconflict> [200000]

set conflict <linear>
conflict handler creating linear constraints

set conflict linear <advanced>
advanced parameters

set conflict linear advanced priority
priority of conflict handler <linear> [1000000]

set conflict <logicor>
conflict handler creating logic or constraints

set conflict logicor <advanced>
advanced parameters

set conflict logicor advanced priority
priority of conflict handler <logicor> [800000]

set conflict <setppc>
conflict handler creating set covering constraints

set conflict setppc <advanced>
advanced parameters

set conflict setppc advanced priority
priority of conflict handler <setppc> [700000]

set conflict conflictgraphweight
the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict graph [1.0]

set conflict conflictweight
the weight the VSIDS score is weight by updating the VSIDS for a variable if it is part of a conflict [0.0]

set conflict enable
should conflict analysis be enabled? [FALSE]

set conflict preferbinary
should binary conflicts be preferred? [FALSE]

set conflict restartfac
factor to increase restartnum with after each restart [1.5]

set conflict restartnum
number of successful conflict analysis calls that trigger a restart (0: disable conflict restarts) [0]

set conflict sepaaltproofs
apply cut generating functions to construct alternative proofs [FALSE]

set conflict useboundlp
should bound exceeding LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray) [b]

set conflict useinflp
should infeasible LP conflict analysis be used? ('o'ff, 'c'onflict graph, 'd'ual ray, 'b'oth conflict graph and dual ray) [b]

set conflict useprop
should propagation conflict analysis be used? [TRUE]

set conflict usepseudo
should pseudo solution conflict analysis be used? [TRUE]

set conflict usesb
should infeasible/bound exceeding strong branching conflict analysis be used? [TRUE]

set <constraints>
change parameters for constraint handlers

set constraints <advanced>
advanced parameters

set constraints advanced agelimit
maximum age an unnecessary constraint can reach before it is deleted (0: dynamic, 1: keep all constraints) [0]

set constraints advanced disableenfops
should enforcement of pseudo solution be disabled? [FALSE]

set constraints advanced obsoleteage
age of a constraint after which it is marked obsolete (0: dynamic, 1 do not mark constraints obsolete) [1]

set constraints <and>
constraint handler for ANDconstraints: r = and(x1, ..., xn)

set constraints and <advanced>
advanced parameters

set constraints and advanced aggrlinearization
should an aggregated linearization be used? [FALSE]

set constraints and advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints and advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints and advanced dualpresolving
should dual presolving be performed? [TRUE]

set constraints and advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints and advanced enforcecuts
should cuts be separated during LP enforcing? [TRUE]

set constraints and advanced linearize
should the ANDconstraint get linearized and removed (in presolving)? [FALSE]

set constraints and advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints and advanced presolpairwise
should pairwise constraint comparison be performed in presolving? [TRUE]

set constraints and advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [20]

set constraints and advanced presolusehashing
should hash table be used for detecting redundant constraints in advance [TRUE]

set constraints and advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints and advanced upgraderesultant
should all binary resultant variables be upgraded to implicit binary variables? [TRUE]

set constraints and propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints and sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <bounddisjunction>
bound disjunction constraints

set constraints bounddisjunction <advanced>
advanced parameters

set constraints bounddisjunction advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints bounddisjunction advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints bounddisjunction advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints bounddisjunction advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints bounddisjunction advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set constraints bounddisjunction advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints bounddisjunction propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints bounddisjunction sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <decomp>
constraint handler for structure detection

set constraints decomp <advanced>
advanced parameters

set constraints decomp advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints decomp advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints decomp advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [1]

set constraints decomp advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [0]

set constraints decomp advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set constraints decomp advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints decomp propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints decomp sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <indicator>
indicator constraint handler

set constraints indicator <advanced>
advanced parameters

set constraints indicator advanced addcoupling
Add coupling constraints or rows if bigM is small enough? [TRUE]

set constraints indicator advanced addcouplingcons
Add initial variable upper bound constraints, if 'addcoupling' is true? [FALSE]

set constraints indicator advanced addopposite
Add opposite inequality in nodes in which the binary variable has been fixed to 0? [FALSE]

set constraints indicator advanced branchindicators
Branch on indicator constraints in enforcing? [FALSE]

set constraints indicator advanced conflictsupgrade
Try to upgrade bounddisjunction conflicts by replacing slack variables? [FALSE]

set constraints indicator advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints indicator advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints indicator advanced dualreductions
Should dual reduction steps be performed? [TRUE]

set constraints indicator advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints indicator advanced enforcecuts
In enforcing try to generate cuts (only if sepaalternativelp is true)? [FALSE]

set constraints indicator advanced forcerestart
Force restart if absolute gap is 1 or enough binary variables have been fixed? [FALSE]

set constraints indicator advanced generatebilinear
Do not generate indicator constraint, but a bilinear constraint instead? [FALSE]

set constraints indicator advanced genlogicor
Generate logicor constraints instead of cuts? [FALSE]

set constraints indicator advanced maxconditionaltlp
maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0.0 to disable check) [0.0]

set constraints indicator advanced maxcouplingvalue
maximum coefficient for binary variable in coupling constraint [10000.0]

set constraints indicator advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints indicator advanced nolinconscont
Decompose problem (do not generate linear constraint if all variables are continuous)? [FALSE]

set constraints indicator advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set constraints indicator advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints indicator advanced removeindicators
Remove indicator constraint if corresponding variable bound constraint has been added? [FALSE]

set constraints indicator advanced restartfrac
fraction of binary variables that need to be fixed before restart occurs (in forcerestart) [0.9]

set constraints indicator advanced scaleslackvar
Scale slack variable coefficient at construction time? [FALSE]

set constraints indicator advanced sepaalternativelp
Separate using the alternative LP? [FALSE]

set constraints indicator advanced sepacouplingcuts
Should the coupling inequalities be separated dynamically? [TRUE]

set constraints indicator advanced sepacouplinglocal
Allow to use local bounds in order to separate coupling inequalities? [FALSE]

set constraints indicator advanced sepacouplingvalue
maximum coefficient for binary variable in separated coupling constraint [10000.0]

set constraints indicator advanced sepaperspective
Separate cuts based on perspective formulation? [FALSE]

set constraints indicator advanced sepapersplocal
Allow to use local bounds in order to separate perspective cuts? [TRUE]

set constraints indicator advanced trysolfromcover
Try to construct a feasible solution from a cover? [FALSE]

set constraints indicator advanced trysolutions
Try to make solutions feasible by setting indicator variables? [TRUE]

set constraints indicator advanced updatebounds
Update bounds of original variables for separation? [FALSE]

set constraints indicator advanced upgradelinear
Try to upgrade linear constraints to indicator constraints? [FALSE]

set constraints indicator advanced useobjectivecut
Use objective cut with current best solution to alternative LP? [FALSE]

set constraints indicator advanced useotherconss
Collect other constraints to alternative LP? [FALSE]

set constraints indicator maxsepacuts
maximal number of cuts separated per separation round [100]

set constraints indicator maxsepacutsroot
maximal number of cuts separated per separation round in the root node [2000]

set constraints indicator maxsepanonviolated
maximal number of separated non violated IISs, before separation is stopped [3]

set constraints indicator propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints indicator sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <integral>
integrality constraint

set constraints integral <advanced>
advanced parameters

set constraints integral advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints integral advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints integral advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [1]

set constraints integral advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [0]

set constraints integral advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set constraints integral advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints integral propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints integral sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <knapsack>
knapsack constraint of the form a^T x <= b, x binary and a >= 0

set constraints knapsack <advanced>
advanced parameters

set constraints knapsack advanced cliqueextractfactor
lower clique size limit for greedy clique extraction algorithm (relative to largest clique) [0.5]

set constraints knapsack advanced clqpartupdatefac
factor on the growth of global cliques to decide when to update a previous (negated) clique partition (used only if updatecliquepartitions is set to TRUE) [1.5]

set constraints knapsack advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints knapsack advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints knapsack advanced detectcutoffbound
should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP? [TRUE]

set constraints knapsack advanced detectlowerbound
should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP? [TRUE]

set constraints knapsack advanced disaggregation
should disaggregation of knapsack constraints be allowed in preprocessing? [TRUE]

set constraints knapsack advanced dualpresolving
should dual presolving steps be performed? [TRUE]

set constraints knapsack advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints knapsack advanced maxcardbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cuts [0.0]

set constraints knapsack advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints knapsack advanced negatedclique
should negated clique information be used in solving process [TRUE]

set constraints knapsack advanced presolpairwise
should pairwise constraint comparison be performed in presolving? [TRUE]

set constraints knapsack advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set constraints knapsack advanced presolusehashing
should hash table be used for detecting redundant constraints in advance [TRUE]

set constraints knapsack advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints knapsack advanced sepacardfreq
multiplier on separation frequency, how often knapsack cuts are separated (1: never, 0: only at root) [1]

set constraints knapsack advanced simplifyinequalities
should presolving try to simplify knapsacks [TRUE]

set constraints knapsack advanced clqpartupdatefac
factor on the growth of global cliques to decide when to update a previous (negated) clique partition (used only if updatecliquepartitions is set to TRUE) [1.5]

set constraints knapsack advanced usegubs
should GUB information be used for separation? [FALSE]

set constraints knapsack maxrounds
maximal number of separation rounds per node (1: unlimited) [5]

set constraints knapsack maxroundsroot
maximal number of separation rounds per node in the root node (1: unlimited) [1]

set constraints knapsack maxsepacuts
maximal number of cuts separated per separation round [50]

set constraints knapsack maxsepacutsroot
maximal number of cuts separated per separation round in the root node [200]

set constraints knapsack propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints knapsack sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <linear>
linear constraints of the form lhs <= a^T x <= rhs

set constraints linear <advanced>
advanced parameters

set constraints linear advanced aggregatevariables
should presolving search for aggregations in equations [TRUE]

set constraints linear advanced checkrelmaxabs
should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)? [FALSE]

set constraints linear advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints linear advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints linear advanced detectcutoffbound
should presolving try to detect constraints parallel to the objective function defining an upper bound and prevent these constraints from entering the LP? [TRUE]

set constraints linear advanced detectlowerbound
should presolving try to detect constraints parallel to the objective function defining a lower bound and prevent these constraints from entering the LP? [TRUE]

set constraints linear advanced checkrelmaxabs
should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)? [FALSE]

set constraints linear advanced dualpresolving
should dual presolving steps be performed? [TRUE]

set constraints linear advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints linear advanced extractcliques
should Cliques be extracted? [TRUE]

set constraints linear advanced maxaggrnormscale
maximal allowed relative gain in maximum norm for constraint aggregation (0.0: disable constraint aggregation) [0.0]

set constraints linear advanced maxcardbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for separating knapsack cardinality cuts [0.0]

set constraints linear advanced maxdualmultaggrquot
maximum coefficient dynamism (ie. maxabsval / minabsval) for dual multiaggregation [1e+20]

set constraints linear advanced maxeasyactivitydelta
maximum activity delta to run easy propagation on linear constraint (faster, but numerically less stable) [1000000.0]

set constraints linear advanced maxmultaggrquot
maximum coefficient dynamism (ie. maxabsval / minabsval) for primal multiaggregation [1000.0]

set constraints linear advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints linear advanced checkrelmaxabs
should the violation for a constraint with side 0.0 be checked relative to 1.0 (FALSE) or to the maximum absolute value in the activity (TRUE)? [FALSE]

set constraints linear advanced multaggrremove
should multiaggregations only be performed if the constraint can be removed afterwards? [FALSE]

set constraints linear advanced nmincomparisons
number for minimal pairwise presolve comparisons [200000]

set constraints linear advanced presolpairwise
should pairwise constraint comparison be performed in presolving? [TRUE]

set constraints linear advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [20]

set constraints linear advanced presolusehashing
should hash table be used for detecting redundant constraints in advance [TRUE]

set constraints linear advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints linear advanced rangedrowartcons
should presolving and propagation extract subconstraints from ranged rows and equations? [TRUE]

set constraints linear advanced rangedrowfreq
frequency for applying ranged row propagation [1]

set constraints linear advanced rangedrowmaxdepth
maximum depth to apply ranged row propagation [2147483647]

set constraints linear advanced rangedrowpropagation
should presolving and propagation try to improve bounds, detect infeasibility, and extract subconstraints from ranged rows and equations? [TRUE]

set constraints linear advanced simplifyinequalities
should presolving try to simplify inequalities [TRUE]

set constraints linear advanced singletonstuffing
should stuffing of singleton continuous variables be performed? [TRUE]

set constraints linear advanced singlevarstuffing
should single variable stuffing be performed, which tries to fulfill constraints using the cheapest variable? [FALSE]

set constraints linear advanced sortvars
apply binaries sorting in decr. order of coeff abs value? [TRUE]

set constraints linear advanced tightenboundsfreq
multiplier on propagation frequency, how often the bounds are tightened (1: never, 0: only at root) [1]

set constraints linear <upgrade>
parameters for <upgrade>

set constraints linear upgrade indicator
enable linear upgrading for constraint handler <indicator> [TRUE]

set constraints linear upgrade knapsack
enable linear upgrading for constraint handler <knapsack> [TRUE]

set constraints linear upgrade logicor
enable linear upgrading for constraint handler <logicor> [TRUE]

set constraints linear upgrade setppc
enable linear upgrading for constraint handler <setppc> [TRUE]

set constraints linear upgrade varbound
enable linear upgrading for constraint handler <varbound> [TRUE]

set constraints linear upgrade xor
enable linear upgrading for constraint handler <xor> [TRUE]

set constraints linear maxrounds
maximal number of separation rounds per node (1: unlimited) [5]

set constraints linear maxroundsroot
maximal number of separation rounds per node in the root node (1: unlimited) [1]

set constraints linear maxsepacuts
maximal number of cuts separated per separation round [50]

set constraints linear maxsepacutsroot
maximal number of cuts separated per separation round in the root node [200]

set constraints linear propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints linear sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints linear separateall
should all constraints be subject to cardinality cut generation instead of only the ones with nonzero dual value? [FALSE]

set constraints <linking>
linking constraint x = sum_{i=1}^{n} c_i*y_i, y1+...+yn = 1, x real, y's binary

set constraints linking <advanced>
advanced parameters

set constraints linking advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints linking advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints linking advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints linking advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints linking advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [8]

set constraints linking advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints linking linearize
this constraint will not propagate or separate, linear and setppc are used? [FALSE]

set constraints linking propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints linking sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <logicor>
logic or constraints

set constraints logicor <advanced>
advanced parameters

set constraints logicor advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints logicor advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints logicor advanced dualpresolving
should dual presolving steps be performed? [TRUE]

set constraints logicor advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints logicor advanced implications
should implications/cliques be used in presolving [TRUE]

set constraints logicor advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints logicor advanced negatedclique
should negated clique information be used in presolving [TRUE]

set constraints logicor advanced presolpairwise
should pairwise constraint comparison be performed in presolving? [TRUE]

set constraints logicor advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set constraints logicor advanced presolusehashing
should hash table be used for detecting redundant constraints in advance [TRUE]

set constraints logicor advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints logicor advanced strengthen
should pairwise constraint comparison try to strengthen constraints by removing superflous nonzeros? [TRUE]

set constraints logicor propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints logicor sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <or>
constraint handler for or constraints: r = or(x1, ..., xn)

set constraints or <advanced>
advanced parameters

set constraints or advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints or advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints or advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints or advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints or advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [8]

set constraints or advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints or propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints or sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <orbitope>
symmetry breaking constraint handler relying on (partitioning/packing) orbitopes

set constraints orbitope <advanced>
advanced parameters

set constraints orbitope advanced checkpporbitope
Strengthen orbitope constraints to packing/partioning orbitopes? [TRUE]

set constraints orbitope advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints orbitope advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints orbitope advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [1]

set constraints orbitope advanced forceconscopy
Whether orbitope constraints should be forced to be copied to sub SCIPs. [FALSE]

set constraints orbitope advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints orbitope advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [8]

set constraints orbitope advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints orbitope advanced sepafullorbitope
Whether we separate inequalities for full orbitopes? [FALSE]

set constraints orbitope propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints orbitope sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <origbranch>
store branching decision at nodes of the tree constraint handler

set constraints origbranch <advanced>
advanced parameters

set constraints origbranch advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints origbranch advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints origbranch advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints origbranch advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [0]

set constraints origbranch advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set constraints origbranch advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints origbranch propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints origbranch sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <setppc>
set partitioning / packing / covering constraints

set constraints setppc <advanced>
advanced parameters

set constraints setppc advanced addvariablesascliques
should we try to generate extra cliques out of all binary variables to maybe fasten redundant constraint detection [FALSE]

set constraints setppc advanced cliquelifting
should we try to lift variables into other clique constraints, fix variables, aggregate them, and also shrink the amount of variables in clique constraints [FALSE]

set constraints setppc advanced cliqueshrinking
should we try to shrink the number of variables in a clique constraints, by replacing more than one variable by only one [TRUE]

set constraints setppc advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints setppc advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints setppc advanced dualpresolving
should dual presolving steps be performed? [TRUE]

set constraints setppc advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints setppc advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints setppc advanced npseudobranches
number of children created in pseudo branching (0: disable pseudo branching) [2]

set constraints setppc advanced presolpairwise
should pairwise constraint comparison be performed in presolving? [TRUE]

set constraints setppc advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set constraints setppc advanced presolusehashing
should hash table be used for detecting redundant constraints in advance [TRUE]

set constraints setppc advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints setppc propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints setppc sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints <varbound>
variable bounds lhs <= x + c*y <= rhs, x nonbinary, y noncontinuous

set constraints varbound <advanced>
advanced parameters

set constraints varbound advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints varbound advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints varbound advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints varbound advanced maxlpcoef
maximum coefficient in varbound constraint to be added as a row into LP [1000000000.0]

set constraints varbound advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints varbound advanced presolpairwise
should pairwise constraint comparison be performed in presolving? [TRUE]

set constraints varbound advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [12]

set constraints varbound advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints varbound propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints varbound sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set constraints varbound usebdwidening
should bound widening be used in conflict analysis? [TRUE]

set constraints <xor>
constraint handler for xor constraints: r = xor(x1, ..., xn)

set constraints xor <advanced>
advanced parameters

set constraints xor advanced addextendedform
should the extended formulation be added in presolving? [FALSE]

set constraints xor advanced addflowextended
should the extended flow formulation be added (nonsymmetric formulation otherwise)? [FALSE]

set constraints xor advanced delayprop
should propagation method be delayed, if other propagators found reductions? [FALSE]

set constraints xor advanced delaysepa
should separation method be delayed, if other separators found cuts? [FALSE]

set constraints xor advanced eagerfreq
frequency for using all instead of only the useful constraints in separation, propagation and enforcement (1: never, 0: only in first evaluation) [100]

set constraints xor advanced gausspropfreq
frequency for applying the Gauss propagator [5]

set constraints xor advanced maxprerounds
maximal number of presolving rounds the constraint handler participates in (1: no limit) [1]

set constraints xor advanced presolpairwise
should pairwise constraint comparison be performed in presolving? [TRUE]

set constraints xor advanced presoltiming
timing mask of the constraint handler's presolving method (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set constraints xor advanced presolusehashing
should hash table be used for detecting redundant constraints in advance? [TRUE]

set constraints xor advanced proptiming
timing when constraint propagation should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS) [1]

set constraints xor advanced separateparity
should parity inequalities be separated? [FALSE]

set constraints xor propfreq
frequency for propagating domains (1: never, 0: only in root node) [1]

set constraints xor sepafreq
frequency for separating cuts (1: never, 0: only in root node) [1]

set <cutselection>
change parameters for cut selectors

set cutselection <hybrid>
weighted sum of efficacy, dircutoffdist, objparal, and intsupport

set cutselection hybrid dircutoffdistweight
weight of directed cutoff distance in cut score calculation [0.0]

set cutselection hybrid efficacyweight
weight of efficacy in cut score calculation [1.0]

set cutselection hybrid intsupportweight
weight of integral support in cut score calculation [0.1]

set cutselection hybrid minortho
minimal orthogonality for a cut to enter the LP [0.9]

set cutselection hybrid minorthoroot
minimal orthogonality for a cut to enter the LP in the root node [0.9]

set cutselection hybrid objparalweight
weight of objective parallelism in cut score calculation [0.1]

set cutselection hybrid priority
priority of cut selection rule <hybrid> [8000]

set <decomposition>
parameters for <decomposition>

set decomposition applybenders
if a decomposition exists, should Benders' decomposition be applied? [FALSE]

set decomposition benderslabels
should the variables be labelled for the application of Benders' decomposition? [FALSE]

set decomposition disablemeasures
disable expensive measures [FALSE]

set decomposition maxgraphedge
maximum number of edges in block graph computation (1: no limit, 0: disable block graph computation) [10000]

set <detection>
change parameters for detection in general

set detection <aggregation>
parameters for <aggregation>

set detection aggregation limitnconssperblock
Limits the number of constraints of a block (aggregation information for block is not calculated when exceeded) [300]

set detection aggregation limitnvarsperblock
Limits the number of variables of a block (aggregation information for block is not calculated when exceeded) [300]

set detection <benders>
parameters for <benders>

set detection benders enabled
Enables benders detection [FALSE]

set detection benders onlybinmaster
If enabled only decomposition with only binary variables in the master are searched [FALSE]

set detection benders onlycontsubpr
If enabled only decomposition with only continiuous variables in the subproblems are searched [FALSE]

set detection <blocknrcandidates>
set block number and related parameter

set detection blocknrcandidates addblocknr
add block number candidates (as white space separated list)

set detection blocknrcandidates maxnclasses
Maximum number of classes a partition can use for voting nblockcandidates [18]

set detection blocknrcandidates medianvarspercons
Enables the use of medianvarspercons calculation for block number candidates calculation [FALSE]

set detection <classification>
classification settings

set detection classification <consclassifier>
parameters for <consclassifier>

set detection classification consclassifier <consnamelevenshtein>
parameters for <consnamelevenshtein>

set detection classification consclassifier consnamelevenshtein enabled
flag to indicate whether constraint classifier for <constraint names (according to levenshtein distance graph)> is enabled [FALSE]

set detection classification consclassifier <consnamenonumbers>
parameters for <consnamenonumbers>

set detection classification consclassifier consnamenonumbers enabled
flag to indicate whether constraint classifier for <constraint names (remove digits; check for identity)> is enabled [FALSE]

set detection classification consclassifier <gamsdomain>
parameters for <gamsdomain>

set detection classification consclassifier gamsdomain enabled
flag to indicate whether constraint classifier for <domain in GAMS file> is enabled [TRUE]

set detection classification consclassifier <gamssymbol>
parameters for <gamssymbol>

set detection classification consclassifier gamssymbol enabled
flag to indicate whether constraint classifier for <symbol in GAMS file> is enabled [TRUE]

set detection classification consclassifier <miplibconstype>
parameters for <miplibconstype>

set detection classification consclassifier miplibconstype enabled
flag to indicate whether constraint classifier for <miplib constypes> is enabled [TRUE]

set detection classification consclassifier <nnonzeros>
parameters for <nnonzeros>

set detection classification consclassifier nnonzeros enabled
flag to indicate whether constraint classifier for <nnonezero entries> is enabled [TRUE]

set detection classification consclassifier <scipconstype>
parameters for <scipconstype>

set detection classification consclassifier scipconstype enabled
flag to indicate whether constraint classifier for <scip constypes> is enabled [TRUE]

set detection classification <varclassifier>
parameters for <varclassifier>

set detection classification varclassifier <gamsdomain>
parameters for <gamsdomain>

set detection classification varclassifier gamsdomain enabled
flag to indicate whether variable classifier for <domain in gams file> is enabled [TRUE]

set detection classification varclassifier <gamssymbol>
parameters for <gamssymbol>

set detection classification varclassifier gamssymbol enabled
flag to indicate whether variable classifier for <symbol in gams file> is enabled [TRUE]

set detection classification varclassifier <objectivevalues>
parameters for <objectivevalues>

set detection classification varclassifier objectivevalues enabled
flag to indicate whether variable classifier for <objective function values> is enabled [TRUE]

set detection classification varclassifier <objectivevaluesigns>
parameters for <objectivevaluesigns>

set detection classification varclassifier objectivevaluesigns enabled
flag to indicate whether variable classifier for <objective function value signs> is enabled [TRUE]

set detection classification varclassifier <scipvartype>
parameters for <scipvartype>

set detection classification varclassifier scipvartype enabled
flag to indicate whether variable classifier for <scipvartypes> is enabled [TRUE]

set detection classification allowduplicates
If enabled partition duplicates are allowed (for statistical reasons) [FALSE]

set detection classification enabled
Enables classification [TRUE]

set detection classification <varclassifier>
parameters for <varclassifier>

set detection classification varclassifier <gamsdomain>
parameters for <gamsdomain>

set detection classification varclassifier gamsdomain enabled
flag to indicate whether variable classifier for <domain in gams file> is enabled [TRUE]

set detection classification varclassifier <gamssymbol>
parameters for <gamssymbol>

set detection classification varclassifier gamssymbol enabled
flag to indicate whether variable classifier for <symbol in gams file> is enabled [TRUE]

set detection classification varclassifier <objectivevalues>
parameters for <objectivevalues>

set detection classification varclassifier objectivevalues enabled
flag to indicate whether variable classifier for <objective function values> is enabled [TRUE]

set detection classification varclassifier <objectivevaluesigns>
parameters for <objectivevaluesigns>

set detection classification varclassifier objectivevaluesigns enabled
flag to indicate whether variable classifier for <objective function value signs> is enabled [TRUE]

set detection classification varclassifier <scipvartype>
parameters for <scipvartype>

set detection classification varclassifier scipvartype enabled
flag to indicate whether variable classifier for <scipvartypes> is enabled [TRUE]

set detection classification <varclassifier>
parameters for <varclassifier>

set detection classification varclassifier <gamsdomain>
parameters for <gamsdomain>

set detection classification varclassifier gamsdomain enabled
flag to indicate whether variable classifier for <domain in gams file> is enabled [TRUE]

set detection classification varclassifier <gamssymbol>
parameters for <gamssymbol>

set detection classification varclassifier gamssymbol enabled
flag to indicate whether variable classifier for <symbol in gams file> is enabled [TRUE]

set detection classification varclassifier <objectivevalues>
parameters for <objectivevalues>

set detection classification varclassifier objectivevalues enabled
flag to indicate whether variable classifier for <objective function values> is enabled [TRUE]

set detection classification varclassifier <objectivevaluesigns>
parameters for <objectivevaluesigns>

set detection classification varclassifier objectivevaluesigns enabled
flag to indicate whether variable classifier for <objective function value signs> is enabled [TRUE]

set detection classification varclassifier <scipvartype>
parameters for <scipvartype>

set detection classification varclassifier scipvartype enabled
flag to indicate whether variable classifier for <scipvartypes> is enabled [TRUE]

set detection <detectors>
parameters for <detectors>

set detection detectors <compgreedily>
parameters for <compgreedily>

set detection detectors compgreedily enabled
flag to indicate whether detector <compgreedily> is enabled [FALSE]

set detection detectors compgreedily finishingenabled
flag to indicate whether detector <compgreedily> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors compgreedily freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <compgreedily> [1]

set detection detectors compgreedily maxcallround
maximum round the detector gets called in detection loop <compgreedily> [2147483647]

set detection detectors compgreedily mincallround
minimum round the detector gets called in detection loop <compgreedily> [0]

set detection detectors compgreedily origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <compgreedily> [1]

set detection detectors compgreedily origmaxcallround
maximum round the detector gets called in detection loop <compgreedily> [2147483647]

set detection detectors compgreedily origmincallround
minimum round the detector gets called in detection loop <compgreedily> [0]

set detection detectors compgreedily overruleemphasis
flag to indicate whether emphasis settings for detector <compgreedily> should be overruled by normal settings [FALSE]

set detection detectors compgreedily postprocessingenabled
flag to indicate whether detector <compgreedily> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors compgreedily priority
priority of detector <compgreedily> [0]

set detection detectors compgreedily skip
flag to indicate whether detector <compgreedily> should be skipped if others found decompositions [FALSE]

set detection detectors compgreedily usefullrecall
flag to indicate whether detector <compgreedily> should be called on descendants of the current partialdec [FALSE]

set detection detectors <connected_nonewlinkingvars>
parameters for <connected_nonewlinkingvars>

set detection detectors connected_nonewlinkingvars enabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled [FALSE]

set detection detectors connected_nonewlinkingvars finishingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors connected_nonewlinkingvars freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars maxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars mincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars origmaxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars origmincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars overruleemphasis
flag to indicate whether emphasis settings for detector <connected_nonewlinkingvars> should be overruled by normal settings [FALSE]

set detection detectors connected_nonewlinkingvars postprocessingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors connected_nonewlinkingvars priority
priority of detector <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars skip
flag to indicate whether detector <connected_nonewlinkingvars> should be skipped if others found decompositions [FALSE]

set detection detectors connected_nonewlinkingvars usefullrecall
flag to indicate whether detector <connected_nonewlinkingvars> should be called on descendants of the current partialdec [FALSE]

set detection detectors <connectedbase>
parameters for <connectedbase>

set detection detectors connectedbase enabled
flag to indicate whether detector <connectedbase> is enabled [FALSE]

set detection detectors connectedbase finishingenabled
flag to indicate whether detector <connectedbase> is enabled for finishing of incomplete decompositions [TRUE]

set detection detectors connectedbase freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connectedbase> [1]

set detection detectors connectedbase maxcallround
maximum round the detector gets called in detection loop <connectedbase> [2147483647]

set detection detectors connectedbase mincallround
minimum round the detector gets called in detection loop <connectedbase> [0]

set detection detectors connectedbase origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connectedbase> [1]

set detection detectors connectedbase origmaxcallround
maximum round the detector gets called in detection loop <connectedbase> [2147483647]

set detection detectors connectedbase origmincallround
minimum round the detector gets called in detection loop <connectedbase> [0]

set detection detectors connectedbase overruleemphasis
flag to indicate whether emphasis settings for detector <connectedbase> should be overruled by normal settings [FALSE]

set detection detectors connectedbase postprocessingenabled
flag to indicate whether detector <connectedbase> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors connectedbase priority
priority of detector <connectedbase> [0]

set detection detectors connectedbase skip
flag to indicate whether detector <connectedbase> should be skipped if others found decompositions [FALSE]

set detection detectors connectedbase useconssadj
should the constraint adjacency be used [TRUE]

set detection detectors connectedbase usefullrecall
flag to indicate whether detector <connectedbase> should be called on descendants of the current partialdec [FALSE]

set detection detectors <consclass>
parameters for <consclass>

set detection detectors consclass enabled
flag to indicate whether detector <consclass> is enabled [TRUE]

set detection detectors consclass finishingenabled
flag to indicate whether detector <consclass> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors consclass freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <consclass> [1]

set detection detectors consclass maxcallround
maximum round the detector gets called in detection loop <consclass> [0]

set detection detectors consclass maxnclasses
maximum number of classes [5]

set detection detectors consclass mincallround
minimum round the detector gets called in detection loop <consclass> [0]

set detection detectors consclass origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <consclass> [1]

set detection detectors consclass origmaxcallround
maximum round the detector gets called in detection loop <consclass> [2147483647]

set detection detectors consclass origmincallround
minimum round the detector gets called in detection loop <consclass> [0]

set detection detectors consclass overruleemphasis
flag to indicate whether emphasis settings for detector <consclass> should be overruled by normal settings [FALSE]

set detection detectors consclass postprocessingenabled
flag to indicate whether detector <consclass> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors consclass priority
priority of detector <consclass> [0]

set detection detectors consclass skip
flag to indicate whether detector <consclass> should be skipped if others found decompositions [FALSE]

set detection detectors consclass usefullrecall
flag to indicate whether detector <consclass> should be called on descendants of the current partialdec [FALSE]

set detection detectors <constype>
parameters for <constype>

set detection detectors constype enabled
flag to indicate whether detector <constype> is enabled [FALSE]

set detection detectors constype finishingenabled
flag to indicate whether detector <constype> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors constype freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <constype> [1]

set detection detectors constype maxcallround
maximum round the detector gets called in detection loop <constype> [0]

set detection detectors constype mincallround
minimum round the detector gets called in detection loop <constype> [0]

set detection detectors constype origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <constype> [1]

set detection detectors constype origmaxcallround
maximum round the detector gets called in detection loop <constype> [0]

set detection detectors constype origmincallround
minimum round the detector gets called in detection loop <constype> [0]

set detection detectors constype overruleemphasis
flag to indicate whether emphasis settings for detector <constype> should be overruled by normal settings [FALSE]

set detection detectors constype postprocessingenabled
flag to indicate whether detector <constype> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors constype priority
priority of detector <constype> [0]

set detection detectors constype skip
flag to indicate whether detector <constype> should be skipped if others found decompositions [FALSE]

set detection detectors constype usefullrecall
flag to indicate whether detector <constype> should be called on descendants of the current partialdec [FALSE]

set detection detectors <densemasterconss>
parameters for <densemasterconss>

set detection detectors densemasterconss enabled
flag to indicate whether detector <densemasterconss> is enabled [TRUE]

set detection detectors densemasterconss finishingenabled
flag to indicate whether detector <densemasterconss> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors densemasterconss freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <densemasterconss> [1]

set detection detectors densemasterconss maxcallround
maximum round the detector gets called in detection loop <densemasterconss> [0]

set detection detectors densemasterconss mincallround
minimum round the detector gets called in detection loop <densemasterconss> [0]

set detection detectors densemasterconss origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <densemasterconss> [1]

set detection detectors densemasterconss origmaxcallround
maximum round the detector gets called in detection loop <densemasterconss> [2147483647]

set detection detectors densemasterconss origmincallround
minimum round the detector gets called in detection loop <densemasterconss> [0]

set detection detectors densemasterconss overruleemphasis
flag to indicate whether emphasis settings for detector <densemasterconss> should be overruled by normal settings [FALSE]

set detection detectors densemasterconss postprocessingenabled
flag to indicate whether detector <densemasterconss> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors densemasterconss priority
priority of detector <densemasterconss> [0]

set detection detectors densemasterconss skip
flag to indicate whether detector <densemasterconss> should be skipped if others found decompositions [FALSE]

set detection detectors densemasterconss usefullrecall
flag to indicate whether detector <densemasterconss> should be called on descendants of the current partialdec [FALSE]

set detection detectors <connected_nonewlinkingvars>
parameters for <connected_nonewlinkingvars>

set detection detectors connected_nonewlinkingvars enabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled [FALSE]

set detection detectors connected_nonewlinkingvars finishingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors connected_nonewlinkingvars freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars maxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars mincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars origmaxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars origmincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars overruleemphasis
flag to indicate whether emphasis settings for detector <connected_nonewlinkingvars> should be overruled by normal settings [FALSE]

set detection detectors connected_nonewlinkingvars postprocessingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors connected_nonewlinkingvars priority
priority of detector <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars skip
flag to indicate whether detector <connected_nonewlinkingvars> should be skipped if others found decompositions [FALSE]

set detection detectors connected_nonewlinkingvars usefullrecall
flag to indicate whether detector <connected_nonewlinkingvars> should be called on descendants of the current partialdec [FALSE]

set detection detectors <connected_nonewlinkingvars>
parameters for <connected_nonewlinkingvars>

set detection detectors connected_nonewlinkingvars enabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled [FALSE]

set detection detectors connected_nonewlinkingvars finishingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors connected_nonewlinkingvars freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars maxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars mincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars origmaxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars origmincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars overruleemphasis
flag to indicate whether emphasis settings for detector <connected_nonewlinkingvars> should be overruled by normal settings [FALSE]

set detection detectors connected_nonewlinkingvars postprocessingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors connected_nonewlinkingvars priority
priority of detector <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars skip
flag to indicate whether detector <connected_nonewlinkingvars> should be skipped if others found decompositions [FALSE]

set detection detectors connected_nonewlinkingvars usefullrecall
flag to indicate whether detector <connected_nonewlinkingvars> should be called on descendants of the current partialdec [FALSE]

set detection detectors <connected_nonewlinkingvars>
parameters for <connected_nonewlinkingvars>

set detection detectors connected_nonewlinkingvars enabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled [FALSE]

set detection detectors connected_nonewlinkingvars finishingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors connected_nonewlinkingvars freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars maxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars mincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <connected_nonewlinkingvars> [1]

set detection detectors connected_nonewlinkingvars origmaxcallround
maximum round the detector gets called in detection loop <connected_nonewlinkingvars> [2147483647]

set detection detectors connected_nonewlinkingvars origmincallround
minimum round the detector gets called in detection loop <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars overruleemphasis
flag to indicate whether emphasis settings for detector <connected_nonewlinkingvars> should be overruled by normal settings [FALSE]

set detection detectors connected_nonewlinkingvars postprocessingenabled
flag to indicate whether detector <connected_nonewlinkingvars> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors connected_nonewlinkingvars priority
priority of detector <connected_nonewlinkingvars> [0]

set detection detectors connected_nonewlinkingvars skip
flag to indicate whether detector <connected_nonewlinkingvars> should be skipped if others found decompositions [FALSE]

set detection detectors connected_nonewlinkingvars usefullrecall
flag to indicate whether detector <connected_nonewlinkingvars> should be called on descendants of the current partialdec [FALSE]

set detection detectors <hcgpartition>
parameters for <hcgpartition>

set detection detectors hcgpartition alpha
Factor on how heavy the standard deviation of the coefficients is measured [0.0]

set detection detectors hcgpartition beta
Factor on how heavy equality (beta) and inequality constraints are measured [0.5]

set detection detectors hcgpartition consWeight
Weight of a constraint hyperedge [5]

set detection detectors hcgpartition consWeightSetppc
Weight for constraint hyperedges that are setpartitioning or covering constraints [5]

set detection detectors hcgpartition dummynodes
Percentage of dummy nodes for metis [0.2]

set detection detectors hcgpartition enabled
flag to indicate whether detector <hcgpartition> is enabled [FALSE]

set detection detectors hcgpartition finishingenabled
flag to indicate whether detector <hcgpartition> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors hcgpartition freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <hcgpartition> [1]

set detection detectors hcgpartition maxblocks
The maximal number of blocks (detector is called for all block numbers in [minblocks,maxblocks]) [20]

set detection detectors hcgpartition maxcallround
maximum round the detector gets called in detection loop <hcgpartition> [0]

set detection detectors hcgpartition maxnblockcandidates
The maximal number of block number candidates [1]

set detection detectors hcgpartition metisuseptyperb
Should the rb or kway method be used for partitioning by metis [TRUE]

set detection detectors hcgpartition metisverbose
Should the metis output be displayed [FALSE]

set detection detectors hcgpartition minblocks
The minimal number of blocks (detector is called for all block numbers in [minblocks,maxblocks]) [2]

set detection detectors hcgpartition mincallround
minimum round the detector gets called in detection loop <hcgpartition> [0]

set detection detectors hcgpartition origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <hcgpartition> [1]

set detection detectors hcgpartition origmaxcallround
maximum round the detector gets called in detection loop <hcgpartition> [0]

set detection detectors hcgpartition origmincallround
minimum round the detector gets called in detection loop <hcgpartition> [0]

set detection detectors hcgpartition overruleemphasis
flag to indicate whether emphasis settings for detector <hcgpartition> should be overruled by normal settings [FALSE]

set detection detectors hcgpartition postprocessingenabled
flag to indicate whether detector <hcgpartition> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors hcgpartition priority
priority of detector <hcgpartition> [1000]

set detection detectors hcgpartition randomseed
Random seed for hmetis [1]

set detection detectors hcgpartition realname
Should the problem be used for metis files or a temporary name [FALSE]

set detection detectors hcgpartition skip
flag to indicate whether detector <hcgpartition> should be skipped if others found decompositions [FALSE]

set detection detectors hcgpartition tidy
Whether to clean up temporary files [TRUE]

set detection detectors hcgpartition ubfactor
Unbalance factor for metis [5.0]

set detection detectors hcgpartition usefullrecall
flag to indicate whether detector <hcgpartition> should be called on descendants of the current partialdec [TRUE]

set detection detectors hcgpartition varWeight
Weight of a variable hyperedge [1]

set detection detectors hcgpartition varWeightBinary
Weight of a binary variable hyperedge [2]

set detection detectors hcgpartition varWeightContinous
Weight of a continuos variable hyperedge [1]

set detection detectors hcgpartition varWeightImplint
Weight of a implicit integer variable hyperedge [2]

set detection detectors hcgpartition varWeightInteger
Weight of a integer variable hyperedge [2]

set detection detectors <hrcgpartition>
parameters for <hrcgpartition>

set detection detectors hrcgpartition alpha
Factor on how heavy the standard deviation of the coefficients is measured [0.0]

set detection detectors hrcgpartition beta
Factor on how heavy equality (beta) and inequality constraints are measured [0.5]

set detection detectors hrcgpartition consWeight
Weight of a constraint hyperedge [1]

set detection detectors hrcgpartition consWeightSetppc
Weight for constraint hyperedges that are setpartitioning or covering constraints [5]

set detection detectors hrcgpartition dummynodes
Percentage of dummy nodes for metis [0.2]

set detection detectors hrcgpartition enabled
flag to indicate whether detector <hrcgpartition> is enabled [FALSE]

set detection detectors hrcgpartition finishingenabled
flag to indicate whether detector <hrcgpartition> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors hrcgpartition freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <hrcgpartition> [1]

set detection detectors hrcgpartition maxblocks
The maximal number of blocks (detector is called for all block numbers in [minblocks,maxblocks]) [20]

set detection detectors hrcgpartition maxcallround
maximum round the detector gets called in detection loop <hrcgpartition> [1]

set detection detectors hrcgpartition maxnblockcandidates
The maximal number of block number candidates [3]

set detection detectors hrcgpartition metisuseptyperb
Should the rb or kway method be used for partitioning by metis [TRUE]

set detection detectors hrcgpartition metisverbose
Should the metis output be displayed [FALSE]

set detection detectors hrcgpartition minblocks
The minimal number of blocks (detector is called for all block numbers in [minblocks,maxblocks]) [2]

set detection detectors hrcgpartition mincallround
minimum round the detector gets called in detection loop <hrcgpartition> [0]

set detection detectors hrcgpartition origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <hrcgpartition> [1]

set detection detectors hrcgpartition origmaxcallround
maximum round the detector gets called in detection loop <hrcgpartition> [1]

set detection detectors hrcgpartition origmincallround
minimum round the detector gets called in detection loop <hrcgpartition> [0]

set detection detectors hrcgpartition overruleemphasis
flag to indicate whether emphasis settings for detector <hrcgpartition> should be overruled by normal settings [FALSE]

set detection detectors hrcgpartition postprocessingenabled
flag to indicate whether detector <hrcgpartition> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors hrcgpartition priority
priority of detector <hrcgpartition> [1000]

set detection detectors hrcgpartition randomseed
Random seed for hmetis [1]

set detection detectors hrcgpartition realname
Should the problem be used for metis files or a temporary name [FALSE]

set detection detectors hrcgpartition skip
flag to indicate whether detector <hrcgpartition> should be skipped if others found decompositions [FALSE]

set detection detectors hrcgpartition tidy
Whether to clean up temporary files [TRUE]

set detection detectors hrcgpartition ubfactor
Unbalance factor for metis [5.0]

set detection detectors hrcgpartition usefullrecall
flag to indicate whether detector <hrcgpartition> should be called on descendants of the current partialdec [TRUE]

set detection detectors hrcgpartition varWeight
Weight of a variable hyperedge [2]

set detection detectors hrcgpartition varWeightBinary
Weight of a binary variable hyperedge [3]

set detection detectors hrcgpartition varWeightContinous
Weight of a continuos variable hyperedge [2]

set detection detectors hrcgpartition varWeightImplint
Weight of a implicit integer variable hyperedge [3]

set detection detectors hrcgpartition varWeightInteger
Weight of a integer variable hyperedge [3]

set detection detectors <hrgpartition>
parameters for <hrgpartition>

set detection detectors hrgpartition <advanced>
advanced parameters

set detection detectors hrgpartition alpha
Factor on how heavy the standard deviation of the coefficients is measured [0.0]

set detection detectors hrgpartition beta
Factor on how heavy equality (beta) and inequality constraints are measured [0.5]

set detection detectors hrgpartition consWeight
Weight of a constraint hyperedge [5]

set detection detectors hrgpartition consWeightSetppc
Weight for constraint hyperedges that are setpartitioning or covering constraints [5]

set detection detectors hrgpartition dummynodes
Percentage of dummy nodes for metis [0.2]

set detection detectors hrgpartition enabled
flag to indicate whether detector <hrgpartition> is enabled [FALSE]

set detection detectors hrgpartition finishingenabled
flag to indicate whether detector <hrgpartition> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors hrgpartition freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <hrgpartition> [1]

set detection detectors hrgpartition maxblocks
The maximal number of blocks (detector is called for all block numbers in [minblocks,maxblocks]) [20]

set detection detectors hrgpartition maxcallround
maximum round the detector gets called in detection loop <hrgpartition> [0]

set detection detectors hrgpartition maxnblockcandidates
The maximal number of block number candidates [3]

set detection detectors hrgpartition metisuseptyperb
Should the rb or kway method be used for partitioning by metis [TRUE]

set detection detectors hrgpartition metisverbose
Should the metis output be displayed [FALSE]

set detection detectors hrgpartition minblocks
The minimal number of blocks (detector is called for all block numbers in [minblocks,maxblocks]) [2]

set detection detectors hrgpartition mincallround
minimum round the detector gets called in detection loop <hrgpartition> [0]

set detection detectors hrgpartition origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <hrgpartition> [1]

set detection detectors hrgpartition origmaxcallround
maximum round the detector gets called in detection loop <hrgpartition> [0]

set detection detectors hrgpartition origmincallround
minimum round the detector gets called in detection loop <hrgpartition> [0]

set detection detectors hrgpartition overruleemphasis
flag to indicate whether emphasis settings for detector <hrgpartition> should be overruled by normal settings [FALSE]

set detection detectors hrgpartition postprocessingenabled
flag to indicate whether detector <hrgpartition> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors hrgpartition priority
priority of detector <hrgpartition> [1000]

set detection detectors hrgpartition randomseed
Random seed for hmetis [1]

set detection detectors hrgpartition realname
Should the problem be used for metis files or a temporary name [FALSE]

set detection detectors hrgpartition skip
flag to indicate whether detector <hrgpartition> should be skipped if others found decompositions [FALSE]

set detection detectors hrgpartition tidy
Whether to clean up temporary files [TRUE]

set detection detectors hrgpartition ubfactor
Unbalance factor for metis [5.0]

set detection detectors hrgpartition usefullrecall
flag to indicate whether detector <hrgpartition> should be called on descendants of the current partialdec [TRUE]

set detection detectors hrgpartition varWeight
Weight of a variable hyperedge [1]

set detection detectors hrgpartition varWeightBinary
Weight of a binary variable hyperedge [2]

set detection detectors hrgpartition varWeightContinous
Weight of a continuos variable hyperedge [1]

set detection detectors hrgpartition varWeightImplint
Weight of a implicit integer variable hyperedge [2]

set detection detectors hrgpartition varWeightInteger
Weight of a integer variable hyperedge [2]

set detection detectors <isomorph>
parameters for <isomorph>

set detection detectors isomorph enabled
flag to indicate whether detector <isomorph> is enabled [FALSE]

set detection detectors isomorph finishingenabled
flag to indicate whether detector <isomorph> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors isomorph freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <isomorph> [1]

set detection detectors isomorph maxcallround
maximum round the detector gets called in detection loop <isomorph> [0]

set detection detectors isomorph maxdecompsexact
Maximum number of solutions/decompositions with exact detection [6]

set detection detectors isomorph maxdecompsextend
Maximum number of solutions/decompositions with extended detection [4]

set detection detectors isomorph mincallround
minimum round the detector gets called in detection loop <isomorph> [0]

set detection detectors isomorph origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <isomorph> [1]

set detection detectors isomorph origmaxcallround
maximum round the detector gets called in detection loop <isomorph> [0]

set detection detectors isomorph origmincallround
minimum round the detector gets called in detection loop <isomorph> [0]

set detection detectors isomorph overruleemphasis
flag to indicate whether emphasis settings for detector <isomorph> should be overruled by normal settings [FALSE]

set detection detectors isomorph postprocessingenabled
flag to indicate whether detector <isomorph> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors isomorph priority
priority of detector <isomorph> [100]

set detection detectors isomorph skip
flag to indicate whether detector <isomorph> should be skipped if others found decompositions [TRUE]

set detection detectors isomorph usefullrecall
flag to indicate whether detector <isomorph> should be called on descendants of the current partialdec [FALSE]

set detection detectors <mastersetcover>
parameters for <mastersetcover>

set detection detectors mastersetcover enabled
flag to indicate whether detector <mastersetcover> is enabled [TRUE]

set detection detectors mastersetcover finishingenabled
flag to indicate whether detector <mastersetcover> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors mastersetcover freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <mastersetcover> [1]

set detection detectors mastersetcover maxcallround
maximum round the detector gets called in detection loop <mastersetcover> [2147483647]

set detection detectors mastersetcover mincallround
minimum round the detector gets called in detection loop <mastersetcover> [0]

set detection detectors mastersetcover origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <mastersetcover> [1]

set detection detectors mastersetcover origmaxcallround
maximum round the detector gets called in detection loop <mastersetcover> [2147483647]

set detection detectors mastersetcover origmincallround
minimum round the detector gets called in detection loop <mastersetcover> [0]

set detection detectors mastersetcover overruleemphasis
flag to indicate whether emphasis settings for detector <mastersetcover> should be overruled by normal settings [FALSE]

set detection detectors mastersetcover postprocessingenabled
flag to indicate whether detector <mastersetcover> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors mastersetcover priority
priority of detector <mastersetcover> [0]

set detection detectors mastersetcover skip
flag to indicate whether detector <mastersetcover> should be skipped if others found decompositions [FALSE]

set detection detectors mastersetcover usefullrecall
flag to indicate whether detector <mastersetcover> should be called on descendants of the current partialdec [FALSE]

set detection detectors <mastersetpack>
parameters for <mastersetpack>

set detection detectors mastersetpack enabled
flag to indicate whether detector <mastersetpack> is enabled [TRUE]

set detection detectors mastersetpack finishingenabled
flag to indicate whether detector <mastersetpack> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors mastersetpack freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <mastersetpack> [1]

set detection detectors mastersetpack maxcallround
maximum round the detector gets called in detection loop <mastersetpack> [2147483647]

set detection detectors mastersetpack mincallround
minimum round the detector gets called in detection loop <mastersetpack> [0]

set detection detectors mastersetpack origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <mastersetpack> [1]

set detection detectors mastersetpack origmaxcallround
maximum round the detector gets called in detection loop <mastersetpack> [2147483647]

set detection detectors mastersetpack origmincallround
minimum round the detector gets called in detection loop <mastersetpack> [0]

set detection detectors mastersetpack overruleemphasis
flag to indicate whether emphasis settings for detector <mastersetpack> should be overruled by normal settings [FALSE]

set detection detectors mastersetpack postprocessingenabled
flag to indicate whether detector <mastersetpack> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors mastersetpack priority
priority of detector <mastersetpack> [0]

set detection detectors mastersetpack skip
flag to indicate whether detector <mastersetpack> should be skipped if others found decompositions [FALSE]

set detection detectors mastersetpack usefullrecall
flag to indicate whether detector <mastersetpack> should be called on descendants of the current partialdec [FALSE]

set detection detectors <mastersetpart>
parameters for <mastersetpart>

set detection detectors mastersetpart enabled
flag to indicate whether detector <mastersetpart> is enabled [TRUE]

set detection detectors mastersetpart finishingenabled
flag to indicate whether detector <mastersetpart> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors mastersetpart freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <mastersetpart> [1]

set detection detectors mastersetpart maxcallround
maximum round the detector gets called in detection loop <mastersetpart> [2147483647]

set detection detectors mastersetpart mincallround
minimum round the detector gets called in detection loop <mastersetpart> [0]

set detection detectors mastersetpart origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <mastersetpart> [1]

set detection detectors mastersetpart origmaxcallround
maximum round the detector gets called in detection loop <mastersetpart> [2147483647]

set detection detectors mastersetpart origmincallround
minimum round the detector gets called in detection loop <mastersetpart> [0]

set detection detectors mastersetpart overruleemphasis
flag to indicate whether emphasis settings for detector <mastersetpart> should be overruled by normal settings [FALSE]

set detection detectors mastersetpart postprocessingenabled
flag to indicate whether detector <mastersetpart> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors mastersetpart priority
priority of detector <mastersetpart> [0]

set detection detectors mastersetpart skip
flag to indicate whether detector <mastersetpart> should be skipped if others found decompositions [FALSE]

set detection detectors mastersetpart usefullrecall
flag to indicate whether detector <mastersetpart> should be called on descendants of the current partialdec [FALSE]

set detection detectors <neighborhoodmaster>
parameters for <neighborhoodmaster>

set detection detectors neighborhoodmaster enabled
flag to indicate whether detector <neighborhoodmaster> is enabled [TRUE]

set detection detectors neighborhoodmaster finishingenabled
flag to indicate whether detector <neighborhoodmaster> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors neighborhoodmaster freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <neighborhoodmaster> [1]

set detection detectors neighborhoodmaster maxcallround
maximum round the detector gets called in detection loop <neighborhoodmaster> [0]

set detection detectors neighborhoodmaster maxratio
the maximal ratio of open constraints that are assigned to the master problem [0.2]

set detection detectors neighborhoodmaster mincallround
minimum round the detector gets called in detection loop <neighborhoodmaster> [0]

set detection detectors neighborhoodmaster origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <neighborhoodmaster> [1]

set detection detectors neighborhoodmaster origmaxcallround
maximum round the detector gets called in detection loop <neighborhoodmaster> [2147483647]

set detection detectors neighborhoodmaster origmincallround
minimum round the detector gets called in detection loop <neighborhoodmaster> [0]

set detection detectors neighborhoodmaster overruleemphasis
flag to indicate whether emphasis settings for detector <neighborhoodmaster> should be overruled by normal settings [FALSE]

set detection detectors neighborhoodmaster postprocessingenabled
flag to indicate whether detector <neighborhoodmaster> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors neighborhoodmaster priority
priority of detector <neighborhoodmaster> [0]

set detection detectors neighborhoodmaster skip
flag to indicate whether detector <neighborhoodmaster> should be skipped if others found decompositions [FALSE]

set detection detectors neighborhoodmaster usefullrecall
flag to indicate whether detector <neighborhoodmaster> should be called on descendants of the current partialdec [FALSE]

set detection detectors <postprocess>
parameters for <postprocess>

set detection detectors postprocess enabled
flag to indicate whether detector <postprocess> is enabled [FALSE]

set detection detectors postprocess finishingenabled
flag to indicate whether detector <postprocess> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors postprocess freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <postprocess> [1]

set detection detectors postprocess maxcallround
maximum round the detector gets called in detection loop <postprocess> [2147483647]

set detection detectors postprocess mincallround
minimum round the detector gets called in detection loop <postprocess> [0]

set detection detectors postprocess origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <postprocess> [1]

set detection detectors postprocess origmaxcallround
maximum round the detector gets called in detection loop <postprocess> [2147483647]

set detection detectors postprocess origmincallround
minimum round the detector gets called in detection loop <postprocess> [0]

set detection detectors postprocess overruleemphasis
flag to indicate whether emphasis settings for detector <postprocess> should be overruled by normal settings [FALSE]

set detection detectors postprocess postprocessingenabled
flag to indicate whether detector <postprocess> is enabled for postprocessing of finished decompositions [TRUE]

set detection detectors postprocess priority
priority of detector <postprocess> [1000000]

set detection detectors postprocess skip
flag to indicate whether detector <postprocess> should be skipped if others found decompositions [FALSE]

set detection detectors postprocess useconssadj
should the constraint adjacency be used [TRUE]

set detection detectors postprocess usefullrecall
flag to indicate whether detector <postprocess> should be called on descendants of the current partialdec [FALSE]

set detection detectors <staircase_lsp>
parameters for <staircase_lsp>

set detection detectors staircase_lsp enabled
flag to indicate whether detector <staircase_lsp> is enabled [FALSE]

set detection detectors staircase_lsp finishingenabled
flag to indicate whether detector <staircase_lsp> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors staircase_lsp freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <staircase_lsp> [1]

set detection detectors staircase_lsp maxcallround
maximum round the detector gets called in detection loop <staircase_lsp> [2147483647]

set detection detectors staircase_lsp mincallround
minimum round the detector gets called in detection loop <staircase_lsp> [0]

set detection detectors staircase_lsp origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <staircase_lsp> [1]

set detection detectors staircase_lsp origmaxcallround
maximum round the detector gets called in detection loop <staircase_lsp> [2147483647]

set detection detectors staircase_lsp origmincallround
minimum round the detector gets called in detection loop <staircase_lsp> [0]

set detection detectors staircase_lsp overruleemphasis
flag to indicate whether emphasis settings for detector <staircase_lsp> should be overruled by normal settings [FALSE]

set detection detectors staircase_lsp postprocessingenabled
flag to indicate whether detector <staircase_lsp> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors staircase_lsp priority
priority of detector <staircase_lsp> [200]

set detection detectors staircase_lsp skip
flag to indicate whether detector <staircase_lsp> should be skipped if others found decompositions [FALSE]

set detection detectors staircase_lsp usefullrecall
flag to indicate whether detector <staircase_lsp> should be called on descendants of the current partialdec [FALSE]

set detection detectors <stairheur>
parameters for <stairheur>

set detection detectors stairheur desiredblocks
The desired number of blocks. 0 means automatic determination of the number of blocks. [0]

set detection detectors stairheur dynamicblocking
Enable blocking type 'dynamic' [FALSE]

set detection detectors stairheur enabled
flag to indicate whether detector <stairheur> is enabled [FALSE]

set detection detectors stairheur finishingenabled
flag to indicate whether detector <stairheur> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors stairheur freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <stairheur> [1]

set detection detectors stairheur maxblocks
The maximal number of blocks [20]

set detection detectors stairheur maxcallround
maximum round the detector gets called in detection loop <stairheur> [2147483647]

set detection detectors stairheur maxiterationsROC
The maximum number of iterations of the ROCalgorithm. 1 for no limit [1000000]

set detection detectors stairheur minblocks
The minimal number of blocks [2]

set detection detectors stairheur mincallround
minimum round the detector gets called in detection loop <stairheur> [0]

set detection detectors stairheur multipledecomps
Enables multiple decompositions for all enabled blocking types. Ranging from minblocks to maxblocks [TRUE]

set detection detectors stairheur nconssperblock
The number of constraints per block (static blocking only) [32]

set detection detectors stairheur origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <stairheur> [1]

set detection detectors stairheur origmaxcallround
maximum round the detector gets called in detection loop <stairheur> [2147483647]

set detection detectors stairheur origmincallround
minimum round the detector gets called in detection loop <stairheur> [0]

set detection detectors stairheur overruleemphasis
flag to indicate whether emphasis settings for detector <stairheur> should be overruled by normal settings [FALSE]

set detection detectors stairheur postprocessingenabled
flag to indicate whether detector <stairheur> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors stairheur priority
priority of detector <stairheur> [1200]

set detection detectors stairheur skip
flag to indicate whether detector <stairheur> should be skipped if others found decompositions [FALSE]

set detection detectors stairheur staticblocking
Enable blocking type 'static' [TRUE]

set detection detectors stairheur usefullrecall
flag to indicate whether detector <stairheur> should be called on descendants of the current partialdec [FALSE]

set detection detectors <varclass>
parameters for <varclass>

set detection detectors varclass enabled
flag to indicate whether detector <varclass> is enabled [TRUE]

set detection detectors varclass finishingenabled
flag to indicate whether detector <varclass> is enabled for finishing of incomplete decompositions [FALSE]

set detection detectors varclass freqcallround
frequency the detector gets called in detection loop ,ie it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <varclass> [1]

set detection detectors varclass maxcallround
maximum round the detector gets called in detection loop <varclass> [0]

set detection detectors varclass maxnclasses
maximum number of classes [8]

set detection detectors varclass mincallround
minimum round the detector gets called in detection loop <varclass> [0]

set detection detectors varclass origfreqcallround
frequency the detector gets called in detection loop,i.e., it is called in round r if and only if minCallRound <= r <= maxCallRound AND (r  minCallRound) mod freqCallRound == 0 <varclass> [1]

set detection detectors varclass origmaxcallround
maximum round the detector gets called in detection loop <varclass> [2147483647]

set detection detectors varclass origmincallround
minimum round the detector gets called in detection loop <varclass> [0]

set detection detectors varclass overruleemphasis
flag to indicate whether emphasis settings for detector <varclass> should be overruled by normal settings [FALSE]

set detection detectors varclass postprocessingenabled
flag to indicate whether detector <varclass> is enabled for postprocessing of finished decompositions [FALSE]

set detection detectors varclass priority
priority of detector <varclass> [0]

set detection detectors varclass skip
flag to indicate whether detector <varclass> should be skipped if others found decompositions [FALSE]

set detection detectors varclass usefullrecall
flag to indicate whether detector <varclass> should be called on descendants of the current partialdec [FALSE]

set detection <emphasis>
predefined parameter settings

set detection emphasis aggressive
sets detection <aggressive>

set detection emphasis default
sets detection <default>

set detection emphasis fast
sets detection <fast>

set detection emphasis off
turns <off> all detectors

set detection <origprob>
parameters for <origprob>

set detection origprob <advanced>
advanced parameters

set detection origprob classificationenabled
Enables classification for the original problem [TRUE]

set detection origprob enabled
Enables detection for the original problem [TRUE]

set detection <score>
parameters for <score>

set detection score <strong_detection>
parameters for <strong_detection>

set detection score strong_detection dualvalrandommethod
Method for random dual values use for strong decomposition: 1: naive, 2: expected equality exponential distributed, 3: expected overestimation exponential distributed [1]

set detection score strong_detection timelimit
Timelimit for strong decompositions score calculation per partialdec in seconds [30.0]

set detection score scoretype
Score calculation for comparing (partial) decompositions (0: max white, 1: border area, 2: classic, 3: max foreseeing white, 4: ppcmaxwhite, 5: max foreseeing white with aggregation info, 6: ppcmaxwhite with aggregation info, 7: experimental benders score, 8: strong decomposition score) [4]

set detection enabled
Enables detection [TRUE]

set detection maxrounds
Maximum number of detection loop rounds [1]

set detection maxtime
Maximum detection time in seconds [600]

set detection postprocess
Enables postprocessing of complete decompositions [TRUE]

set <display>
change parameters for display columns

set display <avgdualbound>
average dual bound of all unprocessed nodes

set display avgdualbound active
display activation status of display column <avgdualbound> (0: off, 1: auto, 2:on) [1]

set display <conflicts>
total number of conflicts found in conflict analysis

set display conflicts active
display activation status of display column <conflicts> (0: off, 1: auto, 2:on) [1]

set display <conss>
number of globally valid constraints in the problem

set display conss active
display activation status of display column <conss> (0: off, 1: auto, 2:on) [1]

set display <curcols>
number of LP columns in current node

set display curcols active
display activation status of display column <curcols> (0: off, 1: auto, 2:on) [1]

set display <curconss>
number of enabled constraints in current node

set display curconss active
display activation status of display column <curconss> (0: off, 1: auto, 2:on) [1]

set display <curdualbound>
dual bound of current node

set display curdualbound active
display activation status of display column <curdualbound> (0: off, 1: auto, 2:on) [1]

set display <currows>
number of LP rows in current node

set display currows active
display activation status of display column <currows> (0: off, 1: auto, 2:on) [1]

set display <cutoffbound>
current cutoff bound

set display cutoffbound active
display activation status of display column <cutoffbound> (0: off, 1: auto, 2:on) [1]

set display <cuts>
total number of cuts applied to the original LPs

set display cuts active
display activation status of display column <cuts> (0: off, 1: auto, 2:on) [1]

set display <degeneracy>
current average degeneracy

set display degeneracy active
display activation status of display column <degeneracy> (0: off, 1: auto, 2:on) [1]

set display <depth>
depth of current node

set display depth active
display activation status of display column <depth> (0: off, 1: auto, 2:on) [1]

set display <dualbound>
current global dual bound

set display dualbound active
display activation status of display column <dualbound> (0: off, 1: auto, 2:on) [1]

set display <estimate>
estimated value of feasible solution in current node

set display estimate active
display activation status of display column <estimate> (0: off, 1: auto, 2:on) [1]

set display <gap>
current (relative) gap using primaldual/MIN(dual,primal)

set display gap active
display activation status of display column <gap> (0: off, 1: auto, 2:on) [1]

set display <lpavgiterations>
average number of LP iterations since the last output line

set display lpavgiterations active
display activation status of display column <lpavgiterations> (0: off, 1: auto, 2:on) [1]

set display <lpcond>
estimate on condition number of LP solution

set display lpcond active
display activation status of display column <lpcond> (0: off, 1: auto, 2:on) [1]

set display <lpiterations>
number of simplex iterations

set display lpiterations active
display activation status of display column <lpiterations> (0: off, 1: auto, 2:on) [1]

set display <lpobj>
current LP objective value

set display lpobj active
display activation status of display column <lpobj> (0: off, 1: auto, 2:on) [1]

set display <maxdepth>
maximal depth of all processed nodes

set display maxdepth active
display activation status of display column <maxdepth> (0: off, 1: auto, 2:on) [1]

set display <mconss>
number of globally valid constraints in the master problem

set display mconss active
display activation status of display column <mconss> (0: off, 1: auto, 2:on) [1]

set display <mcuts>
total number of cuts applied to the master LPs

set display mcuts active
display activation status of display column <mcuts> (0: off, 1: auto, 2:on) [1]

set display <memused>
total number of bytes used in block memory

set display memused active
display activation status of display column <memused> (0: off, 1: auto, 2:on) [1]

set display <mlpiterations>
number of simplex iterations in the master

set display mlpiterations active
display activation status of display column <mlpiterations> (0: off, 1: auto, 2:on) [1]

set display <mvars>
number of variables in the master problem

set display mvars active
display activation status of display column <mvars> (0: off, 1: auto, 2:on) [1]

set display <nexternbranchcands>
number of extern branching variables in the current node

set display nexternbranchcands active
display activation status of display column <nexternbranchcands> (0: off, 1: auto, 2:on) [1]

set display <nfrac>
number of fractional variables in the current solution

set display nfrac active
display activation status of display column <nfrac> (0: off, 1: auto, 2:on) [1]

set display <nnodes>
number of processed nodes

set display nnodes active
display activation status of display column <nnodes> (0: off, 1: auto, 2:on) [1]

set display <nnodesbelowinc>
current number of nodes with an estimate better than the current incumbent

set display nnodesbelowinc active
display activation status of display column <nnodesbelowinc> (0: off, 1: auto, 2:on) [0]

set display <nodesleft>
number of unprocessed nodes

set display nodesleft active
display activation status of display column <nodesleft> (0: off, 1: auto, 2:on) [1]

set display <nrank1nodes>
current number of rank1 nodes left

set display nrank1nodes active
display activation status of display column <nrank1nodes> (0: off, 1: auto, 2:on) [0]

set display <nsols>
current number of solutions found

set display nsols active
display activation status of display column <nsols> (0: off, 1: auto, 2:on) [1]

set display <plungedepth>
current plunging depth

set display plungedepth active
display activation status of display column <plungedepth> (0: off, 1: auto, 2:on) [1]

set display <poolsize>
number of LP rows in the cut pool

set display poolsize active
display activation status of display column <poolsize> (0: off, 1: auto, 2:on) [1]

set display <primalbound>
current primal bound

set display primalbound active
display activation status of display column <primalbound> (0: off, 1: auto, 2:on) [1]

set display <primalgap>
current (relative) gap using primaldual/primal

set display primalgap active
display activation status of display column <primalgap> (0: off, 1: auto, 2:on) [0]

set display <pseudoobj>
current pseudo objective value

set display pseudoobj active
display activation status of display column <pseudoobj> (0: off, 1: auto, 2:on) [1]

set display <separounds>
number of separation rounds performed at the current node

set display separounds active
display activation status of display column <separounds> (0: off, 1: auto, 2:on) [1]

set display <solfound>
letter that indicates the heuristic, that found the solution

set display solfound active
display activation status of display column <solfound> (0: off, 1: auto, 2:on) [1]

set display <strongbranchs>
total number of strong branching calls

set display strongbranchs active
display activation status of display column <strongbranchs> (0: off, 1: auto, 2:on) [1]

set display <sumlpiterations>
number of simplex iterations in master and pricing problems

set display sumlpiterations active
display activation status of display column <sumlpiterations> (0: off, 1: auto, 2:on) [1]

set display <time>
total solution time

set display time active
display activation status of display column <time> (0: off, 1: auto, 2:on) [1]

set display <vars>
number of variables in the original problem

set display vars active
display activation status of display column <vars> (0: off, 1: auto, 2:on) [1]

set display allviols
display all violations for a given start solution / the best solution after the solving process? [FALSE]

set display freq
frequency for displaying node information lines [100]

set display headerfreq
frequency for displaying header lines (every n'th node information line) [15]

set display lpinfo
should the LP solver display status messages? [FALSE]

set display relevantstats
should the relevant statistics be displayed at the end of solving? [TRUE]

set display verblevel
verbosity level of output [4]

set display width
maximal number of characters in a node information line [143]

set <emphasis>
predefined parameter settings

set emphasis benchmark
predefined parameter settings for running in benchmark mode

set emphasis counter
predefined parameter settings for a "feasible" and "fast" counting process

set emphasis cpsolver
predefined parameter settings for CP like search

set emphasis easycip
predefined parameter settings for easy problems

set emphasis feasibility
predefined parameter settings for feasibility problems

set emphasis hardlp
predefined parameter settings for problems with a hard LP

set emphasis numerics
predefined parameter settings for increased numerical stability

set emphasis optimality
predefined parameter settings for proving optimality fast

set <estimation>
change parameters for restarts and tree size estimation

set <eventhdlr>
parameters for <eventhdlr>

set eventhdlr <solvingstats>
parameters for <solvingstats>

set eventhdlr solvingstats filename
filename to write all bounds to []

set <expr>
change parameters for expression handlers

set <heuristics>
change parameters for primal heuristics

set heuristics <actconsdiving>
LP diving heuristic that chooses fixings w.r.t. the active constraints

set heuristics actconsdiving <advanced>
advanced parameters

set heuristics actconsdiving advanced maxdepth
maximal depth level to call primal heuristic <actconsdiving> (1: no limit) [1]

set heuristics actconsdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics actconsdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [1.0]

set heuristics actconsdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics actconsdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [1.0]

set heuristics actconsdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics actconsdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics actconsdiving advanced priority
priority of heuristic <actconsdiving> [1003700]

set heuristics actconsdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics actconsdiving freq
frequency for calling primal heuristic <actconsdiving> (1: never, 0: only at depth freqofs) [1]

set heuristics actconsdiving freqofs
frequency offset for calling primal heuristic <actconsdiving> [5]

set heuristics actconsdiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics actconsdiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics actconsdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics actconsdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics actconsdiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [TRUE]

set heuristics <adaptivediving>
diving heuristic that selects adaptively between the existing, public divesets

set heuristics adaptivediving <advanced>
advanced parameters

set heuristics adaptivediving advanced maxdepth
maximal depth level to call primal heuristic <adaptivediving> (1: no limit) [1]

set heuristics adaptivediving advanced priority
priority of heuristic <adaptivediving> [70000]

set heuristics adaptivediving advanced useadaptivecontext
should the heuristic use its own statistics, or shared statistics? [FALSE]

set heuristics adaptivediving bestsolweight
weight of incumbent solutions compared to other solutions in computation of LP iteration limit [10.0]

set heuristics adaptivediving epsilon
parameter that increases probability of exploration among divesets (only active if seltype is 'e') [1.0]

set heuristics adaptivediving freq
frequency for calling primal heuristic <adaptivediving> (1: never, 0: only at depth freqofs) [5]

set heuristics adaptivediving freqofs
frequency offset for calling primal heuristic <adaptivediving> [3]

set heuristics adaptivediving maxlpiterofs
additional number of allowed LP iterations [1500]

set heuristics adaptivediving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.1]

set heuristics adaptivediving scoretype
score parameter for selection: minimize either average 'n'odes, LP 'i'terations,backtrack/'c'onflict ratio, 'd'epth, 1 / 's'olutions, or 1 / solutions'u'ccess [c]

set heuristics adaptivediving selconfidencecoeff
coefficient c to decrease initial confidence (calls + 1.0) / (calls + c) in scores [10.0]

set heuristics adaptivediving seltype
selection strategy: (e)psilongreedy, (w)eighted distribution, (n)ext diving [w]

set heuristics <advanced>
advanced parameters

set heuristics advanced useuctsubscip
should setting of common subscip parameters include the activation of the UCT node selector? [FALSE]

set heuristics <alns>
Large neighborhood search heuristic that orchestrates the popular neighborhoods Local Branching, RINS, RENS, DINS etc.

set heuristics alns <advanced>
advanced parameters

set heuristics alns advanced adjustfixingrate
should the heuristic adjust the target fixing rate based on the success? [TRUE]

set heuristics alns advanced adjustminimprove
should the factor by which the minimum improvement is bound be dynamically updated? [FALSE]

set heuristics alns advanced adjusttargetnodes
should the target nodes be dynamically adjusted? [TRUE]

set heuristics alns advanced alpha
parameter to increase the confidence width in UCB [0.0016]

set heuristics alns advanced banditalgo
the bandit algorithm: (u)pper confidence bounds, (e)xp.3, epsilon (g)reedy [u]

set heuristics alns advanced beta
reward offset between 0 and 1 at every observation for Exp.3 [0.0]

set heuristics alns advanced copycuts
should cutting planes be copied to the subSCIP? [FALSE]

set heuristics alns advanced domorefixings
should the ALNS heuristic do more fixings by itself based on variable prioritization until the target fixing rate is reached? [TRUE]

set heuristics alns advanced eps
increase exploration in epsilongreedy bandit algorithm [0.4685844]

set heuristics alns advanced fixtol
tolerance by which the fixing rate may be missed without generic fixing [0.1]

set heuristics alns advanced gamma
weight between uniform (gamma ~ 1) and weight driven (gamma ~ 0) probability distribution for exp3 [0.07041455]

set heuristics alns advanced initduringroot
should the heuristic be executed multiple times during the root node? [FALSE]

set heuristics alns advanced maxcallssamesol
number of allowed executions of the heuristic on the same incumbent solution (1: no limit, 0: number of active neighborhoods) [1]

set heuristics alns advanced maxdepth
maximal depth level to call primal heuristic <alns> (1: no limit) [1]

set heuristics alns advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics alns advanced minimprovehigh
upper bound for the minimal improvement over the incumbent [0.01]

set heuristics alns advanced minimprovelow
lower threshold for the minimal improvement over the incumbent [0.01]

set heuristics alns advanced minnodes
minimum number of nodes required to start a subSCIP [50]

set heuristics alns advanced priority
priority of heuristic <alns> [1100500]

set heuristics alns advanced resetweights
should the bandit algorithms be reset when a new problem is read? [TRUE]

set heuristics alns advanced rewardbaseline
the reward baseline to separate successful and failed calls [0.5]

set heuristics alns advanced rewardcontrol
reward control to increase the weight of the simple solution indicator and decrease the weight of the closed gap reward [0.8]

set heuristics alns advanced rewardfilename
file name to store all rewards and the selection of the bandit []

set heuristics alns advanced scalebyeffort
should the reward be scaled by the effort? [TRUE]

set heuristics alns advanced startminimprove
initial factor by which ALNS should at least improve the incumbent [0.01]

set heuristics alns advanced subsciprandseeds
should random seeds of subSCIPs be altered to increase diversification? [FALSE]

set heuristics alns advanced targetnodefactor
factor by which target node number is eventually increased [1.05]

set heuristics alns advanced unfixtol
tolerance by which the fixing rate may be exceeded without generic unfixing [0.1]

set heuristics alns advanced usedistances
distances from fixed variables be used for variable prioritization [TRUE]

set heuristics alns advanced uselocalredcost
should local reduced costs be used for generic (un)fixing? [FALSE]

set heuristics alns advanced usepscost
should pseudo cost scores be used for variable priorization? [TRUE]

set heuristics alns advanced useredcost
should reduced cost scores be used for variable prioritization? [TRUE]

set heuristics alns advanced usesubscipheurs
should the heuristic activate other subSCIP heuristics during its search? [FALSE]

set heuristics alns advanced waitingnodes
number of nodes since last incumbent solution that the heuristic should wait [25]

set heuristics alns <crossover>
parameters for <crossover>

set heuristics alns crossover <advanced>
advanced parameters

set heuristics alns crossover advanced active
is this neighborhood active? [TRUE]

set heuristics alns crossover advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns crossover advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns crossover advanced nsols
the number of solutions that crossover should combine [2]

set heuristics alns crossover advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns <dins>
parameters for <dins>

set heuristics alns dins <advanced>
advanced parameters

set heuristics alns dins advanced active
is this neighborhood active? [TRUE]

set heuristics alns dins advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns dins advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns dins advanced npoolsols
number of pool solutions where binary solution values must agree [5]

set heuristics alns dins advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns <localbranching>
parameters for <localbranching>

set heuristics alns localbranching <advanced>
advanced parameters

set heuristics alns localbranching advanced active
is this neighborhood active? [TRUE]

set heuristics alns localbranching advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns localbranching advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns localbranching advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns <mutation>
parameters for <mutation>

set heuristics alns mutation <advanced>
advanced parameters

set heuristics alns mutation advanced active
is this neighborhood active? [TRUE]

set heuristics alns mutation advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns mutation advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns mutation advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns <proximity>
parameters for <proximity>

set heuristics alns proximity <advanced>
advanced parameters

set heuristics alns proximity advanced active
is this neighborhood active? [TRUE]

set heuristics alns proximity advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns proximity advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns proximity advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns <rens>
parameters for <rens>

set heuristics alns rens <advanced>
advanced parameters

set heuristics alns rens advanced active
is this neighborhood active? [TRUE]

set heuristics alns rens advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns rens advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns rens advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns <rins>
parameters for <rins>

set heuristics alns rins <advanced>
advanced parameters

set heuristics alns rins advanced active
is this neighborhood active? [TRUE]

set heuristics alns rins advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns rins advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns rins advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns <trustregion>
parameters for <trustregion>

set heuristics alns trustregion <advanced>
advanced parameters

set heuristics alns trustregion advanced active
is this neighborhood active? [FALSE]

set heuristics alns trustregion advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns trustregion advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns trustregion advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns trustregion violpenalty
the penalty for each change in the binary variables from the candidate solution [100.0]

set heuristics alns <zeroobjective>
parameters for <zeroobjective>

set heuristics alns zeroobjective <advanced>
advanced parameters

set heuristics alns zeroobjective advanced active
is this neighborhood active? [TRUE]

set heuristics alns zeroobjective advanced maxfixingrate
maximum fixing rate for this neighborhood [0.9]

set heuristics alns zeroobjective advanced minfixingrate
minimum fixing rate for this neighborhood [0.3]

set heuristics alns zeroobjective advanced priority
positive call priority to initialize bandit algorithms [1.0]

set heuristics alns freq
frequency for calling primal heuristic <alns> (1: never, 0: only at depth freqofs) [20]

set heuristics alns freqofs
frequency offset for calling primal heuristic <alns> [0]

set heuristics alns nodesofs
offset added to the nodes budget [500]

set heuristics alns nodesquot
fraction of nodes compared to the main SCIP for budget computation [0.1]

set heuristics alns nodesquotmin
lower bound fraction of nodes compared to the main SCIP for budget computation [0.0]

set heuristics alns nsolslim
limit on the number of improving solutions in a subSCIP call [3]

set heuristics alns seed
initial random seed for bandit algorithms and random decisions by neighborhoods [113]

set heuristics <bound>
heuristic which fixes all integer variables to a bound and solves the remaining LP

set heuristics bound <advanced>
advanced parameters

set heuristics bound advanced maxdepth
maximal depth level to call primal heuristic <bound> (1: no limit) [1]

set heuristics bound advanced maxproprounds
maximum number of propagation rounds during probing (1 infinity, 2 parameter settings) [0]

set heuristics bound advanced onlywithoutsol
Should heuristic only be executed if no primal solution was found, yet? [TRUE]

set heuristics bound advanced priority
priority of heuristic <bound> [1107000]

set heuristics bound bound
to which bound should integer variables be fixed? ('l'ower, 'u'pper, or 'b'oth) [l]

set heuristics bound freq
frequency for calling primal heuristic <bound> (1: never, 0: only at depth freqofs) [1]

set heuristics bound freqofs
frequency offset for calling primal heuristic <bound> [0]

set heuristics <clique>
LNS heuristic using a clique partition to restrict the search neighborhood

set heuristics clique <advanced>
advanced parameters

set heuristics clique advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics clique advanced maxbacktracks
maximum number of backtracks during the fixing process [10]

set heuristics clique advanced maxdepth
maximal depth level to call primal heuristic <clique> (1: no limit) [1]

set heuristics clique advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics clique advanced maxproprounds
maximum number of propagation rounds during probing (1 infinity) [2]

set heuristics clique advanced minimprove
factor by which clique heuristic should at least improve the incumbent [0.01]

set heuristics clique advanced minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics clique advanced priority
priority of heuristic <clique> [5000]

set heuristics clique advanced uselockfixings
should more variables be fixed based on variable locks if the fixing rate was not reached? [FALSE]

set heuristics clique freq
frequency for calling primal heuristic <clique> (1: never, 0: only at depth freqofs) [1]

set heuristics clique freqofs
frequency offset for calling primal heuristic <clique> [0]

set heuristics clique minintfixingrate
minimum percentage of integer variables that have to be fixable [0.65]

set heuristics clique minmipfixingrate
minimum percentage of fixed variables in the subMIP [0.65]

set heuristics clique nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics clique nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <coefdiving>
LP diving heuristic that chooses fixings w.r.t. the matrix coefficients

set heuristics coefdiving <advanced>
advanced parameters

set heuristics coefdiving advanced maxdepth
maximal depth level to call primal heuristic <coefdiving> (1: no limit) [1]

set heuristics coefdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics coefdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics coefdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics coefdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics coefdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics coefdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics coefdiving advanced priority
priority of heuristic <coefdiving> [1001000]

set heuristics coefdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics coefdiving freq
frequency for calling primal heuristic <coefdiving> (1: never, 0: only at depth freqofs) [1]

set heuristics coefdiving freqofs
frequency offset for calling primal heuristic <coefdiving> [1]

set heuristics coefdiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics coefdiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics coefdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics coefdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics coefdiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [FALSE]

set heuristics <completesol>
primal heuristic trying to complete given partial solutions

set heuristics completesol <advanced>
advanced parameters

set heuristics completesol advanced addallsols
should all subproblem solutions be added to the original SCIP? [FALSE]

set heuristics completesol advanced boundwidening
bound widening factor applied to continuous variables (0: fix variables to given solution values, 1: relax to global bounds) [0.1]

set heuristics completesol advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [2.0]

set heuristics completesol advanced maxdepth
maximal depth level to call primal heuristic <completesol> (1: no limit) [0]

set heuristics completesol advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics completesol advanced minimprove
factor by which the incumbent should be improved at least [0.01]

set heuristics completesol advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics completesol advanced objweight
weight of the original objective function (1: only original objective) [1.0]

set heuristics completesol advanced priority
priority of heuristic <completesol> [0]

set heuristics completesol beforepresol
should the heuristic run before presolving? [TRUE]

set heuristics completesol freq
frequency for calling primal heuristic <completesol> (1: never, 0: only at depth freqofs) [0]

set heuristics completesol freqofs
frequency offset for calling primal heuristic <completesol> [0]

set heuristics completesol ignorecont
should number of continuous variables be ignored? [FALSE]

set heuristics completesol maxcontvars
maximal number of continuous variables after presolving [1]

set heuristics completesol maxlpiter
maximal number of LP iterations (1: no limit) [1]

set heuristics completesol maxproprounds
maximal number of iterations in propagation (1: no limit) [10]

set heuristics completesol maxunknownrate
maximal rate of unknown solution values [0.85]

set heuristics completesol nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics completesol nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics completesol solutions
heuristic stops, if the given number of improving solutions were found (1: no limit) [5]

set heuristics <conflictdiving>
LP diving heuristic that chooses fixings w.r.t. conflict locks

set heuristics conflictdiving <advanced>
advanced parameters

set heuristics conflictdiving advanced likecoef
perform rounding like coefficient diving [FALSE]

set heuristics conflictdiving advanced lockweight
weight used in a convex combination of conflict and variable locks [0.75]

set heuristics conflictdiving advanced maxdepth
maximal depth level to call primal heuristic <conflictdiving> (1: no limit) [1]

set heuristics conflictdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics conflictdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics conflictdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics conflictdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics conflictdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics conflictdiving advanced maxviol
try to maximize the violation [TRUE]

set heuristics conflictdiving advanced minconflictlocks
minimal number of conflict locks per variable [5]

set heuristics conflictdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics conflictdiving advanced priority
priority of heuristic <conflictdiving> [1000100]

set heuristics conflictdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics conflictdiving freq
frequency for calling primal heuristic <conflictdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics conflictdiving freqofs
frequency offset for calling primal heuristic <conflictdiving> [0]

set heuristics conflictdiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics conflictdiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics conflictdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics conflictdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.15]

set heuristics conflictdiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [FALSE]

set heuristics <crossover>
LNS heuristic that fixes all variables that are identic in a couple of solutions

set heuristics crossover <advanced>
advanced parameters

set heuristics crossover advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics crossover advanced dontwaitatroot
should the nwaitingnodes parameter be ignored at the root node? [FALSE]

set heuristics crossover advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [2.0]

set heuristics crossover advanced maxdepth
maximal depth level to call primal heuristic <crossover> (1: no limit) [1]

set heuristics crossover advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics crossover advanced minimprove
factor by which Crossover should at least improve the incumbent [0.01]

set heuristics crossover advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics crossover advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [200]

set heuristics crossover advanced permute
should the subproblem be permuted to increase diversification? [FALSE]

set heuristics crossover advanced priority
priority of heuristic <crossover> [1104000]

set heuristics crossover advanced randomization
should the choice which sols to take be randomized? [TRUE]

set heuristics crossover advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics crossover advanced useuct
should uct node selection be used at the beginning of the search? [FALSE]

set heuristics crossover bestsollimit
limit on number of improving incumbent solutions in subCIP [1]

set heuristics crossover freq
frequency for calling primal heuristic <crossover> (1: never, 0: only at depth freqofs) [30]

set heuristics crossover freqofs
frequency offset for calling primal heuristic <crossover> [0]

set heuristics crossover minfixingrate
minimum percentage of integer variables that have to be fixed [0.666]

set heuristics crossover nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics crossover nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics crossover nusedsols
number of solutions to be taken into account [3]

set heuristics <dins>
distance induced neighborhood search by Ghosh

set heuristics dins <advanced>
advanced parameters

set heuristics dins advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics dins advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [1.5]

set heuristics dins advanced maxdepth
maximal depth level to call primal heuristic <dins> (1: no limit) [1]

set heuristics dins advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics dins advanced minimprove
factor by which dins should at least improve the incumbent [0.01]

set heuristics dins advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [200]

set heuristics dins advanced priority
priority of heuristic <dins> [1105000]

set heuristics dins advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics dins advanced useuct
should uct node selection be used at the beginning of the search? [FALSE]

set heuristics dins bestsollimit
limit on number of improving incumbent solutions in subCIP [3]

set heuristics dins freq
frequency for calling primal heuristic <dins> (1: never, 0: only at depth freqofs) [1]

set heuristics dins freqofs
frequency offset for calling primal heuristic <dins> [0]

set heuristics dins minfixingrate
minimum percentage of integer variables that have to be fixable [0.3]

set heuristics dins minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics dins neighborhoodsize
radius (using Manhattan metric) of the incumbent's neighborhood to be searched [18]

set heuristics dins nodesofs
number of nodes added to the contingent of the total nodes [5000]

set heuristics dins nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.05]

set heuristics dins solnum
number of poolsolutions to be checked for flag array update (for hard fixing of binary variables) [5]

set heuristics <distributiondiving>
Diving heuristic that chooses fixings w.r.t. changes in the solution density

set heuristics distributiondiving <advanced>
advanced parameters

set heuristics distributiondiving advanced maxdepth
maximal depth level to call primal heuristic <distributiondiving> (1: no limit) [1]

set heuristics distributiondiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics distributiondiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics distributiondiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics distributiondiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics distributiondiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics distributiondiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics distributiondiving advanced priority
priority of heuristic <distributiondiving> [1003300]

set heuristics distributiondiving advanced scoreparam
the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w'), 'r'evolving [r]

set heuristics distributiondiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics distributiondiving freq
frequency for calling primal heuristic <distributiondiving> (1: never, 0: only at depth freqofs) [10]

set heuristics distributiondiving freqofs
frequency offset for calling primal heuristic <distributiondiving> [3]

set heuristics distributiondiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics distributiondiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics distributiondiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics distributiondiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics distributiondiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [TRUE]

set heuristics <dps>
primal heuristic for decomposable MIPs

set heuristics dps <advanced>
advanced parameters

set heuristics dps advanced maxdepth
maximal depth level to call primal heuristic <dps> (1: no limit) [1]

set heuristics dps advanced priority
priority of heuristic <dps> [75000]

set heuristics dps freq
frequency for calling primal heuristic <dps> (1: never, 0: only at depth freqofs) [1]

set heuristics dps freqofs
frequency offset for calling primal heuristic <dps> [0]

set heuristics dps maxiterations
maximal number of iterations [50]

set heuristics dps maxlinkscore
maximal linking score of used decomposition (equivalent to percentage of linking constraints) [1.0]

set heuristics dps penalty
multiplier for absolute increase of penalty parameters (0: no increase) [100.0]

set heuristics dps reoptimize
should the problem get reoptimized with the original objective function? [FALSE]

set heuristics dps reuse
should solutions get reused in subproblems? [FALSE]

set heuristics <dualval>
primal heuristic using dual values

set heuristics dualval <advanced>
advanced parameters

set heuristics dualval advanced forceimprovements
exit if objective doesn't improve [FALSE]

set heuristics dualval advanced maxdepth
maximal depth level to call primal heuristic <dualval> (1: no limit) [1]

set heuristics dualval advanced onlycheaper
add constraint to ensure that discrete vars are improving [TRUE]

set heuristics dualval advanced priority
priority of heuristic <dualval> [0]

set heuristics dualval dynamicdepth
says if and how the recursion depth is computed at runtime [0]

set heuristics dualval freq
frequency for calling primal heuristic <dualval> (1: never, 0: only at depth freqofs) [1]

set heuristics dualval freqofs
frequency offset for calling primal heuristic <dualval> [0]

set heuristics dualval heurverblevel
verblevel of the heuristic, default is 0 to display nothing [0]

set heuristics dualval lambdaobj
scaling factor for the objective function [0.0]

set heuristics dualval lambdaslack
value added to objective of slack variables, must not be zero [1.0]

set heuristics dualval maxcalls
maximal number of recursive calls of the heuristic (if dynamicdepth is off) [25]

set heuristics dualval maxequalranks
maximal number of variables that may have maximal rank, quit if there are more, turn off by setting 1 [50]

set heuristics dualval mingap
minimal gap for which we still run the heuristic, if gap is less we return without doing anything [5.0]

set heuristics dualval nlpverblevel
verblevel of the nlp solver, can be 0 or 1 [0]

set heuristics dualval onlyleaves
disable the heuristic if it was not called at a leaf of the B&B tree [FALSE]

set heuristics dualval rankvalue
number of ranks that should be displayed when the heuristic is called [10]

set heuristics dualval relaxcontvars
relax the continous variables [FALSE]

set heuristics dualval relaxindicators
relax the indicator variables by introducing continuous copies [FALSE]

set heuristics <emphasis>
predefined parameter settings

set heuristics emphasis aggressive
sets heuristics <aggressive>

set heuristics emphasis default
sets heuristics settings to <default>

set heuristics emphasis fast
sets heuristics <fast>

set heuristics emphasis off
turns <off> all heuristics

set heuristics <farkasdiving>
LP diving heuristic that tries to construct a Farkasproof

set heuristics farkasdiving <advanced>
advanced parameters

set heuristics farkasdiving advanced checkcands
should diving candidates be checked before running? [FALSE]

set heuristics farkasdiving advanced maxdepth
maximal depth level to call primal heuristic <farkasdiving> (1: no limit) [1]

set heuristics farkasdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics farkasdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics farkasdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics farkasdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics farkasdiving advanced maxobjocc
maximal occurance factor of an objective coefficient [1.0]

set heuristics farkasdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics farkasdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics farkasdiving advanced objdynamism
minimal objective dynamism (log) to run [0.0001]

set heuristics farkasdiving advanced priority
priority of heuristic <farkasdiving> [900000]

set heuristics farkasdiving advanced rootsuccess
should the heuristic only run within the tree if at least one solution was found at the root node? [TRUE]

set heuristics farkasdiving advanced scalescore
should the score be scaled? [TRUE]

set heuristics farkasdiving advanced scaletype
scale score by [f]ractionality or [i]mpact on farkasproof [i]

set heuristics farkasdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics farkasdiving freq
frequency for calling primal heuristic <farkasdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics farkasdiving freqofs
frequency offset for calling primal heuristic <farkasdiving> [0]

set heuristics farkasdiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics farkasdiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [1]

set heuristics farkasdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics farkasdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics farkasdiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [FALSE]

set heuristics <feaspump>
objective feasibility pump 2.0

set heuristics feaspump <advanced>
advanced parameters

set heuristics feaspump advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics feaspump advanced cyclelength
maximum length of cycles to be checked explicitly in each round [3]

set heuristics feaspump advanced maxdepth
maximal depth level to call primal heuristic <feaspump> (1: no limit) [1]

set heuristics feaspump advanced maxloops
maximal number of pumping loops (1: no limit) [10000]

set heuristics feaspump advanced maxsols
total number of feasible solutions found up to which heuristic is called (1: no limit) [10]

set heuristics feaspump advanced maxstallloops
maximal number of pumping rounds without fractionality improvement (1: no limit) [10]

set heuristics feaspump advanced minflips
minimum number of random variables to flip, if a 1cycle is encountered [10]

set heuristics feaspump advanced perturbfreq
number of iterations until a random perturbation is forced [100]

set heuristics feaspump advanced priority
priority of heuristic <feaspump> [1000000]

set heuristics feaspump alpha
initial weight of the objective function in the convex combination [1.0]

set heuristics feaspump alphadiff
threshold difference for the convex parameter to perform perturbation [1.0]

set heuristics feaspump beforecuts
should the feasibility pump be called at root node before cut separation? [TRUE]

set heuristics feaspump freq
frequency for calling primal heuristic <feaspump> (1: never, 0: only at depth freqofs) [20]

set heuristics feaspump freqofs
frequency offset for calling primal heuristic <feaspump> [0]

set heuristics feaspump maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics feaspump maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.01]

set heuristics feaspump neighborhoodsize
radius (using Manhattan metric) of the neighborhood to be searched in stage 3 [18]

set heuristics feaspump objfactor
factor by which the regard of the objective is decreased in each round, 1.0 for dynamic [0.1]

set heuristics feaspump pertsolfound
should a random perturbation be performed if a feasible solution was found? [TRUE]

set heuristics feaspump stage3
should we solve a local branching subMIP if no solution could be found? [FALSE]

set heuristics feaspump usefp20
should an iterative roundandpropagate scheme be used to find the integral points? [FALSE]

set heuristics <fixandinfer>
iteratively fixes variables and propagates inferences

set heuristics fixandinfer <advanced>
advanced parameters

set heuristics fixandinfer advanced maxdepth
maximal depth level to call primal heuristic <fixandinfer> (1: no limit) [1]

set heuristics fixandinfer advanced minfixings
minimal number of fixings to apply before dive may be aborted [100]

set heuristics fixandinfer advanced priority
priority of heuristic <fixandinfer> [500000]

set heuristics fixandinfer advanced proprounds
maximal number of propagation rounds in probing subproblems (1: no limit, 0: auto) [0]

set heuristics fixandinfer freq
frequency for calling primal heuristic <fixandinfer> (1: never, 0: only at depth freqofs) [1]

set heuristics fixandinfer freqofs
frequency offset for calling primal heuristic <fixandinfer> [0]

set heuristics <fracdiving>
LP diving heuristic that chooses fixings w.r.t. the fractionalities

set heuristics fracdiving <advanced>
advanced parameters

set heuristics fracdiving advanced maxdepth
maximal depth level to call primal heuristic <fracdiving> (1: no limit) [1]

set heuristics fracdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics fracdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics fracdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics fracdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics fracdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics fracdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics fracdiving advanced priority
priority of heuristic <fracdiving> [1003000]

set heuristics fracdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics fracdiving freq
frequency for calling primal heuristic <fracdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics fracdiving freqofs
frequency offset for calling primal heuristic <fracdiving> [3]

set heuristics fracdiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics fracdiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics fracdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics fracdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics fracdiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [FALSE]

set heuristics <gcgcoefdiving>
LP diving heuristic that chooses fixings w.r.t. the matrix coefficients

set heuristics gcgcoefdiving <advanced>
advanced parameters

set heuristics gcgcoefdiving advanced backtrack
single backtracking by choosing another variable in case of infeasibility [FALSE]

set heuristics gcgcoefdiving advanced maxdepth
maximal depth level to call primal heuristic <gcgcoefdiving> (1: no limit) [1]

set heuristics gcgcoefdiving advanced maxdiscdepth
maximal depth until which a limited discrepancy search is performed [0]

set heuristics gcgcoefdiving advanced maxdiscrepancy
maximal discrepancy allowed in backtracking and limited discrepancy search [2]

set heuristics gcgcoefdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics gcgcoefdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics gcgcoefdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics gcgcoefdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics gcgcoefdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics gcgcoefdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics gcgcoefdiving advanced priority
priority of heuristic <gcgcoefdiving> [1001000]

set heuristics gcgcoefdiving advanced usefarkasonly
perform pricing only if infeasibility is encountered [FALSE]

set heuristics gcgcoefdiving advanced usemasterlocks
calculate the number of locks w.r.t. the master LP? [FALSE]

set heuristics gcgcoefdiving freq
frequency for calling primal heuristic <gcgcoefdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics gcgcoefdiving freqofs
frequency offset for calling primal heuristic <gcgcoefdiving> [1]

set heuristics gcgcoefdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics gcgcoefdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics gcgcoefdiving maxpricerounds
maximal number of allowed pricing rounds (1: no limit) [0]

set heuristics gcgcoefdiving otherdirection
try to branch the diving variable in the other direction in case of infeasibility [TRUE]

set heuristics <gcgdins>
distance induced neighborhood search by Ghosh

set heuristics gcgdins <advanced>
advanced parameters

set heuristics gcgdins advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics gcgdins advanced maxdepth
maximal depth level to call primal heuristic <gcgdins> (1: no limit) [1]

set heuristics gcgdins advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics gcgdins advanced minimprove
factor by which gcgdins should at least improve the incumbent [0.01]

set heuristics gcgdins advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [0]

set heuristics gcgdins advanced priority
priority of heuristic <gcgdins> [1105000]

set heuristics gcgdins advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics gcgdins freq
frequency for calling primal heuristic <gcgdins> (1: never, 0: only at depth freqofs) [1]

set heuristics gcgdins freqofs
frequency offset for calling primal heuristic <gcgdins> [0]

set heuristics gcgdins minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics gcgdins neighborhoodsize
radius (using Manhattan metric) of the incumbent's neighborhood to be searched [18]

set heuristics gcgdins nodesofs
number of nodes added to the contingent of the total nodes [5000]

set heuristics gcgdins nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.05]

set heuristics gcgdins solnum
number of poolsolutions to be checked for flag array update (for hard fixing of binary variables) [5]

set heuristics <gcgfeaspump>
objective feasibility pump 2.0

set heuristics gcgfeaspump <advanced>
advanced parameters

set heuristics gcgfeaspump advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics gcgfeaspump advanced cyclelength
maximum length of cycles to be checked explicitly in each round [3]

set heuristics gcgfeaspump advanced maxdepth
maximal depth level to call primal heuristic <gcgfeaspump> (1: no limit) [1]

set heuristics gcgfeaspump advanced maxloops
maximal number of pumping loops (1: no limit) [10000]

set heuristics gcgfeaspump advanced maxsols
total number of feasible solutions found up to which heuristic is called (1: no limit) [10]

set heuristics gcgfeaspump advanced maxstallloops
maximal number of pumping rounds without fractionality improvement (1: no limit) [10]

set heuristics gcgfeaspump advanced minflips
minimum number of random variables to flip, if a 1cycle is encountered [10]

set heuristics gcgfeaspump advanced perturbfreq
number of iterations until a random perturbation is forced [100]

set heuristics gcgfeaspump advanced priority
priority of heuristic <gcgfeaspump> [1000000]

set heuristics gcgfeaspump alphadiff
threshold difference for the convex parameter to perform perturbation [1.0]

set heuristics gcgfeaspump freq
frequency for calling primal heuristic <gcgfeaspump> (1: never, 0: only at depth freqofs) [1]

set heuristics gcgfeaspump freqofs
frequency offset for calling primal heuristic <gcgfeaspump> [0]

set heuristics gcgfeaspump maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics gcgfeaspump maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.01]

set heuristics gcgfeaspump neighborhoodsize
radius (using Manhattan metric) of the neighborhood to be searched in stage 3 [18]

set heuristics gcgfeaspump objfactor
factor by which the regard of the objective is decreased in each round, 1.0 for dynamic [1.0]

set heuristics gcgfeaspump pertsolfound
should a random perturbation be performed if a feasible solution was found? [TRUE]

set heuristics gcgfeaspump stage3
should we solve a local branching subMIP if no solution could be found? [FALSE]

set heuristics gcgfeaspump usefp20
should an iterative roundandpropagate scheme be used to find the integral points? [FALSE]

set heuristics <gcgfracdiving>
LP diving heuristic that chooses fixings w.r.t. the fractionalities

set heuristics gcgfracdiving <advanced>
advanced parameters

set heuristics gcgfracdiving advanced backtrack
single backtracking by choosing another variable in case of infeasibility [FALSE]

set heuristics gcgfracdiving advanced maxdepth
maximal depth level to call primal heuristic <gcgfracdiving> (1: no limit) [1]

set heuristics gcgfracdiving advanced maxdiscdepth
maximal depth until which a limited discrepancy search is performed [0]

set heuristics gcgfracdiving advanced maxdiscrepancy
maximal discrepancy allowed in backtracking and limited discrepancy search [2]

set heuristics gcgfracdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics gcgfracdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics gcgfracdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics gcgfracdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics gcgfracdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics gcgfracdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics gcgfracdiving advanced priority
priority of heuristic <gcgfracdiving> [1003000]

set heuristics gcgfracdiving advanced usefarkasonly
perform pricing only if infeasibility is encountered [FALSE]

set heuristics gcgfracdiving advanced usemasterfracs
calculate the fractionalities w.r.t. the master LP? [FALSE]

set heuristics gcgfracdiving freq
frequency for calling primal heuristic <gcgfracdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics gcgfracdiving freqofs
frequency offset for calling primal heuristic <gcgfracdiving> [3]

set heuristics gcgfracdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics gcgfracdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics gcgfracdiving maxpricerounds
maximal number of allowed pricing rounds (1: no limit) [0]

set heuristics gcgfracdiving otherdirection
try to branch the diving variable in the other direction in case of infeasibility [TRUE]

set heuristics <gcgguideddiving>
LP diving heuristic that chooses fixings in direction of incumbent solutions

set heuristics gcgguideddiving <advanced>
advanced parameters

set heuristics gcgguideddiving advanced backtrack
single backtracking by choosing another variable in case of infeasibility [FALSE]

set heuristics gcgguideddiving advanced maxdepth
maximal depth level to call primal heuristic <gcgguideddiving> (1: no limit) [1]

set heuristics gcgguideddiving advanced maxdiscdepth
maximal depth until which a limited discrepancy search is performed [0]

set heuristics gcgguideddiving advanced maxdiscrepancy
maximal discrepancy allowed in backtracking and limited discrepancy search [2]

set heuristics gcgguideddiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics gcgguideddiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics gcgguideddiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics gcgguideddiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics gcgguideddiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics gcgguideddiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics gcgguideddiving advanced priority
priority of heuristic <gcgguideddiving> [1007000]

set heuristics gcgguideddiving advanced usefarkasonly
perform pricing only if infeasibility is encountered [FALSE]

set heuristics gcgguideddiving advanced usemasterfracs
calculate the fractionalities w.r.t. the master LP? [FALSE]

set heuristics gcgguideddiving freq
frequency for calling primal heuristic <gcgguideddiving> (1: never, 0: only at depth freqofs) [10]

set heuristics gcgguideddiving freqofs
frequency offset for calling primal heuristic <gcgguideddiving> [7]

set heuristics gcgguideddiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics gcgguideddiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics gcgguideddiving maxpricerounds
maximal number of allowed pricing rounds (1: no limit) [0]

set heuristics gcgguideddiving otherdirection
try to branch the diving variable in the other direction in case of infeasibility [TRUE]

set heuristics <gcglinesdiving>
LP diving heuristic that chooses fixings following the line from root solution to current solution

set heuristics gcglinesdiving <advanced>
advanced parameters

set heuristics gcglinesdiving advanced backtrack
single backtracking by choosing another variable in case of infeasibility [FALSE]

set heuristics gcglinesdiving advanced maxdepth
maximal depth level to call primal heuristic <gcglinesdiving> (1: no limit) [1]

set heuristics gcglinesdiving advanced maxdiscdepth
maximal depth until which a limited discrepancy search is performed [0]

set heuristics gcglinesdiving advanced maxdiscrepancy
maximal discrepancy allowed in backtracking and limited discrepancy search [2]

set heuristics gcglinesdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics gcglinesdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics gcglinesdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics gcglinesdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics gcglinesdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics gcglinesdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics gcglinesdiving advanced priority
priority of heuristic <gcglinesdiving> [1006000]

set heuristics gcglinesdiving advanced usefarkasonly
perform pricing only if infeasibility is encountered [FALSE]

set heuristics gcglinesdiving freq
frequency for calling primal heuristic <gcglinesdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics gcglinesdiving freqofs
frequency offset for calling primal heuristic <gcglinesdiving> [6]

set heuristics gcglinesdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics gcglinesdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics gcglinesdiving maxpricerounds
maximal number of allowed pricing rounds (1: no limit) [0]

set heuristics gcglinesdiving otherdirection
try to branch the diving variable in the other direction in case of infeasibility [TRUE]

set heuristics <gcgpscostdiving>
LP diving heuristic that chooses fixings w.r.t. the pseudo cost values

set heuristics gcgpscostdiving <advanced>
advanced parameters

set heuristics gcgpscostdiving advanced backtrack
single backtracking by choosing another variable in case of infeasibility [FALSE]

set heuristics gcgpscostdiving advanced maxdepth
maximal depth level to call primal heuristic <gcgpscostdiving> (1: no limit) [1]

set heuristics gcgpscostdiving advanced maxdiscdepth
maximal depth until which a limited discrepancy search is performed [0]

set heuristics gcgpscostdiving advanced maxdiscrepancy
maximal discrepancy allowed in backtracking and limited discrepancy search [2]

set heuristics gcgpscostdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics gcgpscostdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics gcgpscostdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics gcgpscostdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics gcgpscostdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics gcgpscostdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics gcgpscostdiving advanced priority
priority of heuristic <gcgpscostdiving> [1002000]

set heuristics gcgpscostdiving advanced usefarkasonly
perform pricing only if infeasibility is encountered [FALSE]

set heuristics gcgpscostdiving advanced usemasterpscosts
shall pseudocosts be calculated w.r.t. the master problem? [FALSE]

set heuristics gcgpscostdiving freq
frequency for calling primal heuristic <gcgpscostdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics gcgpscostdiving freqofs
frequency offset for calling primal heuristic <gcgpscostdiving> [2]

set heuristics gcgpscostdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics gcgpscostdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics gcgpscostdiving maxpricerounds
maximal number of allowed pricing rounds (1: no limit) [0]

set heuristics gcgpscostdiving otherdirection
try to branch the diving variable in the other direction in case of infeasibility [TRUE]

set heuristics <gcgrens>
LNS exploring fractional neighborhood of relaxation's optimum

set heuristics gcgrens <advanced>
advanced parameters

set heuristics gcgrens advanced addallsols
should all subproblem solutions be added to the original SCIP? [FALSE]

set heuristics gcgrens advanced binarybounds
should general integers get binary bounds [floor(.),ceil(.)] ? [TRUE]

set heuristics gcgrens advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics gcgrens advanced maxdepth
maximal depth level to call primal heuristic <gcgrens> (1: no limit) [1]

set heuristics gcgrens advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics gcgrens advanced minimprove
factor by which RENS should at least improve the incumbent [0.01]

set heuristics gcgrens advanced minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics gcgrens advanced priority
priority of heuristic <gcgrens> [1100000]

set heuristics gcgrens advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics gcgrens freq
frequency for calling primal heuristic <gcgrens> (1: never, 0: only at depth freqofs) [0]

set heuristics gcgrens freqofs
frequency offset for calling primal heuristic <gcgrens> [0]

set heuristics gcgrens minfixingrate
minimum percentage of integer variables that have to be fixable [0.5]

set heuristics gcgrens nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics gcgrens nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <gcgrins>
relaxation induced neighborhood search by Danna, Rothberg, and Le Pape

set heuristics gcgrins <advanced>
advanced parameters

set heuristics gcgrins advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics gcgrins advanced maxdepth
maximal depth level to call primal heuristic <gcgrins> (1: no limit) [1]

set heuristics gcgrins advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics gcgrins advanced minimprove
factor by which gcgrins should at least improve the incumbent [0.01]

set heuristics gcgrins advanced minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics gcgrins advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [200]

set heuristics gcgrins advanced priority
priority of heuristic <gcgrins> [1101000]

set heuristics gcgrins advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics gcgrins freq
frequency for calling primal heuristic <gcgrins> (1: never, 0: only at depth freqofs) [20]

set heuristics gcgrins freqofs
frequency offset for calling primal heuristic <gcgrins> [5]

set heuristics gcgrins minfixingrate
minimum percentage of integer variables that have to be fixed [0.0]

set heuristics gcgrins nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics gcgrins nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <gcgrounding>
LP rounding heuristic on original variables with infeasibility recovering

set heuristics gcgrounding <advanced>
advanced parameters

set heuristics gcgrounding advanced maxdepth
maximal depth level to call primal heuristic <gcgrounding> (1: no limit) [1]

set heuristics gcgrounding advanced priority
priority of heuristic <gcgrounding> [1000]

set heuristics gcgrounding advanced successfactor
number of calls per found solution that are considered as standard success, a higher factor causes the heuristic to be called more often [100]

set heuristics gcgrounding freq
frequency for calling primal heuristic <gcgrounding> (1: never, 0: only at depth freqofs) [1]

set heuristics gcgrounding freqofs
frequency offset for calling primal heuristic <gcgrounding> [0]

set heuristics <gcgshifting>
LP rounding heuristic on original variables with infeasibility recovering also using continuous variables

set heuristics gcgshifting <advanced>
advanced parameters

set heuristics gcgshifting advanced maxdepth
maximal depth level to call primal heuristic <gcgshifting> (1: no limit) [1]

set heuristics gcgshifting advanced priority
priority of heuristic <gcgshifting> [5000]

set heuristics gcgshifting freq
frequency for calling primal heuristic <gcgshifting> (1: never, 0: only at depth freqofs) [10]

set heuristics gcgshifting freqofs
frequency offset for calling primal heuristic <gcgshifting> [0]

set heuristics <gcgsimplerounding>
simple and fast LP rounding heuristic on original variables

set heuristics gcgsimplerounding <advanced>
advanced parameters

set heuristics gcgsimplerounding advanced maxdepth
maximal depth level to call primal heuristic <gcgsimplerounding> (1: no limit) [1]

set heuristics gcgsimplerounding advanced priority
priority of heuristic <gcgsimplerounding> [0]

set heuristics gcgsimplerounding freq
frequency for calling primal heuristic <gcgsimplerounding> (1: never, 0: only at depth freqofs) [1]

set heuristics gcgsimplerounding freqofs
frequency offset for calling primal heuristic <gcgsimplerounding> [0]

set heuristics <gcgveclendiving>
LP diving heuristic that rounds variables with long column vectors

set heuristics gcgveclendiving <advanced>
advanced parameters

set heuristics gcgveclendiving advanced backtrack
single backtracking by choosing another variable in case of infeasibility [FALSE]

set heuristics gcgveclendiving advanced maxdepth
maximal depth level to call primal heuristic <gcgveclendiving> (1: no limit) [1]

set heuristics gcgveclendiving advanced maxdiscdepth
maximal depth until which a limited discrepancy search is performed [0]

set heuristics gcgveclendiving advanced maxdiscrepancy
maximal discrepancy allowed in backtracking and limited discrepancy search [2]

set heuristics gcgveclendiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics gcgveclendiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics gcgveclendiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics gcgveclendiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics gcgveclendiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics gcgveclendiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics gcgveclendiving advanced priority
priority of heuristic <gcgveclendiving> [1003100]

set heuristics gcgveclendiving advanced usefarkasonly
perform pricing only if infeasibility is encountered [FALSE]

set heuristics gcgveclendiving advanced usemasterscores
calculate vector length scores w.r.t. the master LP? [FALSE]

set heuristics gcgveclendiving freq
frequency for calling primal heuristic <gcgveclendiving> (1: never, 0: only at depth freqofs) [10]

set heuristics gcgveclendiving freqofs
frequency offset for calling primal heuristic <gcgveclendiving> [4]

set heuristics gcgveclendiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics gcgveclendiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics gcgveclendiving maxpricerounds
maximal number of allowed pricing rounds (1: no limit) [0]

set heuristics gcgveclendiving otherdirection
try to branch the diving variable in the other direction in case of infeasibility [TRUE]

set heuristics <gcgzirounding>
rounding heuristic on original variables as suggested by C. Wallace taking row slacks and bounds into account

set heuristics gcgzirounding <advanced>
advanced parameters

set heuristics gcgzirounding advanced maxdepth
maximal depth level to call primal heuristic <gcgzirounding> (1: no limit) [1]

set heuristics gcgzirounding advanced maxroundingloops
determines maximum number of rounding loops [2]

set heuristics gcgzirounding advanced minstopncalls
determines the minimum number of calls before percentagebased deactivation of Zirounding is applied [1000]

set heuristics gcgzirounding advanced priority
priority of heuristic <gcgzirounding> [500]

set heuristics gcgzirounding advanced stoppercentage
if percentage of found solutions falls below this parameter, Zirounding will be deactivated [0.02]

set heuristics gcgzirounding advanced stopziround
flag to determine if Zirounding is deactivated after a certain percentage of unsuccessful calls [TRUE]

set heuristics gcgzirounding freq
frequency for calling primal heuristic <gcgzirounding> (1: never, 0: only at depth freqofs) [1]

set heuristics gcgzirounding freqofs
frequency offset for calling primal heuristic <gcgzirounding> [0]

set heuristics <gins>
gins works on kneighborhood in a variableconstraint graph

set heuristics gins <advanced>
advanced parameters

set heuristics gins advanced consecutiveblocks
should blocks be treated consecutively (sorted by ascending label?) [TRUE]

set heuristics gins advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics gins advanced fixcontvars
should continuous variables outside the neighborhoods be fixed? [FALSE]

set heuristics gins advanced maxdepth
maximal depth level to call primal heuristic <gins> (1: no limit) [1]

set heuristics gins advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics gins advanced minimprove
factor by which gins should at least improve the incumbent [0.01]

set heuristics gins advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics gins advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [100]

set heuristics gins advanced overlap
overlap of blocks between runs  0.0: no overlap, 1.0: shift by only 1 block [0.0]

set heuristics gins advanced potential
the reference point to compute the neighborhood potential: (r)oot, (l)ocal lp, or (p)seudo solution [r]

set heuristics gins advanced priority
priority of heuristic <gins> [1103000]

set heuristics gins advanced relaxdenseconss
should dense constraints (at least as dense as 1  minfixingrate) be ignored by connectivity graph? [FALSE]

set heuristics gins advanced rollhorizonlimfac
limiting percentage for variables already used in subSCIPs to terminate rolling horizon approach [0.4]

set heuristics gins advanced usedecomp
should user decompositions be considered, if available? [TRUE]

set heuristics gins advanced usedecomprollhorizon
should user decompositions be considered for initial selection in rolling horizon, if available? [FALSE]

set heuristics gins advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics gins advanced userollinghorizon
should the heuristic solve a sequence of subMIP's around the first selected variable [TRUE]

set heuristics gins advanced useselfallback
should random initial variable selection be used if decomposition was not successful? [TRUE]

set heuristics gins bestsollimit
limit on number of improving incumbent solutions in subCIP [3]

set heuristics gins freq
frequency for calling primal heuristic <gins> (1: never, 0: only at depth freqofs) [20]

set heuristics gins freqofs
frequency offset for calling primal heuristic <gins> [8]

set heuristics gins maxdistance
maximum distance to selected variable to enter the subproblem, or 1 to select the distance that best approximates the minimum fixing rate from below [3]

set heuristics gins minfixingrate
percentage of integer variables that have to be fixed [0.66]

set heuristics gins nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics gins nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.15]

set heuristics <guideddiving>
LP diving heuristic that chooses fixings in direction of incumbent solutions

set heuristics guideddiving <advanced>
advanced parameters

set heuristics guideddiving advanced maxdepth
maximal depth level to call primal heuristic <guideddiving> (1: no limit) [1]

set heuristics guideddiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics guideddiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [1.0]

set heuristics guideddiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics guideddiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [1.0]

set heuristics guideddiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics guideddiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics guideddiving advanced priority
priority of heuristic <guideddiving> [1007000]

set heuristics guideddiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics guideddiving freq
frequency for calling primal heuristic <guideddiving> (1: never, 0: only at depth freqofs) [10]

set heuristics guideddiving freqofs
frequency offset for calling primal heuristic <guideddiving> [7]

set heuristics guideddiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics guideddiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics guideddiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics guideddiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics guideddiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [FALSE]

set heuristics <indicator>
indicator heuristic to create feasible solutions from values for indicator variables

set heuristics indicator <advanced>
advanced parameters

set heuristics indicator advanced improvesols
Try to improve other solutions by oneopt? [FALSE]

set heuristics indicator advanced maxdepth
maximal depth level to call primal heuristic <indicator> (1: no limit) [1]

set heuristics indicator advanced oneopt
whether the oneopt heuristic should be started [FALSE]

set heuristics indicator advanced priority
priority of heuristic <indicator> [20200]

set heuristics indicator freq
frequency for calling primal heuristic <indicator> (1: never, 0: only at depth freqofs) [1]

set heuristics indicator freqofs
frequency offset for calling primal heuristic <indicator> [0]

set heuristics <intdiving>
LP diving heuristic that fixes binary variables with large LP value to one

set heuristics intdiving <advanced>
advanced parameters

set heuristics intdiving advanced maxdepth
maximal depth level to call primal heuristic <intdiving> (1: no limit) [1]

set heuristics intdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics intdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics intdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics intdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics intdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics intdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics intdiving advanced priority
priority of heuristic <intdiving> [1003500]

set heuristics intdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics intdiving freq
frequency for calling primal heuristic <intdiving> (1: never, 0: only at depth freqofs) [1]

set heuristics intdiving freqofs
frequency offset for calling primal heuristic <intdiving> [9]

set heuristics intdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics intdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics <intshifting>
LP rounding heuristic with infeasibility recovering and final LP solving

set heuristics intshifting <advanced>
advanced parameters

set heuristics intshifting advanced maxdepth
maximal depth level to call primal heuristic <intshifting> (1: no limit) [1]

set heuristics intshifting advanced priority
priority of heuristic <intshifting> [10000]

set heuristics intshifting freq
frequency for calling primal heuristic <intshifting> (1: never, 0: only at depth freqofs) [10]

set heuristics intshifting freqofs
frequency offset for calling primal heuristic <intshifting> [0]

set heuristics <linesearchdiving>
LP diving heuristic that chooses fixings following the line from root solution to current solution

set heuristics linesearchdiving <advanced>
advanced parameters

set heuristics linesearchdiving advanced maxdepth
maximal depth level to call primal heuristic <linesearchdiving> (1: no limit) [1]

set heuristics linesearchdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics linesearchdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics linesearchdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics linesearchdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics linesearchdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics linesearchdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics linesearchdiving advanced priority
priority of heuristic <linesearchdiving> [1006000]

set heuristics linesearchdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics linesearchdiving freq
frequency for calling primal heuristic <linesearchdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics linesearchdiving freqofs
frequency offset for calling primal heuristic <linesearchdiving> [6]

set heuristics linesearchdiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics linesearchdiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics linesearchdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics linesearchdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics linesearchdiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [FALSE]

set heuristics <localbranching>
local branching heuristic by Fischetti and Lodi

set heuristics localbranching <advanced>
advanced parameters

set heuristics localbranching advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics localbranching advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [1.5]

set heuristics localbranching advanced maxdepth
maximal depth level to call primal heuristic <localbranching> (1: no limit) [1]

set heuristics localbranching advanced maxnodes
maximum number of nodes to regard in the subproblem [10000]

set heuristics localbranching advanced minimprove
factor by which localbranching should at least improve the incumbent [0.01]

set heuristics localbranching advanced minnodes
minimum number of nodes required to start the subproblem [1000]

set heuristics localbranching advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [200]

set heuristics localbranching advanced priority
priority of heuristic <localbranching> [1102000]

set heuristics localbranching advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics localbranching bestsollimit
limit on number of improving incumbent solutions in subCIP [3]

set heuristics localbranching freq
frequency for calling primal heuristic <localbranching> (1: never, 0: only at depth freqofs) [1]

set heuristics localbranching freqofs
frequency offset for calling primal heuristic <localbranching> [0]

set heuristics localbranching neighborhoodsize
radius (using Manhattan metric) of the incumbent's neighborhood to be searched [18]

set heuristics localbranching nodesofs
number of nodes added to the contingent of the total nodes [1000]

set heuristics localbranching nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.05]

set heuristics <locks>
heuristic that fixes variables based on their rounding locks

set heuristics locks <advanced>
advanced parameters

set heuristics locks advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics locks advanced maxdepth
maximal depth level to call primal heuristic <locks> (1: no limit) [1]

set heuristics locks advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics locks advanced maxproprounds
maximum number of propagation rounds to be performed in each propagation call (1: no limit, 2: parameter settings) [2]

set heuristics locks advanced minfixingratelp
minimum fixing rate over all variables (including continuous) to solve LP [0.0]

set heuristics locks advanced minimprove
factor by which locks heuristic should at least improve the incumbent [0.01]

set heuristics locks advanced minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics locks advanced priority
priority of heuristic <locks> [3000]

set heuristics locks advanced updatelocks
should the locks be updated based on LP rows? [TRUE]

set heuristics locks advanced usefinalsubmip
should a final subMIP be solved to costruct a feasible solution if the LP was not roundable? [TRUE]

set heuristics locks freq
frequency for calling primal heuristic <locks> (1: never, 0: only at depth freqofs) [0]

set heuristics locks freqofs
frequency offset for calling primal heuristic <locks> [0]

set heuristics locks minfixingrate
minimum percentage of integer variables that have to be fixable [0.65]

set heuristics locks nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics locks nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics locks roundupprobability
probability for rounding a variable up in case of ties [0.67]

set heuristics <lpface>
LNS heuristic that searches the optimal LP face inside a subMIP

set heuristics lpface <advanced>
advanced parameters

set heuristics lpface advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics lpface advanced dualbasisequations
should dually nonbasic rows be turned into equations? [FALSE]

set heuristics lpface advanced keepsubscip
should the heuristic continue solving the same subSCIP? [FALSE]

set heuristics lpface advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [2.0]

set heuristics lpface advanced maxdepth
maximal depth level to call primal heuristic <lpface> (1: no limit) [1]

set heuristics lpface advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics lpface advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics lpface advanced minpathlen
the minimum active search tree path length along which lower bound hasn't changed before heuristic becomes active [5]

set heuristics lpface advanced priority
priority of heuristic <lpface> [1104000]

set heuristics lpface advanced subscipobjective
objective function in the subSCIP: (z)ero, (r)ootLPdifference, (i)nference, LP (f)ractionality, (o)riginal [z]

set heuristics lpface advanced uselprows
should subproblem be created out of the rows in the LP rows? [TRUE]

set heuristics lpface freq
frequency for calling primal heuristic <lpface> (1: never, 0: only at depth freqofs) [15]

set heuristics lpface freqofs
frequency offset for calling primal heuristic <lpface> [0]

set heuristics lpface minfixingrate
required percentage of fixed integer variables in subMIP to run [0.1]

set heuristics lpface nodesofs
number of nodes added to the contingent of the total nodes [200]

set heuristics lpface nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <mpec>
regularization heuristic for convex and nonconvex MINLPs

set heuristics mpec <advanced>
advanced parameters

set heuristics mpec advanced maxdepth
maximal depth level to call primal heuristic <mpec> (1: no limit) [1]

set heuristics mpec advanced priority
priority of heuristic <mpec> [2050000]

set heuristics mpec freq
frequency for calling primal heuristic <mpec> (1: never, 0: only at depth freqofs) [50]

set heuristics mpec freqofs
frequency offset for calling primal heuristic <mpec> [0]

set heuristics mpec inittheta
initial regularization righthand side value [0.125]

set heuristics mpec maxiter
maximum number of iterations of the MPEC loop [100]

set heuristics mpec maxnlpcost
maximum cost available for solving NLPs per call of the heuristic [100000000.0]

set heuristics mpec maxnlpiter
maximum number of NLP iterations per solve [500]

set heuristics mpec maxnunsucc
maximum number of consecutive calls for which the heuristic did not find an improving solution [10]

set heuristics mpec mingapleft
minimum amount of gap left in order to call the heuristic [0.05]

set heuristics mpec minimprove
factor by which heuristic should at least improve the incumbent [0.01]

set heuristics mpec sigma
regularization update factor [0.5]

set heuristics mpec subnlptrigger
maximum number of NLP iterations per solve [0.001]

set heuristics <multistart>
multistart heuristic for convex and nonconvex MINLPs

set heuristics multistart <advanced>
advanced parameters

set heuristics multistart advanced maxdepth
maximal depth level to call primal heuristic <multistart> (1: no limit) [1]

set heuristics multistart advanced priority
priority of heuristic <multistart> [2100000]

set heuristics multistart freq
frequency for calling primal heuristic <multistart> (1: never, 0: only at depth freqofs) [0]

set heuristics multistart freqofs
frequency offset for calling primal heuristic <multistart> [0]

set heuristics multistart gradlimit
limit for gradient computations for all improvePoint() calls (0 for no limit) [5000000.0]

set heuristics multistart maxboundsize
maximum variable domain size for unbounded variables [20000.0]

set heuristics multistart maxiter
number of iterations to reduce the maximum violation of a point [300]

set heuristics multistart maxncluster
maximum number of considered clusters per heuristic call [3]

set heuristics multistart maxreldist
maximum distance between two points in the same cluster [0.15]

set heuristics multistart minimprfac
minimum required improving factor to proceed in improvement of a single point [0.05]

set heuristics multistart minimpriter
number of iteration when checking the minimum improvement [10]

set heuristics multistart nrndpoints
number of random points generated per execution call [100]

set heuristics multistart onlynlps
should the heuristic run only on continuous problems? [TRUE]

set heuristics <mutation>
mutation heuristic randomly fixing variables

set heuristics mutation <advanced>
advanced parameters

set heuristics mutation advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics mutation advanced maxdepth
maximal depth level to call primal heuristic <mutation> (1: no limit) [1]

set heuristics mutation advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics mutation advanced minimprove
factor by which mutation should at least improve the incumbent [0.01]

set heuristics mutation advanced minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics mutation advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [200]

set heuristics mutation advanced priority
priority of heuristic <mutation> [1103000]

set heuristics mutation advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics mutation advanced useuct
should uct node selection be used at the beginning of the search? [FALSE]

set heuristics mutation bestsollimit
limit on number of improving incumbent solutions in subCIP [1]

set heuristics mutation freq
frequency for calling primal heuristic <mutation> (1: never, 0: only at depth freqofs) [1]

set heuristics mutation freqofs
frequency offset for calling primal heuristic <mutation> [8]

set heuristics mutation minfixingrate
percentage of integer variables that have to be fixed [0.8]

set heuristics mutation nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics mutation nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <nlpdiving>
NLP diving heuristic that chooses fixings w.r.t. the fractionalities

set heuristics nlpdiving <advanced>
advanced parameters

set heuristics nlpdiving advanced lp
should the LP relaxation be solved before the NLP relaxation? [FALSE]

set heuristics nlpdiving advanced maxdepth
maximal depth level to call primal heuristic <nlpdiving> (1: no limit) [1]

set heuristics nlpdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics nlpdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics nlpdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics nlpdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics nlpdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics nlpdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics nlpdiving advanced nlpstart
which point should be used as starting point for the NLP solver? ('n'one, last 'f'easible, from dive's'tart) [s]

set heuristics nlpdiving advanced preferlpfracs
prefer variables that are also fractional in LP solution? [FALSE]

set heuristics nlpdiving advanced priority
priority of heuristic <nlpdiving> [1003000]

set heuristics nlpdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics nlpdiving fixquot
percentage of fractional variables that should be fixed before the next NLP solve [0.2]

set heuristics nlpdiving freq
frequency for calling primal heuristic <nlpdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics nlpdiving freqofs
frequency offset for calling primal heuristic <nlpdiving> [3]

set heuristics nlpdiving maxfeasnlps
maximal number of NLPs with feasible solution to solve during one dive [10]

set heuristics nlpdiving maxnlpiterabs
minimial absolute number of allowed NLP iterations [200]

set heuristics nlpdiving maxnlpiterrel
additional allowed number of NLP iterations relative to successfully found solutions [10]

set heuristics nlpdiving minsuccquot
heuristic will not run if less then this percentage of calls succeeded (0.0: no limit) [0.1]

set heuristics nlpdiving nlpfastfail
should the NLP solver stop early if it converges slow? [TRUE]

set heuristics nlpdiving prefercover
should variables in a minimal cover be preferred? [TRUE]

set heuristics nlpdiving solvesubmip
should a subMIP be solved if all cover variables are fixed? [FALSE]

set heuristics nlpdiving varselrule
which variable selection should be used? ('f'ractionality, 'c'oefficient, 'p'seudocost, 'g'uided, 'd'ouble, 'v'eclen) [d]

set heuristics <objpscostdiving>
LP diving heuristic that changes variable's objective values instead of bounds, using pseudo costs as guide

set heuristics objpscostdiving <advanced>
advanced parameters

set heuristics objpscostdiving advanced depthfac
maximal diving depth: number of binary/integer variables times depthfac [0.5]

set heuristics objpscostdiving advanced depthfacnosol
maximal diving depth factor if no feasible solution was found yet [2.0]

set heuristics objpscostdiving advanced maxdepth
maximal depth level to call primal heuristic <objpscostdiving> (1: no limit) [1]

set heuristics objpscostdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics objpscostdiving advanced maxsols
total number of feasible solutions found up to which heuristic is called (1: no limit) [1]

set heuristics objpscostdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics objpscostdiving advanced priority
priority of heuristic <objpscostdiving> [1004000]

set heuristics objpscostdiving freq
frequency for calling primal heuristic <objpscostdiving> (1: never, 0: only at depth freqofs) [20]

set heuristics objpscostdiving freqofs
frequency offset for calling primal heuristic <objpscostdiving> [4]

set heuristics objpscostdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics objpscostdiving maxlpiterquot
maximal fraction of diving LP iterations compared to total iteration number [0.01]

set heuristics <octane>
octane primal heuristic for pure {0;1}problems based on Balas et al.

set heuristics octane <advanced>
advanced parameters

set heuristics octane advanced ffirst
number of 01points to be tested at first whether they violate a common row [10]

set heuristics octane advanced fmax
number of 01points to be tested as possible solutions by OCTANE [100]

set heuristics octane advanced maxdepth
maximal depth level to call primal heuristic <octane> (1: no limit) [1]

set heuristics octane advanced priority
priority of heuristic <octane> [1008000]

set heuristics octane advanced useavgnbray
should the weighted average of the nonbasic cone be used as one ray direction? [TRUE]

set heuristics octane advanced useavgray
should the average of the basic cone be used as one ray direction? [TRUE]

set heuristics octane advanced useavgwgtray
should the weighted average of the basic cone be used as one ray direction? [TRUE]

set heuristics octane advanced usediffray
should the difference between the root solution and the current LP solution be used as one ray direction? [FALSE]

set heuristics octane advanced usefracspace
execute OCTANE only in the space of fractional variables (TRUE) or in the full space? [TRUE]

set heuristics octane advanced useobjray
should the inner normal of the objective be used as one ray direction? [TRUE]

set heuristics octane freq
frequency for calling primal heuristic <octane> (1: never, 0: only at depth freqofs) [1]

set heuristics octane freqofs
frequency offset for calling primal heuristic <octane> [0]

set heuristics <ofins>
primal heuristic for reoptimization, objective function induced neighborhood search

set heuristics ofins <advanced>
advanced parameters

set heuristics ofins advanced addallsols
should all subproblem solutions be added to the original SCIP? [FALSE]

set heuristics ofins advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics ofins advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [2.0]

set heuristics ofins advanced maxdepth
maximal depth level to call primal heuristic <ofins> (1: no limit) [0]

set heuristics ofins advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics ofins advanced minimprove
factor by which RENS should at least improve the incumbent [0.01]

set heuristics ofins advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics ofins advanced priority
priority of heuristic <ofins> [60000]

set heuristics ofins freq
frequency for calling primal heuristic <ofins> (1: never, 0: only at depth freqofs) [0]

set heuristics ofins freqofs
frequency offset for calling primal heuristic <ofins> [0]

set heuristics ofins maxchange
maximal rate of change per coefficient to get fixed [0.04]

set heuristics ofins maxchangerate
maximal rate of changed coefficients [0.5]

set heuristics ofins nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics ofins nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <oneopt>
1opt heuristic which tries to improve setting of single integer variables

set heuristics oneopt <advanced>
advanced parameters

set heuristics oneopt advanced beforepresol
should the heuristic be called before presolving? [FALSE]

set heuristics oneopt advanced duringroot
should the heuristic be called before and during the root node? [TRUE]

set heuristics oneopt advanced forcelpconstruction
should the construction of the LP be forced even if LP solving is deactivated? [FALSE]

set heuristics oneopt advanced maxdepth
maximal depth level to call primal heuristic <oneopt> (1: no limit) [1]

set heuristics oneopt advanced priority
priority of heuristic <oneopt> [20000]

set heuristics oneopt advanced useloop
should the heuristic continue to run as long as improvements are found? [TRUE]

set heuristics oneopt advanced weightedobj
should the objective be weighted with the potential shifting value when sorting the shifting candidates? [TRUE]

set heuristics oneopt freq
frequency for calling primal heuristic <oneopt> (1: never, 0: only at depth freqofs) [1]

set heuristics oneopt freqofs
frequency offset for calling primal heuristic <oneopt> [0]

set heuristics <padm>
penalty alternating direction method primal heuristic

set heuristics padm <advanced>
advanced parameters

set heuristics padm advanced admiterations
maximal number of ADM iterations in each penalty loop [4]

set heuristics padm advanced gap
mipgap at start [2.0]

set heuristics padm advanced maxdepth
maximal depth level to call primal heuristic <padm> (1: no limit) [1]

set heuristics padm advanced maxnodes
maximum number of nodes to regard in all subproblems [5000]

set heuristics padm advanced minnodes
minimum number of nodes to regard in one subproblem [50]

set heuristics padm advanced nodefac
factor to control nodelimits of subproblems [0.8]

set heuristics padm advanced original
should the original problem be used? This is only for testing and not recommended! [FALSE]

set heuristics padm advanced penaltyiterations
maximal number of penalty iterations [100]

set heuristics padm advanced priority
priority of heuristic <padm> [70000]

set heuristics padm advanced scaling
enable sigmoid rescaling of penalty parameters [TRUE]

set heuristics padm assignlinking
should linking constraints be assigned? [TRUE]

set heuristics padm freq
frequency for calling primal heuristic <padm> (1: never, 0: only at depth freqofs) [0]

set heuristics padm freqofs
frequency offset for calling primal heuristic <padm> [0]

set heuristics padm reoptimize
should the problem get reoptimized with the original objective function? [TRUE]

set heuristics padm timing
should the heuristic run before or after the processing of the node? (0: before, 1: after, 2: both) [0]

set heuristics <proximity>
heuristic trying to improve the incumbent by an auxiliary proximity objective function

set heuristics proximity <advanced>
advanced parameters

set heuristics proximity advanced binvarquot
threshold for percentage of binary variables required to start [0.1]

set heuristics proximity advanced lpitersquot
quotient of subMIP LP iterations with respect to LP iterations so far [0.2]

set heuristics proximity advanced maxdepth
maximal depth level to call primal heuristic <proximity> (1: no limit) [1]

set heuristics proximity advanced maxlpiters
maximum number of LP iterations to be performed in the subproblem [100000]

set heuristics proximity advanced maxnodes
maximum number of nodes to regard in the subproblem [10000]

set heuristics proximity advanced mingap
minimum primaldual gap for which the heuristic is executed [0.01]

set heuristics proximity advanced minimprove
factor by which proximity should at least improve the incumbent [0.02]

set heuristics proximity advanced minlpiters
minimum number of LP iterations performed in subproblem [200]

set heuristics proximity advanced minnodes
minimum number of nodes required to start the subproblem [1]

set heuristics proximity advanced nodesofs
number of nodes added to the contingent of the total nodes [50]

set heuristics proximity advanced nodesquot
subMIP node limit w.r.t number of original nodes [0.1]

set heuristics proximity advanced priority
priority of heuristic <proximity> [2000000]

set heuristics proximity advanced restart
should the heuristic immediately run again on its newly found solution? [TRUE]

set heuristics proximity advanced usefinallp
should the heuristic solve a final LP in case of continuous objective variables? [FALSE]

set heuristics proximity advanced uselprows
should subproblem be constructed based on LP row information? [FALSE]

set heuristics proximity advanced useuct
should uct node selection be used at the beginning of the search? [FALSE]

set heuristics proximity advanced waitingnodes
waiting nodes since last incumbent before heuristic is executed [100]

set heuristics proximity freq
frequency for calling primal heuristic <proximity> (1: never, 0: only at depth freqofs) [1]

set heuristics proximity freqofs
frequency offset for calling primal heuristic <proximity> [0]

set heuristics <pscostdiving>
LP diving heuristic that chooses fixings w.r.t. the pseudo cost values

set heuristics pscostdiving <advanced>
advanced parameters

set heuristics pscostdiving advanced maxdepth
maximal depth level to call primal heuristic <pscostdiving> (1: no limit) [1]

set heuristics pscostdiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics pscostdiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics pscostdiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics pscostdiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics pscostdiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics pscostdiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics pscostdiving advanced priority
priority of heuristic <pscostdiving> [1002000]

set heuristics pscostdiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics pscostdiving freq
frequency for calling primal heuristic <pscostdiving> (1: never, 0: only at depth freqofs) [10]

set heuristics pscostdiving freqofs
frequency offset for calling primal heuristic <pscostdiving> [2]

set heuristics pscostdiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics pscostdiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics pscostdiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics pscostdiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics pscostdiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [TRUE]

set heuristics <randrounding>
fast LP rounding heuristic

set heuristics randrounding <advanced>
advanced parameters

set heuristics randrounding advanced maxdepth
maximal depth level to call primal heuristic <randrounding> (1: no limit) [1]

set heuristics randrounding advanced maxproprounds
limit of rounds for each propagation call [1]

set heuristics randrounding advanced oncepernode
should the heuristic only be called once per node? [FALSE]

set heuristics randrounding advanced priority
priority of heuristic <randrounding> [200]

set heuristics randrounding advanced propagateonlyroot
should the probing part of the heuristic be applied exclusively at the root node? [TRUE]

set heuristics randrounding advanced usesimplerounding
should the heuristic apply the variable lock strategy of simple rounding, if possible? [FALSE]

set heuristics randrounding freq
frequency for calling primal heuristic <randrounding> (1: never, 0: only at depth freqofs) [20]

set heuristics randrounding freqofs
frequency offset for calling primal heuristic <randrounding> [0]

set heuristics <rens>
LNS exploring fractional neighborhood of relaxation's optimum

set heuristics rens <advanced>
advanced parameters

set heuristics rens advanced addallsols
should all subproblem solutions be added to the original SCIP? [FALSE]

set heuristics rens advanced binarybounds
should general integers get binary bounds [floor(.),ceil(.)] ? [TRUE]

set heuristics rens advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics rens advanced extratime
should the RENS subCIP get its own full time limit? This is only for testing and not recommended! [FALSE]

set heuristics rens advanced fullscale
should the RENS subCIP be solved with cuts, conflicts, strong branching,... This is only for testing and not recommended! [FALSE]

set heuristics rens advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [2.0]

set heuristics rens advanced maxdepth
maximal depth level to call primal heuristic <rens> (1: no limit) [1]

set heuristics rens advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics rens advanced minimprove
factor by which RENS should at least improve the incumbent [0.01]

set heuristics rens advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics rens advanced priority
priority of heuristic <rens> [1100000]

set heuristics rens advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics rens advanced useuct
should uct node selection be used at the beginning of the search? [FALSE]

set heuristics rens bestsollimit
limit on number of improving incumbent solutions in subCIP [1]

set heuristics rens freq
frequency for calling primal heuristic <rens> (1: never, 0: only at depth freqofs) [0]

set heuristics rens freqofs
frequency offset for calling primal heuristic <rens> [0]

set heuristics rens minfixingrate
minimum percentage of integer variables that have to be fixable [0.5]

set heuristics rens nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics rens nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics rens startsol
solution that is used for fixing values ('l'p relaxation, 'n'lp relaxation) [l]

set heuristics <reoptsols>
primal heuristic updating solutions found in a previous optimization round

set heuristics reoptsols <advanced>
advanced parameters

set heuristics reoptsols advanced maxdepth
maximal depth level to call primal heuristic <reoptsols> (1: no limit) [0]

set heuristics reoptsols advanced maxruns
check solutions of the last k runs. (1: all) [1]

set heuristics reoptsols advanced maxsols
maximal number solutions which should be checked. (1: all) [1000]

set heuristics reoptsols advanced priority
priority of heuristic <reoptsols> [40000]

set heuristics reoptsols freq
frequency for calling primal heuristic <reoptsols> (1: never, 0: only at depth freqofs) [0]

set heuristics reoptsols freqofs
frequency offset for calling primal heuristic <reoptsols> [0]

set heuristics <repair>
tries to repair a primal infeasible solution

set heuristics repair <advanced>
advanced parameters

set heuristics repair advanced alpha
factor for the potential of var fixings [2.0]

set heuristics repair advanced maxdepth
maximal depth level to call primal heuristic <repair> (1: no limit) [1]

set heuristics repair advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics repair advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics repair advanced priority
priority of heuristic <repair> [0]

set heuristics repair filename
file name of a solution to be used as infeasible starting point, [] if not available []

set heuristics repair freq
frequency for calling primal heuristic <repair> (1: never, 0: only at depth freqofs) [1]

set heuristics repair freqofs
frequency offset for calling primal heuristic <repair> [0]

set heuristics repair minfixingrate
minimum percentage of integer variables that have to be fixed [0.3]

set heuristics repair nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics repair nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics repair roundit
True : fractional variables which are not fractional in the given solution are rounded, FALSE : solving process of this heuristic is stopped. [TRUE]

set heuristics repair useobjfactor
should a scaled objective function for original variables be used in repair subproblem? [FALSE]

set heuristics repair useslackvars
should slack variables be used in repair subproblem? [FALSE]

set heuristics repair usevarfix
should variable fixings be used in repair subproblem? [TRUE]

set heuristics <rins>
relaxation induced neighborhood search by Danna, Rothberg, and Le Pape

set heuristics rins <advanced>
advanced parameters

set heuristics rins advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics rins advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [2.0]

set heuristics rins advanced maxdepth
maximal depth level to call primal heuristic <rins> (1: no limit) [1]

set heuristics rins advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics rins advanced minimprove
factor by which rins should at least improve the incumbent [0.01]

set heuristics rins advanced minnodes
minimum number of nodes required to start the subproblem [50]

set heuristics rins advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [200]

set heuristics rins advanced priority
priority of heuristic <rins> [1101000]

set heuristics rins advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics rins advanced useuct
should uct node selection be used at the beginning of the search? [FALSE]

set heuristics rins freq
frequency for calling primal heuristic <rins> (1: never, 0: only at depth freqofs) [25]

set heuristics rins freqofs
frequency offset for calling primal heuristic <rins> [0]

set heuristics rins minfixingrate
minimum percentage of integer variables that have to be fixed [0.3]

set heuristics rins nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics rins nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.3]

set heuristics <rootsoldiving>
LP diving heuristic that changes variable's objective values using root LP solution as guide

set heuristics rootsoldiving <advanced>
advanced parameters

set heuristics rootsoldiving advanced alpha
soft rounding factor to fade out objective coefficients [0.9]

set heuristics rootsoldiving advanced depthfac
maximal diving depth: number of binary/integer variables times depthfac [0.5]

set heuristics rootsoldiving advanced depthfacnosol
maximal diving depth factor if no feasible solution was found yet [2.0]

set heuristics rootsoldiving advanced maxdepth
maximal depth level to call primal heuristic <rootsoldiving> (1: no limit) [1]

set heuristics rootsoldiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics rootsoldiving advanced maxsols
total number of feasible solutions found up to which heuristic is called (1: no limit) [1]

set heuristics rootsoldiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics rootsoldiving advanced priority
priority of heuristic <rootsoldiving> [1005000]

set heuristics rootsoldiving freq
frequency for calling primal heuristic <rootsoldiving> (1: never, 0: only at depth freqofs) [20]

set heuristics rootsoldiving freqofs
frequency offset for calling primal heuristic <rootsoldiving> [5]

set heuristics rootsoldiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics rootsoldiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.01]

set heuristics <rounding>
LP rounding heuristic with infeasibility recovering

set heuristics rounding <advanced>
advanced parameters

set heuristics rounding advanced maxdepth
maximal depth level to call primal heuristic <rounding> (1: no limit) [1]

set heuristics rounding advanced oncepernode
should the heuristic only be called once per node? [FALSE]

set heuristics rounding advanced priority
priority of heuristic <rounding> [1000]

set heuristics rounding advanced successfactor
number of calls per found solution that are considered as standard success, a higher factor causes the heuristic to be called more often [100]

set heuristics rounding freq
frequency for calling primal heuristic <rounding> (1: never, 0: only at depth freqofs) [1]

set heuristics rounding freqofs
frequency offset for calling primal heuristic <rounding> [0]

set heuristics <shiftandpropagate>
Preroot heuristic to expand an auxiliary branchandbound tree and apply propagation techniques

set heuristics shiftandpropagate <advanced>
advanced parameters

set heuristics shiftandpropagate advanced binlocksfirst
should binary variables with no locks be preferred in the ordering? [FALSE]

set heuristics shiftandpropagate advanced collectstats
should variable statistics be collected during probing? [TRUE]

set heuristics shiftandpropagate advanced cutoffbreaker
The number of cutoffs before heuristic stops [15]

set heuristics shiftandpropagate advanced fixbinlocks
should binary variables with no locks in one direction be fixed to that direction? [TRUE]

set heuristics shiftandpropagate advanced impliscontinuous
should implicit integer variables be treated as continuous variables? [TRUE]

set heuristics shiftandpropagate advanced maxcutoffquot
maximum percentage of allowed cutoffs before stopping the heuristic [0.0]

set heuristics shiftandpropagate advanced maxdepth
maximal depth level to call primal heuristic <shiftandpropagate> (1: no limit) [1]

set heuristics shiftandpropagate advanced minfixingratelp
minimum fixing rate over all variables (including continuous) to solve LP [0.0]

set heuristics shiftandpropagate advanced normalize
should coefficients and left/right hand sides be normalized by max row coeff? [TRUE]

set heuristics shiftandpropagate advanced nozerofixing
should variables with a zero shifting value be delayed instead of being fixed? [FALSE]

set heuristics shiftandpropagate advanced nproprounds
The number of propagation rounds used for each propagation [10]

set heuristics shiftandpropagate advanced onlywithoutsol
Should heuristic only be executed if no primal solution was found, yet? [TRUE]

set heuristics shiftandpropagate advanced preferbinaries
Should binary variables be shifted first? [TRUE]

set heuristics shiftandpropagate advanced priority
priority of heuristic <shiftandpropagate> [1000]

set heuristics shiftandpropagate advanced probing
Should domains be reduced by probing? [TRUE]

set heuristics shiftandpropagate advanced relax
Should continuous variables be relaxed? [TRUE]

set heuristics shiftandpropagate advanced selectbest
should the heuristic choose the best candidate in every round? (set to FALSE for static order)? [FALSE]

set heuristics shiftandpropagate advanced sortkey
the key for variable sorting: (n)orms down, norms (u)p, (v)iolations down, viola(t)ions up, or (r)andom [v]

set heuristics shiftandpropagate advanced sortvars
Should variables be sorted for the heuristic? [TRUE]

set heuristics shiftandpropagate advanced stopafterfeasible
Should the heuristic stop calculating optimal shift values when no more rows are violated? [TRUE]

set heuristics shiftandpropagate advanced updateweights
should row weight be increased every time the row is violated? [FALSE]

set heuristics shiftandpropagate freq
frequency for calling primal heuristic <shiftandpropagate> (1: never, 0: only at depth freqofs) [0]

set heuristics shiftandpropagate freqofs
frequency offset for calling primal heuristic <shiftandpropagate> [0]

set heuristics <shifting>
LP rounding heuristic with infeasibility recovering also using continuous variables

set heuristics shifting <advanced>
advanced parameters

set heuristics shifting advanced maxdepth
maximal depth level to call primal heuristic <shifting> (1: no limit) [1]

set heuristics shifting advanced priority
priority of heuristic <shifting> [5000]

set heuristics shifting freq
frequency for calling primal heuristic <shifting> (1: never, 0: only at depth freqofs) [10]

set heuristics shifting freqofs
frequency offset for calling primal heuristic <shifting> [0]

set heuristics <simplerounding>
simple and fast LP rounding heuristic

set heuristics simplerounding <advanced>
advanced parameters

set heuristics simplerounding advanced maxdepth
maximal depth level to call primal heuristic <simplerounding> (1: no limit) [1]

set heuristics simplerounding advanced oncepernode
should the heuristic only be called once per node? [FALSE]

set heuristics simplerounding advanced priority
priority of heuristic <simplerounding> [0]

set heuristics simplerounding freq
frequency for calling primal heuristic <simplerounding> (1: never, 0: only at depth freqofs) [1]

set heuristics simplerounding freqofs
frequency offset for calling primal heuristic <simplerounding> [0]

set heuristics <subnlp>
primal heuristic that performs a local search in an NLP after fixing integer variables and presolving

set heuristics subnlp <advanced>
advanced parameters

set heuristics subnlp advanced keepcopy
whether to keep SCIP copy or to create new copy each time heuristic is applied [TRUE]

set heuristics subnlp advanced maxdepth
maximal depth level to call primal heuristic <subnlp> (1: no limit) [1]

set heuristics subnlp advanced opttol
absolute optimality tolerance to use for NLP solves [1e07]

set heuristics subnlp advanced priority
priority of heuristic <subnlp> [2000000]

set heuristics subnlp expectinfeas
percentage of NLP solves with infeasible status required to tell NLP solver to expect an infeasible NLP [0.0]

set heuristics subnlp feastolfactor
factor on SCIP feasibility tolerance for NLP solves if resolving when NLP solution not feasible in CIP [0.1]

set heuristics subnlp forbidfixings
whether to add constraints that forbid specific fixings that turned out to be infeasible [FALSE]

set heuristics subnlp freq
frequency for calling primal heuristic <subnlp> (1: never, 0: only at depth freqofs) [1]

set heuristics subnlp freqofs
frequency offset for calling primal heuristic <subnlp> [0]

set heuristics subnlp iterinit
number of iterations used for initial NLP solves [300]

set heuristics subnlp itermin
minimal number of iterations for NLP solves [20]

set heuristics subnlp maxpresolverounds
limit on number of presolve rounds in subSCIP (1 for unlimited, 0 for no presolve) [1]

set heuristics subnlp ninitsolves
number of successful NLP solves until switching to iterlimit guess and using success rate [2]

set heuristics subnlp nlpverblevel
verbosity level of NLP solver [0]

set heuristics subnlp nodesfactor
factor on number of nodes in SCIP (plus nodesoffset) to compute itercontingent (higher value runs heuristics more frequently) [0.3]

set heuristics subnlp nodesoffset
number of nodes added to the current number of nodes when computing itercontingent (higher value runs heuristic more often in early search) [1600]

set heuristics subnlp presolveemphasis
presolve emphasis in subSCIP (0: default, 1: aggressive, 2: fast, 3: off) [2]

set heuristics subnlp setcutoff
whether to set cutoff in subSCIP to current primal bound [TRUE]

set heuristics subnlp successrateexp
exponent for power of success rate to be multiplied with itercontingent (lower value decreases impact of success rate) [1.0]

set heuristics <trivial>
start heuristic which tries some trivial solutions

set heuristics trivial <advanced>
advanced parameters

set heuristics trivial advanced maxdepth
maximal depth level to call primal heuristic <trivial> (1: no limit) [1]

set heuristics trivial advanced priority
priority of heuristic <trivial> [10000]

set heuristics trivial freq
frequency for calling primal heuristic <trivial> (1: never, 0: only at depth freqofs) [0]

set heuristics trivial freqofs
frequency offset for calling primal heuristic <trivial> [0]

set heuristics <trivialnegation>
negate solution entries if an objective coefficient changes the sign, enters or leaves the objective.

set heuristics trivialnegation <advanced>
advanced parameters

set heuristics trivialnegation advanced maxdepth
maximal depth level to call primal heuristic <trivialnegation> (1: no limit) [0]

set heuristics trivialnegation advanced priority
priority of heuristic <trivialnegation> [40000]

set heuristics trivialnegation freq
frequency for calling primal heuristic <trivialnegation> (1: never, 0: only at depth freqofs) [0]

set heuristics trivialnegation freqofs
frequency offset for calling primal heuristic <trivialnegation> [0]

set heuristics <trustregion>
LNS heuristic for Benders' decomposition based on trust region methods

set heuristics trustregion <advanced>
advanced parameters

set heuristics trustregion advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics trustregion advanced lplimfac
factor by which the limit on the number of LP depends on the node limit [1.5]

set heuristics trustregion advanced maxdepth
maximal depth level to call primal heuristic <trustregion> (1: no limit) [1]

set heuristics trustregion advanced maxnodes
maximum number of nodes to regard in the subproblem [10000]

set heuristics trustregion advanced minnodes
minimum number of nodes required to start the subproblem [100]

set heuristics trustregion advanced nwaitingnodes
number of nodes without incumbent change that heuristic should wait [1]

set heuristics trustregion advanced priority
priority of heuristic <trustregion> [1102000]

set heuristics trustregion advanced uselprows
should subproblem be created out of the rows in the LP rows? [FALSE]

set heuristics trustregion bestsollimit
limit on number of improving incumbent solutions in subCIP [3]

set heuristics trustregion freq
frequency for calling primal heuristic <trustregion> (1: never, 0: only at depth freqofs) [1]

set heuristics trustregion freqofs
frequency offset for calling primal heuristic <trustregion> [0]

set heuristics trustregion minbinvars
the number of binary variables necessary to run the heuristic [10]

set heuristics trustregion nodesofs
number of nodes added to the contingent of the total nodes [1000]

set heuristics trustregion nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.05]

set heuristics trustregion objminimprove
the minimum absolute improvement in the objective function value [0.01]

set heuristics trustregion violpenalty
the penalty for each change in the binary variables from the candidate solution [100.0]

set heuristics <trysol>
try solution heuristic

set heuristics trysol <advanced>
advanced parameters

set heuristics trysol advanced maxdepth
maximal depth level to call primal heuristic <trysol> (1: no limit) [1]

set heuristics trysol advanced priority
priority of heuristic <trysol> [3000000]

set heuristics trysol freq
frequency for calling primal heuristic <trysol> (1: never, 0: only at depth freqofs) [1]

set heuristics trysol freqofs
frequency offset for calling primal heuristic <trysol> [0]

set heuristics <twoopt>
primal heuristic to improve incumbent solution by flipping pairs of variables

set heuristics twoopt <advanced>
advanced parameters

set heuristics twoopt advanced intopt
Should Integer2Optimization be applied or not? [FALSE]

set heuristics twoopt advanced matchingrate
parameter to determine the percentage of rows two variables have to share before they are considered equal [0.5]

set heuristics twoopt advanced maxdepth
maximal depth level to call primal heuristic <twoopt> (1: no limit) [1]

set heuristics twoopt advanced maxnslaves
maximum number of slaves for one master variable [199]

set heuristics twoopt advanced priority
priority of heuristic <twoopt> [20100]

set heuristics twoopt advanced waitingnodes
user parameter to determine number of nodes to wait after last best solution before calling heuristic [0]

set heuristics twoopt freq
frequency for calling primal heuristic <twoopt> (1: never, 0: only at depth freqofs) [1]

set heuristics twoopt freqofs
frequency offset for calling primal heuristic <twoopt> [0]

set heuristics <undercover>
solves a subCIP determined by a set covering approach

set heuristics undercover <advanced>
advanced parameters

set heuristics undercover advanced beforecuts
should the heuristic be called at root node before cut separation? [TRUE]

set heuristics undercover advanced conflictweight
weight for conflict score in fixing order [1000.0]

set heuristics undercover advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics undercover advanced coverbd
should bounddisjunction constraints be covered (or just copied)? [FALSE]

set heuristics undercover advanced coveringobj
objective function of the covering problem (influenced nonlinear 'c'onstraints/'t'erms, 'd'omain size, 'l'ocks, 'm'in of up/down locks, 'u'nit penalties) [u]

set heuristics undercover advanced cutoffweight
weight for cutoff score in fixing order [1.0]

set heuristics undercover advanced fixingorder
order in which variables should be fixed (increasing 'C'onflict score, decreasing 'c'onflict score, increasing 'V'ariable index, decreasing 'v'ariable index [v]

set heuristics undercover advanced fixintfirst
should integer variables in the cover be fixed first? [FALSE]

set heuristics undercover advanced inferenceweight
weight for inference score in fixing order [1.0]

set heuristics undercover advanced locksrounding
shall LP values for integer vars be rounded according to locks? [TRUE]

set heuristics undercover advanced maxbacktracks
maximum number of backtracks in fixandpropagate [6]

set heuristics undercover advanced maxcoversizeconss
maximum coversize (as ratio to the percentage of nonaffected constraints) [1.79769313486232e+308]

set heuristics undercover advanced maxcoversizevars
maximum coversize (as fraction of total number of variables) [1.0]

set heuristics undercover advanced maxdepth
maximal depth level to call primal heuristic <undercover> (1: no limit) [1]

set heuristics undercover advanced maxnodes
maximum number of nodes to regard in the subproblem [500]

set heuristics undercover advanced maxrecovers
maximum number of recoverings [0]

set heuristics undercover advanced maxreorders
maximum number of reorderings of the fixing order [1]

set heuristics undercover advanced mincoveredabs
minimum number of nonlinear constraints in the original problem [5]

set heuristics undercover advanced mincoveredrel
minimum percentage of nonlinear constraints in the original problem [0.15]

set heuristics undercover advanced minimprove
factor by which the heuristic should at least improve the incumbent [0.0]

set heuristics undercover advanced minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics undercover advanced priority
priority of heuristic <undercover> [1110000]

set heuristics undercover advanced recoverdiv
fraction of covering variables in the last cover which need to change their value when recovering [0.9]

set heuristics undercover advanced reusecover
shall the cover be reused if a conflict was added after an infeasible subproblem? [FALSE]

set heuristics undercover fixingalts
prioritized sequence of fixing values used ('l'p relaxation, 'n'lp relaxation, 'i'ncumbent solution) [li]

set heuristics undercover freq
frequency for calling primal heuristic <undercover> (1: never, 0: only at depth freqofs) [0]

set heuristics undercover freqofs
frequency offset for calling primal heuristic <undercover> [0]

set heuristics undercover nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics undercover nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics undercover onlyconvexify
should we only fix variables in order to obtain a convex problem? [FALSE]

set heuristics undercover postnlp
should the NLP heuristic be called to polish a feasible solution? [TRUE]

set heuristics <vbounds>
LNS heuristic uses the variable lower and upper bounds to determine the search neighborhood

set heuristics vbounds <advanced>
advanced parameters

set heuristics vbounds advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics vbounds advanced feasvariant
which variants of the vbounds heuristic that try to stay feasible should be called? (0: off, 1: w/o looking at obj, 2: only fix to best bound, 4: only fix to worst bound [6]

set heuristics vbounds advanced maxbacktracks
maximum number of backtracks during the fixing process [10]

set heuristics vbounds advanced maxdepth
maximal depth level to call primal heuristic <vbounds> (1: no limit) [1]

set heuristics vbounds advanced maxnodes
maximum number of nodes to regard in the subproblem [5000]

set heuristics vbounds advanced maxproprounds
maximum number of propagation rounds during probing (1 infinity) [2]

set heuristics vbounds advanced minimprove
factor by which vbounds heuristic should at least improve the incumbent [0.01]

set heuristics vbounds advanced minnodes
minimum number of nodes required to start the subproblem [500]

set heuristics vbounds advanced priority
priority of heuristic <vbounds> [2500]

set heuristics vbounds advanced tightenvariant
which tightening variants of the vbounds heuristic should be called? (0: off, 1: w/o looking at obj, 2: only fix to best bound, 4: only fix to worst bound [7]

set heuristics vbounds advanced uselockfixings
should more variables be fixed based on variable locks if the fixing rate was not reached? [FALSE]

set heuristics vbounds freq
frequency for calling primal heuristic <vbounds> (1: never, 0: only at depth freqofs) [0]

set heuristics vbounds freqofs
frequency offset for calling primal heuristic <vbounds> [0]

set heuristics vbounds minintfixingrate
minimum percentage of integer variables that have to be fixed [0.65]

set heuristics vbounds minmipfixingrate
minimum percentage of variables that have to be fixed within subSCIP (integer and continuous) [0.65]

set heuristics vbounds nodesofs
number of nodes added to the contingent of the total nodes [500]

set heuristics vbounds nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <veclendiving>
LP diving heuristic that rounds variables with long column vectors

set heuristics veclendiving <advanced>
advanced parameters

set heuristics veclendiving advanced maxdepth
maximal depth level to call primal heuristic <veclendiving> (1: no limit) [1]

set heuristics veclendiving advanced maxdiveavgquot
maximal quotient (curlowerbound  lowerbound)/(avglowerbound  lowerbound) where diving is performed (0.0: no limit) [0.0]

set heuristics veclendiving advanced maxdiveavgquotnosol
maximal AVGQUOT when no solution was found yet (0.0: no limit) [0.0]

set heuristics veclendiving advanced maxdiveubquot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where diving is performed (0.0: no limit) [0.8]

set heuristics veclendiving advanced maxdiveubquotnosol
maximal UBQUOT when no solution was found yet (0.0: no limit) [0.1]

set heuristics veclendiving advanced maxreldepth
maximal relative depth to start diving [1.0]

set heuristics veclendiving advanced minreldepth
minimal relative depth to start diving [0.0]

set heuristics veclendiving advanced priority
priority of heuristic <veclendiving> [1003100]

set heuristics veclendiving backtrack
use one level of backtracking if infeasibility is encountered? [TRUE]

set heuristics veclendiving freq
frequency for calling primal heuristic <veclendiving> (1: never, 0: only at depth freqofs) [10]

set heuristics veclendiving freqofs
frequency offset for calling primal heuristic <veclendiving> [4]

set heuristics veclendiving lpresolvedomchgquot
percentage of immediate domain changes during probing to trigger LP resolve [0.15]

set heuristics veclendiving lpsolvefreq
LP solve frequency for diving heuristics (0: only after enough domain changes have been found) [0]

set heuristics veclendiving maxlpiterofs
additional number of allowed LP iterations [1000]

set heuristics veclendiving maxlpiterquot
maximal fraction of diving LP iterations compared to node LP iterations [0.05]

set heuristics veclendiving onlylpbranchcands
should only LP branching candidates be considered instead of the slower but more general constraint handler diving variable selection? [FALSE]

set heuristics <xpcrossover>
Extreme Point Crossover

set heuristics xpcrossover <advanced>
advanced parameters

set heuristics xpcrossover advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics xpcrossover advanced maxdepth
maximal depth level to call primal heuristic <xpcrossover> (1: no limit) [1]

set heuristics xpcrossover advanced maxnodes
maximum number of nodes to regard in the subproblem [1000]

set heuristics xpcrossover advanced minimprove
factor by which crossover should at least improve the incumbent [0.01]

set heuristics xpcrossover advanced minnodes
minimum number of nodes required to start the subproblem [200]

set heuristics xpcrossover advanced priority
priority of heuristic <xpcrossover> [1100500]

set heuristics xpcrossover advanced randomization
should the choice which sols to take be randomized? [FALSE]

set heuristics xpcrossover freq
frequency for calling primal heuristic <xpcrossover> (1: never, 0: only at depth freqofs) [0]

set heuristics xpcrossover freqofs
frequency offset for calling primal heuristic <xpcrossover> [0]

set heuristics xpcrossover minfixingrate
minimum percentage of integer variables that have to be fixed [0.4]

set heuristics xpcrossover nodesofs
number of nodes added to the contingent of the total nodes [200]

set heuristics xpcrossover nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics xpcrossover nusedpts
number of extreme pts per block that will be taken into account [4]

set heuristics <xprins>
Extreme Point RINS

set heuristics xprins <advanced>
advanced parameters

set heuristics xprins advanced copycuts
if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set heuristics xprins advanced maxdepth
maximal depth level to call primal heuristic <xprins> (1: no limit) [1]

set heuristics xprins advanced maxnodes
maximum number of nodes to regard in the subproblem [1000]

set heuristics xprins advanced minimprove
factor by which crossover should at least improve the incumbent [0.01]

set heuristics xprins advanced minnodes
minimum number of nodes required to start the subproblem [200]

set heuristics xprins advanced priority
priority of heuristic <xprins> [1100600]

set heuristics xprins advanced randomization
should the choice which sols to take be randomized? [FALSE]

set heuristics xprins equalityrate
minimum percentage of coincidence of relaxation and extreme pts [0.5]

set heuristics xprins freq
frequency for calling primal heuristic <xprins> (1: never, 0: only at depth freqofs) [0]

set heuristics xprins freqofs
frequency offset for calling primal heuristic <xprins> [0]

set heuristics xprins minfixingrate
minimum percentage of integer variables that have to be fixed [0.4]

set heuristics xprins nodesofs
number of nodes added to the contingent of the total nodes [200]

set heuristics xprins nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics xprins nusedpts
number of extreme pts per block that will be taken into account (1: all; 0: all which contribute to current relaxation solution) [1]

set heuristics <zeroobj>
heuristic trying to solve the problem without objective

set heuristics zeroobj <advanced>
advanced parameters

set heuristics zeroobj advanced addallsols
should all subproblem solutions be added to the original SCIP? [FALSE]

set heuristics zeroobj advanced maxdepth
maximal depth level to call primal heuristic <zeroobj> (1: no limit) [0]

set heuristics zeroobj advanced maxlpiters
maximum number of LP iterations to be performed in the subproblem [5000]

set heuristics zeroobj advanced maxnodes
maximum number of nodes to regard in the subproblem [1000]

set heuristics zeroobj advanced minimprove
factor by which zeroobj should at least improve the incumbent [0.01]

set heuristics zeroobj advanced minnodes
minimum number of nodes required to start the subproblem [100]

set heuristics zeroobj advanced onlywithoutsol
should heuristic only be executed if no primal solution was found, yet? [TRUE]

set heuristics zeroobj advanced priority
priority of heuristic <zeroobj> [100]

set heuristics zeroobj advanced useuct
should uct node selection be used at the beginning of the search? [FALSE]

set heuristics zeroobj freq
frequency for calling primal heuristic <zeroobj> (1: never, 0: only at depth freqofs) [1]

set heuristics zeroobj freqofs
frequency offset for calling primal heuristic <zeroobj> [0]

set heuristics zeroobj nodesofs
number of nodes added to the contingent of the total nodes [100]

set heuristics zeroobj nodesquot
contingent of sub problem nodes in relation to the number of nodes of the original problem [0.1]

set heuristics <zirounding>
LP rounding heuristic as suggested by C. Wallace taking row slacks and bounds into account

set heuristics zirounding <advanced>
advanced parameters

set heuristics zirounding advanced maxdepth
maximal depth level to call primal heuristic <zirounding> (1: no limit) [1]

set heuristics zirounding advanced maxroundingloops
determines maximum number of rounding loops [2]

set heuristics zirounding advanced minstopncalls
determines the minimum number of calls before percentagebased deactivation of Zirounding is applied [1000]

set heuristics zirounding advanced priority
priority of heuristic <zirounding> [500]

set heuristics zirounding advanced stoppercentage
if percentage of found solutions falls below this parameter, Zirounding will be deactivated [0.02]

set heuristics zirounding advanced stopziround
flag to determine if Zirounding is deactivated after a certain percentage of unsuccessful calls [TRUE]

set heuristics zirounding freq
frequency for calling primal heuristic <zirounding> (1: never, 0: only at depth freqofs) [1]

set heuristics zirounding freqofs
frequency offset for calling primal heuristic <zirounding> [0]

set <history>
parameters for <history>

set history allowmerge
should variable histories be merged from subSCIPs whenever possible? [FALSE]

set history allowtransfer
should variable histories be transferred to initialize SCIP copies? [FALSE]

set history valuebased
should statistics be collected for variable domain value pairs? [FALSE]

set <limits>
change parameters for time, memory, objective value, and other limits

set limits absgap
solving stops, if the absolute gap = primalbound  dualbound is below the given value [0.0]

set limits autorestartnodes
if solve exceeds this number of nodes for the first time, an automatic restart is triggered (1: no automatic restart) [1]

set limits bestsol
solving stops, if the given number of solution improvements were found (1: no limit) [1]

set limits gap
solving stops, if the relative gap = primal  dual/MIN(dual,primal) is below the given value, the gap is 'Infinity', if primal and dual bound have opposite signs [0.0]

set limits maxorigsol
maximal number of solutions candidates to store in the solution storage of the original problem [10]

set limits maxsol
maximal number of solutions to store in the solution storage [100]

set limits memory
maximal memory usage in MB; reported memory usage is lower than real memory usage! [8796093022207.0]

set limits nodes
maximal number of nodes to process (1: no limit) [1]

set limits objective
set limit on objective function, such that only solutions better than this limit are accepted

set limits restarts
solving stops, if the given number of restarts was triggered (1: no limit) [1]

set limits solutions
solving stops, if the given number of solutions were found (1: no limit) [1]

set limits stallnodes
solving stops, if the given number of nodes was processed since the last improvement of the primal solution value (1: no limit) [1]

set limits time
maximal time in seconds to run [1e+20]

set limits totalnodes
maximal number of total nodes (incl. restarts) to process (1: no limit) [1]

set <lp>
change parameters for linear programming relaxations

set lp <advanced>
advanced parameters

set lp advanced checkdualfeas
should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur? [TRUE]

set lp advanced checkfarkas
should infeasibility proofs from the LP be checked? [TRUE]

set lp advanced checkprimfeas
should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur? [TRUE]

set lp advanced checkstability
should LP solver's return status be checked for stability? [TRUE]

set lp advanced cleanupcols
should new nonbasic columns be removed after LP solving? [FALSE]

set lp advanced cleanupcolsroot
should new nonbasic columns be removed after root LP solving? [FALSE]

set lp advanced cleanuprows
should new basic rows be removed after LP solving? [TRUE]

set lp advanced cleanuprowsroot
should new basic rows be removed after root LP solving? [TRUE]

set lp advanced clearinitialprobinglp
should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving? [TRUE]

set lp advanced colagelimit
maximum age a dynamic column can reach before it is deleted from the LP (1: don't delete columns due to aging) [10]

set lp advanced conditionlimit
maximum condition number of LP basis counted as stable (1.0: no limit) [1.0]

set lp advanced disablecutoff
disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto) [2]

set lp advanced fastmip
which FASTMIP setting of LP solver should be used? 0: off, 1: low [1]

set lp advanced freesolvalbuffers
should the buffers for storing LP solution values during diving be freed at end of diving? [FALSE]

set lp advanced iterlim
iteration limit for each single LP solve (1: no limit) [1]

set lp advanced lexdualalgo
should the lexicographic dual algorithm be used? [FALSE]

set lp advanced lexdualbasic
choose fractional basic variables in lexicographic dual algorithm? [FALSE]

set lp advanced lexdualmaxrounds
maximum number of rounds in the lexicographic dual algorithm (1: unbounded) [2]

set lp advanced lexdualrootonly
should the lexicographic dual algorithm be applied only at the root node [TRUE]

set lp advanced lexdualstalling
turn on the lex dual algorithm only when stalling? [TRUE]

set lp advanced minmarkowitz
minimal Markowitz threshold to control sparsity/stability in LU factorization [0.01]

set lp advanced presolving
should presolving of LP solver be used? [TRUE]

set lp advanced refactorinterval
LP refactorization interval (0: auto) [0]

set lp advanced resolveiterfac
factor of average LP iterations that is used as LP iteration limit for LP resolve (1: unlimited) [1.0]

set lp advanced resolveitermin
minimum number of iterations that are allowed for LP resolve [1000]

set lp advanced resolverestore
should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)? [FALSE]

set lp advanced rootiterlim
iteration limit for initial root LP solve (1: no limit) [1]

set lp advanced rowagelimit
maximum age a dynamic row can reach before it is deleted from the LP (1: don't delete rows due to aging) [10]

set lp advanced rowrepswitch
simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (1.0 to disable row representation) [1.2]

set lp advanced scaling
LP scaling (0: none, 1: normal, 2: aggressive) [1]

set lp advanced solutionpolishing
LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto) [3]

set lp advanced threads
number of threads used for solving the LP (0: automatic) [0]

set lp alwaysgetduals
should the Farkas duals always be collected when an LP is found to be infeasible? [FALSE]

set lp initalgorithm
LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover) [s]

set lp pricing
LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing) [l]

set lp resolvealgorithm
LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover) [s]

set lp solvedepth
maximal depth for solving LP at the nodes (1: no depth limit) [1]

set lp solvefreq
frequency for solving LP at the nodes (1: never; 0: only root LP) [0]

set <memory>
change parameters for memory management

set memory <advanced>
advanced parameters

set memory advanced arraygrowfac
memory growing factor for dynamically allocated arrays [1.2]

set memory advanced arraygrowinit
initial size of dynamically allocated arrays [4]

set memory advanced pathgrowfac
memory growing factor for path array [2.0]

set memory advanced pathgrowinit
initial size of path array [256]

set memory advanced treegrowfac
memory growing factor for tree array [2.0]

set memory advanced treegrowinit
initial size of tree array [65536]

set memory savefac
fraction of maximal memory usage resulting in switch to memory saving mode [0.8]

set <misc>
change parameters for miscellaneous stuff

set misc allowstrongdualreds
should strong dual reductions be allowed in propagation and presolving? [TRUE]

set misc allowweakdualreds
should weak dual reductions be allowed in propagation and presolving? [TRUE]

set misc avoidmemout
try to avoid running into memory limit by restricting plugins like heuristics? [TRUE]

set misc calcintegral
should SCIP calculate the primal dual integral value? [FALSE]

set misc catchctrlc
should the CTRLC interrupt be caught by SCIP? [TRUE]

set misc estimexternmem
should the usage of external memory be estimated? [TRUE]

set misc finitesolutionstore
should SCIP try to remove infinite fixings from solutions copied to the solution store? [FALSE]

set misc improvingsols
should only solutions be checked which improve the primal bound [FALSE]

set misc outputorigsol
should the best solution be transformed to the orignal space and be output in command line run? [TRUE]

set misc printreason
should the reason be printed if a given start solution is infeasible [TRUE]

set misc referencevalue
objective value for reference purposes [1e+99]

set misc resetstat
should the statistics be reset if the transformed problem is freed (in case of a Benders' decomposition this parameter should be set to FALSE) [TRUE]

set misc scaleobj
should the objective function be scaled so that it is always integer? [TRUE]

set misc transorigsols
should SCIP try to transfer original solutions to the transformed space (after presolving)? [TRUE]

set misc transsolsorig
should SCIP try to transfer transformed solutions to the original space (after solving)? [TRUE]

set misc useconstable
should a hashtable be used to map from constraint names to constraints? [TRUE]

set misc usesmalltables
should smaller hashtables be used? yields better performance for small problems with about 100 variables [FALSE]

set misc usesymmetry
bitset describing used symmetry handling technique (0: off; 1: polyhedral (orbitopes and/or symresacks); 2: orbital fixing; 3: orbitopes and orbital fixing; 4: Schreier Sims cuts; 5: Schreier Sims cuts and orbitopes); 6: Schreier Sims cuts and orbital fixing; 7: Schreier Sims cuts, orbitopes, and orbital fixing, see type_symmetry.h. [7]

set misc usevartable
should a hashtable be used to map from variable names to variables? [TRUE]

set <nlhdlr>
change parameters for nonlinear handlers

set <nlp>
change parameters for nonlinear programming relaxation

set nlp disable
should the NLP relaxation be always disabled (also for NLPs/MINLPs)? [FALSE]

set nlp solver
solver to use for solving NLPs; leave empty to select NLPI with highest priority []

set <nlpi>
change parameters for NLP solver interfaces

set <nodeselection>
change parameters for node selectors

set nodeselection <bfs>
best first search

set nodeselection bfs <advanced>
advanced parameters

set nodeselection bfs advanced maxplungedepth
maximal plunging depth, before new best node is forced to be selected (1 for dynamic setting) [1]

set nodeselection bfs advanced maxplungequot
maximal quotient (curlowerbound  lowerbound)/(cutoffbound  lowerbound) where plunging is performed [0.25]

set nodeselection bfs advanced memsavepriority
priority of node selection rule <bfs> in memory saving mode [0]

set nodeselection bfs advanced minplungedepth
minimal plunging depth, before new best node may be selected (1 for dynamic setting) [1]

set nodeselection bfs stdpriority
priority of node selection rule <bfs> in standard mode [100000]

set nodeselection <breadthfirst>
breadth first search

set nodeselection breadthfirst <advanced>
advanced parameters

set nodeselection breadthfirst advanced memsavepriority
priority of node selection rule <breadthfirst> in memory saving mode [1000000]

set nodeselection breadthfirst stdpriority
priority of node selection rule <breadthfirst> in standard mode [10000]

set nodeselection <dfs>
depth first search

set nodeselection dfs <advanced>
advanced parameters

set nodeselection dfs advanced memsavepriority
priority of node selection rule <dfs> in memory saving mode [100000]

set nodeselection dfs stdpriority
priority of node selection rule <dfs> in standard mode [0]

set nodeselection <estimate>
best estimate search

set nodeselection estimate <advanced>
advanced parameters

set nodeselection estimate advanced maxplungedepth
maximal plunging depth, before new best node is forced to be selected (1 for dynamic setting) [1]

set nodeselection estimate advanced maxplungequot
maximal quotient (estimate  lowerbound)/(cutoffbound  lowerbound) where plunging is performed [0.25]

set nodeselection estimate advanced memsavepriority
priority of node selection rule <estimate> in memory saving mode [100]

set nodeselection estimate advanced minplungedepth
minimal plunging depth, before new best node may be selected (1 for dynamic setting) [1]

set nodeselection estimate bestnodefreq
frequency at which the best node instead of the best estimate is selected (0: never) [10]

set nodeselection estimate breadthfirstdepth
depth until breadthfirst search is applied [1]

set nodeselection estimate plungeoffset
number of nodes before doing plunging the first time [0]

set nodeselection estimate stdpriority
priority of node selection rule <estimate> in standard mode [200000]

set nodeselection <hybridestim>
hybrid best estimate / best bound search

set nodeselection hybridestim <advanced>
advanced parameters

set nodeselection hybridestim advanced estimweight
weight of estimate value in node selection score (0: pure best bound search, 1: pure best estimate search) [0.1]

set nodeselection hybridestim advanced maxplungedepth
maximal plunging depth, before new best node is forced to be selected (1 for dynamic setting) [1]

set nodeselection hybridestim advanced maxplungequot
maximal quotient (estimate  lowerbound)/(cutoffbound  lowerbound) where plunging is performed [0.25]

set nodeselection hybridestim advanced memsavepriority
priority of node selection rule <hybridestim> in memory saving mode [50]

set nodeselection hybridestim advanced minplungedepth
minimal plunging depth, before new best node may be selected (1 for dynamic setting) [1]

set nodeselection hybridestim bestnodefreq
frequency at which the best node instead of the hybrid best estimate / best bound is selected (0: never) [1000]

set nodeselection hybridestim stdpriority
priority of node selection rule <hybridestim> in standard mode [50000]

set nodeselection <restartdfs>
depth first search with periodical selection of the best node

set nodeselection restartdfs <advanced>
advanced parameters

set nodeselection restartdfs advanced memsavepriority
priority of node selection rule <restartdfs> in memory saving mode [50000]

set nodeselection restartdfs countonlyleaves
count only leaf nodes (otherwise all nodes)? [TRUE]

set nodeselection restartdfs selectbestfreq
frequency for selecting the best node instead of the deepest one [100]

set nodeselection restartdfs stdpriority
priority of node selection rule <restartdfs> in standard mode [10000]

set nodeselection <uct>
node selector which balances exploration and exploitation

set nodeselection uct <advanced>
advanced parameters

set nodeselection uct advanced memsavepriority
priority of node selection rule <uct> in memory saving mode [0]

set nodeselection uct advanced nodelimit
maximum number of nodes before switching to default rule [31]

set nodeselection uct advanced useestimate
should the estimate (TRUE) or lower bound of a node be used for UCT score? [FALSE]

set nodeselection uct advanced weight
weight for visit quotient of node selection rule [0.1]

set nodeselection uct stdpriority
priority of node selection rule <uct> in standard mode [10]

set nodeselection childsel
child selection rule ('d'own, 'u'p, 'p'seudo costs, 'i'nference, 'l'p value, 'r'oot LP value difference, 'h'ybrid inference/root LP value difference) [h]

set <numerics>
change parameters for numerical values

set numerics <advanced>
advanced parameters

set numerics advanced barrierconvtol
LP convergence tolerance used in barrier algorithm [1e10]

set numerics advanced boundstreps
minimal relative improve for strengthening bounds [0.05]

set numerics advanced hugeval
values larger than this are considered huge and should be handled separately (e.g., in activity computation) [1e+15]

set numerics advanced pseudocostdelta
minimal objective distance value to use for branching pseudo cost updates [0.0001]

set numerics advanced pseudocosteps
minimal variable distance value to use for branching pseudo cost updates [0.1]

set numerics advanced recomputefac
minimal decrease factor that causes the recomputation of a value (e.g., pseudo objective) instead of an update [10000000.0]

set numerics checkfeastolfac
feasibility tolerance factor; for checking the feasibility of the best solution [1.0]

set numerics dualfeastol
feasibility tolerance for reduced costs in LP solution [1e07]

set numerics epsilon
absolute values smaller than this are considered zero [1e09]

set numerics feastol
feasibility tolerance for constraints [1e06]

set numerics infinity
values larger than this are considered infinity [1e+20]

set numerics lpfeastolfactor
factor w.r.t. primal feasibility tolerance that determines default (and maximal) primal feasibility tolerance of LP solver [1.0]

set numerics sumepsilon
absolute values of sums smaller than this are considered zero [1e06]

set <parallel>
change parameters for parallel implementation

set parallel maxnthreads
the maximum number of threads used during parallel solve [8]

set parallel minnthreads
the minimum number of threads used during parallel solve [1]

set parallel mode
parallel optimisation mode, 0: opportunistic or 1: deterministic. [1]

set <presolving>
change parameters for presolving

set presolving <advanced>
advanced parameters

set presolving advanced abortfac
abort presolve, if at most this fraction of the problem was changed in last presolve round [0.0008]

set presolving advanced clqtablefac
limit on number of entries in clique table relative to number of problem nonzeros [2.0]

set presolving advanced donotaggr
should aggregation of variables be forbidden? [FALSE]

set presolving advanced donotmultaggr
should multiaggregation of variables be forbidden? [FALSE]

set presolving advanced immrestartfac
fraction of integer variables that were fixed in the root node triggering an immediate restart with preprocessing [0.1]

set presolving advanced restartfac
fraction of integer variables that were fixed in the root node triggering a restart with preprocessing after root node evaluation [0.025]

set presolving advanced restartminred
minimal fraction of integer variables removed after restart to allow for an additional restart [0.1]

set presolving advanced subrestartfac
fraction of integer variables that were globally fixed during the solving process triggering a restart with preprocessing [1.0]

set presolving <boundshift>
converts variables with domain [a,b] to variables with domain [0,ba]

set presolving boundshift <advanced>
advanced parameters

set presolving boundshift advanced flipping
is flipping allowed (multiplying with 1)? [TRUE]

set presolving boundshift advanced integer
shift only integer ranges? [TRUE]

set presolving boundshift advanced maxshift
absolute value of maximum shift [9223372036854775807]

set presolving boundshift advanced priority
priority of presolver <boundshift> [7900000]

set presolving boundshift advanced timing
timing mask of presolver <boundshift> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set presolving boundshift maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [0]

set presolving <convertinttobin>
converts integer variables to binaries

set presolving convertinttobin <advanced>
advanced parameters

set presolving convertinttobin advanced maxdomainsize
absolute value of maximum domain size for converting an integer variable to binaries variables [9223372036854775807]

set presolving convertinttobin advanced onlypoweroftwo
should only integer variables with a domain size of 2^p  1 be converted(, there we don't need an knapsackconstraint for restricting the sum of the binaries) [FALSE]

set presolving convertinttobin advanced priority
priority of presolver <convertinttobin> [6000000]

set presolving convertinttobin advanced onlypoweroftwo
should only integer variables with a domain size of 2^p  1 be converted(, there we don't need an knapsackconstraint for restricting the sum of the binaries) [FALSE]

set presolving convertinttobin advanced timing
timing mask of presolver <convertinttobin> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set presolving convertinttobin maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [0]

set presolving <domcol>
dominated column presolver

set presolving domcol <advanced>
advanced parameters

set presolving domcol advanced priority
priority of presolver <domcol> [1000]

set presolving domcol advanced timing
timing mask of presolver <domcol> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving domcol continuousred
should reductions for continuous variables be performed? [TRUE]

set presolving domcol maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving domcol nummaxpairs
maximal number of pair comparisons [1048576]

set presolving domcol numminpairs
minimal number of pair comparisons [1024]

set presolving domcol predbndstr
should predictive bound strengthening be applied? [FALSE]

set presolving <dualagg>
aggregate variables by dual arguments

set presolving dualagg <advanced>
advanced parameters

set presolving dualagg advanced priority
priority of presolver <dualagg> [12000]

set presolving dualagg advanced timing
timing mask of presolver <dualagg> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving dualagg maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [0]

set presolving <dualcomp>
compensate single up/downlocks by singleton continuous variables

set presolving dualcomp <advanced>
advanced parameters

set presolving dualcomp advanced priority
priority of presolver <dualcomp> [50]

set presolving dualcomp advanced timing
timing mask of presolver <dualcomp> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving dualcomp componlydisvars
should only discrete variables be compensated? [FALSE]

set presolving dualcomp maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving <dualinfer>
exploit dual information for fixings and side changes

set presolving dualinfer <advanced>
advanced parameters

set presolving dualinfer advanced maxcombinefails
maximal number of consecutive useless column combines [1000]

set presolving dualinfer advanced maxconsiderednonzeros
maximal number of considered nonzeros within one column (1: no limit) [100]

set presolving dualinfer advanced maxhashfac
Maximum number of hashlist entries as multiple of number of columns in the problem (1: no limit) [10]

set presolving dualinfer advanced maxpairfac
Maximum number of processed column pairs as multiple of the number of columns in the problem (1: no limit) [1]

set presolving dualinfer advanced maxretrievefails
maximal number of consecutive useless hashtable retrieves [1000]

set presolving dualinfer advanced priority
priority of presolver <dualinfer> [3000]

set presolving dualinfer advanced timing
timing mask of presolver <dualinfer> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving dualinfer maxdualbndloops
maximal number of dual bound strengthening loops [12]

set presolving dualinfer maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [0]

set presolving dualinfer maxrowsupport
Maximum number of row's nonzeros for changing inequality to equality [3]

set presolving dualinfer twocolcombine
use convex combination of columns for determining dual bounds [TRUE]

set presolving <dualsparsify>
eliminate nonzero coefficients

set presolving dualsparsify <advanced>
advanced parameters

set presolving dualsparsify advanced enablecopy
should dualsparsify presolver be copied to subSCIPs? [TRUE]

set presolving dualsparsify advanced maxconsiderednonzeros
maximal number of considered nonzeros within one column (1: no limit) [70]

set presolving dualsparsify advanced maxretrievefac
limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constraints [100.0]

set presolving dualsparsify advanced preservegoodlocks
should we preserve good locked properties of variables (at most one lock in one direction)? [FALSE]

set presolving dualsparsify advanced preserveintcoefs
should we forbid cancellations that destroy integer coefficients? [FALSE]

set presolving dualsparsify advanced priority
priority of presolver <dualsparsify> [240000]

set presolving dualsparsify advanced timing
timing mask of presolver <dualsparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving dualsparsify advanced waitingfac
number of calls to wait until next execution as a multiple of the number of useless calls [2.0]

set presolving dualsparsify maxbinfillin
maximal fillin for binary variables (1: unlimited) [1]

set presolving dualsparsify maxcontfillin
maximal fillin for continuous variables (1: unlimited) [1]

set presolving dualsparsify maxintfillin
maximal fillin for integer variables including binaries (1: unlimited) [1]

set presolving dualsparsify maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving dualsparsify mineliminatednonzeros
minimal eliminated nonzeros within one column if we need to add a constraint to the problem [100]

set presolving <emphasis>
predefined parameter settings

set presolving emphasis aggressive
sets presolving <aggressive>

set presolving emphasis default
sets presolving settings to <default>

set presolving emphasis fast
sets presolving <fast>

set presolving emphasis off
turns <off> all presolving

set presolving <gateextraction>
presolver extracting gate(and)constraints

set presolving gateextraction <advanced>
advanced parameters

set presolving gateextraction advanced onlysetpart
should we only try to extract setpartitioning constraints and no andconstraints [FALSE]

set presolving gateextraction advanced priority
priority of presolver <gateextraction> [1000000]

set presolving gateextraction advanced searchequations
should we try to extract setpartitioning constraint out of one logicor and one corresponding setpacking constraint [TRUE]

set presolving gateextraction advanced sorting
order logicor contraints to extract biggates before smaller ones (1), do not order them (0) or order them to extract smaller gates at first (1) [1]

set presolving gateextraction advanced timing
timing mask of presolver <gateextraction> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving gateextraction maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving <implics>
implication graph aggregator

set presolving implics <advanced>
advanced parameters

set presolving implics advanced priority
priority of presolver <implics> [10000]

set presolving implics advanced timing
timing mask of presolver <implics> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [8]

set presolving implics maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving <inttobinary>
converts integer variables with domain [a,a+1] to binaries

set presolving inttobinary <advanced>
advanced parameters

set presolving inttobinary advanced priority
priority of presolver <inttobinary> [7000000]

set presolving inttobinary advanced timing
timing mask of presolver <inttobinary> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set presolving inttobinary maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving <redvub>
detect redundant variable bound constraints

set presolving redvub <advanced>
advanced parameters

set presolving redvub advanced priority
priority of presolver <redvub> [9000000]

set presolving redvub advanced timing
timing mask of presolver <redvub> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving redvub maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [0]

set presolving <sparsify>
eliminate nonzero coefficients

set presolving sparsify <advanced>
advanced parameters

set presolving sparsify advanced cancellinear
should we cancel nonzeros in constraints of the linear constraint handler? [TRUE]

set presolving sparsify advanced enablecopy
should sparsify presolver be copied to subSCIPs? [TRUE]

set presolving sparsify advanced maxconsiderednonzeros
maximal number of considered nonzeros within one row (1: no limit) [70]

set presolving sparsify advanced maxnonzeros
maximal support of one equality to be used for cancelling (1: no limit) [1]

set presolving sparsify advanced maxretrievefac
limit on the number of useless vs. useful hashtable retrieves as a multiple of the number of constraints [100.0]

set presolving sparsify advanced preserveintcoefs
should we forbid cancellations that destroy integer coefficients? [TRUE]

set presolving sparsify advanced priority
priority of presolver <sparsify> [24000]

set presolving sparsify advanced rowsort
order in which to process inequalities ('n'o sorting, 'i'ncreasing nonzeros, 'd'ecreasing nonzeros) [d]

set presolving sparsify advanced timing
timing mask of presolver <sparsify> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving sparsify advanced waitingfac
number of calls to wait until next execution as a multiple of the number of useless calls [2.0]

set presolving sparsify maxbinfillin
maximal fillin for binary variables (1: unlimited) [0]

set presolving sparsify maxcontfillin
maximal fillin for continuous variables (1: unlimited) [0]

set presolving sparsify maxintfillin
maximal fillin for integer variables including binaries (1: unlimited) [0]

set presolving sparsify maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving <stuffing>
fix redundant singleton continuous variables

set presolving stuffing <advanced>
advanced parameters

set presolving stuffing advanced priority
priority of presolver <stuffing> [100]

set presolving stuffing advanced timing
timing mask of presolver <stuffing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving stuffing maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [0]

set presolving <trivial>
round fractional bounds on integers, fix variables with equal bounds

set presolving trivial <advanced>
advanced parameters

set presolving trivial advanced priority
priority of presolver <trivial> [9000000]

set presolving trivial advanced timing
timing mask of presolver <trivial> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set presolving trivial maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [1]

set presolving <tworowbnd>
do bound tigthening by using two rows

set presolving tworowbnd <advanced>
advanced parameters

set presolving tworowbnd advanced enablecopy
should tworowbnd presolver be copied to subSCIPs? [TRUE]

set presolving tworowbnd advanced priority
priority of presolver <tworowbnd> [2000]

set presolving tworowbnd advanced timing
timing mask of presolver <tworowbnd> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set presolving tworowbnd maxcombinefails
maximal number of consecutive useless row combines [1000]

set presolving tworowbnd maxconsiderednonzeros
maximal number of considered nonzeros within one row (1: no limit) [100]

set presolving tworowbnd maxhashfac
Maximum number of hashlist entries as multiple of number of rows in the problem (1: no limit) [10]

set presolving tworowbnd maxpairfac
Maximum number of processed row pairs as multiple of the number of rows in the problem (1: no limit) [1]

set presolving tworowbnd maxretrievefails
maximal number of consecutive useless hashtable retrieves [1000]

set presolving tworowbnd maxrounds
maximal number of presolving rounds the presolver participates in (1: no limit) [0]

set presolving maxrestarts
maximal number of restarts (1: unlimited) [0]

set presolving maxrounds
maximal number of presolving rounds (1: unlimited, 0: off) [1]

set <pricing>
change parameters for pricing variables

set pricing <masterpricer>
parameters for <masterpricer>

set pricing masterpricer <advanced>
advanced parameters

set pricing masterpricer advanced abortpricinggap
gap between dual bound and RMP objective at which pricing is aborted [0.0]

set pricing masterpricer advanced abortpricingint
should pricing be aborted due to integral objective function? [TRUE]

set pricing masterpricer advanced chunksize
maximal number of pricing problems to be solved during one pricing loop [2147483647]

set pricing masterpricer advanced nroundscol
number of previous pricing rounds for which the number of improving columns should be counted [15]

set pricing masterpricer <colpool>
parameters for <colpool>

set pricing masterpricer colpool agelimit
age limit for columns in column pool? (1 for no limit) [100]

set pricing masterpricer <pricestore>
parameters for <pricestore>

set pricing masterpricer pricestore efficiacychoice
choice to base efficiacy on [0]

set pricing masterpricer pricestore mincolorth
minimal orthogonality of columns to add [0.0]

set pricing masterpricer pricestore objparalfac
factor of objective parallelism in score function [0.0]

set pricing masterpricer pricestore orthofac
factor of orthogonalities in score function [0.0]

set pricing masterpricer pricestore redcostfac
factor of redcost/norm in score function [1.0]

set pricing masterpricer bigmartificial
value for for big M objective of artificial variables (negative if max obj should be used) [1000.0]

set pricing masterpricer disablecutoff
should the cutoffbound be applied in master LP solving (0: on, 1:off, 2:auto)? [2]

set pricing masterpricer dispinfos
should additional informations concerning the pricing process be displayed? [FALSE]

set pricing masterpricer eagerfreq
frequency at which all pricingproblems should be solved (0 to disable) [10]

set pricing masterpricer factorunreliable
factor to use for objective of unbounded variables [1000.0]

set pricing masterpricer heurpricingiters
maximum number of heuristic pricing iterations per pricing call and problem [1]

set pricing masterpricer maxcolsprobfarkas
maximal number of columns per problem to be generated during Farkas pricing [10]

set pricing masterpricer maxcolsprobredcost
maximal number of columns per problem to be generated during red. cost pricing [10]

set pricing masterpricer <colpool>
parameters for <colpool>

set pricing masterpricer colpool agelimit
age limit for columns in column pool? (1 for no limit) [100]

set pricing masterpricer maxcolsroundfarkas
maximal number of columns per Farkas pricing round [10]

set pricing masterpricer maxcolsroundredcost
maximal number of columns per reduced cost pricing round [100]

set pricing masterpricer <colpool>
parameters for <colpool>

set pricing masterpricer colpool agelimit
age limit for columns in column pool? (1 for no limit) [100]

set pricing masterpricer maxheurdepth
maximum depth at which heuristic pricing should be performed (1 for infinity) [1]

set pricing masterpricer maxroundsredcost
maximal number of pricing rounds per node after the root node [2147483647]

set pricing masterpricer <colpool>
parameters for <colpool>

set pricing masterpricer colpool agelimit
age limit for columns in column pool? (1 for no limit) [100]

set pricing masterpricer onlyreliablebigm
only use maxobj for big M objective of artificial variables if it is reliable [TRUE]

set pricing masterpricer relmaxprobsfarkas
maximal percentage of Farkas pricing problems that are solved if variables have already been found [1.0]

set pricing masterpricer relmaxprobsredcost
maximal percentage of red. cost pricing problems that are solved if variables have already been found [1.0]

set pricing masterpricer <colpool>
parameters for <colpool>

set pricing masterpricer colpool agelimit
age limit for columns in column pool? (1 for no limit) [100]

set pricing masterpricer <colpool>
parameters for <colpool>

set pricing masterpricer colpool agelimit
age limit for columns in column pool? (1 for no limit) [100]

set pricing masterpricer sorting
order by which the pricing problems should be sorted ('i'ndices, 'd'ual solutions of convexity constraints, 'r'eliability from previous rounds, reliability from the 'l'ast nroundscol rounds) [r]

set pricing masterpricer stabilization
should stabilization be performed? [TRUE]

set pricing masterpricer stabilizationtree
should stabilization be performed in the tree (in nodes other than the root node)? [FALSE]

set pricing masterpricer threads
how many threads should be used to concurrently solve the pricing problem (0 to guess threads by OpenMP) [0]

set pricing masterpricer useartificialvars
should artificial variables be used to make the RMP feasible (instead of applying Farkas pricing)? [FALSE]

set pricing masterpricer usecolpool
should the colpool be checked for negative redcost cols before solving the pricing problems? [TRUE]

set pricing masterpricer usemaxobj
use maxobj for big M objective of artificial variables [TRUE]

set pricing abortfac
pricing is aborted, if fac * pricing/maxvars pricing candidates were found [2.0]

set pricing delvars
should variables created at the current node be deleted when the node is solved in case they are not present in the LP anymore? [FALSE]

set pricing delvarsroot
should variables created at the root node be deleted when the root is solved in case they are not present in the LP anymore? [FALSE]

set pricing maxvars
maximal number of variables priced in per pricing round [100]

set pricing maxvarsroot
maximal number of priced variables at the root node [2000]

set <pricingsolver>
parameters for <pricingsolver>

set pricingsolver <knapsack>
parameters for <knapsack>

set pricingsolver knapsack exactenabled
flag to indicate whether exact solving method of solver <knapsack> is enabled [TRUE]

set pricingsolver knapsack heurenabled
flag to indicate whether heuristic solving method of solver <knapsack> is enabled [FALSE]

set pricingsolver knapsack priority
priority of solver <knapsack> [200]

set pricingsolver <mip>
parameters for <mip>

set pricingsolver mip <advanced>
advanced parameters

set pricingsolver mip advanced checksols
should solutions of the pricing MIPs be checked for duplicity? [TRUE]

set pricingsolver mip advanced gaplimitfac
factor by which to decrease gap limit for heuristic pricing (1.0: subtract start limit) [0.8]

set pricingsolver mip advanced nodelimitfac
factor by which to increase node limit for heuristic pricing (1.0: add start limit) [1.0]

set pricingsolver mip advanced settingsfile
settings file for pricing problems []

set pricingsolver mip advanced sollimitfac
factor by which to increase solution limit for heuristic pricing (1.0: add start limit) [1.0]

set pricingsolver mip advanced stallnodelimitfac
factor by which to increase stalling node limit for heuristic pricing (1.0: add start limit) [1.0]

set pricingsolver mip advanced startgaplimit
start gap limit for heuristic pricing [0.2]

set pricingsolver mip advanced startnodelimit
start node limit for heuristic pricing [1000]

set pricingsolver mip advanced startsollimit
start solution limit for heuristic pricing [10]

set pricingsolver mip advanced startstallnodelimit
start stalling node limit for heuristic pricing [100]

set pricingsolver mip exactenabled
flag to indicate whether exact solving method of solver <mip> is enabled [TRUE]

set pricingsolver mip heurenabled
flag to indicate whether heuristic solving method of solver <mip> is enabled [TRUE]

set pricingsolver mip priority
priority of solver <mip> [0]

set <propagating>
change parameters for constraint propagation

set propagating <dualfix>
parameters for <dualfix>

set propagating dualfix <advanced>
advanced parameters

set propagating dualfix advanced delay
should propagator be delayed, if other propagators found reductions? [FALSE]

set propagating dualfix advanced presolpriority
presolving priority of propagator <dualfix> [8000000]

set propagating dualfix advanced presoltiming
timing mask of the presolving method of propagator <dualfix> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set propagating dualfix advanced priority
priority of propagator <dualfix> [8000000]

set propagating dualfix advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [1]

set propagating dualfix freq
frequency for calling propagator <dualfix> (1: never, 0: only in root node) [0]

set propagating dualfix maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating <genvbounds>
parameters for <genvbounds>

set propagating genvbounds <advanced>
advanced parameters

set propagating genvbounds advanced delay
should propagator be delayed, if other propagators found reductions? [FALSE]

set propagating genvbounds advanced global
apply global propagation? [TRUE]

set propagating genvbounds advanced presolpriority
presolving priority of propagator <genvbounds> [2000000]

set propagating genvbounds advanced presoltiming
timing mask of the presolving method of propagator <genvbounds> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set propagating genvbounds advanced priority
priority of propagator <genvbounds> [3000000]

set propagating genvbounds advanced propasconss
should genvbounds be transformed to (linear) constraints? [FALSE]

set propagating genvbounds advanced propinrootnode
apply genvbounds in root node if no new incumbent was found? [TRUE]

set propagating genvbounds advanced sort
sort genvbounds and wait for bound change events? [TRUE]

set propagating genvbounds advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [15]

set propagating genvbounds freq
frequency for calling propagator <genvbounds> (1: never, 0: only in root node) [1]

set propagating genvbounds maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating <nlobbt>
parameters for <nlobbt>

set propagating nlobbt <advanced>
advanced parameters

set propagating nlobbt advanced delay
should propagator be delayed, if other propagators found reductions? [TRUE]

set propagating nlobbt advanced feastolfac
factor for NLP feasibility tolerance [0.01]

set propagating nlobbt advanced itlimitfactor
LP iteration limit for nlobbt will be this factor times total LP iterations in root node [2.0]

set propagating nlobbt advanced minlinearfrac
minimum (#convex nlrows)/(#linear nlrows) threshold to apply propagator [0.02]

set propagating nlobbt advanced minnonconvexfrac
(#convex nlrows)/(#nonconvex nlrows) threshold to apply propagator [0.2]

set propagating nlobbt advanced nlpiterlimit
iteration limit of NLP solver; 0 for no limit [500]

set propagating nlobbt advanced nlptimelimit
time limit of NLP solver; 0.0 for no limit [0.0]

set propagating nlobbt advanced nlpverblevel
verbosity level of NLP solver [0]

set propagating nlobbt advanced presolpriority
presolving priority of propagator <nlobbt> [0]

set propagating nlobbt advanced presoltiming
timing mask of the presolving method of propagator <nlobbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set propagating nlobbt advanced priority
priority of propagator <nlobbt> [1100000]

set propagating nlobbt advanced relobjtolfac
factor for NLP relative objective tolerance [0.01]

set propagating nlobbt advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [4]

set propagating nlobbt addlprows
should noninitial LP rows be used? [TRUE]

set propagating nlobbt freq
frequency for calling propagator <nlobbt> (1: never, 0: only in root node) [1]

set propagating nlobbt maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating <obbt>
parameters for <obbt>

set propagating obbt <advanced>
advanced parameters

set propagating obbt advanced applyfilterrounds
try to filter bounds in socalled filter rounds by solving auxiliary LPs? [FALSE]

set propagating obbt advanced applytrivialfilter
try to filter bounds with the LP solution after each solve? [TRUE]

set propagating obbt advanced createbilinineqs
solve auxiliary LPs in order to find valid inequalities for bilinear terms? [TRUE]

set propagating obbt advanced creategenvbounds
should obbt try to provide genvbounds if possible? [TRUE]

set propagating obbt advanced createlincons
create linear constraints from inequalities for bilinear terms? [FALSE]

set propagating obbt advanced delay
should propagator be delayed, if other propagators found reductions? [TRUE]

set propagating obbt advanced genvbdsduringfilter
should we try to generate genvbounds during trivial and aggressive filtering? [TRUE]

set propagating obbt advanced genvbdsduringsepa
try to create genvbounds during separation process? [TRUE]

set propagating obbt advanced minfilter
minimal number of filtered bounds to apply another filter round [2]

set propagating obbt advanced normalize
should coefficients in filtering be normalized w.r.t. the domains sizes? [TRUE]

set propagating obbt advanced onlynonconvexvars
only apply obbt on nonconvex variables [TRUE]

set propagating obbt advanced orderingalgo
select the type of ordering algorithm which should be used (0: no special ordering, 1: greedy, 2: greedy reverse) [1]

set propagating obbt advanced presolpriority
presolving priority of propagator <obbt> [0]

set propagating obbt advanced presoltiming
timing mask of the presolving method of propagator <obbt> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set propagating obbt advanced priority
priority of propagator <obbt> [1000000]

set propagating obbt advanced propagatefreq
trigger a propagation round after that many bound tightenings (0: no propagation) [0]

set propagating obbt advanced sepamaxiter
maximum number of iteration spend to separate an obbt LP solution [10]

set propagating obbt advanced sepaminiter
minimum number of iteration spend to separate an obbt LP solution [0]

set propagating obbt advanced separatesol
should the obbt LP solution be separated? [FALSE]

set propagating obbt advanced applytrivialfilter
try to filter bounds with the LP solution after each solve? [TRUE]

set propagating obbt advanced tightintboundsprobing
should integral bounds be tightened during the probing mode? [TRUE]

set propagating obbt advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [4]

set propagating obbt boundstreps
minimal relative improve for strengthening bounds [0.001]

set propagating obbt conditionlimit
maximum condition limit used in LP solver (1.0: no limit) [1.0]

set propagating obbt dualfeastol
feasibility tolerance for reduced costs used in obbt; this value is used if SCIP's dual feastol is greater [1e09]

set propagating obbt freq
frequency for calling propagator <obbt> (1: never, 0: only in root node) [0]

set propagating obbt itlimitfactor
multiple of root node LP iterations used as total LP iteration limit for obbt (<= 0: no limit ) [10.0]

set propagating obbt itlimitfactorbilin
multiple of OBBT LP limit used as total LP iteration limit for solving bilinear inequality LPs (< 0 for no limit) [3.0]

set propagating obbt maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating obbt minitlimit
minimum LP iteration limit [5000]

set propagating obbt minnonconvexity
minimum absolute value of nonconvex eigenvalues for a bilinear term [0.1]

set propagating <probing>
parameters for <probing>

set propagating probing <advanced>
advanced parameters

set propagating probing advanced delay
should propagator be delayed, if other propagators found reductions? [TRUE]

set propagating probing advanced maxdepth
maximal depth until propagation is executed(1: no limit) [1]

set propagating probing advanced maxfixings
maximal number of fixings found, until probing is interrupted (0: don't iterrupt) [25]

set propagating probing advanced maxsumuseless
maximal number of probings without fixings, until probing is aborted (0: don't abort) [0]

set propagating probing advanced maxtotaluseless
maximal number of successive probings without fixings, bound changes, and implications, until probing is aborted (0: don't abort) [50]

set propagating probing advanced maxuseless
maximal number of successive probings without fixings, until probing is aborted (0: don't abort) [1000]

set propagating probing advanced presolpriority
presolving priority of propagator <probing> [100000]

set propagating probing advanced presoltiming
timing mask of the presolving method of propagator <probing> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [16]

set propagating probing advanced priority
priority of propagator <probing> [100000]

set propagating probing advanced proprounds
maximal number of propagation rounds in probing subproblems (1: no limit, 0: auto) [1]

set propagating probing advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [4]

set propagating probing freq
frequency for calling propagator <probing> (1: never, 0: only in root node) [1]

set propagating probing maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating probing maxruns
maximal number of runs, probing participates in (1: no limit) [1]

set propagating <pseudoobj>
parameters for <pseudoobj>

set propagating pseudoobj <advanced>
advanced parameters

set propagating pseudoobj advanced delay
should propagator be delayed, if other propagators found reductions? [FALSE]

set propagating pseudoobj advanced force
should the propagator be forced even if active pricer are present? [FALSE]

set propagating pseudoobj advanced maximplvars
maximum number of binary variables the implications are used if turned on (1: unlimited)? [50000]

set propagating pseudoobj advanced maxnewvars
number of variables added after the propagator is reinitialized? [1000]

set propagating pseudoobj advanced maxvarsfrac
maximal fraction of nonbinary variables with nonzero objective without a bound reduction before aborted [0.1]

set propagating pseudoobj advanced minuseless
minimal number of successive nonbinary variable propagations without a bound reduction before aborted [100]

set propagating pseudoobj advanced presolpriority
presolving priority of propagator <pseudoobj> [6000000]

set propagating pseudoobj advanced presoltiming
timing mask of the presolving method of propagator <pseudoobj> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [4]

set propagating pseudoobj advanced priority
priority of propagator <pseudoobj> [3000000]

set propagating pseudoobj advanced propcutoffbound
propagate new cutoff bound directly globally [TRUE]

set propagating pseudoobj advanced propfullinroot
whether to propagate all nonbinary variables when we are propagating the root node [TRUE]

set propagating pseudoobj advanced propuseimplics
use implications to strengthen the propagation of binary variable (increasing the objective change)? [TRUE]

set propagating pseudoobj advanced respropuseimplics
use implications to strengthen the resolve propagation of binary variable (increasing the objective change)? [TRUE]

set propagating pseudoobj advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [7]

set propagating pseudoobj freq
frequency for calling propagator <pseudoobj> (1: never, 0: only in root node) [1]

set propagating pseudoobj maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating <redcost>
parameters for <redcost>

set propagating redcost <advanced>
advanced parameters

set propagating redcost advanced delay
should propagator be delayed, if other propagators found reductions? [FALSE]

set propagating redcost advanced force
should the propagator be forced even if active pricer are present? [FALSE]

set propagating redcost advanced presolpriority
presolving priority of propagator <redcost> [0]

set propagating redcost advanced presoltiming
timing mask of the presolving method of propagator <redcost> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set propagating redcost advanced priority
priority of propagator <redcost> [1000000]

set propagating redcost advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [6]

set propagating redcost continuous
should reduced cost fixing be also applied to continuous variables? [FALSE]

set propagating redcost freq
frequency for calling propagator <redcost> (1: never, 0: only in root node) [1]

set propagating redcost maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating redcost useimplics
should implications be used to strength the reduced cost for binary variables? [FALSE]

set propagating <rootredcost>
parameters for <rootredcost>

set propagating rootredcost <advanced>
advanced parameters

set propagating rootredcost advanced delay
should propagator be delayed, if other propagators found reductions? [FALSE]

set propagating rootredcost advanced force
should the propagator be forced even if active pricer are present? [FALSE]

set propagating rootredcost advanced onlybinary
should only binary variables be propagated? [FALSE]

set propagating rootredcost advanced presolpriority
presolving priority of propagator <rootredcost> [0]

set propagating rootredcost advanced presoltiming
timing mask of the presolving method of propagator <rootredcost> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [28]

set propagating rootredcost advanced priority
priority of propagator <rootredcost> [10000000]

set propagating rootredcost advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [5]

set propagating rootredcost freq
frequency for calling propagator <rootredcost> (1: never, 0: only in root node) [1]

set propagating rootredcost maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating <vbounds>
parameters for <vbounds>

set propagating vbounds <advanced>
advanced parameters

set propagating vbounds advanced delay
should propagator be delayed, if other propagators found reductions? [FALSE]

set propagating vbounds advanced presolpriority
presolving priority of propagator <vbounds> [90000]

set propagating vbounds advanced presoltiming
timing mask of the presolving method of propagator <vbounds> (4:FAST, 8:MEDIUM, 16:EXHAUSTIVE, 32:FINAL) [24]

set propagating vbounds advanced priority
priority of propagator <vbounds> [3000000]

set propagating vbounds advanced sortcliques
should cliques be regarded for the topological sort? [FALSE]

set propagating vbounds advanced timingmask
timing when propagator should be called (1:BEFORELP, 2:DURINGLPLOOP, 4:AFTERLPLOOP, 15:ALWAYS)) [5]

set propagating vbounds advanced usecliques
should cliques be propagated? [FALSE]

set propagating vbounds advanced useimplics
should implications be propagated? [FALSE]

set propagating vbounds advanced usevbounds
should vbounds be propagated? [TRUE]

set propagating vbounds detectcycles
should cycles in the variable bound graph be identified? [FALSE]

set propagating vbounds dotoposort
should the bounds be topologically sorted in advance? [TRUE]

set propagating vbounds freq
frequency for calling propagator <vbounds> (1: never, 0: only in root node) [1]

set propagating vbounds maxcliquesexhaustive
maximum number of cliques per variable to run clique table analysis in exhaustive presolving [100.0]

set propagating vbounds maxcliquesmedium
maximum number of cliques per variable to run clique table analysis in medium presolving [50.0]

set propagating vbounds maxprerounds
maximal number of presolving rounds the propagator participates in (1: no limit) [1]

set propagating vbounds minnewcliques
minimum percentage of new cliques to trigger another clique table analysis [0.1]

set propagating vbounds usebdwidening
should bound widening be used to initialize conflict analysis? [TRUE]

set propagating abortoncutoff
should propagation be aborted immediately? setting this to FALSE could help conflict analysis to produce more conflict constraints [TRUE]

set propagating maxrounds
maximal number of propagation rounds per node (1: unlimited) [100]

set propagating maxroundsroot
maximal number of propagation rounds in the root node (1: unlimited) [1000]

set <randomization>
parameters for <randomization>

set randomization <advanced>
advanced parameters

set randomization advanced permuteconss
should order of constraints be permuted (depends on permutationseed)? [TRUE]

set randomization advanced permutevars
should order of variables be permuted (depends on permutationseed)? [FALSE]

set randomization lpseed
random seed for LP solver, e.g. for perturbations in the simplex (0: LP default) [0]

set randomization permutationseed
seed value for permuting the problem after reading/transformation (0: no permutation) [0]

set randomization randomseedshift
global shift of all random seeds in the plugins and the LP random seed [0]

set <reading>
change parameters for problem file readers

set reading <blkreader>
file reader for structures in blk format

set reading <bndreader>
file reader for variable bounds

set reading bndreader improveonly
only use improving bounds [FALSE]

set reading <ccgreader>
file writer for column connectivity graph file format

set reading <cipreader>
file reader for CIP (Constraint Integer Program) format

set reading cipreader writefixedvars
should fixed and aggregated variables be printed (if not, reparsing might fail) [TRUE]

set reading <clsreader>
reader for writing classification data

set reading clsreader usetransform
should the transformed (and possibly presolved problem) be use or original one [TRUE]

set reading <cnfreader>
file reader for SAT problems in conjunctive normal form

set reading cnfreader useobj
should an artificial objective, depending on the number of clauses a variable appears in, be used? [FALSE]

set reading <decreader>
file reader for blocks in dec format

set reading <fixreader>
file reader for variable fixings

set reading <fznreader>
file reader for FlatZinc format

set reading <gmsreader>
file writer for MI(NL)(SOC)Ps in GAMS file format

set reading gmsreader bigmdefault
default M value for bigM reformulation of indicator constraints in case no bound on slack variable is given [1000000.0]

set reading gmsreader freeints
have integer variables no upper bound by default (depending on GAMS version)? [FALSE]

set reading gmsreader indicatorreform
which reformulation to use for indicator constraints: 'b'igM, 's'os1 [s]

set reading gmsreader replaceforbiddenchars
shall characters '#', '*', '+', '/', and '' in variable and constraint names be replaced by '_'? [FALSE]

set reading gmsreader signpower
is it allowed to use the gams function signpower(x,a)? [FALSE]

set reading <gpreader>
gnuplot file writer for partialdec visualization

set reading <lpreader>
file reader for MIPs in IBM CPLEX's LP file format

set reading lpreader <advanced>
advanced parameters

set reading <mpsreader>
file reader for MIQPs in IBM's Mathematical Programming System format

set reading mpsreader <advanced>
advanced parameters

set reading <opbreader>
file reader for pseudoBoolean problem in opb format

set reading opbreader <advanced>
advanced parameters

set reading opbreader advanced multisymbol
use '*' between coefficients and variables by writing to problem? [FALSE]

set reading opbreader dynamicconss
should model constraints be subject to aging? [FALSE]

set reading <osilreader>
file reader for OS instance language (OSiL) format

set reading <pbmreader>
file writer for portable bitmap file format (PBM), open with common graphic viewer programs (e.g. xview)

set reading pbmreader binary
should the output format be binary(P4) (otherwise plain(P1) format) [TRUE]

set reading pbmreader maxcols
maximum number of columns in the scaled picture (1 for no limit) [1000]

set reading pbmreader maxrows
maximum number of rows in the scaled picture (1 for no limit) [1000]

set reading <pipreader>
file reader for polynomial mixedinteger programs in PIP format

set reading <refreader>
file reader for blocks corresponding to a mip in lpb format

set reading <rlpreader>
file reader for MIPs in IBM CPLEX's RLP file format

set reading <solreader>
file reader for primal solutions

set reading <texreader>
LaTeX file writer for partialdec visualization

set reading <wboreader>
file reader for pseudoboolean wbo file format

set reading dynamiccols
should columns be added and removed dynamically to the LP? [FALSE]

set reading dynamicconss
should model constraints be subject to aging? [TRUE]

set reading dynamicrows
should rows be added and removed dynamically to the LP? [FALSE]

set reading initialconss
should model constraints be marked as initial? [TRUE]

set <relaxing>
parameters for <relaxing>

set relaxing <gcg>
parameters for <gcg>

set relaxing gcg <bliss>
parameters for <bliss>

set relaxing gcg bliss <advanced>
advanced parameters

set relaxing gcg bliss advanced generatorlimit
bliss generator limit (0: unlimited), requires patched bliss version [0]

set relaxing gcg bliss advanced searchnodelimit
bliss search node limit (0: unlimited), requires patched bliss version [0]

set relaxing gcg bliss enabled
should bliss be used to check for identical blocks? [TRUE]

set relaxing gcg aggregation
should identical blocks be aggregated (only for discretization approach)? [TRUE]

set relaxing gcg discretization
should discretization (TRUE) or convexification (FALSE) approach be used? [TRUE]

set relaxing gcg dispinfos
should additional information about the blocks be displayed? [FALSE]

set relaxing gcg enforceproper
should propagated bound changes in the original be enforced in the master (only proper vars)? [TRUE]

set relaxing gcg freq
frequency for calling relaxation handler <gcg> (1: never, 0: only in root node) [1]

set relaxing gcg mipdiscretization
should discretization (TRUE) or convexification (FALSE) approach be used in mixedinteger programs? [TRUE]

set relaxing gcg mode
the decomposition mode that GCG will use. (0: DantzigWolfe (default), 1: Benders' decomposition, 2: no decomposition will be performed) [0]

set relaxing gcg priority
priority of relaxation handler <gcg> [1]

set <reoptimization>
parameters for <reoptimization>

set reoptimization <advanced>
advanced parameters

set reoptimization advanced commontimelimit
time limit over all reoptimization rounds?. [FALSE]

set reoptimization advanced delay
minimum similarity for using reoptimization of the search tree. [1.0]

set reoptimization advanced forceheurrestart
force a restart if the last n optimal solutions were found by heuristic reoptsols [3]

set reoptimization advanced maxcutage
maximal age of a cut to be use for reoptimization [0]

set reoptimization advanced maxdiffofnodes
maximal number of bound changes between two stored nodes on one path [2147483647]

set reoptimization advanced maxsavednodes
maximal number of saved nodes [2147483647]

set reoptimization advanced objsimrootLP
similarity of two sequential objective function to disable solving the root LP. [0.8]

set reoptimization advanced objsimsol
similarity of two objective functions to reuse stored solutions [1.0]

set reoptimization advanced reducetofrontier
delete stored nodes which were not reoptimized [TRUE]

set reoptimization advanced saveconsprop
save constraint propagations [FALSE]

set reoptimization advanced savesols
number of best solutions which should be saved for the following runs. (1: save all) [2147483647]

set reoptimization advanced sepabestsol
separate the optimal solution, i.e., for constrained shortest path [FALSE]

set reoptimization advanced shrinkinner
replace branched inner nodes by their child nodes, if the number of bound changes is not to large [TRUE]

set reoptimization advanced solvelp
at which reopttype should the LP be solved? (1: transit, 3: strong branched, 4: w/ added logicor, 5: only leafs). [1]

set reoptimization advanced solvelpdiff
maximal number of bound changes at node to skip solving the LP [1]

set reoptimization advanced storevarhistory
use variable history of the previous solve if the objctive function has changed only slightly [FALSE]

set reoptimization advanced strongbranchinginit
try to fix variables at the root node before reoptimizing by probing like strong branching [TRUE]

set reoptimization advanced usecuts
reoptimize cuts found at the root node [FALSE]

set reoptimization advanced usepscost
reuse pseudo costs if the objective function changed only slightly [FALSE]

set reoptimization advanced usesplitcons
use constraints to reconstruct the subtree pruned be dual reduction when reactivating the node [TRUE]

set reoptimization advanced varorderinterdiction
use 'd'efault, 'r'andom or a variable ordering based on 'i'nference score for interdiction branching used during reoptimization [d]

set reoptimization <globalcons>
parameters for <globalcons>

set reoptimization globalcons sepainfsubtrees
save global constraints to separate infeasible subtrees. [TRUE]

set reoptimization enable
should reoptimization used? [FALSE]

set <sepa>
change parameters for gcg separators

set sepa <basis>
parameters for <basis>

set sepa basis chgobj
parameter returns if basis is searched with different objective [TRUE]

set sepa basis chgobjallways
parameter returns if obj is changed not only in the first round [FALSE]

set sepa basis enable
is basis separator enabled? [TRUE]

set sepa basis enableobj
is objective constraint of separator enabled? [FALSE]

set sepa basis enableobjround
round obj rhs/lhs of obj constraint if obj is int? [FALSE]

set sepa basis enableposslack
should positive slack influence the probing objective function? [FALSE]

set sepa basis enableppcuts
add cuts generated during pricing to newconss array? [FALSE]

set sepa basis enableppobjcg
is objective constraint for redcost of each pp during pricing of separator enabled? [FALSE]

set sepa basis enableppobjconss
is objective constraint for redcost of each pp of separator enabled? [FALSE]

set sepa basis forcecuts
parameter returns if cuts are forced to enter the LP [FALSE]

set sepa basis genobjconvex
generated obj convex dynamically [FALSE]

set sepa basis maxrounds
parameter returns maximum number of separation rounds in probing LP (1 if unlimited) [1]

set sepa basis maxroundsroot
parameter returns maximum number of separation rounds in probing LP in root node (1 if unlimited) [1]

set sepa basis mincuts
parameter returns number of minimum cuts needed to return *result = SCIP_Separated [50]

set sepa basis objconvex
convex combination factor (= 0.0, use original objective; = 1.0, use face objective) [0.0]

set sepa basis paramsetting
parameter returns which parameter setting is used for separation (default = 0, aggressive = 1, fast = 2 [0]

set sepa basis posslackexp
exponent of positive slack usage [1]

set sepa basis posslackexpgen
automatically generated exponent? [FALSE]

set sepa basis posslackexpgenfactor
factor for automatically generated exponent [0.1]

set sepa <emphasis>
predefined parameter settings

set sepa emphasis aggressive
sets separators <aggressive>

set sepa emphasis default
sets separators <default>

set sepa emphasis fast
sets separators <fast>

set sepa emphasis off
turns <off> all separators

set sepa <master>
parameters for <master>

set sepa master enable
enable master separator [TRUE]

set sepa master paramsetting
parameter returns which parameter setting is used for separation (default = 0, aggressive = 1, fast = 2 [1]

set <separating>
change parameters for cut separators

set separating <advanced>
advanced parameters

set separating advanced cutagelimit
maximum age a cut can reach before it is deleted from the global cut pool, or 1 to keep all cuts [80]

set separating advanced cutselrestart
cut selection during restart ('a'ge, activity 'q'uotient) [a]

set separating advanced cutselsubscip
cut selection for sub SCIPs ('a'ge, activity 'q'uotient) [a]

set separating advanced efficacynorm
row norm to use for efficacy calculation ('e'uclidean, 'm'aximum, 's'um, 'd'iscrete) [e]

set separating advanced filtercutpoolrel
should cutpool separate only cuts with high relative efficacy? [TRUE]

set separating advanced maxaddrounds
maximal additional number of separation rounds in subsequent priceandcut loops (1: no additional restriction) [1]

set separating advanced maxroundsrootsubrun
maximal number of separation rounds in the root node of a subsequent run (1: unlimited) [1]

set separating advanced maxruns
maximal number of runs for which separation is enabled (1: unlimited) [1]

set separating advanced orthofunc
function used for calc. scalar prod. in orthogonality test ('e'uclidean, 'd'iscrete) [e]

set separating <clique>
clique separator of stable set relaxation

set separating clique <advanced>
advanced parameters

set separating clique advanced backtrackfreq
frequency for premature backtracking up to tree level 1 (0: no backtracking) [1000]

set separating clique advanced cliquedensity
minimal density of cliques to use a dense clique table [0.0]

set separating clique advanced cliquetablemem
maximal memory size of dense clique table (in kb) [20000.0]

set separating clique advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating clique advanced expbackoff
base for exponential increase of frequency at which separator <clique> is called (1: call at each multiple of frequency) [4]

set separating clique advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <clique> (0.0: only on current best node, 1.0: on all nodes) [0.0]

set separating clique advanced maxtreenodes
maximal number of nodes in branch and bound tree (1: no limit) [10000]

set separating clique advanced maxzeroextensions
maximal number of zerovalued variables extending the clique (1: no limit) [1000]

set separating clique advanced priority
priority of separator <clique> [5000]

set separating clique advanced scaleval
factor for scaling weights [1000.0]

set separating clique freq
frequency for calling separator <clique> (1: never, 0: only in root node) [1]

set separating clique maxsepacuts
maximal number of clique cuts separated per separation round (1: no limit) [10]

set separating <closecuts>
closecuts meta separator

set separating closecuts <advanced>
advanced parameters

set separating closecuts advanced closethres
threshold on number of generated cuts below which the ordinary separation is started [50]

set separating closecuts advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating closecuts advanced expbackoff
base for exponential increase of frequency at which separator <closecuts> is called (1: call at each multiple of frequency) [4]

set separating closecuts advanced inclobjcutoff
include an objective cutoff when computing the relative interior? [FALSE]

set separating closecuts advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <closecuts> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating closecuts advanced maxlpiterfactor
factor for maximal LP iterations in relative interior computation compared to node LP iterations (negative for no limit) [10.0]

set separating closecuts advanced maxunsuccessful
turn off separation in current node after unsuccessful calls (1 never turn off) [0]

set separating closecuts advanced priority
priority of separator <closecuts> [1000000]

set separating closecuts advanced recomputerelint
recompute relative interior point in each separation call? [FALSE]

set separating closecuts advanced sepacombvalue
convex combination value for close cuts [0.3]

set separating closecuts advanced separelint
generate close cuts w.r.t. relative interior point (best solution otherwise)? [TRUE]

set separating closecuts freq
frequency for calling separator <closecuts> (1: never, 0: only in root node) [1]

set separating <emphasis>
predefined parameter settings

set separating emphasis aggressive
sets separating <aggressive>

set separating emphasis default
sets separating settings to <default>

set separating emphasis fast
sets separating <fast>

set separating emphasis off
turns <off> all separation

set separating <gomory>
separator for Gomory mixedinteger and strong CG cuts from LP tableau rows

set separating gomory <advanced>
advanced parameters

set separating gomory advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating gomory advanced delayedcuts
should cuts be added to the delayed cut pool? [FALSE]

set separating gomory advanced expbackoff
base for exponential increase of frequency at which separator <gomory> is called (1: call at each multiple of frequency) [4]

set separating gomory advanced forcecuts
if conversion to integral coefficients failed still consider the cut [TRUE]

set separating gomory advanced genbothgomscg
Should both Gomory and strong CG cuts be generated (otherwise take best)? [TRUE]

set separating gomory advanced makeintegral
try to scale cuts to integral coefficients [FALSE]

set separating gomory advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gomory> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating gomory advanced priority
priority of separator <gomory> [1000]

set separating gomory advanced separaterows
separate rows with integral slack [TRUE]

set separating gomory advanced sidetypebasis
choose side types of row (lhs/rhs) based on basis information? [TRUE]

set separating gomory advanced trystrongcg
try to generate strengthened ChvatalGomory cuts? [TRUE]

set separating gomory away
minimal integrality violation of a basis variable in order to try Gomory cut [0.01]

set separating gomory dynamiccuts
should generated cuts be removed from the LP if they are no longer tight? [TRUE]

set separating gomory freq
frequency for calling separator <gomory> (1: never, 0: only in root node) [1]

set separating gomory maxrank
maximal rank of a gomory cut that could not be scaled to integral coefficients (1: unlimited) [1]

set separating gomory maxrankintegral
maximal rank of a gomory cut that could be scaled to integral coefficients (1: unlimited) [1]

set separating gomory maxrounds
maximal number of gomory separation rounds per node (1: unlimited) [5]

set separating gomory maxroundsroot
maximal number of gomory separation rounds in the root node (1: unlimited) [10]

set separating gomory maxsepacuts
maximal number of gomory cuts separated per separation round [50]

set separating gomory maxsepacutsroot
maximal number of gomory cuts separated per separation round in the root node [200]

set separating <gomorymi>
separator for Gomory mixedinteger cuts

set separating gomorymi <advanced>
advanced parameters

set separating gomorymi advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating gomorymi advanced expbackoff
base for exponential increase of frequency at which separator <gomorymi> is called (1: call at each multiple of frequency) [4]

set separating gomorymi advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <gomorymi> (0.0: only on current best node, 1.0: on all nodes) [0.0]

set separating gomorymi advanced priority
priority of separator <gomorymi> [100000]

set separating gomorymi freq
frequency for calling separator <gomorymi> (1: never, 0: only in root node) [1]

set separating <impliedbounds>
implied bounds separator

set separating impliedbounds <advanced>
advanced parameters

set separating impliedbounds advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating impliedbounds advanced expbackoff
base for exponential increase of frequency at which separator <impliedbounds> is called (1: call at each multiple of frequency) [4]

set separating impliedbounds advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <impliedbounds> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating impliedbounds advanced priority
priority of separator <impliedbounds> [50]

set separating impliedbounds advanced usetwosizecliques
should violated inequalities for cliques with 2 variables be separated? [TRUE]

set separating impliedbounds freq
frequency for calling separator <impliedbounds> (1: never, 0: only in root node) [1]

set separating <interminor>
separator (via intersection cuts) to ensure that 2x2 minors of X (= xx') have determinant 0

set separating interminor <advanced>
advanced parameters

set separating interminor advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating interminor advanced expbackoff
base for exponential increase of frequency at which separator <interminor> is called (1: call at each multiple of frequency) [4]

set separating interminor advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <interminor> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating interminor advanced priority
priority of separator <interminor> [0]

set separating interminor freq
frequency for calling separator <interminor> (1: never, 0: only in root node) [1]

set separating interminor maxrounds
maximal number of separation rounds per node (1: unlimited) [10]

set separating interminor maxroundsroot
maximal number of separation rounds in the root node (1: unlimited) [1]

set separating interminor mincutviol
minimum required violation of a cut [0.0001]

set separating interminor usebounds
whether to also enforce nonegativity bounds of principle minors [FALSE]

set separating interminor usestrengthening
whether to use strengthened intersection cuts to separate minors [FALSE]

set separating <intobj>
integer objective value separator

set separating intobj <advanced>
advanced parameters

set separating intobj advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating intobj advanced expbackoff
base for exponential increase of frequency at which separator <intobj> is called (1: call at each multiple of frequency) [4]

set separating intobj advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <intobj> (0.0: only on current best node, 1.0: on all nodes) [0.0]

set separating intobj advanced priority
priority of separator <intobj> [100]

set separating intobj freq
frequency for calling separator <intobj> (1: never, 0: only in root node) [1]

set separating <mcf>
multicommodityflow network cut separator

set separating mcf <advanced>
advanced parameters

set separating mcf advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating mcf advanced expbackoff
base for exponential increase of frequency at which separator <mcf> is called (1: call at each multiple of frequency) [4]

set separating mcf advanced fixintegralrhs
should an additional variable be complemented if f0 = 0? [TRUE]

set separating mcf advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <mcf> (0.0: only on current best node, 1.0: on all nodes) [0.0]

set separating mcf advanced maxinconsistencyratio
maximum inconsistency ratio for separation at all [0.02]

set separating mcf advanced maxtestdelta
maximal number of different deltas to try (1: unlimited)  default separation [20]

set separating mcf advanced maxweightrange
maximal valid range max(weights)/min(weights) of row weights [1000000.0]

set separating mcf advanced modeltype
model type of network (0: auto, 1:directed, 2:undirected) [0]

set separating mcf advanced nclusters
number of clusters to generate in the shrunken network  default separation [5]

set separating mcf advanced priority
priority of separator <mcf> [10000]

set separating mcf advanced separateflowcutset
should we separate flowcutset inequalities on the network cuts? [TRUE]

set separating mcf advanced separateknapsack
should we separate knapsack cover inequalities on the network cuts? [TRUE]

set separating mcf advanced trynegscaling
should negative values also be tested in scaling? [FALSE]

set separating mcf dynamiccuts
should generated cuts be removed from the LP if they are no longer tight? [TRUE]

set separating mcf freq
frequency for calling separator <mcf> (1: never, 0: only in root node) [1]

set separating mcf maxsepacuts
maximal number of mcf cuts separated per separation round [100]

set separating mcf maxsepacutsroot
maximal number of mcf cuts separated per separation round in the root node  default separation [200]

set separating <minor>
separator to ensure that 2x2 principal minors of X  xx' are positive semidefinite

set separating minor <advanced>
advanced parameters

set separating minor advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating minor advanced expbackoff
base for exponential increase of frequency at which separator <minor> is called (1: call at each multiple of frequency) [4]

set separating minor advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <minor> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating minor advanced priority
priority of separator <minor> [0]

set separating minor freq
frequency for calling separator <minor> (1: never, 0: only in root node) [1]

set separating minor ignorepackingconss
whether to ignore circle packing constraints during minor detection [TRUE]

set separating minor maxminorsconst
constant for the maximum number of minors, i.e., max(const, fac * # quadratic terms) [3000]

set separating minor maxminorsfac
factor for the maximum number of minors, i.e., max(const, fac * # quadratic terms) [10.0]

set separating minor maxrounds
maximal number of separation rounds per node (1: unlimited) [10]

set separating minor maxroundsroot
maximal number of separation rounds in the root node (1: unlimited) [1]

set separating minor mincutviol
minimum required violation of a cut [0.0001]

set separating <mixing>
mixing inequality separator

set separating mixing <advanced>
advanced parameters

set separating mixing advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating mixing advanced expbackoff
base for exponential increase of frequency at which separator <mixing> is called (1: call at each multiple of frequency) [4]

set separating mixing advanced iscutsonints
Should general integer variables be used to generate cuts? [FALSE]

set separating mixing advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <mixing> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating mixing advanced priority
priority of separator <mixing> [50]

set separating mixing advanced uselocalbounds
Should local bounds be used? [FALSE]

set separating mixing freq
frequency for calling separator <mixing> (1: never, 0: only in root node) [1]

set separating mixing maxnunsuccessful
maximal number of consecutive unsuccessful iterations [10]

set separating mixing maxrounds
maximal number of mixing separation rounds per node (1: unlimited) [1]

set separating mixing maxroundsroot
maximal number of mixing separation rounds in the root node (1: unlimited) [1]

set separating <oddcycle>
odd cycle separator

set separating oddcycle <advanced>
advanced parameters

set separating oddcycle advanced addselfarcs
add links between a variable and its negated [TRUE]

set separating oddcycle advanced allowmultiplecuts
Even if a variable is already covered by a cut, still allow another cut to cover it too? [TRUE]

set separating oddcycle advanced cutthreshold
maximal number of other cuts s.t. separation is applied (1 for direct call) [1]

set separating oddcycle advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating oddcycle advanced expbackoff
base for exponential increase of frequency at which separator <oddcycle> is called (1: call at each multiple of frequency) [4]

set separating oddcycle advanced includetriangles
separate triangles found as 3cycles or repaired larger cycles [TRUE]

set separating oddcycle advanced lpliftcoef
Choose lifting candidate by coef*lpvalue or only by coef? [FALSE]

set separating oddcycle advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <oddcycle> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating oddcycle advanced maxcutslevel
maximal number of oddcycle cuts generated in every level of the level graph [50]

set separating oddcycle advanced maxcutsroot
maximal number of oddcycle cuts generated per chosen variable as root of the level graph [1]

set separating oddcycle advanced maxnlevels
maximal number of levels in level graph [20]

set separating oddcycle advanced maxpernodeslevel
percentage of nodes allowed in the same level of the level graph [0100] [100]

set separating oddcycle advanced maxreference
minimal weight on an edge (in level graph or bipartite graph) [0]

set separating oddcycle advanced maxunsucessfull
number of unsuccessful calls at current node [3]

set separating oddcycle advanced multiplecuts
Even if a variable is already covered by a cut, still try it as start node for a cycle search? [FALSE]

set separating oddcycle advanced offsetnodeslevel
offset of nodes allowed in the same level of the level graph (additional to the percentage of levelnodes) [10]

set separating oddcycle advanced offsettestvars
offset of variables to try the chosen method on (additional to the percentage of testvars) [100]

set separating oddcycle advanced percenttestvars
percentage of variables to try the chosen method on [0100] [0]

set separating oddcycle advanced priority
priority of separator <oddcycle> [15000]

set separating oddcycle advanced recalcliftcoef
Calculate lifting coefficient of every candidate in every step (or only if its chosen)? [TRUE]

set separating oddcycle advanced repaircycles
try to repair violated cycles with double appearance of a variable [TRUE]

set separating oddcycle advanced scalingfactor
factor for scaling of the arcweights [1000]

set separating oddcycle advanced sortrootneighbors
sort level of the root neighbors by fractionality (maxfrac) [TRUE]

set separating oddcycle advanced sortswitch
use sorted variable array (unsorted(0), maxlp(1), minlp(2), maxfrac(3), minfrac(4)) [3]

set separating oddcycle freq
frequency for calling separator <oddcycle> (1: never, 0: only in root node) [1]

set separating oddcycle liftoddcycles
Should odd cycle cuts be lifted? [FALSE]

set separating oddcycle maxrounds
maximal number of oddcycle separation rounds per node (1: unlimited) [10]

set separating oddcycle maxroundsroot
maximal number of oddcycle separation rounds in the root node (1: unlimited) [10]

set separating oddcycle maxsepacuts
maximal number of oddcycle cuts separated per separation round [5000]

set separating oddcycle maxsepacutsroot
maximal number of oddcycle cuts separated per separation round in the root node [5000]

set separating oddcycle usegls
Should the search method by Groetschel, Lovasz, Schrijver be used? Otherwise use levelgraph method by Hoffman, Padberg. [TRUE]

set separating <rapidlearning>
rapid learning heuristic and separator

set separating rapidlearning <advanced>
advanced parameters

set separating rapidlearning advanced applybdchgs
should the found global bound deductions be applied in the original SCIP? [TRUE]

set separating rapidlearning advanced applyconflicts
should the found conflicts be applied in the original SCIP? [TRUE]

set separating rapidlearning advanced applyinfervals
should the inference values be used as initialization in the original SCIP? [TRUE]

set separating rapidlearning advanced applyprimalsol
should the incumbent solution be copied to the original SCIP? [TRUE]

set separating rapidlearning advanced applysolved
should a solved status be copied to the original SCIP? [TRUE]

set separating rapidlearning advanced checkdegeneracy
should local LP degeneracy be checked? [TRUE]

set separating rapidlearning advanced checkdualbound
should the progress on the dual bound be checked? [FALSE]

set separating rapidlearning advanced checkexec
check whether rapid learning should be executed [TRUE]

set separating rapidlearning advanced checkleaves
should the ratio of leaves proven to be infeasible and exceeding the cutoff bound be checked? [FALSE]

set separating rapidlearning advanced checknsols
should the number of solutions found so far be checked? [TRUE]

set separating rapidlearning advanced checkobj
should the (local) objective function be checked? [FALSE]

set separating rapidlearning advanced contvars
should rapid learning be applied when there are continuous variables? [FALSE]

set separating rapidlearning advanced contvarsquot
maximal portion of continuous variables to apply rapid learning [0.3]

set separating rapidlearning advanced copycuts
should all active cuts from cutpool be copied to constraints in subproblem? [TRUE]

set separating rapidlearning advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating rapidlearning advanced expbackoff
base for exponential increase of frequency at which separator <rapidlearning> is called (1: call at each multiple of frequency) [4]

set separating rapidlearning advanced lpiterquot
maximal fraction of LP iterations compared to node LP iterations [0.2]

set separating rapidlearning advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <rapidlearning> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating rapidlearning advanced maxcalls
maximum number of overall calls [100]

set separating rapidlearning advanced maxnconss
maximum problem size (constraints) for which rapid learning will be called [10000]

set separating rapidlearning advanced maxnodes
maximum number of nodes considered in rapid learning run [5000]

set separating rapidlearning advanced maxnvars
maximum problem size (variables) for which rapid learning will be called [10000]

set separating rapidlearning advanced mindegeneracy
minimal degeneracy threshold to allow local rapid learning [0.7]

set separating rapidlearning advanced mininflpratio
minimal threshold of inf/obj leaves to allow local rapid learning [10.0]

set separating rapidlearning advanced minnodes
minimum number of nodes considered in rapid learning run [500]

set separating rapidlearning advanced minvarconsratio
minimal ratio of unfixed variables in relation to basis size to allow local rapid learning [2.0]

set separating rapidlearning advanced nwaitingnodes
number of nodes that should be processed before rapid learning is executed locally based on the progress of the dualbound [100]

set separating rapidlearning advanced priority
priority of separator <rapidlearning> [1200000]

set separating rapidlearning advanced reducedinfer
should the inference values only be used when rapidlearning found other reductions? [FALSE]

set separating rapidlearning freq
frequency for calling separator <rapidlearning> (1: never, 0: only in root node) [1]

set separating <strongcg>
separator for strong CG cuts

set separating strongcg <advanced>
advanced parameters

set separating strongcg advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating strongcg advanced expbackoff
base for exponential increase of frequency at which separator <strongcg> is called (1: call at each multiple of frequency) [4]

set separating strongcg advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <strongcg> (0.0: only on current best node, 1.0: on all nodes) [0.0]

set separating strongcg advanced priority
priority of separator <strongcg> [100000]

set separating strongcg freq
frequency for calling separator <strongcg> (1: never, 0: only in root node) [1]

set separating <zerohalf>
{0,1/2}cuts separator

set separating zerohalf <advanced>
advanced parameters

set separating zerohalf advanced badscore
threshold for score of cut relative to best score to be discarded [0.5]

set separating zerohalf advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating zerohalf advanced densityoffset
additional number of variables allowed in row on top of density [100]

set separating zerohalf advanced dircutoffdistweight
weight of directed cutoff distance in cut score calculation [0.0]

set separating zerohalf advanced efficacyweight
weight of efficacy in cut score calculation [1.0]

set separating zerohalf advanced expbackoff
base for exponential increase of frequency at which separator <zerohalf> is called (1: call at each multiple of frequency) [4]

set separating zerohalf advanced goodmaxparall
maximum parallelism for good cuts [0.1]

set separating zerohalf advanced goodscore
threshold for score of cut relative to best score to be considered good, so that less strict filtering is applied [1.0]

set separating zerohalf advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <zerohalf> (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating zerohalf advanced maxparall
maximum parallelism for nongood cuts [0.1]

set separating zerohalf advanced maxrowdensity
maximal density of row to be used in aggregation [0.05]

set separating zerohalf advanced maxslack
maximal slack of rows to be used in aggregation [0.0]

set separating zerohalf advanced maxslackroot
maximal slack of rows to be used in aggregation in the root node [0.0]

set separating zerohalf advanced minviol
minimal violation to generate zerohalfcut for [0.1]

set separating zerohalf advanced objparalweight
weight of objective parallelism in cut score calculation [0.0]

set separating zerohalf advanced priority
priority of separator <zerohalf> [6000]

set separating zerohalf dynamiccuts
should generated cuts be removed from the LP if they are no longer tight? [TRUE]

set separating zerohalf freq
frequency for calling separator <zerohalf> (1: never, 0: only in root node) [1]

set separating zerohalf initseed
initial seed used for random tiebreaking in cut selection [24301]

set separating zerohalf maxcutcands
maximal number of zerohalf cuts considered per separation round [2000]

set separating zerohalf maxrounds
maximal number of zerohalf separation rounds per node (1: unlimited) [5]

set separating zerohalf maxroundsroot
maximal number of zerohalf separation rounds in the root node (1: unlimited) [20]

set separating zerohalf maxsepacuts
maximal number of zerohalf cuts separated per separation round [20]

set separating zerohalf maxsepacutsroot
maximal number of zerohalf cuts separated per separation round in the root node [100]

set separating maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation (0.0: only on current best node, 1.0: on all nodes) [1.0]

set separating maxcoefratio
maximal ratio between coefficients in strongcg, cmir, and flowcover cuts [10000.0]

set separating <clique>
clique separator of stable set relaxation

set separating clique <advanced>
advanced parameters

set separating clique advanced backtrackfreq
frequency for premature backtracking up to tree level 1 (0: no backtracking) [1000]

set separating clique advanced cliquedensity
minimal density of cliques to use a dense clique table [0.0]

set separating clique advanced cliquetablemem
maximal memory size of dense clique table (in kb) [20000.0]

set separating clique advanced delay
should separator be delayed, if other separators found cuts? [FALSE]

set separating clique advanced expbackoff
base for exponential increase of frequency at which separator <clique> is called (1: call at each multiple of frequency) [4]

set separating clique advanced maxbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separator <clique> (0.0: only on current best node, 1.0: on all nodes) [0.0]

set separating clique advanced maxtreenodes
maximal number of nodes in branch and bound tree (1: no limit) [10000]

set separating clique advanced maxzeroextensions
maximal number of zerovalued variables extending the clique (1: no limit) [1000]

set separating clique advanced priority
priority of separator <clique> [5000]

set separating clique advanced scaleval
factor for scaling weights [1000.0]

set separating clique freq
frequency for calling separator <clique> (1: never, 0: only in root node) [1]

set separating clique maxsepacuts
maximal number of clique cuts separated per separation round (1: no limit) [10]

set separating maxcuts
maximal number of cuts separated per separation round (0: disable local separation) [100]

set separating maxcutsroot
maximal number of separated cuts at the root node (0: disable root node separation) [2000]

set separating maxlocalbounddist
maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying local separation (0.0: only on current best node, 1.0: on all nodes) [0.0]

set separating maxrounds
maximal number of separation rounds per node (1: unlimited) [1]

set separating maxroundsroot
maximal number of separation rounds in the root node (1: unlimited) [1]

set separating maxstallrounds
maximal number of consecutive separation rounds without objective or integrality improvement in local nodes (1: no additional restriction) [1]

set separating maxstallroundsroot
maximal number of consecutive separation rounds without objective or integrality improvement in the root node (1: no additional restriction) [10]

set separating minactivityquot
minimum cut activity quotient to convert cuts into constraints during a restart (0.0: all cuts are converted) [0.8]

set separating minefficacy
minimal efficacy for a cut to enter the LP [0.0001]

set separating minefficacyroot
minimal efficacy for a cut to enter the LP in the root node [0.0001]

set separating poolfreq
separation frequency for the global cut pool (1: disable global cut pool, 0: only separate pool at the root) [10]

set <solvingphases>
parameters for <solvingphases>

set solvingphases enabled
should the event handler adapt the solver behavior? [FALSE]

set solvingphases fallback
should the event handler fall back from optimal phase? [FALSE]

set solvingphases feassetname
settings file for feasibility phase  precedence over emphasis settings []

set solvingphases improvesetname
settings file for improvement phase  precedence over emphasis settings []

set solvingphases interruptoptimal
should the event handler interrupt the solving process after optimal solution was found? [FALSE]

set solvingphases nodeoffset
node offset for rank1 and estimate transitions [50]

set solvingphases optimalvalue
optimal solution value for problem [1e+99]

set solvingphases proofsetname
settings file for proof phase  precedence over emphasis settings []

set solvingphases testmode
should the event handler test all phase transitions? [FALSE]

set solvingphases transitionmethod
transition method: Possible options are 'e'stimate,'l'ogarithmic regression,'o'ptimalvalue based,'r'ank1 [r]

set solvingphases useemphsettings
should emphasis settings for the solving phases be used, or settings files? [TRUE]

set solvingphases userestart1to2
should a restart be applied between the feasibility and improvement phase? [FALSE]

set solvingphases userestart2to3
should a restart be applied between the improvement and the proof phase? [FALSE]

set solvingphases xtype
xtype for logarithmic regression  (t)ime, (n)odes, (l)p iterations [n]

set <table>
parameters for <table>

set table <benders>
parameters for <benders>

set table benders active
is statistics table <benders> active [TRUE]

set table <branchrules>
parameters for <branchrules>

set table branchrules active
is statistics table <branchrules> active [TRUE]

set table <compression>
parameters for <compression>

set table compression active
is statistics table <compression> active [TRUE]

set table <concurrentsolver>
parameters for <concurrentsolver>

set table concurrentsolver active
is statistics table <concurrentsolver> active [TRUE]

set table <conflict>
parameters for <conflict>

set table conflict active
is statistics table <conflict> active [TRUE]

set table <constiming>
parameters for <constiming>

set table constiming active
is statistics table <constiming> active [TRUE]

set table <constraint>
parameters for <constraint>

set table constraint active
is statistics table <constraint> active [TRUE]

set table <cutsel>
parameters for <cutsel>

set table cutsel active
is statistics table <cutsel> active [TRUE]

set table <exprhdlr>
parameters for <exprhdlr>

set table exprhdlr active
is statistics table <exprhdlr> active [TRUE]

set table <heuristics>
parameters for <heuristics>

set table heuristics active
is statistics table <heuristics> active [TRUE]

set table <lp>
parameters for <lp>

set table lp active
is statistics table <lp> active [TRUE]

set table <neighborhood>
parameters for <neighborhood>

set table neighborhood active
is statistics table <neighborhood> active [TRUE]

set table <nlp>
parameters for <nlp>

set table nlp active
is statistics table <nlp> active [TRUE]

set table <nlpi>
parameters for <nlpi>

set table nlpi active
is statistics table <nlpi> active [TRUE]

set table <origprob>
parameters for <origprob>

set table origprob active
is statistics table <origprob> active [TRUE]

set table <presolvedprob>
parameters for <presolvedprob>

set table presolvedprob active
is statistics table <presolvedprob> active [TRUE]

set table <presolver>
parameters for <presolver>

set table presolver active
is statistics table <presolver> active [TRUE]

set table <pricer>
parameters for <pricer>

set table pricer active
is statistics table <pricer> active [TRUE]

set table <propagator>
parameters for <propagator>

set table propagator active
is statistics table <propagator> active [TRUE]

set table <relaxator>
parameters for <relaxator>

set table relaxator active
is statistics table <relaxator> active [TRUE]

set table <root>
parameters for <root>

set table root active
is statistics table <root> active [TRUE]

set table <separator>
parameters for <separator>

set table separator active
is statistics table <separator> active [TRUE]

set table <solution>
parameters for <solution>

set table solution active
is statistics table <solution> active [TRUE]

set table <status>
parameters for <status>

set table status active
is statistics table <status> active [TRUE]

set table <timing>
parameters for <timing>

set table timing active
is statistics table <timing> active [TRUE]

set table <tree>
parameters for <tree>

set table tree active
is statistics table <tree> active [TRUE]

set <timing>
change parameters for timing issues

set timing clocktype
default clock type (1: CPU user seconds, 2: wall clock time) [2]

set timing enabled
is timing enabled? [TRUE]

set timing nlpieval
should time for evaluation in NLP solves be measured? [FALSE]

set timing rareclockcheck
should clock checks of solving time be performed less frequently (note: time limit could be exceeded slightly) [FALSE]

set timing reading
belongs reading time to solving time? [FALSE]

set timing statistictiming
should timing for statistic output be performed? [TRUE]

set <visual>
change parameters for visualization output

set visual <colors>
parameters for <colors>

set visual colors colorblock
color for found blocks in hex code [#718CDB]

set visual colors colorlines
color for lines in hex code [#000000]

set visual colors colorlinking
color for linking variables in hex code [#FFB72D]

set visual colors colormasterconss
color for master constraints in hex code [#1340C7]

set visual colors colormastervars
color for master variables in hex code [#1340C7]

set visual colors colornonzeros
color for nonzeros in hex code [#000000]

set visual colors coloropen
color for open areas in hex code [#FFD88F]

set visual colors colorstairlinking
color for stairlinking variables in hex code [#886100]

set visual <report>
parameters for <report>

set visual report maxndecomps
maximum number of decompositions shown in report (best scores first) [20]

set visual report showstatistics
if true statistics are included for each decomp [TRUE]

set visual report showtitle
if true a title page is included [TRUE]

set visual report showtoc
if true a table of contents is included [TRUE]

set visual report usegp
if true gnuplot is used for subvisualizations in report, otherwise LaTeX/Tikz [FALSE]

set visual bakfilename
name of the BAK tool output file, or  if no BAK tool output should be created []

set visual colorscheme
type number: 0=default, 1=black and white, 2=manual [0]

set visual displb
should lower bound information be visualized? [FALSE]

set visual dispsols
should the node where solutions are found be visualized? [FALSE]

set visual draftmode
if true no nonzeros are shown (may improve performance) [FALSE]

set visual nmaxdecompstowrite
maximum number of decompositions to write (1: no limit) [1]

set visual nonzeroradius
integer value to scale points on range 110 [2]

set visual objextern
should be output the external value of the objective? [TRUE]

set visual pdfreader
pdf reader that opens visualizations in decomposition explorer [xdgopen]

set visual realtime
should the real solving time be used instead of a time step counter in visualization? [TRUE]

set visual vbcfilename
name of the VBC tool output file, or  if no VBC tool output should be created []

set <write>
parameters for <write>

set write allconss
should all constraints be written (including the redundant constraints)? [FALSE]

set write genericnamesoffset
when writing a generic problem the index for the first variable should start with? [0]

set write printzeros
should variables set to zero be printed? [FALSE]

set default
reset parameter settings to their default values

set diffsave
save nondefault parameter settings to a file

set load
load parameter settings from a file

set loadmaster
load parameter settings for master problem from a file

set save
save parameter settings to a file

<write>
write information to file

write alldecompositions
write all known decompositions to files (format is given by file extension, e.g. {dec,blk,ref,gp,tex})

write cliquegraph
write graph of cliques and implications of binary variables to GML file (better call after presolving)

write finitesolution
write best primal solution to file (try to make solution values finite, first)

write genproblem
write original problem with generic names to file (format is given by file extension, e.g., orig.{lp,rlp,cip,mps})

write gentransproblem
write current node transformed problem with generic names to file (format is given by file extension, e.g., trans.{lp,rlp,cip,mps})

write history
write command line history to a file (only works if SCIP was compiled with 'readline')

write lp
write current node LP relaxation in LP format to file

write matrix
write gnuplot file showing the nonzero structure of the original matrix

write mip
write current node MIP relaxation in LP format to file

write mipstart
write mip start to file

write nlp
write current node NLP relaxation to file

write problem
write original problem to file (format is given by file extension, e.g., orig.{lp,rlp,cip,mps})

write report
write report of all finished decompositions to LaTeX format

write selected
write selected (in "explore" submenu) decompositions to files (format is given by file extension, e.g. {dec,blk,ref,gp,tex})

write solution
write best primal solution to file

write statistics
write statistics to file

write transmatrix
write gnuplot file showing the nonzero structure of the transformed (presolved) matrix

write transproblem
write current node transformed problem to file (format is given by file extension, e.g., trans.{lp,rlp,cip,mps})

checksol
double checks best solution w.r.t. original problem

concurrentopt
solve the problem using concurrent solvers

detect
detect structure

explore
explore decompositions

free
free current problem from memory

help
display this help

master
switch to the interactive shell of the master problem

newstart
reset branch and bound tree to start again from root

optimize
solve the problem

presolve
presolve the problem

quit
leave GCG

read
read a problem

transform
transform the problem

validatesolve
validate the solution against external objective reference interval