 -help                         Print this message.

Specifying Essence Prime input files (for Normal mode):
 -in-eprime <filename>         Optional if filename ends with ".eprime".
 -in-param <filename>          Parameter file; optional if ends with ".param".
 -params <string>              Format is same as for parameter file; language
                               line is optional: "letting identifier=value" or
                               "letting identifier be value". For example:
                                 -params "letting n_nurses=4 letting \
                                 Demand=[[1,0,1,0],[0,2,1,0]]"

Specifying output format (for Normal mode):
 -minion  (default)            Minion 3 format, flat for numerical expressions
                               but non-flat for And/Or, which are implemented
                               with watched-and/watched-or metaconstraints.
 -gecode                       Flatzinc format for fzn-gecode. Uses mostly
                               same translation pipeline as for Minion output.
                               Main differences: model is entirely flat, some
                               constraints may be rewritten for reification.
 -chuffed                      Format for fzn-chuffed. Similar to -gecode.
 -minizinc                     Partly flat, instance-level subset of MiniZinc,
                               allowing access to several solvers via the
                               MiniZinc toolchain. Similar to Flatzinc outputs.
 -sat                          DIMACS format for SAT solver.
 -maxsat                       DIMACS-like format for MaxSAT solver. 
 -dominion                     Dominion Input Language output. Experimental!
                               Separate translation pipeline. Uses class-level
                               flattening if some parameters not instantiated.

Output filename options (each has default value so all are optional):
 -out-minion <filename>        Minion output.
 -out-gecode <filename>        Gecode (flatzinc) output.
 -out-chuffed <filename>       Chuffed (flatzinc) output.
 -out-minizinc <filename>      Minizinc output.
 -out-sat <filename>           SAT (DIMACS) output, MaxSAT output.
 -out-dominion <filename>      Dominion output.
 -out-solution <filename>      Solution if Savile Row runs a solver and parses
                               the solver's output.
 -out-info <filename>          Statistics from Savile Row and Minion.
 -out-aux <filename>           Symbol table; required for ReadSolution mode.

Optimisation levels:
 -O0                           Switch off all optional optimisations.
                               Expressions are still simplified. For example,
                               boolean expression 3+4=10 simplifies to false.
 -O1                           Space and time efficient optimisations:
                               -active-cse and -deletevars.
 -O2  (default)                Generally recommended optimisations: -O1 and
                               -reduce-domains and -aggregate. 
 -O3                           Most available optimisations: -O2, -ac-cse
                               and -tabulate.

Symmetry breaking levels:
 -S0                           Switch off all optimisations that change the
                               number of solutions.
 -S1  (default)                Allow Savile Row to delete unused variables,
                               and to create auxiliary variables that are not
                               necessarily functionally defined by the 
                               primary ('find') variables. Changes the 
                               number of solutions. Equivalent to 
                               -remove-redundant-vars and -aux-non-functional.
 -S2                           In addition to -S1, detect and break symmetry
                               among decision variables (-var-sym-breaking)
                               by applying a graph automorphism solver.

Translation Options (CSE is common subexpression elimination):
 -no-cse                       Switch off CSE.
 -identical-cse                Perform CSE for identical subexpressions only.
 -ac-cse                       Perform Associative-Commutative CSE for
                               operators And (/\), Or (\/), Product and Sum;
                               exploits associativity and commutativity.
 -active-cse                   Perform Active CSE. May be used with -ac-cse;
                               attempts to match expressions modulo a simple
                               transformation such as negation.
 -active-ac-cse                Perform Active AC-CSE; extends AC-CSE on sums
                               by matching a subexpression with its negation.
                               For example it can extract x+y from the
                               expressions x+y+z, w-x-y and 10-x-y.
                               Identical to AC-CSE on And, Or and Product.
 -deletevars                   Switch on variable deletion for variables that
                               equal a constant or another decision variable.
 -reduce-domains               Filter domains of 'find' decision variables if
                               Minion is available. Calls Minion for SACBounds
                               preprocessing, a restricted form of SAC where
                               the SAC test is applied to the upper and lower
                               bound of each variable.
 -reduce-domains-extend        Extension of -reduce-domains that filters
                               domains of auxiliary and 'find' variables.
 -aggregate                    Collect constraints into global constraints.
                               Currently performs two types of aggregation:
                               constructing GCC constraints from atleast and 
                               atmost, and AllDifferent from not-equal, 
                               less-than and shorter AllDifferent constraints.
 -tabulate                     Convert some constraint expressions into table
                               constraints to improve propagation. Candidate
                               expressions are identified by a set of 
                               heuristics. See documentation for more detail.
 -nomappers                    When translating to Dominion, do not use
                               mappers (views).
 -minionmappers                When translating to Dominion, only use mappers
                               when a comparable mapped constraint is also
                               available in Minion (e.g. multiplication
                               mappers inside a sum constraint are allowed
                               because Minion has a weighted sum constraint).
 -no-bound-vars                When translating to Minion, never use BOUND
                               type variables; use DISCRETE even for large
                               domains. Default is DISCRETE for domain size up
                               to 10,000, BOUND for larger domains. Using
                               BOUND type variables can reduce the level of
                               consistency enforced for some constraints.
 -remove-redundant-vars        Remove redundant variables by adding constraint
                               assigning variables that are not mentioned in
                               some constraint or the objective function.
                               Enabling this may lose solutions.
 -var-sym-breaking             Automatically identify and break symmetry 
                               among decision variables using a graph 
                               automorphism solver. 
