#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
void cronsh_help(void) {
  fprintf(stderr, "NAME\n");
  fprintf(stderr, "\tcronsh - a shell for executing cron jobs\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "SYNOPSIS\n");
  fprintf(stderr, "\tcronsh -c command -h\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "DESCRIPTION\n");
  fprintf(stderr, "\tcronsh (or cronshell) is a shell for executing cron jobs. "
                  "It collects stdout, stderr, the return code, and other\n");
  fprintf(stderr,
          "\tvalues from the command it runs. At the end of executing the "
          "command, all captured data is arranged in a YAML document.\n");
  fprintf(stderr, "\tThis document will be sent to stdout, written to a file "
                  "(see CRONSH_FILE), or piped to an other command (see\n");
  fprintf(stderr, "\tCRONSH_PIPE). Set CRONSH_OPTIONS for specifying the "
                  "default behaviour.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tIn the crontab, point the SHELL environment variable to "
                  "cronsh. cron will then execute cronsh by calling\n");
  fprintf(stderr, "\tit with the -c option and the command line as its value. "
                  "The anatomy of the command line is:\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t   [executable] [arguments]? #[tag]? [options]?\n");
  fprintf(stderr, "\n");
  fprintf(stderr,
          "\tEverything after (and including) the first # will not be part of "
          "the executed command and its arguments. Directly following\n");
  fprintf(stderr,
          "\tthe # up to the first blank or the end of the line is considered "
          "as a tag for this command. Associating a tag is optional.\n");
  fprintf(stderr,
          "\tThe options for the command are inherited from CRONSH_OPTIONS and "
          "can be modified by specifying addional options. This is\n");
  fprintf(stderr, "\toptional.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tThe anatomy of the YAML is:\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t---\n");
  fprintf(stderr, "\thostname: Ingos-MacBook-Air.local                         "
                  "          - CRONSH_HOSTNAME or gethostname().\n");
  fprintf(stderr, "\tuser: ioppermann                                          "
                  "          - USER or LOGNAME.\n");
  fprintf(stderr, "\trawcommand: /usr/bin/printf 'hello world' #tag "
                  "sendto-file          - crontab command line.\n");
  fprintf(stderr, "\tcommand:                                                  "
                  "          - executed command.\n");
  fprintf(stderr, "\t  - /usr/bin/printf\n");
  fprintf(stderr, "\t  - hello world\n");
  fprintf(stderr, "\ttag: tag                                                  "
                  "          - tag as specified in rawcommand.\n");
  fprintf(stderr, "\tstarttime: 1396712280                                     "
                  "          - UNIX timestamp.\n");
  fprintf(stderr, "\truntime: 3                                                "
                  "          - runtime in milliseconds.\n");
  fprintf(stderr, "\tpid: 4471                                                 "
                  "          - PID of the excuted command.\n");
  fprintf(stderr, "\tppid: 4470                                                "
                  "          - PID of cronsh.\n");
  fprintf(stderr, "\tstatus: 0                                                 "
                  "          - exit status of executed command.\n");
  fprintf(stderr, "\tsignal: 0                                                 "
                  "          - signal that caused exiting.\n");
  fprintf(stderr, "\tstdout: hello world                                       "
                  "          - captured stdout.\n");
  fprintf(stderr, "\tstderr:                                                   "
                  "          - captured stderr.\n");
  fprintf(stderr, "\trusage:                                                   "
                  "          - the values of the rusage struct.\n");
  fprintf(stderr, "\t...\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "OPTIONS\n");
  fprintf(stderr, "\t-c command\n");
  fprintf(stderr, "\t    The command to execute.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t-V verbosity\n");
  fprintf(stderr, "\t    Sets the environment variable CRONSH_LOGLEVEL.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t-s shell\n");
  fprintf(stderr, "\t    Sets the environment variable CRONSH_SHELL.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t-l file\n");
  fprintf(stderr, "\t    Sets the environment variable CRONSH_LOG.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t-p command\n");
  fprintf(stderr, "\t    Sets the environment variable CRONSH_PIPE.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t-o options\n");
  fprintf(stderr, "\t    Sets the environment variable CRONSH_OPTIONS.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t-H hostname\n");
  fprintf(stderr, "\t    Sets the environment variable CRONSH_HOSTNAME.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\t-h\n");
  fprintf(stderr, "\t    Display the help screen.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "ENVIRONMENT\n");
  fprintf(stderr, "\tThese environment variables are recognized by cronsh and "
                  "can be set in the crontab.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tCRONSH_LOGLEVEL\n");
  fprintf(stderr, "\t    Set the logging verbosity for messages written to "
                  "CRONSH_LOG. Valid verbosity levels are:\n");
  fprintf(stderr, "\t         debug     - very verbose logging, includes warn "
                  "and critical.\n");
  fprintf(stderr,
          "\t         notice    - less verbose logging, includes critical.\n");
  fprintf(stderr, "\t         critical  - only logs events that prevent the "
                  "proper execution of cronsh.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tCRONSH_SHELL\n");
  fprintf(
      stderr,
      "\t    Path to a shell to used for executing the command. The default is "
      "/bin/sh"
      "\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tCRONSH_LOG\n");
  fprintf(stderr, "\t    Path to the file where to write log messages to.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tCRONSH_FILE\n");
  fprintf(stderr, "\t    Write the YAML document to this file if the option "
                  "'sendto-file' is given.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tCRONSH_PIPE\n");
  fprintf(stderr, "\t    Write the YAML document to STDIN of this command if "
                  "the option 'sendto-pipe' is given.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tCRONSH_OPTIONS\n");
  fprintf(stderr, "\t    Set the different options to define the default "
                  "behaviour of cronsh. The order of the\n");
  fprintf(stderr, "\t    options is crucial. Valid options are:\n");
  fprintf(stderr, "\t         silent              - nothing will be send "
                  "neither to cron, file, nor pipe.\n");
  fprintf(stderr,
          "\t         crondefault         - mimic the default cron behaviour, "
          "i.e. send the YAML to cron only if there's output.\n");
  fprintf(stderr, "\t         capture-stdout      - capture stdout.\n");
  fprintf(stderr, "\t         capture-stderr      - capture stderr.\n");
  fprintf(stderr,
          "\t         capture-all         - capture stdout and stderr.\n");
  fprintf(stderr,
          "\t         sendto-stdout       - send the YAML to stdout.\n");
  fprintf(stderr, "\t         sendto-file         - send the YAML to a file "
                  "(see CRONSH_FILE).\n");
  fprintf(stderr, "\t         sendto-pipe         - send the YAML to the pipe "
                  "(see CRONSH_PIPE).\n");
  fprintf(stderr, "\t         sendto-all          - send the YAML to cron, "
                  "file, and pipe.\n");
  fprintf(stderr,
          "\t         sendto-fallback     - try to send the YAML first to "
          "pipe, then to file, and then cron if the previous didn't work.\n");
  fprintf(stderr, "\t         sendif-status       - send the YAML only if the "
                  "return status is not 0.\n");
  fprintf(stderr, "\t         sendif-status-ok    - send the YAML only if the "
                  "return status is 0.\n");
  fprintf(
      stderr,
      "\t         sendif-status-any   - send the YAML on any return status.\n");
  fprintf(stderr, "\t         sendif-signal       - send the YAML only if the "
                  "signal status is not 0.\n");
  fprintf(stderr, "\t         sendif-signal-ok    - send the YAML only if the "
                  "signal status is 0.\n");
  fprintf(
      stderr,
      "\t         sendif-signal-any   - send the YAML on any signal status.\n");
  fprintf(stderr, "\t         sendif-stdout       - send the YAML only if "
                  "there was output to stdout.\n");
  fprintf(stderr, "\t         sendif-stdout-none  - send the YAML only if "
                  "there was no output to stdout.\n");
  fprintf(
      stderr,
      "\t         sendif-stdout-any   - send the YAML on any stdout value.\n");
  fprintf(stderr, "\t         sendif-stderr       - send the YAML only if "
                  "there was output to stderr.\n");
  fprintf(stderr, "\t         sendif-stderr-none  - send the YAML only if "
                  "there was no output to stderr.\n");
  fprintf(
      stderr,
      "\t         sendif-stderr-any   - send the YAML on any stderr value.\n");
  fprintf(stderr,
          "\t         sendif-any          - send the YAML in any case.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tCRONSH_HOSTNAME\n");
  fprintf(stderr, "\t    Override the hostname as given by gethostname().\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tUSER / LOGNAME\n");
  fprintf(stderr, "\t    The user who owns this crontab and this command will "
                  "be run as. See the man page for crontab.\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "BUGS\n");
  fprintf(stderr, "\tNo known bugs (but probably there are some).\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "AUTHOR\n");
  fprintf(stderr, "\t(c) 2014+ Ingo Oppermann\n");
  return;
}


x86 assembly (clang, -O0):
<cronsh_help>:
push   %rbp
mov    %rsp,%rbp
mov    0x3ec5(%rip),%rax
mov    (%rax),%edi
lea    0x25ad(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3eb0(%rip),%rax
mov    (%rax),%edi
lea    0xec7(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e9b(%rip),%rax
mov    (%rax),%edi
lea    0x1351(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e86(%rip),%rax
mov    (%rax),%edi
lea    0xec8(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e71(%rip),%rax
mov    (%rax),%edi
lea    0xebd(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e5c(%rip),%rax
mov    (%rax),%edi
lea    0x1312(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e47(%rip),%rax
mov    (%rax),%edi
lea    0xeaa(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e32(%rip),%rax
mov    (%rax),%edi
lea    0xea2(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e1d(%rip),%rax
mov    (%rax),%edi
lea    0xf00(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e08(%rip),%rax
mov    (%rax),%edi
lea    0xf65(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3df3(%rip),%rax
mov    (%rax),%edi
lea    0xfbf(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3dde(%rip),%rax
mov    (%rax),%edi
lea    0x1294(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3dc9(%rip),%rax
mov    (%rax),%edi
lea    0xfde(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3db4(%rip),%rax
mov    (%rax),%edi
lea    0x1034(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d9f(%rip),%rax
mov    (%rax),%edi
lea    0x1255(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d8a(%rip),%rax
mov    (%rax),%edi
lea    0x1069(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d75(%rip),%rax
mov    (%rax),%edi
lea    0x122b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d60(%rip),%rax
mov    (%rax),%edi
lea    0x1071(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d4b(%rip),%rax
mov    (%rax),%edi
lea    0x10da(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d36(%rip),%rax
mov    (%rax),%edi
lea    0x1142(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d21(%rip),%rax
mov    (%rax),%edi
lea    0x11a9(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d0c(%rip),%rax
mov    (%rax),%edi
lea    0x11c2(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3cf7(%rip),%rax
mov    (%rax),%edi
lea    0x118b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ce2(%rip),%rax
mov    (%rax),%edi
lea    0x1198(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ccd(%rip),%rax
mov    (%rax),%edi
lea    0x117f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3cb8(%rip),%rax
mov    (%rax),%edi
lea    0x1170(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ca3(%rip),%rax
mov    (%rax),%edi
lea    0x11c5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c8e(%rip),%rax
mov    (%rax),%edi
lea    0x1209(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c79(%rip),%rax
mov    (%rax),%edi
lea    0x1252(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c64(%rip),%rax
mov    (%rax),%edi
lea    0x1297(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c4f(%rip),%rax
mov    (%rax),%edi
lea    0x1298(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c3a(%rip),%rax
mov    (%rax),%edi
lea    0x1295(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c25(%rip),%rax
mov    (%rax),%edi
lea    0x12e8(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c10(%rip),%rax
mov    (%rax),%edi
lea    0x132b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bfb(%rip),%rax
mov    (%rax),%edi
lea    0x1377(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3be6(%rip),%rax
mov    (%rax),%edi
lea    0x13c6(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bd1(%rip),%rax
mov    (%rax),%edi
lea    0x1408(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bbc(%rip),%rax
mov    (%rax),%edi
lea    0x145c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ba7(%rip),%rax
mov    (%rax),%edi
lea    0x14ab(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b92(%rip),%rax
mov    (%rax),%edi
lea    0x14ef(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b7d(%rip),%rax
mov    (%rax),%edi
lea    0x1533(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b68(%rip),%rax
mov    (%rax),%edi
lea    0x1587(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b53(%rip),%rax
mov    (%rax),%edi
lea    0x1009(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b3e(%rip),%rax
mov    (%rax),%edi
lea    0x1a57(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b29(%rip),%rax
mov    (%rax),%edi
lea    0x154e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b14(%rip),%rax
mov    (%rax),%edi
lea    0x1546(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3aff(%rip),%rax
mov    (%rax),%edi
lea    0xfb5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3aea(%rip),%rax
mov    (%rax),%edi
lea    0x153a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ad5(%rip),%rax
mov    (%rax),%edi
lea    0x1534(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ac0(%rip),%rax
mov    (%rax),%edi
lea    0xf76(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3aab(%rip),%rax
mov    (%rax),%edi
lea    0x153f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a96(%rip),%rax
mov    (%rax),%edi
lea    0x1535(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a81(%rip),%rax
mov    (%rax),%edi
lea    0xf37(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a6c(%rip),%rax
mov    (%rax),%edi
lea    0x153d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a57(%rip),%rax
mov    (%rax),%edi
lea    0x1532(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a42(%rip),%rax
mov    (%rax),%edi
lea    0xef8(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a2d(%rip),%rax
mov    (%rax),%edi
lea    0x1538(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a18(%rip),%rax
mov    (%rax),%edi
lea    0x1530(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a03(%rip),%rax
mov    (%rax),%edi
lea    0xeb9(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39ee(%rip),%rax
mov    (%rax),%edi
lea    0x1537(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39d9(%rip),%rax
mov    (%rax),%edi
lea    0x152f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39c4(%rip),%rax
mov    (%rax),%edi
lea    0xe7a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39af(%rip),%rax
mov    (%rax),%edi
lea    0x1539(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x399a(%rip),%rax
mov    (%rax),%edi
lea    0x1532(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3985(%rip),%rax
mov    (%rax),%edi
lea    0xe3b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3970(%rip),%rax
mov    (%rax),%edi
lea    0x153d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x395b(%rip),%rax
mov    (%rax),%edi
lea    0x152d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3946(%rip),%rax
mov    (%rax),%edi
lea    0xdfc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3931(%rip),%rax
mov    (%rax),%edi
lea    0x1522(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x391c(%rip),%rax
mov    (%rax),%edi
lea    0x151a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3907(%rip),%rax
mov    (%rax),%edi
lea    0xdbd(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38f2(%rip),%rax
mov    (%rax),%edi
lea    0x1546(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38dd(%rip),%rax
mov    (%rax),%edi
lea    0x1543(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38c8(%rip),%rax
mov    (%rax),%edi
lea    0x158e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x38b3(%rip),%rax
mov    (%rax),%edi
lea    0x15c2(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x389e(%rip),%rax
mov    (%rax),%edi
lea    0x15ed(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3889(%rip),%rax
mov    (%rax),%edi
lea    0xd3f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3874(%rip),%rax
mov    (%rax),%edi
lea    0x1618(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x385f(%rip),%rax
mov    (%rax),%edi
lea    0x1612(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x384a(%rip),%rax
mov    (%rax),%edi
lea    0xd00(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3835(%rip),%rax
mov    (%rax),%edi
lea    0x1638(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3820(%rip),%rax
mov    (%rax),%edi
lea    0x1630(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x380b(%rip),%rax
mov    (%rax),%edi
lea    0xcc1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37f6(%rip),%rax
mov    (%rax),%edi
lea    0x163d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37e1(%rip),%rax
mov    (%rax),%edi
lea    0x1636(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37cc(%rip),%rax
mov    (%rax),%edi
lea    0xc82(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37b7(%rip),%rax
mov    (%rax),%edi
lea    0x165d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x37a2(%rip),%rax
mov    (%rax),%edi
lea    0x1656(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x378d(%rip),%rax
mov    (%rax),%edi
lea    0xc43(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3778(%rip),%rax
mov    (%rax),%edi
lea    0x1689(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3763(%rip),%rax
mov    (%rax),%edi
lea    0x1685(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x374e(%rip),%rax
mov    (%rax),%edi
lea    0x16cc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3739(%rip),%rax
mov    (%rax),%edi
lea    0x16e4(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3724(%rip),%rax
mov    (%rax),%edi
lea    0x1726(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x370f(%rip),%rax
mov    (%rax),%edi
lea    0x1787(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x36fa(%rip),%rax
mov    (%rax),%edi
lea    0x17a3(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x36e5(%rip),%rax
mov    (%rax),%edi
lea    0x17bf(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x36d0(%rip),%rax
mov    (%rax),%edi
lea    0x17e6(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x36bb(%rip),%rax
mov    (%rax),%edi
lea    0x180b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x36a6(%rip),%rax
mov    (%rax),%edi
lea    0x1842(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3691(%rip),%rax
mov    (%rax),%edi
lea    0x187b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x367c(%rip),%rax
mov    (%rax),%edi
lea    0x18ae(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3667(%rip),%rax
mov    (%rax),%edi
lea    0x1917(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3652(%rip),%rax
mov    (%rax),%edi
lea    0x1955(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x363d(%rip),%rax
mov    (%rax),%edi
lea    0x198f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3628(%rip),%rax
mov    (%rax),%edi
lea    0x19bf(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3613(%rip),%rax
mov    (%rax),%edi
lea    0x19fd(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x35fe(%rip),%rax
mov    (%rax),%edi
lea    0x1a37(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x35e9(%rip),%rax
mov    (%rax),%edi
lea    0x1a67(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x35d4(%rip),%rax
mov    (%rax),%edi
lea    0x1aa5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x35bf(%rip),%rax
mov    (%rax),%edi
lea    0x1ae6(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x35aa(%rip),%rax
mov    (%rax),%edi
lea    0x1b15(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3595(%rip),%rax
mov    (%rax),%edi
lea    0x1b53(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3580(%rip),%rax
mov    (%rax),%edi
lea    0x1b94(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x356b(%rip),%rax
mov    (%rax),%edi
lea    0x1bc3(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3556(%rip),%rax
mov    (%rax),%edi
lea    0xa0c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3541(%rip),%rax
mov    (%rax),%edi
lea    0x1bd5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x352c(%rip),%rax
mov    (%rax),%edi
lea    0x1bd2(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3517(%rip),%rax
mov    (%rax),%edi
lea    0x9cd(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3502(%rip),%rax
mov    (%rax),%edi
lea    0x1bdf(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x34ed(%rip),%rax
mov    (%rax),%edi
lea    0x1bdb(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x34d8(%rip),%rax
mov    (%rax),%edi
lea    0x98e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x34c3(%rip),%rax
mov    (%rax),%edi
lea    0x1c15(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x34ae(%rip),%rax
mov    (%rax),%edi
lea    0x1c06(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3499(%rip),%rax
mov    (%rax),%edi
lea    0x94f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3484(%rip),%rax
mov    (%rax),%edi
lea    0x1c0b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x346f(%rip),%rax
mov    (%rax),%edi
lea    0x1bfe(%rip),%rsi
call   1030 <fprintf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cronsh_help>:
push   %r14
push   %rbx
push   %rax
mov    0x3ec5(%rip),%rbx
mov    (%rbx),%edi
lea    0x25ad(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xece(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x135f(%rip),%r14
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xeda(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xed6(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xed5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xed4(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf39(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfa5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1006(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1037(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1094(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10db(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10f5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1165(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11d4(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1242(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1236(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x123c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1234(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1290(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12db(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x132b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1377(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x137f(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1383(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13dd(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1427(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x147a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14d0(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1519(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1574(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x15ca(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1615(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1660(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16bb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b9d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x169b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x169a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16a0(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16a1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16be(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16bb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16d5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16d1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16e9(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16e8(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1701(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1700(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x171c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x171c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1739(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1730(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1737(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1736(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1774(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1778(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x17ca(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1805(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1837(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1874(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1875(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x18ad(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x18ac(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x18cb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x18cb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1904(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1904(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1949(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x194c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x199a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x19b9(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1a02(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1a6a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1a8d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1ab0(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1ade(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b0a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b48(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b88(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1bc2(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1c32(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1c77(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1cb8(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1cef(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1d34(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1d75(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1dac(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1df1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1e39(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1e6f(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1eb4(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1efc(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f32(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f56(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f5a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f79(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f7c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1fc8(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1fc0(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1fd7(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1fd1(%rip),%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1030 <fprintf@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [6 x i8] c"NAME\0A\00"
@.str.1 = [43 x i8] c"\09cronsh - a shell for executing cron jobs\0A\00"
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [10 x i8] c"SYNOPSIS\0A\00"
@.str.4 = [23 x i8] c"\09cronsh -c command -h\0A\00"
@.str.5 = [13 x i8] c"DESCRIPTION\0A\00"
@.str.6 = [115 x i8] c"\09cronsh (or cronshell) is a shell for executing cron jobs. It collects stdout, stderr, the return code, and other\0A\00"
@.str.7 = [122 x i8] c"\09values from the command it runs. At the end of executing the command, all captured data is arranged in a YAML document.\0A\00"
@.str.8 = [111 x i8] c"\09This document will be sent to stdout, written to a file (see CRONSH_FILE), or piped to an other command (see\0A\00"
@.str.9 = [73 x i8] c"\09CRONSH_PIPE). Set CRONSH_OPTIONS for specifying the default behaviour.\0A\00"
@.str.10 = [107 x i8] c"\09In the crontab, point the SHELL environment variable to cronsh. cron will then execute cronsh by calling\0A\00"
@.str.11 = [95 x i8] c"\09it with the -c option and the command line as its value. The anatomy of the command line is:\0A\00"
@.str.12 = [50 x i8] c"\09 [executable] [arguments]? #[tag]? [options]?\0A\00"
@.str.13 = [126 x i8] c"\09Everything after (and including) the first # will not be part of the executed command and its arguments. Directly following\0A\00"
@.str.14 = [125 x i8] c"\09the # up to the first blank or the end of the line is considered as a tag for this command. Associating a tag is optional.\0A\00"
@.str.15 = [124 x i8] c"\09The options for the command are inherited from CRONSH_OPTIONS and can be modified by specifying addional options. This is\0A\00"
@.str.16 = [12 x i8] c"\09optional.\0A\00"
@.str.17 = [30 x i8] c"\09The anatomy of the YAML is:\0A\00"
@.str.18 = [6 x i8] c"\09---\0A\00"
@.str.19 = [106 x i8] c"\09hostname: Ingos-MacBook-Air.local - CRONSH_HOSTNAME or gethostname().\0A\00"
@.str.20 = [89 x i8] c"\09user: ioppermann - USER or LOGNAME.\0A\00"
@.str.21 = [94 x i8] c"\09rawcommand: /usr/bin/printf 'hello world' #tag sendto-file - crontab command line.\0A\00"
@.str.22 = [90 x i8] c"\09command: - executed command.\0A\00"
@.str.23 = [22 x i8] c"\09 - /usr/bin/printf\0A\00"
@.str.24 = [18 x i8] c"\09 - hello world\0A\00"
@.str.25 = [104 x i8] c"\09tag: tag - tag as specified in rawcommand.\0A\00"
@.str.26 = [88 x i8] c"\09starttime: 1396712280 - UNIX timestamp.\0A\00"
@.str.27 = [97 x i8] c"\09runtime: 3 - runtime in milliseconds.\0A\00"
@.str.28 = [100 x i8] c"\09pid: 4471 - PID of the excuted command.\0A\00"
@.str.29 = [87 x i8] c"\09ppid: 4470 - PID of cronsh.\0A\00"
@.str.30 = [105 x i8] c"\09status: 0 - exit status of executed command.\0A\00"
@.str.31 = [100 x i8] c"\09signal: 0 - signal that caused exiting.\0A\00"
@.str.32 = [89 x i8] c"\09stdout: hello world - captured stdout.\0A\00"
@.str.33 = [89 x i8] c"\09stderr: - captured stderr.\0A\00"
@.str.34 = [105 x i8] c"\09rusage: - the values of the rusage struct.\0A\00"
@.str.35 = [6 x i8] c"\09...\0A\00"
@.str.36 = [9 x i8] c"OPTIONS\0A\00"
@.str.37 = [13 x i8] c"\09-c command\0A\00"
@.str.38 = [30 x i8] c"\09 The command to execute.\0A\00"
@.str.39 = [15 x i8] c"\09-V verbosity\0A\00"
@.str.40 = [53 x i8] c"\09 Sets the environment variable CRONSH_LOGLEVEL.\0A\00"
@.str.41 = [11 x i8] c"\09-s shell\0A\00"
@.str.42 = [50 x i8] c"\09 Sets the environment variable CRONSH_SHELL.\0A\00"
@.str.43 = [10 x i8] c"\09-l file\0A\00"
@.str.44 = [48 x i8] c"\09 Sets the environment variable CRONSH_LOG.\0A\00"
@.str.45 = [13 x i8] c"\09-p command\0A\00"
@.str.46 = [49 x i8] c"\09 Sets the environment variable CRONSH_PIPE.\0A\00"
@.str.47 = [13 x i8] c"\09-o options\0A\00"
@.str.48 = [52 x i8] c"\09 Sets the environment variable CRONSH_OPTIONS.\0A\00"
@.str.49 = [14 x i8] c"\09-H hostname\0A\00"
@.str.50 = [53 x i8] c"\09 Sets the environment variable CRONSH_HOSTNAME.\0A\00"
@.str.51 = [5 x i8] c"\09-h\0A\00"
@.str.52 = [31 x i8] c"\09 Display the help screen.\0A\00"
@.str.53 = [13 x i8] c"ENVIRONMENT\0A\00"
@.str.54 = [86 x i8] c"\09These environment variables are recognized by cronsh and can be set in the crontab.\0A\00"
@.str.55 = [18 x i8] c"\09CRONSH_LOGLEVEL\0A\00"
@.str.56 = [96 x i8] c"\09 Set the logging verbosity for messages written to CRONSH_LOG. Valid verbosity levels are:\0A\00"
@.str.57 = [73 x i8] c"\09 debug - very verbose logging, includes warn and critical.\0A\00"
@.str.58 = [64 x i8] c"\09 notice - less verbose logging, includes critical.\0A\00"
@.str.59 = [85 x i8] c"\09 critical - only logs events that prevent the proper execution of cronsh.\0A\00"
@.str.60 = [15 x i8] c"\09CRONSH_SHELL\0A\00"
@.str.61 = [80 x i8] c"\09 Path to a shell to used for executing the command. The default is /bin/sh\0A\00"
@.str.62 = [13 x i8] c"\09CRONSH_LOG\0A\00"
@.str.63 = [55 x i8] c"\09 Path to the file where to write log messages to.\0A\00"
@.str.64 = [14 x i8] c"\09CRONSH_FILE\0A\00"
@.str.65 = [81 x i8] c"\09 Write the YAML document to this file if the option 'sendto-file' is given.\0A\00"
@.str.66 = [14 x i8] c"\09CRONSH_PIPE\0A\00"
@.str.67 = [93 x i8] c"\09 Write the YAML document to STDIN of this command if the option 'sendto-pipe' is given.\0A\00"
@.str.68 = [17 x i8] c"\09CRONSH_OPTIONS\0A\00"
@.str.69 = [92 x i8] c"\09 Set the different options to define the default behaviour of cronsh. The order of the\0A\00"
@.str.70 = [45 x i8] c"\09 options is crucial. Valid options are:\0A\00"
@.str.71 = [87 x i8] c"\09 silent - nothing will be send neither to cron, file, nor pipe.\0A\00"
@.str.72 = [118 x i8] c"\09 crondefault - mimic the default cron behaviour, i.e. send the YAML to cron only if there's output.\0A\00"
@.str.73 = [49 x i8] c"\09 capture-stdout - capture stdout.\0A\00"
@.str.74 = [49 x i8] c"\09 capture-stderr - capture stderr.\0A\00"
@.str.75 = [60 x i8] c"\09 capture-all - capture stdout and stderr.\0A\00"
@.str.76 = [58 x i8] c"\09 sendto-stdout - send the YAML to stdout.\0A\00"
@.str.77 = [76 x i8] c"\09 sendto-file - send the YAML to a file (see CRONSH_FILE).\0A\00"
@.str.78 = [78 x i8] c"\09 sendto-pipe - send the YAML to the pipe (see CRONSH_PIPE).\0A\00"
@.str.79 = [72 x i8] c"\09 sendto-all - send the YAML to cron, file, and pipe.\0A\00"
@.str.80 = [126 x i8] c"\09 sendto-fallback - try to send the YAML first to pipe, then to file, and then cron if the previous didn't work.\0A\00"
@.str.81 = [83 x i8] c"\09 sendif-status - send the YAML only if the return status is not 0.\0A\00"
@.str.82 = [79 x i8] c"\09 sendif-status-ok - send the YAML only if the return status is 0.\0A\00"
@.str.83 = [69 x i8] c"\09 sendif-status-any - send the YAML on any return status.\0A\00"
@.str.84 = [83 x i8] c"\09 sendif-signal - send the YAML only if the signal status is not 0.\0A\00"
@.str.85 = [79 x i8] c"\09 sendif-signal-ok - send the YAML only if the signal status is 0.\0A\00"
@.str.86 = [69 x i8] c"\09 sendif-signal-any - send the YAML on any signal status.\0A\00"
@.str.87 = [83 x i8] c"\09 sendif-stdout - send the YAML only if there was output to stdout.\0A\00"
@.str.88 = [86 x i8] c"\09 sendif-stdout-none - send the YAML only if there was no output to stdout.\0A\00"
@.str.89 = [68 x i8] c"\09 sendif-stdout-any - send the YAML on any stdout value.\0A\00"
@.str.90 = [83 x i8] c"\09 sendif-stderr - send the YAML only if there was output to stderr.\0A\00"
@.str.91 = [86 x i8] c"\09 sendif-stderr-none - send the YAML only if there was no output to stderr.\0A\00"
@.str.92 = [68 x i8] c"\09 sendif-stderr-any - send the YAML on any stderr value.\0A\00"
@.str.93 = [60 x i8] c"\09 sendif-any - send the YAML in any case.\0A\00"
@.str.94 = [18 x i8] c"\09CRONSH_HOSTNAME\0A\00"
@.str.95 = [55 x i8] c"\09 Override the hostname as given by gethostname().\0A\00"
@.str.96 = [17 x i8] c"\09USER / LOGNAME\0A\00"
@.str.97 = [100 x i8] c"\09 The user who owns this crontab and this command will be run as. See the man page for crontab.\0A\00"
@.str.98 = [6 x i8] c"BUGS\0A\00"
@.str.99 = [47 x i8] c"\09No known bugs (but probably there are some).\0A\00"
@.str.100 = [8 x i8] c"AUTHOR\0A\00"
@.str.101 = [27 x i8] c"\09(c) 2014+ Ingo Oppermann\0A\00"
define void @cronsh_help() {
%1 = load i32, i32* @stderr
%2 = call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([115 x i8], [115 x i8]* @.str.6, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([122 x i8], [122 x i8]* @.str.7, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([111 x i8], [111 x i8]* @.str.8, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.9, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.10, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.11, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.12, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([126 x i8], [126 x i8]* @.str.13, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([125 x i8], [125 x i8]* @.str.14, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.15, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.16, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.17, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.18, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.19, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.20, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.21, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.22, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.23, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.24, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.25, i64 0, i64 0))
%65 = load i32, i32* @stderr
%66 = call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.26, i64 0, i64 0))
%67 = load i32, i32* @stderr
%68 = call i32 @fprintf(i32 %67, i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.27, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = call i32 @fprintf(i32 %69, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.28, i64 0, i64 0))
%71 = load i32, i32* @stderr
%72 = call i32 @fprintf(i32 %71, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.29, i64 0, i64 0))
%73 = load i32, i32* @stderr
%74 = call i32 @fprintf(i32 %73, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.30, i64 0, i64 0))
%75 = load i32, i32* @stderr
%76 = call i32 @fprintf(i32 %75, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.31, i64 0, i64 0))
%77 = load i32, i32* @stderr
%78 = call i32 @fprintf(i32 %77, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.32, i64 0, i64 0))
%79 = load i32, i32* @stderr
%80 = call i32 @fprintf(i32 %79, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.33, i64 0, i64 0))
%81 = load i32, i32* @stderr
%82 = call i32 @fprintf(i32 %81, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.34, i64 0, i64 0))
%83 = load i32, i32* @stderr
%84 = call i32 @fprintf(i32 %83, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.35, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = call i32 @fprintf(i32 %85, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%87 = load i32, i32* @stderr
%88 = call i32 @fprintf(i32 %87, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.36, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.37, i64 0, i64 0))
%91 = load i32, i32* @stderr
%92 = call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.38, i64 0, i64 0))
%93 = load i32, i32* @stderr
%94 = call i32 @fprintf(i32 %93, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%95 = load i32, i32* @stderr
%96 = call i32 @fprintf(i32 %95, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.39, i64 0, i64 0))
%97 = load i32, i32* @stderr
%98 = call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.40, i64 0, i64 0))
%99 = load i32, i32* @stderr
%100 = call i32 @fprintf(i32 %99, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%101 = load i32, i32* @stderr
%102 = call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.41, i64 0, i64 0))
%103 = load i32, i32* @stderr
%104 = call i32 @fprintf(i32 %103, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.42, i64 0, i64 0))
%105 = load i32, i32* @stderr
%106 = call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%107 = load i32, i32* @stderr
%108 = call i32 @fprintf(i32 %107, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.43, i64 0, i64 0))
%109 = load i32, i32* @stderr
%110 = call i32 @fprintf(i32 %109, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.44, i64 0, i64 0))
%111 = load i32, i32* @stderr
%112 = call i32 @fprintf(i32 %111, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%113 = load i32, i32* @stderr
%114 = call i32 @fprintf(i32 %113, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.45, i64 0, i64 0))
%115 = load i32, i32* @stderr
%116 = call i32 @fprintf(i32 %115, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.46, i64 0, i64 0))
%117 = load i32, i32* @stderr
%118 = call i32 @fprintf(i32 %117, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%119 = load i32, i32* @stderr
%120 = call i32 @fprintf(i32 %119, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.47, i64 0, i64 0))
%121 = load i32, i32* @stderr
%122 = call i32 @fprintf(i32 %121, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.48, i64 0, i64 0))
%123 = load i32, i32* @stderr
%124 = call i32 @fprintf(i32 %123, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%125 = load i32, i32* @stderr
%126 = call i32 @fprintf(i32 %125, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.49, i64 0, i64 0))
%127 = load i32, i32* @stderr
%128 = call i32 @fprintf(i32 %127, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.50, i64 0, i64 0))
%129 = load i32, i32* @stderr
%130 = call i32 @fprintf(i32 %129, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%131 = load i32, i32* @stderr
%132 = call i32 @fprintf(i32 %131, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.51, i64 0, i64 0))
%133 = load i32, i32* @stderr
%134 = call i32 @fprintf(i32 %133, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.52, i64 0, i64 0))
%135 = load i32, i32* @stderr
%136 = call i32 @fprintf(i32 %135, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%137 = load i32, i32* @stderr
%138 = call i32 @fprintf(i32 %137, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.53, i64 0, i64 0))
%139 = load i32, i32* @stderr
%140 = call i32 @fprintf(i32 %139, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.54, i64 0, i64 0))
%141 = load i32, i32* @stderr
%142 = call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%143 = load i32, i32* @stderr
%144 = call i32 @fprintf(i32 %143, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.55, i64 0, i64 0))
%145 = load i32, i32* @stderr
%146 = call i32 @fprintf(i32 %145, i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str.56, i64 0, i64 0))
%147 = load i32, i32* @stderr
%148 = call i32 @fprintf(i32 %147, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.57, i64 0, i64 0))
%149 = load i32, i32* @stderr
%150 = call i32 @fprintf(i32 %149, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.58, i64 0, i64 0))
%151 = load i32, i32* @stderr
%152 = call i32 @fprintf(i32 %151, i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.59, i64 0, i64 0))
%153 = load i32, i32* @stderr
%154 = call i32 @fprintf(i32 %153, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%155 = load i32, i32* @stderr
%156 = call i32 @fprintf(i32 %155, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.60, i64 0, i64 0))
%157 = load i32, i32* @stderr
%158 = call i32 @fprintf(i32 %157, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.61, i64 0, i64 0))
%159 = load i32, i32* @stderr
%160 = call i32 @fprintf(i32 %159, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%161 = load i32, i32* @stderr
%162 = call i32 @fprintf(i32 %161, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.62, i64 0, i64 0))
%163 = load i32, i32* @stderr
%164 = call i32 @fprintf(i32 %163, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.63, i64 0, i64 0))
%165 = load i32, i32* @stderr
%166 = call i32 @fprintf(i32 %165, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%167 = load i32, i32* @stderr
%168 = call i32 @fprintf(i32 %167, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.64, i64 0, i64 0))
%169 = load i32, i32* @stderr
%170 = call i32 @fprintf(i32 %169, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.65, i64 0, i64 0))
%171 = load i32, i32* @stderr
%172 = call i32 @fprintf(i32 %171, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%173 = load i32, i32* @stderr
%174 = call i32 @fprintf(i32 %173, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.66, i64 0, i64 0))
%175 = load i32, i32* @stderr
%176 = call i32 @fprintf(i32 %175, i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.67, i64 0, i64 0))
%177 = load i32, i32* @stderr
%178 = call i32 @fprintf(i32 %177, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%179 = load i32, i32* @stderr
%180 = call i32 @fprintf(i32 %179, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.68, i64 0, i64 0))
%181 = load i32, i32* @stderr
%182 = call i32 @fprintf(i32 %181, i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.69, i64 0, i64 0))
%183 = load i32, i32* @stderr
%184 = call i32 @fprintf(i32 %183, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.70, i64 0, i64 0))
%185 = load i32, i32* @stderr
%186 = call i32 @fprintf(i32 %185, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.71, i64 0, i64 0))
%187 = load i32, i32* @stderr
%188 = call i32 @fprintf(i32 %187, i8* getelementptr inbounds ([118 x i8], [118 x i8]* @.str.72, i64 0, i64 0))
%189 = load i32, i32* @stderr
%190 = call i32 @fprintf(i32 %189, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.73, i64 0, i64 0))
%191 = load i32, i32* @stderr
%192 = call i32 @fprintf(i32 %191, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.74, i64 0, i64 0))
%193 = load i32, i32* @stderr
%194 = call i32 @fprintf(i32 %193, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.75, i64 0, i64 0))
%195 = load i32, i32* @stderr
%196 = call i32 @fprintf(i32 %195, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.76, i64 0, i64 0))
%197 = load i32, i32* @stderr
%198 = call i32 @fprintf(i32 %197, i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.77, i64 0, i64 0))
%199 = load i32, i32* @stderr
%200 = call i32 @fprintf(i32 %199, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.78, i64 0, i64 0))
%201 = load i32, i32* @stderr
%202 = call i32 @fprintf(i32 %201, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.79, i64 0, i64 0))
%203 = load i32, i32* @stderr
%204 = call i32 @fprintf(i32 %203, i8* getelementptr inbounds ([126 x i8], [126 x i8]* @.str.80, i64 0, i64 0))
%205 = load i32, i32* @stderr
%206 = call i32 @fprintf(i32 %205, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.81, i64 0, i64 0))
%207 = load i32, i32* @stderr
%208 = call i32 @fprintf(i32 %207, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.82, i64 0, i64 0))
%209 = load i32, i32* @stderr
%210 = call i32 @fprintf(i32 %209, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.83, i64 0, i64 0))
%211 = load i32, i32* @stderr
%212 = call i32 @fprintf(i32 %211, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.84, i64 0, i64 0))
%213 = load i32, i32* @stderr
%214 = call i32 @fprintf(i32 %213, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.85, i64 0, i64 0))
%215 = load i32, i32* @stderr
%216 = call i32 @fprintf(i32 %215, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.86, i64 0, i64 0))
%217 = load i32, i32* @stderr
%218 = call i32 @fprintf(i32 %217, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.87, i64 0, i64 0))
%219 = load i32, i32* @stderr
%220 = call i32 @fprintf(i32 %219, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.88, i64 0, i64 0))
%221 = load i32, i32* @stderr
%222 = call i32 @fprintf(i32 %221, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.89, i64 0, i64 0))
%223 = load i32, i32* @stderr
%224 = call i32 @fprintf(i32 %223, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.90, i64 0, i64 0))
%225 = load i32, i32* @stderr
%226 = call i32 @fprintf(i32 %225, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.91, i64 0, i64 0))
%227 = load i32, i32* @stderr
%228 = call i32 @fprintf(i32 %227, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.92, i64 0, i64 0))
%229 = load i32, i32* @stderr
%230 = call i32 @fprintf(i32 %229, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.93, i64 0, i64 0))
%231 = load i32, i32* @stderr
%232 = call i32 @fprintf(i32 %231, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%233 = load i32, i32* @stderr
%234 = call i32 @fprintf(i32 %233, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.94, i64 0, i64 0))
%235 = load i32, i32* @stderr
%236 = call i32 @fprintf(i32 %235, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.95, i64 0, i64 0))
%237 = load i32, i32* @stderr
%238 = call i32 @fprintf(i32 %237, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%239 = load i32, i32* @stderr
%240 = call i32 @fprintf(i32 %239, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.96, i64 0, i64 0))
%241 = load i32, i32* @stderr
%242 = call i32 @fprintf(i32 %241, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.97, i64 0, i64 0))
%243 = load i32, i32* @stderr
%244 = call i32 @fprintf(i32 %243, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%245 = load i32, i32* @stderr
%246 = call i32 @fprintf(i32 %245, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.98, i64 0, i64 0))
%247 = load i32, i32* @stderr
%248 = call i32 @fprintf(i32 %247, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.99, i64 0, i64 0))
%249 = load i32, i32* @stderr
%250 = call i32 @fprintf(i32 %249, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%251 = load i32, i32* @stderr
%252 = call i32 @fprintf(i32 %251, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.100, i64 0, i64 0))
%253 = load i32, i32* @stderr
%254 = call i32 @fprintf(i32 %253, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.101, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [6 x i8] c"NAME\0A\00"
@.str.1 = [43 x i8] c"\09cronsh - a shell for executing cron jobs\0A\00"
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [10 x i8] c"SYNOPSIS\0A\00"
@.str.4 = [23 x i8] c"\09cronsh -c command -h\0A\00"
@.str.5 = [13 x i8] c"DESCRIPTION\0A\00"
@.str.6 = [115 x i8] c"\09cronsh (or cronshell) is a shell for executing cron jobs. It collects stdout, stderr, the return code, and other\0A\00"
@.str.7 = [122 x i8] c"\09values from the command it runs. At the end of executing the command, all captured data is arranged in a YAML document.\0A\00"
@.str.8 = [111 x i8] c"\09This document will be sent to stdout, written to a file (see CRONSH_FILE), or piped to an other command (see\0A\00"
@.str.9 = [73 x i8] c"\09CRONSH_PIPE). Set CRONSH_OPTIONS for specifying the default behaviour.\0A\00"
@.str.10 = [107 x i8] c"\09In the crontab, point the SHELL environment variable to cronsh. cron will then execute cronsh by calling\0A\00"
@.str.11 = [95 x i8] c"\09it with the -c option and the command line as its value. The anatomy of the command line is:\0A\00"
@.str.12 = [50 x i8] c"\09 [executable] [arguments]? #[tag]? [options]?\0A\00"
@.str.13 = [126 x i8] c"\09Everything after (and including) the first # will not be part of the executed command and its arguments. Directly following\0A\00"
@.str.14 = [125 x i8] c"\09the # up to the first blank or the end of the line is considered as a tag for this command. Associating a tag is optional.\0A\00"
@.str.15 = [124 x i8] c"\09The options for the command are inherited from CRONSH_OPTIONS and can be modified by specifying addional options. This is\0A\00"
@.str.16 = [12 x i8] c"\09optional.\0A\00"
@.str.17 = [30 x i8] c"\09The anatomy of the YAML is:\0A\00"
@.str.18 = [6 x i8] c"\09---\0A\00"
@.str.19 = [106 x i8] c"\09hostname: Ingos-MacBook-Air.local - CRONSH_HOSTNAME or gethostname().\0A\00"
@.str.20 = [89 x i8] c"\09user: ioppermann - USER or LOGNAME.\0A\00"
@.str.21 = [94 x i8] c"\09rawcommand: /usr/bin/printf 'hello world' #tag sendto-file - crontab command line.\0A\00"
@.str.22 = [90 x i8] c"\09command: - executed command.\0A\00"
@.str.23 = [22 x i8] c"\09 - /usr/bin/printf\0A\00"
@.str.24 = [18 x i8] c"\09 - hello world\0A\00"
@.str.25 = [104 x i8] c"\09tag: tag - tag as specified in rawcommand.\0A\00"
@.str.26 = [88 x i8] c"\09starttime: 1396712280 - UNIX timestamp.\0A\00"
@.str.27 = [97 x i8] c"\09runtime: 3 - runtime in milliseconds.\0A\00"
@.str.28 = [100 x i8] c"\09pid: 4471 - PID of the excuted command.\0A\00"
@.str.29 = [87 x i8] c"\09ppid: 4470 - PID of cronsh.\0A\00"
@.str.30 = [105 x i8] c"\09status: 0 - exit status of executed command.\0A\00"
@.str.31 = [100 x i8] c"\09signal: 0 - signal that caused exiting.\0A\00"
@.str.32 = [89 x i8] c"\09stdout: hello world - captured stdout.\0A\00"
@.str.33 = [89 x i8] c"\09stderr: - captured stderr.\0A\00"
@.str.34 = [105 x i8] c"\09rusage: - the values of the rusage struct.\0A\00"
@.str.35 = [6 x i8] c"\09...\0A\00"
@.str.36 = [9 x i8] c"OPTIONS\0A\00"
@.str.37 = [13 x i8] c"\09-c command\0A\00"
@.str.38 = [30 x i8] c"\09 The command to execute.\0A\00"
@.str.39 = [15 x i8] c"\09-V verbosity\0A\00"
@.str.40 = [53 x i8] c"\09 Sets the environment variable CRONSH_LOGLEVEL.\0A\00"
@.str.41 = [11 x i8] c"\09-s shell\0A\00"
@.str.42 = [50 x i8] c"\09 Sets the environment variable CRONSH_SHELL.\0A\00"
@.str.43 = [10 x i8] c"\09-l file\0A\00"
@.str.44 = [48 x i8] c"\09 Sets the environment variable CRONSH_LOG.\0A\00"
@.str.45 = [13 x i8] c"\09-p command\0A\00"
@.str.46 = [49 x i8] c"\09 Sets the environment variable CRONSH_PIPE.\0A\00"
@.str.47 = [13 x i8] c"\09-o options\0A\00"
@.str.48 = [52 x i8] c"\09 Sets the environment variable CRONSH_OPTIONS.\0A\00"
@.str.49 = [14 x i8] c"\09-H hostname\0A\00"
@.str.50 = [53 x i8] c"\09 Sets the environment variable CRONSH_HOSTNAME.\0A\00"
@.str.51 = [5 x i8] c"\09-h\0A\00"
@.str.52 = [31 x i8] c"\09 Display the help screen.\0A\00"
@.str.53 = [13 x i8] c"ENVIRONMENT\0A\00"
@.str.54 = [86 x i8] c"\09These environment variables are recognized by cronsh and can be set in the crontab.\0A\00"
@.str.55 = [18 x i8] c"\09CRONSH_LOGLEVEL\0A\00"
@.str.56 = [96 x i8] c"\09 Set the logging verbosity for messages written to CRONSH_LOG. Valid verbosity levels are:\0A\00"
@.str.57 = [73 x i8] c"\09 debug - very verbose logging, includes warn and critical.\0A\00"
@.str.58 = [64 x i8] c"\09 notice - less verbose logging, includes critical.\0A\00"
@.str.59 = [85 x i8] c"\09 critical - only logs events that prevent the proper execution of cronsh.\0A\00"
@.str.60 = [15 x i8] c"\09CRONSH_SHELL\0A\00"
@.str.61 = [80 x i8] c"\09 Path to a shell to used for executing the command. The default is /bin/sh\0A\00"
@.str.62 = [13 x i8] c"\09CRONSH_LOG\0A\00"
@.str.63 = [55 x i8] c"\09 Path to the file where to write log messages to.\0A\00"
@.str.64 = [14 x i8] c"\09CRONSH_FILE\0A\00"
@.str.65 = [81 x i8] c"\09 Write the YAML document to this file if the option 'sendto-file' is given.\0A\00"
@.str.66 = [14 x i8] c"\09CRONSH_PIPE\0A\00"
@.str.67 = [93 x i8] c"\09 Write the YAML document to STDIN of this command if the option 'sendto-pipe' is given.\0A\00"
@.str.68 = [17 x i8] c"\09CRONSH_OPTIONS\0A\00"
@.str.69 = [92 x i8] c"\09 Set the different options to define the default behaviour of cronsh. The order of the\0A\00"
@.str.70 = [45 x i8] c"\09 options is crucial. Valid options are:\0A\00"
@.str.71 = [87 x i8] c"\09 silent - nothing will be send neither to cron, file, nor pipe.\0A\00"
@.str.72 = [118 x i8] c"\09 crondefault - mimic the default cron behaviour, i.e. send the YAML to cron only if there's output.\0A\00"
@.str.73 = [49 x i8] c"\09 capture-stdout - capture stdout.\0A\00"
@.str.74 = [49 x i8] c"\09 capture-stderr - capture stderr.\0A\00"
@.str.75 = [60 x i8] c"\09 capture-all - capture stdout and stderr.\0A\00"
@.str.76 = [58 x i8] c"\09 sendto-stdout - send the YAML to stdout.\0A\00"
@.str.77 = [76 x i8] c"\09 sendto-file - send the YAML to a file (see CRONSH_FILE).\0A\00"
@.str.78 = [78 x i8] c"\09 sendto-pipe - send the YAML to the pipe (see CRONSH_PIPE).\0A\00"
@.str.79 = [72 x i8] c"\09 sendto-all - send the YAML to cron, file, and pipe.\0A\00"
@.str.80 = [126 x i8] c"\09 sendto-fallback - try to send the YAML first to pipe, then to file, and then cron if the previous didn't work.\0A\00"
@.str.81 = [83 x i8] c"\09 sendif-status - send the YAML only if the return status is not 0.\0A\00"
@.str.82 = [79 x i8] c"\09 sendif-status-ok - send the YAML only if the return status is 0.\0A\00"
@.str.83 = [69 x i8] c"\09 sendif-status-any - send the YAML on any return status.\0A\00"
@.str.84 = [83 x i8] c"\09 sendif-signal - send the YAML only if the signal status is not 0.\0A\00"
@.str.85 = [79 x i8] c"\09 sendif-signal-ok - send the YAML only if the signal status is 0.\0A\00"
@.str.86 = [69 x i8] c"\09 sendif-signal-any - send the YAML on any signal status.\0A\00"
@.str.87 = [83 x i8] c"\09 sendif-stdout - send the YAML only if there was output to stdout.\0A\00"
@.str.88 = [86 x i8] c"\09 sendif-stdout-none - send the YAML only if there was no output to stdout.\0A\00"
@.str.89 = [68 x i8] c"\09 sendif-stdout-any - send the YAML on any stdout value.\0A\00"
@.str.90 = [83 x i8] c"\09 sendif-stderr - send the YAML only if there was output to stderr.\0A\00"
@.str.91 = [86 x i8] c"\09 sendif-stderr-none - send the YAML only if there was no output to stderr.\0A\00"
@.str.92 = [68 x i8] c"\09 sendif-stderr-any - send the YAML on any stderr value.\0A\00"
@.str.93 = [60 x i8] c"\09 sendif-any - send the YAML in any case.\0A\00"
@.str.94 = [18 x i8] c"\09CRONSH_HOSTNAME\0A\00"
@.str.95 = [55 x i8] c"\09 Override the hostname as given by gethostname().\0A\00"
@.str.96 = [17 x i8] c"\09USER / LOGNAME\0A\00"
@.str.97 = [100 x i8] c"\09 The user who owns this crontab and this command will be run as. See the man page for crontab.\0A\00"
@.str.98 = [6 x i8] c"BUGS\0A\00"
@.str.99 = [47 x i8] c"\09No known bugs (but probably there are some).\0A\00"
@.str.100 = [8 x i8] c"AUTHOR\0A\00"
@.str.101 = [27 x i8] c"\09(c) 2014+ Ingo Oppermann\0A\00"
define void @cronsh_help() {
%1 = load i32, i32* @stderr
%2 = tail call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = tail call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = tail call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.4, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = tail call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = tail call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = tail call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([115 x i8], [115 x i8]* @.str.6, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = tail call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([122 x i8], [122 x i8]* @.str.7, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = tail call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([111 x i8], [111 x i8]* @.str.8, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = tail call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.9, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = tail call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = tail call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.10, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = tail call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.11, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = tail call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = tail call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.12, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = tail call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = tail call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([126 x i8], [126 x i8]* @.str.13, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = tail call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([125 x i8], [125 x i8]* @.str.14, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = tail call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.15, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = tail call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.16, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = tail call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = tail call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.17, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = tail call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = tail call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.18, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = tail call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.19, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = tail call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.20, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = tail call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.21, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = tail call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.22, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = tail call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.23, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = tail call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.24, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = tail call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.25, i64 0, i64 0))
%65 = load i32, i32* @stderr
%66 = tail call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.26, i64 0, i64 0))
%67 = load i32, i32* @stderr
%68 = tail call i32 @fprintf(i32 %67, i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.27, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = tail call i32 @fprintf(i32 %69, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.28, i64 0, i64 0))
%71 = load i32, i32* @stderr
%72 = tail call i32 @fprintf(i32 %71, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.29, i64 0, i64 0))
%73 = load i32, i32* @stderr
%74 = tail call i32 @fprintf(i32 %73, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.30, i64 0, i64 0))
%75 = load i32, i32* @stderr
%76 = tail call i32 @fprintf(i32 %75, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.31, i64 0, i64 0))
%77 = load i32, i32* @stderr
%78 = tail call i32 @fprintf(i32 %77, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.32, i64 0, i64 0))
%79 = load i32, i32* @stderr
%80 = tail call i32 @fprintf(i32 %79, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.33, i64 0, i64 0))
%81 = load i32, i32* @stderr
%82 = tail call i32 @fprintf(i32 %81, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.34, i64 0, i64 0))
%83 = load i32, i32* @stderr
%84 = tail call i32 @fprintf(i32 %83, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.35, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = tail call i32 @fprintf(i32 %85, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%87 = load i32, i32* @stderr
%88 = tail call i32 @fprintf(i32 %87, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.36, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = tail call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.37, i64 0, i64 0))
%91 = load i32, i32* @stderr
%92 = tail call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.38, i64 0, i64 0))
%93 = load i32, i32* @stderr
%94 = tail call i32 @fprintf(i32 %93, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%95 = load i32, i32* @stderr
%96 = tail call i32 @fprintf(i32 %95, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.39, i64 0, i64 0))
%97 = load i32, i32* @stderr
%98 = tail call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.40, i64 0, i64 0))
%99 = load i32, i32* @stderr
%100 = tail call i32 @fprintf(i32 %99, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%101 = load i32, i32* @stderr
%102 = tail call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.41, i64 0, i64 0))
%103 = load i32, i32* @stderr
%104 = tail call i32 @fprintf(i32 %103, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.42, i64 0, i64 0))
%105 = load i32, i32* @stderr
%106 = tail call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%107 = load i32, i32* @stderr
%108 = tail call i32 @fprintf(i32 %107, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.43, i64 0, i64 0))
%109 = load i32, i32* @stderr
%110 = tail call i32 @fprintf(i32 %109, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.44, i64 0, i64 0))
%111 = load i32, i32* @stderr
%112 = tail call i32 @fprintf(i32 %111, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%113 = load i32, i32* @stderr
%114 = tail call i32 @fprintf(i32 %113, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.45, i64 0, i64 0))
%115 = load i32, i32* @stderr
%116 = tail call i32 @fprintf(i32 %115, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.46, i64 0, i64 0))
%117 = load i32, i32* @stderr
%118 = tail call i32 @fprintf(i32 %117, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%119 = load i32, i32* @stderr
%120 = tail call i32 @fprintf(i32 %119, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.47, i64 0, i64 0))
%121 = load i32, i32* @stderr
%122 = tail call i32 @fprintf(i32 %121, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.48, i64 0, i64 0))
%123 = load i32, i32* @stderr
%124 = tail call i32 @fprintf(i32 %123, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%125 = load i32, i32* @stderr
%126 = tail call i32 @fprintf(i32 %125, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.49, i64 0, i64 0))
%127 = load i32, i32* @stderr
%128 = tail call i32 @fprintf(i32 %127, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.50, i64 0, i64 0))
%129 = load i32, i32* @stderr
%130 = tail call i32 @fprintf(i32 %129, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%131 = load i32, i32* @stderr
%132 = tail call i32 @fprintf(i32 %131, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.51, i64 0, i64 0))
%133 = load i32, i32* @stderr
%134 = tail call i32 @fprintf(i32 %133, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.52, i64 0, i64 0))
%135 = load i32, i32* @stderr
%136 = tail call i32 @fprintf(i32 %135, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%137 = load i32, i32* @stderr
%138 = tail call i32 @fprintf(i32 %137, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.53, i64 0, i64 0))
%139 = load i32, i32* @stderr
%140 = tail call i32 @fprintf(i32 %139, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.54, i64 0, i64 0))
%141 = load i32, i32* @stderr
%142 = tail call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%143 = load i32, i32* @stderr
%144 = tail call i32 @fprintf(i32 %143, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.55, i64 0, i64 0))
%145 = load i32, i32* @stderr
%146 = tail call i32 @fprintf(i32 %145, i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str.56, i64 0, i64 0))
%147 = load i32, i32* @stderr
%148 = tail call i32 @fprintf(i32 %147, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.57, i64 0, i64 0))
%149 = load i32, i32* @stderr
%150 = tail call i32 @fprintf(i32 %149, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.58, i64 0, i64 0))
%151 = load i32, i32* @stderr
%152 = tail call i32 @fprintf(i32 %151, i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.59, i64 0, i64 0))
%153 = load i32, i32* @stderr
%154 = tail call i32 @fprintf(i32 %153, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%155 = load i32, i32* @stderr
%156 = tail call i32 @fprintf(i32 %155, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.60, i64 0, i64 0))
%157 = load i32, i32* @stderr
%158 = tail call i32 @fprintf(i32 %157, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.61, i64 0, i64 0))
%159 = load i32, i32* @stderr
%160 = tail call i32 @fprintf(i32 %159, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%161 = load i32, i32* @stderr
%162 = tail call i32 @fprintf(i32 %161, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.62, i64 0, i64 0))
%163 = load i32, i32* @stderr
%164 = tail call i32 @fprintf(i32 %163, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.63, i64 0, i64 0))
%165 = load i32, i32* @stderr
%166 = tail call i32 @fprintf(i32 %165, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%167 = load i32, i32* @stderr
%168 = tail call i32 @fprintf(i32 %167, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.64, i64 0, i64 0))
%169 = load i32, i32* @stderr
%170 = tail call i32 @fprintf(i32 %169, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.65, i64 0, i64 0))
%171 = load i32, i32* @stderr
%172 = tail call i32 @fprintf(i32 %171, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%173 = load i32, i32* @stderr
%174 = tail call i32 @fprintf(i32 %173, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.66, i64 0, i64 0))
%175 = load i32, i32* @stderr
%176 = tail call i32 @fprintf(i32 %175, i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.67, i64 0, i64 0))
%177 = load i32, i32* @stderr
%178 = tail call i32 @fprintf(i32 %177, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%179 = load i32, i32* @stderr
%180 = tail call i32 @fprintf(i32 %179, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.68, i64 0, i64 0))
%181 = load i32, i32* @stderr
%182 = tail call i32 @fprintf(i32 %181, i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.69, i64 0, i64 0))
%183 = load i32, i32* @stderr
%184 = tail call i32 @fprintf(i32 %183, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.70, i64 0, i64 0))
%185 = load i32, i32* @stderr
%186 = tail call i32 @fprintf(i32 %185, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.71, i64 0, i64 0))
%187 = load i32, i32* @stderr
%188 = tail call i32 @fprintf(i32 %187, i8* getelementptr inbounds ([118 x i8], [118 x i8]* @.str.72, i64 0, i64 0))
%189 = load i32, i32* @stderr
%190 = tail call i32 @fprintf(i32 %189, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.73, i64 0, i64 0))
%191 = load i32, i32* @stderr
%192 = tail call i32 @fprintf(i32 %191, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.74, i64 0, i64 0))
%193 = load i32, i32* @stderr
%194 = tail call i32 @fprintf(i32 %193, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.75, i64 0, i64 0))
%195 = load i32, i32* @stderr
%196 = tail call i32 @fprintf(i32 %195, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.76, i64 0, i64 0))
%197 = load i32, i32* @stderr
%198 = tail call i32 @fprintf(i32 %197, i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.77, i64 0, i64 0))
%199 = load i32, i32* @stderr
%200 = tail call i32 @fprintf(i32 %199, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.78, i64 0, i64 0))
%201 = load i32, i32* @stderr
%202 = tail call i32 @fprintf(i32 %201, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.79, i64 0, i64 0))
%203 = load i32, i32* @stderr
%204 = tail call i32 @fprintf(i32 %203, i8* getelementptr inbounds ([126 x i8], [126 x i8]* @.str.80, i64 0, i64 0))
%205 = load i32, i32* @stderr
%206 = tail call i32 @fprintf(i32 %205, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.81, i64 0, i64 0))
%207 = load i32, i32* @stderr
%208 = tail call i32 @fprintf(i32 %207, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.82, i64 0, i64 0))
%209 = load i32, i32* @stderr
%210 = tail call i32 @fprintf(i32 %209, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.83, i64 0, i64 0))
%211 = load i32, i32* @stderr
%212 = tail call i32 @fprintf(i32 %211, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.84, i64 0, i64 0))
%213 = load i32, i32* @stderr
%214 = tail call i32 @fprintf(i32 %213, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.85, i64 0, i64 0))
%215 = load i32, i32* @stderr
%216 = tail call i32 @fprintf(i32 %215, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.86, i64 0, i64 0))
%217 = load i32, i32* @stderr
%218 = tail call i32 @fprintf(i32 %217, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.87, i64 0, i64 0))
%219 = load i32, i32* @stderr
%220 = tail call i32 @fprintf(i32 %219, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.88, i64 0, i64 0))
%221 = load i32, i32* @stderr
%222 = tail call i32 @fprintf(i32 %221, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.89, i64 0, i64 0))
%223 = load i32, i32* @stderr
%224 = tail call i32 @fprintf(i32 %223, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.90, i64 0, i64 0))
%225 = load i32, i32* @stderr
%226 = tail call i32 @fprintf(i32 %225, i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.91, i64 0, i64 0))
%227 = load i32, i32* @stderr
%228 = tail call i32 @fprintf(i32 %227, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.92, i64 0, i64 0))
%229 = load i32, i32* @stderr
%230 = tail call i32 @fprintf(i32 %229, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.93, i64 0, i64 0))
%231 = load i32, i32* @stderr
%232 = tail call i32 @fprintf(i32 %231, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%233 = load i32, i32* @stderr
%234 = tail call i32 @fprintf(i32 %233, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.94, i64 0, i64 0))
%235 = load i32, i32* @stderr
%236 = tail call i32 @fprintf(i32 %235, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.95, i64 0, i64 0))
%237 = load i32, i32* @stderr
%238 = tail call i32 @fprintf(i32 %237, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%239 = load i32, i32* @stderr
%240 = tail call i32 @fprintf(i32 %239, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.96, i64 0, i64 0))
%241 = load i32, i32* @stderr
%242 = tail call i32 @fprintf(i32 %241, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.97, i64 0, i64 0))
%243 = load i32, i32* @stderr
%244 = tail call i32 @fprintf(i32 %243, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%245 = load i32, i32* @stderr
%246 = tail call i32 @fprintf(i32 %245, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.98, i64 0, i64 0))
%247 = load i32, i32* @stderr
%248 = tail call i32 @fprintf(i32 %247, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.99, i64 0, i64 0))
%249 = load i32, i32* @stderr
%250 = tail call i32 @fprintf(i32 %249, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%251 = load i32, i32* @stderr
%252 = tail call i32 @fprintf(i32 %251, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.100, i64 0, i64 0))
%253 = load i32, i32* @stderr
%254 = tail call i32 @fprintf(i32 %253, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.101, i64 0, i64 0))
ret void
}