anchor.diff:  /// 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 reals = opts.reals
       let times = opts.times
  -    let approx = opts.approx
   
       let starlingR =
           match (requestFromStage opts.stage) with
  -        | Some otype -> runStarling times optS reals approx verbose otype opts.input
  +        | Some otype -> runStarling times optS backendS verbose otype opts.input
           | None -> fail Error.BadStage
   
       let mview =
  
positive.code:                 "Dump results in raw format instead of pretty-printing.")>]
        raw : bool
        [<Option(
              'A',
              HelpText =
                  "(EXPERIMENTAL) Under-approximate symbols in Z3 proofs.")>]
        approx : bool
        [<Option(
              'R',
              HelpText =
                  "(TEMPORARY) Use reals instead of ints in Z3 proofs.")>]
        reals : bool
        [<Option(
              's',
              HelpText =
  
negative.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 backendS verbose request =
      let optR, optA =
          optS
          |> Option.map Utils.parseOptionString
          |> withDefault (Seq.empty)
          |> Seq.toList
          |> Optimiser.Utils.parseOptString
  
      let bp = backendParams ()
      let { Approx = approx; Reals = reals } =
          backendS
          |> Option.map Utils.parseOptionString
          |> withDefault (Seq.empty)
          |> Seq.fold
                 (fun opts str ->
                      match (bp.TryFind str) with
                      | Some (_, f) -> f opts
                      | None ->
                          eprintfn "unknown backend param %s ignored (try 'list')"
                              str
                          opts)
                 { Approx = false; Reals = false }
  
      let backend m =
          let phase op response =
  