public override void ApplyDefaultOptions()
        {
            Contract.Ensures(TheProverFactory != null);
              Contract.Ensures(vcVariety != VCVariety.Unspecified);

              base.ApplyDefaultOptions();

              // expand macros in filenames, now that LogPrefix is fully determined
              ExpandFilename(ref XmlSinkFilename, LogPrefix, FileTimestamp);
              ExpandFilename(ref PrintFile, LogPrefix, FileTimestamp);
              ExpandFilename(ref SimplifyLogFilePath, LogPrefix, FileTimestamp);
              ExpandFilename(ref PrintErrorModelFile, LogPrefix, FileTimestamp);

              Contract.Assume(XmlSink == null);  // XmlSink is to be set here
              if (XmlSinkFilename != null) {
            XmlSink = new XmlSink(XmlSinkFilename);
              }

              if (TheProverFactory == null) {
            TheProverFactory = ProverFactory.Load("SMTLib");
            ProverName = "SMTLib".ToUpper();
              }

              var proverOpts = TheProverFactory.BlankProverOptions();
              proverOpts.Parse(ProverOptions);
              if (!TheProverFactory.SupportsLabels(proverOpts)) {
            UseLabels = false;
              }

              if (vcVariety == VCVariety.Unspecified) {
            vcVariety = TheProverFactory.DefaultVCVariety;
              }

              if (UseArrayTheory) {
            Monomorphize = true;
              }

              if (inferLeastForUnsat != null) {
            StratifiedInlining = 1;
              }

              if (StratifiedInlining > 0) {
            TypeEncodingMethod = TypeEncoding.Monomorphic;
            UseArrayTheory = true;
            UseAbstractInterpretation = false;
            MaxProverMemory = 0; // no max: avoids restarts
            if (ProverName == "Z3API" || ProverName == "SMTLIB") {
              ProverCCLimit = 1;
            }
            if (UseProverEvaluate)
            StratifiedInliningWithoutModels = true;
              }

              if (Trace) {
            BoogieDebug.DoPrinting = true;  // reuse the -trace option for debug printing
              }
        }
        protected override bool ParseOption(string name, CommandLineOptionEngine.CommandLineParseState ps)
        {
            var args = ps.args;  // convenient synonym
              switch (name) {
            case "infer":
              if (ps.ConfirmArgumentCount(1)) {
            foreach (char c in cce.NonNull(args[ps.i])) {
              switch (c) {
                case 't':
                  Ai.J_Trivial = true;
                  UseAbstractInterpretation = true;
                  break;
                case 'j':
                  Ai.J_Intervals = true;
                  UseAbstractInterpretation = true;
                  break;
                case 's':
                  Ai.DebugStatistics = true;
                  UseAbstractInterpretation = true;
                  break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                  StepsBeforeWidening = (int)char.GetNumericValue(c);
                  break;
                default:
                  ps.Error("Invalid argument '{0}' to option {1}", c.ToString(), ps.s);
                  break;
              }
            }
              }
              return true;

            case "noinfer":
              if (ps.ConfirmArgumentCount(0)) {
            UseAbstractInterpretation = false;
              }
              return true;

            case "break":
            case "launch":
              if (ps.ConfirmArgumentCount(0)) {
            System.Diagnostics.Debugger.Launch();
              }
              return true;

            case "proc":
              if (this.procsToCheck == null) {
            this.procsToCheck = new List<string/*!*/>();
              }
              if (ps.ConfirmArgumentCount(1)) {
            this.procsToCheck.Add(cce.NonNull(args[ps.i]));
              }
              return true;

            case "xml":
              if (ps.ConfirmArgumentCount(1)) {
            XmlSinkFilename = args[ps.i];
              }
              return true;

            case "print":
              if (ps.ConfirmArgumentCount(1)) {
            PrintFile = args[ps.i];
              }
              return true;

            case "pretty":
              int val = 1;
              if (ps.GetNumericArgument(ref val, 2)) {
            PrettyPrint = val == 1;
              }
              return true;

            case "OwickiGries":
              if (ps.ConfirmArgumentCount(1)) {
              OwickiGriesDesugaredOutputFile = args[ps.i];
              }
              return true;

            case "trustLayersUpto":
              if (ps.ConfirmArgumentCount(1))
              {
              ps.GetNumericArgument(ref TrustLayersUpto);
              }
              return true;

            case "trustLayersDownto":
              if (ps.ConfirmArgumentCount(1))
              {
              ps.GetNumericArgument(ref TrustLayersDownto);
              }
              return true;

            case "proverLog":
              if (ps.ConfirmArgumentCount(1)) {
            SimplifyLogFilePath = args[ps.i];
              }
              return true;

            case "proverPreamble":
              if (ps.ConfirmArgumentCount(1))
              {
            ProverPreamble = args[ps.i];
              }
               return true;

              case "logPrefix":
              if (ps.ConfirmArgumentCount(1)) {
            string s = cce.NonNull(args[ps.i]);
            LogPrefix += s.Replace('/', '-').Replace('\\', '-');
              }
              return true;

            case "proverShutdownLimit":
              ps.GetNumericArgument(ref ProverShutdownLimit);
              return true;

            case "errorTrace":
              ps.GetNumericArgument(ref ErrorTrace, 3);
              return true;

            case "proverWarnings": {
            int pw = 0;
            if (ps.GetNumericArgument(ref pw, 3)) {
              switch (pw) {
                case 0:
                  PrintProverWarnings = ProverWarnings.None;
                  break;
                case 1:
                  PrintProverWarnings = ProverWarnings.Stdout;
                  break;
                case 2:
                  PrintProverWarnings = ProverWarnings.Stderr;
                  break;
                default: {
                    Contract.Assert(false);
                    throw new cce.UnreachableException();
                  } // postcondition of GetNumericArgument guarantees that we don't get here
              }
            }
            return true;
              }

            case "env": {
            int e = 0;
            if (ps.GetNumericArgument(ref e, 3)) {
              switch (e) {
                case 0:
                  ShowEnv = ShowEnvironment.Never;
                  break;
                case 1:
                  ShowEnv = ShowEnvironment.DuringPrint;
                  break;
                case 2:
                  ShowEnv = ShowEnvironment.Always;
                  break;
                default: {
                    Contract.Assert(false);
                    throw new cce.UnreachableException();
                  } // postcondition of GetNumericArgument guarantees that we don't get here
              }
            }
            return true;
              }

            case "loopUnroll":
              ps.GetNumericArgument(ref LoopUnrollCount);
              return true;

            case "printModel":
              if (ps.ConfirmArgumentCount(1)) {
            switch (args[ps.i]) {
              case "0":
                PrintErrorModel = 0;
                break;
              case "1":
                PrintErrorModel = 1;
                break;
              case "2":
                PrintErrorModel = 2;
                break;
              case "4":
                PrintErrorModel = 4;
                break;
              default:
                ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                break;
            }
              }
              return true;

            case "mv":
              if (ps.ConfirmArgumentCount(1)) {
            ModelViewFile = args[ps.i];
              }
              return true;

            case "printModelToFile":
              if (ps.ConfirmArgumentCount(1)) {
            PrintErrorModelFile = args[ps.i];
              }
              return true;

            case "enhancedErrorMessages":
              ps.GetNumericArgument(ref EnhancedErrorMessages, 2);
              return true;

            case "printCFG":
              if (ps.ConfirmArgumentCount(1)) {
            PrintCFGPrefix = args[ps.i];
              }
              return true;

            case "inlineDepth":
              ps.GetNumericArgument(ref InlineDepth);
              return true;

            case "subsumption": {
            int s = 0;
            if (ps.GetNumericArgument(ref s, 3)) {
              switch (s) {
                case 0:
                  UseSubsumption = SubsumptionOption.Never;
                  break;
                case 1:
                  UseSubsumption = SubsumptionOption.NotForQuantifiers;
                  break;
                case 2:
                  UseSubsumption = SubsumptionOption.Always;
                  break;
                default: {
                    Contract.Assert(false);
                    throw new cce.UnreachableException();
                  } // postcondition of GetNumericArgument guarantees that we don't get here
              }
            }
            return true;
              }

            case "liveVariableAnalysis": {
            int lva = 0;
            if (ps.GetNumericArgument(ref lva, 3)) {
              LiveVariableAnalysis = lva;
            }
            return true;
              }

            case "removeEmptyBlocks": {
            int reb = 0;
            if (ps.GetNumericArgument(ref reb, 2)) {
              RemoveEmptyBlocks = reb == 1;
            }
            return true;
              }

            case "coalesceBlocks": {
            int cb = 0;
            if (ps.GetNumericArgument(ref cb, 2)) {
              CoalesceBlocks = cb == 1;
            }
            return true;
              }

            case "noPruneInfeasibleEdges": {
            if (ps.ConfirmArgumentCount(0)) {
              PruneInfeasibleEdges = false;
            }
            return true;
            }

            case "stagedHoudini": {
            if (ps.ConfirmArgumentCount(1)) {
                if(args[ps.i] == "COARSE" ||
                   args[ps.i] == "FINE" ||
                   args[ps.i] == "BALANCED") {
                    StagedHoudini = args[ps.i];
                } else {
                    ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                }
            }
            return true;
            }

            case "stagedHoudiniThreads": {
            ps.GetNumericArgument(ref StagedHoudiniThreads);
            return true;
            }

            case "stagedHoudiniReachabilityAnalysis": {
            if (ps.ConfirmArgumentCount(0)) {
              StagedHoudiniReachabilityAnalysis = true;
            }
            return true;
              }

            case "stagedHoudiniMergeIgnoredAnnotations": {
            if (ps.ConfirmArgumentCount(0)) {
              StagedHoudiniMergeIgnoredAnnotations = true;
            }
            return true;
              }

            case "debugStagedHoudini": {
            if (ps.ConfirmArgumentCount(0)) {
              DebugStagedHoudini = true;
            }
            return true;
              }

            case "variableDependenceIgnore": {
            if (ps.ConfirmArgumentCount(1)) {
              VariableDependenceIgnore = args[ps.i];
            }
            return true;
              }

            case "abstractHoudini":
            {
                if (ps.ConfirmArgumentCount(1))
                {
                    AbstractHoudini = args[ps.i];
                }
                return true;
            }
            case "vc":
              if (ps.ConfirmArgumentCount(1)) {
            switch (args[ps.i]) {
              case "s":
              case "structured":
                vcVariety = VCVariety.Structured;
                break;
              case "b":
              case "block":
                vcVariety = VCVariety.Block;
                break;
              case "l":
              case "local":
                vcVariety = VCVariety.Local;
                break;
              case "n":
              case "nested":
                vcVariety = VCVariety.BlockNested;
                break;
              case "m":
                vcVariety = VCVariety.BlockNestedReach;
                break;
              case "r":
                vcVariety = VCVariety.BlockReach;
                break;
              case "d":
              case "dag":
                vcVariety = VCVariety.Dag;
                break;
              case "i":
                vcVariety = VCVariety.DagIterative;
                break;
              case "doomed":
                vcVariety = VCVariety.Doomed;
                break;
              default:
                ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                break;
            }
              }
              return true;

            case "prover":
              if (ps.ConfirmArgumentCount(1)) {
            TheProverFactory = ProverFactory.Load(cce.NonNull(args[ps.i]));
            ProverName = cce.NonNull(args[ps.i]).ToUpper();
              }
              return true;

            case "p":
            case "proverOpt":
              if (ps.ConfirmArgumentCount(1)) {
            ProverOptions = ProverOptions.Concat1(cce.NonNull(args[ps.i]));
              }
              return true;

            case "DoomStrategy":
              ps.GetNumericArgument(ref DoomStrategy);
              return true;

            case "DoomRestartTP":
              if (ps.ConfirmArgumentCount(0)) {
            DoomRestartTP = true;
              }
              return true;

            case "extractLoops":
              if (ps.ConfirmArgumentCount(0)) {
            ExtractLoops = true;
              }
              return true;

            case "deterministicExtractLoops":
              if (ps.ConfirmArgumentCount(0)) {
            DeterministicExtractLoops = true;
              }
              return true;

            case "inline":
              if (ps.ConfirmArgumentCount(1)) {
            switch (args[ps.i]) {
              case "none":
                ProcedureInlining = Inlining.None;
                break;
              case "assert":
                ProcedureInlining = Inlining.Assert;
                break;
              case "assume":
                ProcedureInlining = Inlining.Assume;
                break;
              case "spec":
                ProcedureInlining = Inlining.Spec;
                break;
              default:
                ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                break;
            }
              }
              return true;
            case "secure":
              if (ps.ConfirmArgumentCount(1))
              SecureVcGen = args[ps.i];
              return true;
            case "stratifiedInline":
              if (ps.ConfirmArgumentCount(1)) {
            switch (args[ps.i]) {
              case "0":
                StratifiedInlining = 0;
                break;
              case "1":
                StratifiedInlining = 1;
                break;
              default:
                StratifiedInlining = Int32.Parse(cce.NonNull(args[ps.i]));
                //ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                break;
            }
              }
              return true;
            case "fixedPointEngine":
              if (ps.ConfirmArgumentCount(1))
              {
              FixedPointEngine = args[ps.i];
              }
              return true;
            case "fixedPointInfer":
              if (ps.ConfirmArgumentCount(1))
              {
              switch (args[ps.i])
              {
                  case "corral":
                      FixedPointMode = FixedPointInferenceMode.Corral;
                      break;
                  case "oldCorral":
                      FixedPointMode = FixedPointInferenceMode.OldCorral;
                      break;
                  case "flat":
                      FixedPointMode = FixedPointInferenceMode.Flat;
                      break;
                  case "procedure":
                      FixedPointMode = FixedPointInferenceMode.Procedure;
                      break;
                  case "call":
                      FixedPointMode = FixedPointInferenceMode.Call;
                      break;
                  default:
                      ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                      break;
              }
              }
              return true;
            case "printFixedPoint":
              if (ps.ConfirmArgumentCount(1))
              {
              PrintFixedPoint = args[ps.i];
              }
              return true;
            case "printConjectures":
              if (ps.ConfirmArgumentCount(1))
              {
              PrintConjectures = args[ps.i];
              }
              return true;
            case "siVerbose":
              if (ps.ConfirmArgumentCount(1)) {
            StratifiedInliningVerbose = Int32.Parse(cce.NonNull(args[ps.i]));
              }
              return true;
            case "recursionBound":
              if (ps.ConfirmArgumentCount(1)) {
            RecursionBound = Int32.Parse(cce.NonNull(args[ps.i]));
              }
              return true;
            case "stackDepthBound":
              if (ps.ConfirmArgumentCount(1))
              {
              StackDepthBound = Int32.Parse(cce.NonNull(args[ps.i]));
              }
              return true;
            case "stratifiedInlineOption":
              if (ps.ConfirmArgumentCount(1)) {
            StratifiedInliningOption = Int32.Parse(cce.NonNull(args[ps.i]));
              }
              return true;

            case "inferLeastForUnsat":
              if (ps.ConfirmArgumentCount(1)) {
            inferLeastForUnsat = args[ps.i];
              }
              return true;

            case "typeEncoding":
              if (ps.ConfirmArgumentCount(1)) {
            switch (args[ps.i]) {
              case "n":
              case "none":
                TypeEncodingMethod = TypeEncoding.None;
                break;
              case "p":
              case "predicates":
                TypeEncodingMethod = TypeEncoding.Predicates;
                break;
              case "a":
              case "arguments":
                TypeEncodingMethod = TypeEncoding.Arguments;
                break;
              case "m":
              case "monomorphic":
                TypeEncodingMethod = TypeEncoding.Monomorphic;
                break;
              default:
                ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                break;
            }
              }
              return true;

            case "instrumentInfer":
              if (ps.ConfirmArgumentCount(1)) {
            switch (args[ps.i]) {
              case "e":
                InstrumentInfer = InstrumentationPlaces.Everywhere;
                break;
              case "h":
                InstrumentInfer = InstrumentationPlaces.LoopHeaders;
                break;
              default:
                ps.Error("Invalid argument \"{0}\" to option {1}", args[ps.i], ps.s);
                break;
            }
              }
              return true;

            case "concurrentHoudini":
              if (ps.ConfirmArgumentCount(0)) {
            ConcurrentHoudini = true;
              }
              return true;

            case "modifyTopologicalSorting":
              if (ps.ConfirmArgumentCount(0)) {
            ModifyTopologicalSorting = true;
              }
              return true;

            case "debugConcurrentHoudini":
              if (ps.ConfirmArgumentCount(0)) {
            DebugConcurrentHoudini = true;
              }
              return true;

            case "vcBrackets":
              ps.GetNumericArgument(ref bracketIdsInVC, 2);
              return true;

            case "proverMemoryLimit": {
            int d = 0;
            if (ps.GetNumericArgument(ref d)) {
              MaxProverMemory = d * Megabyte;
            }
            return true;
              }

            case "vcsMaxCost":
              ps.GetNumericArgument(ref VcsMaxCost);
              return true;

            case "vcsPathJoinMult":
              ps.GetNumericArgument(ref VcsPathJoinMult);
              return true;

            case "vcsPathCostMult":
              ps.GetNumericArgument(ref VcsPathCostMult);
              return true;

            case "vcsAssumeMult":
              ps.GetNumericArgument(ref VcsAssumeMult);
              return true;

            case "vcsPathSplitMult":
              ps.GetNumericArgument(ref VcsPathSplitMult);
              return true;

            case "vcsMaxSplits":
              ps.GetNumericArgument(ref VcsMaxSplits);
              return true;

            case "vcsMaxKeepGoingSplits":
              ps.GetNumericArgument(ref VcsMaxKeepGoingSplits);
              return true;

            case "vcsFinalAssertTimeout":
              ps.GetNumericArgument(ref VcsFinalAssertTimeout);
              return true;

            case "vcsKeepGoingTimeout":
              ps.GetNumericArgument(ref VcsKeepGoingTimeout);
              return true;

            case "vcsCores":
              ps.GetNumericArgument(ref VcsCores, a => 1 <= a);
              return true;

            case "vcsLoad":
              double load = 0.0;
              if (ps.GetNumericArgument(ref load)) {
            if (3.0 <= load) {
              ps.Error("surprisingly high load specified; got {0}, expected nothing above 3.0", load.ToString());
              load = 3.0;
            }
            int p = (int)Math.Round(System.Environment.ProcessorCount * load);
            VcsCores = p < 1 ? 1 : p;
              }
              return true;

            case "simplifyMatchDepth":
              ps.GetNumericArgument(ref SimplifyProverMatchDepth);
              return true;

            case "timeLimit":
              ps.GetNumericArgument(ref ProverKillTime);
              return true;

            case "timeLimitPerAssertionInPercent":
              ps.GetNumericArgument(ref TimeLimitPerAssertionInPercent, a => 0 < a);
              return true;

            case "smokeTimeout":
              ps.GetNumericArgument(ref SmokeTimeout);
              return true;

            case "errorLimit":
              ps.GetNumericArgument(ref ProverCCLimit);
              return true;

            case "verifySnapshots":
              ps.GetNumericArgument(ref VerifySnapshots, 4);
              return true;

            case "traceCaching":
              ps.GetNumericArgument(ref TraceCaching, 4);
              return true;

            case "useSmtOutputFormat": {
              if (ps.ConfirmArgumentCount(0)) {
            UseSmtOutputFormat = true;
              }
              return true;
            }

            case "z3opt":
              if (ps.ConfirmArgumentCount(1)) {
            AddZ3Option(cce.NonNull(args[ps.i]));
              }
              return true;

            case "z3lets":
              ps.GetNumericArgument(ref Z3lets, 4);
              return true;

            case "platform":
              if (ps.ConfirmArgumentCount(1)) {
            StringCollection platformOptions = this.ParseNamedArgumentList(args[ps.i]);
            if (platformOptions != null && platformOptions.Count > 0) {
              try {
                this.TargetPlatform = (PlatformType)cce.NonNull(Enum.Parse(typeof(PlatformType), cce.NonNull(platformOptions[0])));
              } catch {
                ps.Error("Bad /platform type '{0}'", platformOptions[0]);
                break;
              }
              if (platformOptions.Count > 1) {
                this.TargetPlatformLocation = platformOptions[1];
                if (!Directory.Exists(platformOptions[1])) {
                  ps.Error("/platform directory '{0}' does not exist", platformOptions[1]);
                  break;
                }
              }
            }
              }
              return true;

            case "z3exe":
              if (ps.ConfirmArgumentCount(1)) {
            Z3ExecutablePath = args[ps.i];
              }
              return true;
             // This sets name of z3 binary boogie binary directory, not path
            case "z3name":
              if (ps.ConfirmArgumentCount(1))
              {
              Z3ExecutableName = args[ps.i];
              }
              return true;

            case "cvc4exe":
            if (ps.ConfirmArgumentCount(1)) {
                CVC4ExecutablePath = args[ps.i];
            }
            return true;

            case "kInductionDepth":
              ps.GetNumericArgument(ref KInductionDepth);
              return true;

            default:
              bool optionValue = false;
              if (ps.CheckBooleanFlag("printUnstructured", ref optionValue)) {
            PrintUnstructured = optionValue ? 1 : 0;
            return true;
              }

              if (ps.CheckBooleanFlag("printDesugared", ref PrintDesugarings) ||
              ps.CheckBooleanFlag("printInstrumented", ref PrintInstrumented) ||
              ps.CheckBooleanFlag("printWithUniqueIds", ref PrintWithUniqueASTIds) ||
              ps.CheckBooleanFlag("wait", ref Wait) ||
              ps.CheckBooleanFlag("trace", ref Trace) ||
              ps.CheckBooleanFlag("traceTimes", ref TraceTimes) ||
              ps.CheckBooleanFlag("tracePOs", ref TraceProofObligations) ||
              ps.CheckBooleanFlag("noResolve", ref NoResolve) ||
              ps.CheckBooleanFlag("noTypecheck", ref NoTypecheck) ||
              ps.CheckBooleanFlag("overlookTypeErrors", ref OverlookBoogieTypeErrors) ||
              ps.CheckBooleanFlag("noVerify", ref Verify, false) ||
              ps.CheckBooleanFlag("traceverify", ref TraceVerify) ||
              ps.CheckBooleanFlag("alwaysAssumeFreeLoopInvariants", ref AlwaysAssumeFreeLoopInvariants, true) ||
              ps.CheckBooleanFlag("nologo", ref DontShowLogo) ||
              ps.CheckBooleanFlag("proverLogAppend", ref SimplifyLogFileAppend) ||
              ps.CheckBooleanFlag("soundLoopUnrolling", ref SoundLoopUnrolling) ||
              ps.CheckBooleanFlag("checkInfer", ref InstrumentWithAsserts) ||
              ps.CheckBooleanFlag("interprocInfer", ref IntraproceduralInfer, false) ||
              ps.CheckBooleanFlag("restartProver", ref RestartProverPerVC) ||
              ps.CheckBooleanFlag("printInlined", ref PrintInlined) ||
              ps.CheckBooleanFlag("smoke", ref SoundnessSmokeTest) ||
              ps.CheckBooleanFlag("vcsDumpSplits", ref VcsDumpSplits) ||
              ps.CheckBooleanFlag("dbgRefuted", ref DebugRefuted) ||
              ps.CheckBooleanFlag("causalImplies", ref CausalImplies) ||
              ps.CheckBooleanFlag("reflectAdd", ref ReflectAdd) ||
              ps.CheckBooleanFlag("z3types", ref Z3types) ||
              ps.CheckBooleanFlag("z3multipleErrors", ref z3AtFlag, false) ||
              ps.CheckBooleanFlag("monomorphize", ref Monomorphize) ||
              ps.CheckBooleanFlag("useArrayTheory", ref UseArrayTheory) ||
              ps.CheckBooleanFlag("weakArrayTheory", ref WeakArrayTheory) ||
              ps.CheckBooleanFlag("doModSetAnalysis", ref DoModSetAnalysis) ||
              ps.CheckBooleanFlag("doNotUseLabels", ref UseLabels, false) ||
              ps.CheckBooleanFlag("runDiagnosticsOnTimeout", ref RunDiagnosticsOnTimeout) ||
              ps.CheckBooleanFlag("traceDiagnosticsOnTimeout", ref TraceDiagnosticsOnTimeout) ||
              ps.CheckBooleanFlag("boolControlVC", ref SIBoolControlVC, true) ||
              ps.CheckBooleanFlag("contractInfer", ref ContractInfer) ||
              ps.CheckBooleanFlag("explainHoudini", ref ExplainHoudini) ||
              ps.CheckBooleanFlag("reverseHoudiniWorklist", ref ReverseHoudiniWorklist) ||
              ps.CheckBooleanFlag("crossDependencies", ref HoudiniUseCrossDependencies) ||
              ps.CheckBooleanFlag("useUnsatCoreForContractInfer", ref UseUnsatCoreForContractInfer) ||
              ps.CheckBooleanFlag("printAssignment", ref PrintAssignment) ||
              ps.CheckBooleanFlag("useProverEvaluate", ref UseProverEvaluate) ||
              ps.CheckBooleanFlag("nonUniformUnfolding", ref NonUniformUnfolding) ||
              ps.CheckBooleanFlag("deterministicExtractLoops", ref DeterministicExtractLoops) ||
              ps.CheckBooleanFlag("verifySeparately", ref VerifySeparately) ||
              ps.CheckBooleanFlag("trustAtomicityTypes", ref TrustAtomicityTypes) ||
              ps.CheckBooleanFlag("trustNonInterference", ref TrustNonInterference) ||
              ps.CheckBooleanFlag("useBaseNameForFileName", ref UseBaseNameForFileName)
              ) {
            // one of the boolean flags matched
            return true;
              }
              break;
              }

              return base.ParseOption(name, ps);  // defer to superclass
        }