anchor.diff:      "            * Not compatible with Optimal DPOR.~n"
       "-  'delay': how many times per interleaving the scheduler is allowed~n"
       "            to skip a chosen process in order to schedule others.~n"}
  -  ,{scheduling_bound, $b, integer,
  +  ,{scheduling_bound, [bound], $b, integer,
       "Scheduling bound value",
       "The maximum number of times the rule specified in '--scheduling_bound_type'"
       " can be violated."}
  -  ,{disable_sleep_sets, undefined, {boolean, false},
  +  ,{disable_sleep_sets, [por, advanced], undefined, {boolean, false},
       "Disables use of sleep sets",
       "This option is only available with '--dpor none'."}
  -  ,{after_timeout, $a, {integer, infinity},
  +  ,{after_timeout, [erlang], $a, {integer, infinity},
       "Ignore timeouts greater than this value",
       "Assume that 'after' clause timeouts higher or equal to the specified value"
       " (integer) will never be triggered."}
  -  ,{instant_delivery, undefined, {boolean, true},
  +  ,{instant_delivery, [erlang], undefined, {boolean, true},
       "Messages and signals arrive instantly",
       "Assume that messages and signals are delivered immediately, when sent to a"
       " process on the same node."}
  -  ,{scheduling, undefined, {atom, round_robin},
  +  ,{scheduling, [advanced], undefined, {atom, round_robin},
       "Scheduling order",
       "How Concuerror picks the next process to run. The available options are"
       " 'oldest', 'newest' and 'round_robin'."}
  -  ,{strict_scheduling, undefined, {boolean, false},
  +  ,{strict_scheduling, [advanced], undefined, {boolean, false},
       "Forces preemptions",
       "Whether Concuerror should enforce the scheduling strategy strictly or let"
       " a process run until blocked before reconsidering the scheduling policy."}
  -  ,{keep_going, $k, {boolean, false},
  -    "Continue running after an error is found",
  +  ,{keep_going, [basic, bug], $k, {boolean, false},
  +    "Keep running after an error is found",
       "Concuerror stops by default when the first error is found. Enable this"
       " flag to keep looking for more errors. Preferably, modify the test, or"
       " use the '--ignore_error' / '--treat_as_normal' options."}
  -  ,{ignore_error, undefined, atom,
  +  ,{ignore_error, [bug], undefined, atom,
       "Ignore 'crash', 'deadlock' or 'depth_bound' errors",
       "Concuerror will not report errors of the specified kind:~n"
       "'crash' (any process crash - check '-h treat_as_normal' for more refined"
       " control)~n"
       "'deadlock' (processes waiting at a receive statement)~n"
       "'depth_bound' (the depth bound was reached - check '-h depth_bound')."}
  -  ,{treat_as_normal, undefined, atom,
  +  ,{treat_as_normal, [bug], undefined, atom,
       "Exit reasons considered 'normal'",
       "A process that exits with the specified atom as reason (or with a reason"
       " that is a tuple with the specified atom as a first element) will not be"
       " reported as exiting abnormally. Useful e.g. when analyzing supervisors"
       " ('shutdown' is usually a normal exit reason in this case)."}
  -  ,{assertions_only, undefined, {boolean, false},
  +  ,{assertions_only, [bug], undefined, {boolean, false},
       "Only crashes due to failed ?asserts are reported.",
       "Only processes that exit with a reason of form '{{assert*, _}, _}' are"
       " considered crashes. Such exit reasons are generated e.g. by the"
       " stdlib/include/assert.hrl header file."}
  -  ,{timeout, undefined, {integer, ?MINIMUM_TIMEOUT},
  +  ,{timeout, [erlang, advanced], undefined, {integer, ?MINIMUM_TIMEOUT},
       "How long to wait for an event (>= " ++
         integer_to_list(?MINIMUM_TIMEOUT) ++ "ms)",
       "How many ms to wait before assuming that a process is stuck in an infinite"
       " loop between two operations with side-effects. Setting this to -1 will"
       " make Concuerror wait indefinitely. Otherwise must be >= " ++
         integer_to_list(?MINIMUM_TIMEOUT) ++ "."}
  -  ,{assume_racing, undefined, {boolean, true},
  +  ,{assume_racing, [por, advanced], undefined, {boolean, true},
       "Unknown operations as considered racing",
       "Concuerror has a list of operation pairs that are known to be non-racing."
       " If there is no info about a specific pair of built-in operations"
       " may race, assume that they do indeed race. If this is set to false,"
       " Concuerror will exit instead. Useful for detecting"
       " missing dependency info."}
  -  ,{non_racing_system, undefined, atom,
  +  ,{non_racing_system, [erlang], undefined, atom,
       "No races due to 'system' messages",
       "Assume that any messages sent to the specified (by registered name) system"
       " process are not racing with each-other. Useful for reducing the number of"
       " interleavings when processes have calls to e.g. io:format/1,2 or similar."}
  +  ,{help, [basic], $h, atom,
  +    "Display help (use also as '-h <option/keyword>')",
  +    "You already know how to use this option! :-)"}
  +  ,{version, [basic], undefined, undefined,
  +    "Display version information"}
      ].
   
   cl_usage(all) ->
  -  getopt:usage(getopt_spec(), "./concuerror"),
  -  to_stderr("More info about a specific option: -h <option>.~n", []),
  -  print_exit_status_info(),
  -  print_bugs_message();
  +  Sort = fun(A, B) -> element(?OPTION_KEY, A) =< element(?OPTION_KEY, B) end,
  +  getopt:usage(getopt_spec(lists:sort(Sort, options())), "./concuerror"),
  +  print_suffix(all);
   cl_usage(Name) ->
     Optname =
       case lists:keyfind(Name, ?OPTION_KEY, options()) of
  
positive.code:     "6 <debug> Used only during debugging~n"
      "7 <trace> Everything else"
     }
    ,{quiet, $q, undefined,
      "Do not write anything to stderr",
      "Shorthand for '-v 0'."}
    ,{output, $o, {string, "concuerror_report.txt"},
      "Output file",
      "This is where Concuerror writes the results of the analysis."}
    ,{graph, undefined, string,
      "Produce a DOT graph in the specified file",
      "The DOT graph can be converted to an image with 'dot -Tsvg -o graph.svg"
      " <graph>"}
    ,{symbolic_names, $s, {boolean, true},
      "Use symbolic PIDs in graph/log",
      "Use symbolic names for process identifiers in the output report (and"
      " graph)."}
    ,{print_depth, undefined, {integer, ?DEFAULT_PRINT_DEPTH},
      "Print depth for log/graph",
      "Specifies the max depth for any terms printed in the log (behaves just as"
      " the extra argument of ~~W and ~~P argument of io:format/3). If you want"
      " more info about a particular piece of data in an interleaving, consider"
      " using erlang:display/1 and checking the 'standard output section; in the"
      " log instead."}
    ,{show_races, undefined, {boolean, false},
      "Show races in log/graph",
      "Determines whether information about pairs of racing instructions will be"
      " included in the logs of erroneous interleavings and the graph."}
    ,{pa, undefined, string,
      "Add directory to Erlang's code path (front)",
      "Works exactly like 'erl -pa'."}
    ,{pz, undefined, string,
      "Add directory to Erlang's code path (rear)",
      "Works exactly like 'erl -pz'."}
    ,{file, $f, string,
      "Load a specific file",
      "Explicitly load a file (.beam or .erl). Source (.erl) files should not"
      " require any special command line compile options. Use a .beam file if"
      " special compilation is needed (preferably compiled with +debug_info)."}
    ,{depth_bound, $d, {integer, 500},
      "Maximum number of events",
      "The maximum number of events allowed in an interleaving. Concuerror will"
      " stop exploring an interleaving that has events beyond this limit."}
    ,{interleaving_bound, $i, {integer, infinity},
      "Maximum number of interleavings",
      "The maximum number of interleavings that will be explored. Concuerror will"
      " stop exploration beyond this limit."}
    ,{dpor, undefined, atom,
      "DPOR techique to use. [default: optimal]",
      "Specifies which Dynamic Partial Order Reduction techique will be used. The"
      " available options are:~n"
  
negative.code:     "                exploration is too slow. Use 'optimal' if a lot of~n"
      "                interleavings are reported as sleep-set blocked.~n"
      "- 'persistent': Using persistent sets. Do not use."}
    ,{optimal, [por], undefined, boolean,
      "Deprecated. Use '--dpor (optimal | source)' instead."}
    ,{scheduling_bound_type, [bound], $c, atom,
      "Use schedule bounding [default: none]",
      "Enables scheduling rules that prevent interleavings from being explored."
      " The available options are:~n"
  