anchor.diff:            >> mapMessages ModelFilterError)
   
   /// <summary>
  +///     Type of the backend parameter structure.
  +/// </summary>
  +type BackendParams =
  +    // TODO(CaptainHayashi): distribute into the target backends?
  +    { /// <summary>
  +      ///     Whether symbols are being approximated.
  +      /// </summary>
  +      Approx : bool
  +      /// <summary>
  +      ///     Whether reals are being substituted for integers in Z3 proofs.
  +      /// </summary>
  +      Reals : bool }
  +
  +/// <summary>
  +///     Map of known backend parameters.
  +/// </summary>
  +let rec backendParams () =
  +    Map.ofList
  +        [ ("approx",
  +           ("Replace all symbols in a proof with their under-approximation.\n\
  +             Allows some symbol proofs to be run by the Z3 backend, but the \
  +             resulting proof may be incomplete.",
  +             fun ps -> { ps with Approx = true } ))
  +          ("reals",
  +           ("In Z3/muZ3 proofs, model integers as reals.\n\
  +             This may speed up the proof at the cost of soundness.",
  +             fun ps -> { ps with Reals = true } ))
  +          ("list",
  +           ("Lists all backend parameters.",
  +            fun ps ->
  +                eprintfn "Backend parameters:\n"
  +                Map.iter
  +                    (fun name (descr, _) -> eprintfn "%s: %s\n" name descr)
  +                    (backendParams ())
  +                eprintfn "--\n"
  +                ps)) ]
  +
  +/// <summary>
   ///     Runs a Starling request.
   /// </summary>
   /// <param name="optS">
   ///     The string governing optimiser overrides.
   /// </param>
  -/// <param name="reals">
  -///     (TEMPORARY) Whether to use reals instead of ints in MuZ proofs.
  -/// </param>
  -/// <param name="approx">
  -///     (EXPERIMENTAL) Whether to try to approximate Boolean symbols.
  +/// <param name="backendS">
  +///     The string governing backend options.
   /// </param>
   /// <param name="verbose">
   ///     If true, dump some internal information to stderr.
  
positive.code: ///     taking a file containing request input and returning a
  ///     <c>Result</c> over <c>Response</c> and <c>Error</c>.
  /// </returns>
  let runStarling times optS reals approx verbose request =
      let optR, optA =
          optS
          |> Option.map Utils.parseOptionString
          |> withDefault (Seq.empty)
          |> Seq.toList
          |> Optimiser.Utils.parseOptString
  
      let backend m =
          let phase op response =
  
negative.code: /// Runs Starling with the given options, and outputs the results.
  let mainWithOptions opts =
      let optS = opts.optimisers
      let backendS = opts.backendOpts
      let verbose = opts.verbose
      let times = opts.times
  
      let starlingR =
          match (requestFromStage opts.stage) with
          | Some otype -> runStarling times optS backendS verbose otype opts.input
          | None -> fail Error.BadStage
  
      let mview =
  