Warnings:
 -Wundef                       Identify potentially undefined expressions.

Controlling Savile Row:
 -timelimit <time>             Wall clock time limit in milliseconds. Savile
                               Row stops when time limit is reached, unless
                               translation is complete and a solver is already
                               running. To apply a time limit to Minion, use
                               -solver-options "-cpulimit <time>"
 -cnflimit <max>               Limit SAT output to at most <max> clauses.
 -seed <integer>               Some transformations use a pseudorandom number
                               generator; this sets the seed value.
Solver control:
 -run-solver                   Run the backend solver. Also parse solver output.
 -all-solutions                Output all solutions, to a sequence of numbered
                               files, one per solution. For example,
                               "nurses.param.solution.000001" to "....000871"
                               Cannot be used on optimisation problems.
 -num-solutions <n>            Output <n> solutions, to a sequence of numbered
                               files as for -all-solutions.
                               Cannot be used on optimisation problems.
 -solutions-to-null            Do not output solutions in any way.
 -solver-options <string>      Pass through additional options to solver.
 -solutions-to-stdout          Instead of writing solutions to files, send
                               them to stdout separated by ----------.
Solver control -- Minion:
 -minion-bin <filename>        Specify where the Minion binary is. Default: use
                               the one included in the Savile Row distribution.
 -preprocess                   Passed to Minion both for solving (when using
                               -run-solver) and for domain filtering (when
                               using -reduce-domains or -O2 or higher).
                               Possible values: None, GAC, SACBounds, SAC,
                               SSAC, SSACBounds. Default is GAC when there are
                               large variable domains, otherwise SACBounds.
Solver control -- Gecode:
 -gecode-bin <filename>        Command to run the Gecode Flatzinc binary.
                               Default is "fzn-gecode".
Solver control -- Chuffed:
 -chuffed-bin <filename>       Command to run the Chuffed Flatzinc binary.
                               Default is "fzn-chuffed".
Solver control -- SAT solver:
 -sat-family <name>            Family of solver: "minisat", "glucose", 
                               "lingeling", "nbc_minisat_all", "bc_minisat_all".
                               Allows parsing output when using the -run-solver
                               flag. Default is "glucose". The _all values
                               imply the -all-solutions flag.
 -satsolver-bin <filename>     Location of SAT solver binary. Default is
                               "minisat", "lingeling", or "glucose" depending
                               on the SAT family. 

Mode of operation:
 -mode Normal  (default)       Reads Essence Prime model file and an optional
                               parameter file, producing output for a solver.
                               May also run a solver and parse solutions.
 -mode ReadSolution            Takes a solution table file created by Minion
                               and produces an Essence Prime solution file.
                               If the solution table file contains multiple
                               solutions, -all-solutions can be used to parse
                               them all, or -num-solutions <n> for first n.
 -minion-sol-file <filename>   Solution table file, produced by Minion's
                               -solsout flag. In ReadSolution mode, flags
                               -out-aux and -out-solution are required, so
                               that Savile Row can load the symbol table
                               saved when translating the problem instance,
                               and to specify where to write solutions, but
                               -all-solutions and -num-solutions are optional.
Examples:
     ./savilerow examples/sudoku/sudoku.eprime \
       examples/sudoku/sudoku.param -run-solver
  Use default optimisation (-O2) and solver (Minion). Minion is called twice,
  first to filter variable domains and then to solve the instance.
     ./savilerow examples/carSequencing/carSequencing.eprime \
       examples/carSequencing/carSequencing10.param -O3 -sat -run-solver
  Targets SAT; with no solver specified, the default (glucose) will be used.
