anchor.diff:  }
   ----
   
  -Implement `Runnable` or `Callable` ➊, and your command can be <<Executing Commands,executed>> in one line of code.
  -The example above uses the `CommandLine.execute` method ➋
  -to parse the command line, handle errors, handle requests for usage and version help, and invoke the business logic.
  -Applications can call `System.exit` ➌ with the returned exit code to signal success or failure to their caller.
  -
  -The <<Mixin Standard Help Options,mixinStandardHelpOptions>> attribute ➍ adds `--help` and `--version` options to your application.
  -
  -
  -== Getting Started
  +_This is how it works_: Create a class ➊ that represents your command and annotate this class with @Command ➑. Let this class implement `Runnable` or `Callable` and picocli will kick off your application after parsing is successfully completed. Then, annotate the fields or methods of the command class with @Parameters ➋ and/or @Option ➌ to declare what positional parameters and/or options your application expects. Picocli will convert the command line arguments given to your app to strongly typed values in the fields ➍ of your class. In the `main` method of your class, use the `CommandLine.execute` method ➎ to parse the command line, handle errors, handle requests for usage and version help, and invoke the business logic ➏. Once your business logic finished, you may call `System.exit` ➐ to return an exit code to your caller, indicating success or failure of your business logic. Additionally, you may make use of the <<Mixin Standard Help Options,mixinStandardHelpOptions>> attribute ➑  which adds `--help` and `--version` options to your application.
  +
  +TIP: Picocli also provides a <<Programmatic API,programmatic API>>, separately from the annotations API.
  +
  +== Setting up your picocli based project
   You can add picocli as an external dependency to your project, or you can include it as source.
   
   === Add as External Dependency
  
positive.code: The user manual for the latest release is at http://picocli.info.
  For the busy and impatient: there is also a link:quick-guide.html[Quick Guide].
  
  == Introduction
  Picocli aims to be the easiest way to create rich command line applications that can run on and off the JVM.
  
  Picocli is a one-file framework for creating Java command line applications with almost zero code.
  Supports a variety of command line syntax styles including POSIX, GNU, MS-DOS and more.
  Generates highly customizable usage help messages with <<ANSI Colors and Styles,ANSI colors and styles>>.
  Picocli-based applications can have link:autocomplete.html[command line TAB completion] showing available options, option parameters and subcommands, for any level of nested subcommands.
  Picocli-based applications can be ahead-of-time compiled to a image:https://www.graalvm.org/resources/img/logo-colored.svg[GraalVM]
  <<GraalVM Native Image,native image>>, with extremely fast startup time and lower memory requirements, which can be distributed as a single executable file.
  
  
  image:checksum-usage-help.png[Screenshot of usage help with Ansi codes enabled]
  
  Picocli <<Generate Man Page Documentation,generates beautiful documentation>> for your application (HTML, PDF and Unix man pages).
  
  Another distinguishing feature of picocli is how it aims
  to let users run picocli-based applications without requiring picocli as an external dependency:
  all the source code lives in a single file, to encourage application authors to include it _in source form_.
  
  How it works: annotate your class and picocli initializes it from the command line arguments,
  converting the input to strongly typed values in the fields of your class.
  
  TIP: picocli also provides a <<Programmatic API,programmatic API>>, separately from the annotations API.
  
  .A full working example picocli-based command line application
  [[CheckSum-application]]
  [source,java]
  ----
  
negative.code: import java.security.MessageDigest;
  import java.util.concurrent.Callable;
  
  @Command(name = "checksum", mixinStandardHelpOptions = true, version = "checksum 4.0", // <8>
           description = "Prints the checksum (MD5 by default) of a file to STDOUT.")
  class CheckSum implements Callable<Integer> { // <1>
  
      @Parameters(index = "0", description = "The file whose checksum to calculate.") // <2>
      private File file; // <4>
  
      @Option(names = {"-a", "--algorithm"}, description = "MD5, SHA-1, SHA-256, ...") // <3>
      private String algorithm = "MD5"; // <4>
  
      // this example implements Callable, so parsing, error handling and handling user
      // requests for usage help or version help can be done with one line of code.
      public static void main(String... args) {
          int exitCode = new CommandLine(new CheckSum()).execute(args); // <5>
          System.exit(exitCode); // <7>
      }
  
      @Override
      public Integer call() throws Exception { // your business logic // <6>
          byte[] fileContents = Files.readAllBytes(file.toPath());
          byte[] digest = MessageDigest.getInstance(algorithm).digest(fileContents);
          System.out.printf("%0" + (digest.length*2) + "x%n", new BigInteger(1, digest));
  