#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char const *);
int /*<<< orphan*/ fputs(char *, int /*<<< orphan*/);
int /*<<< orphan*/ stderr;
void usage(const char *progname) {
  fprintf(stderr,
          "\nusage: %s [-f <input-format>] [-e <input-encoding>] [-l [1|0]] "
          "[-p [1|0]]\n"
          "          [-F <output-format>] [-E <output-encoding>] [-L [1|0]] "
          "[-P [1|0]]\n"
          "          [-q] [-s] [--] [<input-file> [<output-file>]]\n\n",
          progname);
  fputs("Description:\n", stderr);
  fputs("Transforms CIF data among CIF formats and dialects.\n"
        "If no input file is specified, or if input is specified as \"-\", "
        "then input\n"
        "is read from the standard input, else it is from the specified file.  "
        "If no\n"
        "output file is specified, or if output is specified as \"-\", then "
        "output is\n"
        "directed to the standard output, else it goes to the specified "
        "file.\n\n",
        stderr);
  fputs("Options that take boolean arguments (described as 1|0 in the synopsis "
        "and option\n"
        "descriptions) will also accept arguments 'yes', 'true', 'no', and "
        "'false'.\n\n",
        stderr);
  fputs("Options:\n", stderr);
  fputs("  -e <encoding>, --input-encoding=<encoding>\n"
        "          Specifies the input character encoding.  If given as "
        "\"auto\" (the\n"
        "          default) then the program attempts to determine the "
        "encoding from the\n"
        "          input and falls back to a format- and system-specific "
        "default if it is\n",
        stderr);
  fputs("          unable to do so.  Otherwise, the encoding names recognized "
        "are system-\n"
        "          dependent, but they take the form of IANA names and "
        "aliases.  The specified\n"
        "          encoding will be used, even for CIF 2.0 format input (even "
        "though the CIF 2.0\n"
        "          specifications permit only UTF-8).\n\n",
        stderr);
  fputs("  -E <encoding>, --output-encoding=<encoding>\n"
        "          Specifies the output character encoding.  If given as "
        "\"auto\" (the\n"
        "          default) then the program chooses an encoding in a format- "
        "and system-specific\n"
        "          way.  Otherwise, the encoding names recognized are system-\n"
        "          dependent, but they take the form of IANA names and "
        "aliases.  The specified\n"
        "          encoding will be used, even for CIF 2.0 format output (even "
        "though the CIF 2.0\n"
        "          specifications permit only UTF-8).\n\n",
        stderr);
  fputs("  -f <format>, --input-format=<format>\n"
        "          Specifies the input format.  The formats supported are "
        "\"auto\" (the\n"
        "          program guesses; this is the default), \"cif10\" (the "
        "program assumes\n"
        "          CIF 1.0), \"cif11\" (the program assumes CIF 1.1), and "
        "\"cif20\" (the\n"
        "          program assumes CIF 2.0).  A format (other than auto) "
        "specified via this\n"
        "          option overrides any contradictory indications in the file "
        "itself.\n\n",
        stderr);
  fputs("  -F <format>, --output-format=<format>\n"
        "          Specifies the output format.  The formats supported are "
        "\"cif11\" (the\n"
        "          program emits CIF 1.1 format) and \"cif20\" (the program "
        "emits CIF 2.0\n"
        "          format; this is the default).\n\n",
        stderr);
  fputs("  -l 1|0, --input-line-folding=1|0\n"
        "          Specifies whether to recognize and decode the CIF "
        "line-folding protocol\n"
        "          in text fields in the the input.  Defaults to 1 (yes).\n\n",
        stderr);
  fputs("  -L 1|0, --output-line-folding=1|0\n"
        "          Specifies whether to allow line folding of text fields in "
        "the output.\n"
        "          The program chooses automatically, on a field-by-field "
        "basis, whether\n"
        "          to perform folding.  Defaults to 1 (yes).\n\n",
        stderr);
  fputs("  -p 0|1, --input-text-prefixing=0|1\n"
        "          Specifies whether to recognize and decode the CIF "
        "text-prefixing protocol\n"
        "          in text fields in the the input.  Defaults to 1 (yes).\n\n",
        stderr);
  fputs("  -P 0|1, --output-text-prefixing=0|1\n"
        "          Specifies whether to allow line prefixing of text fields in "
        "the output.\n"
        "          The program chooses automatically, on a field-by-field "
        "basis, whether\n"
        "          to perform prefixing.  Defaults to 1 (yes).\n\n",
        stderr);
  fputs("  -q      This option suppresses diagnostic output.  The exit status "
        "will still\n"
        "          provide a general idea of the program's success.\n\n",
        stderr);
  fputs("  -s      This option instructs the program to insist that the input "
        "data strictly\n"
        "          conform to the chosen CIF format.  Any error will cause the "
        "program to\n"
        "          terminate prematurely.  If this option is not given then "
        "the program will\n"
        "          instead make a best effort at reading and processing the "
        "input despite\n"
        "          any errors it may encounter.  Such error recovery efforts "
        "are inherently\n"
        "          uncertain, however, and sometimes lossy.\n\n",
        stderr);
  fputs("  --      Indicates the end of the option arguments.  Any subsequent "
        "arguments are\n"
        "          interpreted as file names.\n\n",
        stderr);
  fputs(
      "Exit Status:\n"
      "The program exits with status 0 if the input was parsed without any "
      "error and\n"
      "successfully transformed.  It exits with status 1 if parse errors were "
      "detected,\n"
      "but the program nevertheless consumed the entire input and produced a\n"
      "transformation.  It exits with status 2 if no parse was attempted.  It "
      "exits with\n"
      "status 3 if parse or transformation is interrupted prior to the full "
      "input being\n"
      "consumed.\n\n",
      stderr);
  exit(2);
}


x86 assembly (clang, -O0):
<usage>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    0x3e9d(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0xeb0(%rip),%rsi
call   1040 <fprintf@plt>
mov    0x3e84(%rip),%rax
mov    (%rax),%esi
lea    0xf6c(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3e6f(%rip),%rax
mov    (%rax),%esi
lea    0xf65(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3e5a(%rip),%rax
mov    (%rax),%esi
lea    0x10ad(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3e45(%rip),%rax
mov    (%rax),%esi
lea    0x1136(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3e30(%rip),%rax
mov    (%rax),%esi
lea    0x112b(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3e1b(%rip),%rax
mov    (%rax),%esi
lea    0x1230(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3e06(%rip),%rax
mov    (%rax),%esi
lea    0x1349(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3df1(%rip),%rax
mov    (%rax),%esi
lea    0x152a(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3ddc(%rip),%rax
mov    (%rax),%esi
lea    0x16c5(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3dc7(%rip),%rax
mov    (%rax),%esi
lea    0x17a0(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3db2(%rip),%rax
mov    (%rax),%esi
lea    0x1843(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3d9d(%rip),%rax
mov    (%rax),%esi
lea    0x1928(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3d88(%rip),%rax
mov    (%rax),%esi
lea    0x19cf(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3d73(%rip),%rax
mov    (%rax),%esi
lea    0x1aba(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3d5e(%rip),%rax
mov    (%rax),%esi
lea    0x1b32(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3d49(%rip),%rax
mov    (%rax),%esi
lea    0x1cee(%rip),%rdi
call   1030 <fputs@plt>
mov    0x3d34(%rip),%rax
mov    (%rax),%esi
lea    0x1d53(%rip),%rdi
call   1030 <fputs@plt>
mov    $0x2,%edi
call   1050 <exit@plt>

x86 assembly (clang, -O2):
<usage>:
push   %rbx
mov    %rdi,%rdx
mov    0x3ea5(%rip),%rbx
mov    (%rbx),%edi
lea    0xebc(%rip),%rsi
call   1040 <fprintf@plt>
mov    (%rbx),%esi
lea    0xf7f(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0xf7f(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x10ce(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x115e(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x115a(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1266(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1386(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x156e(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1710(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x17f2(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x189c(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1988(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1a36(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1b28(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1ba7(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1d6a(%rip),%rdi
call   1030 <fputs@plt>
mov    (%rbx),%esi
lea    0x1dd6(%rip),%rdi
call   1030 <fputs@plt>
mov    $0x2,%edi
call   1050 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [209 x i8] c"\0Ausage: %s [-f <input-format>] [-e <input-encoding>] [-l [1|0]] [-p [1|0]]\0A [-F <output-format>] [-E <output-encoding>] [-L [1|0]] [-P [1|0]]\0A [-q] [-s] [--] [<input-file> [<output-file>]]\0A\0A\00"
@.str.1 = [14 x i8] c"Description:\0A\00"
@.str.2 = [349 x i8] c"Transforms CIF data among CIF formats and dialects.\0AIf no input file is specified, or if input is specified as \22-\22, then input\0Ais read from the standard input, else it is from the specified file. If no\0Aoutput file is specified, or if output is specified as \22-\22, then output is\0Adirected to the standard output, else it goes to the specified file.\0A\0A\00"
@.str.3 = [158 x i8] c"Options that take boolean arguments (described as 1|0 in the synopsis and option\0Adescriptions) will also accept arguments 'yes', 'true', 'no', and 'false'.\0A\0A\00"
@.str.4 = [10 x i8] c"Options:\0A\00"
@.str.5 = [282 x i8] c" -e <encoding>, --input-encoding=<encoding>\0A Specifies the input character encoding. If given as \22auto\22 (the\0A default) then the program attempts to determine the encoding from the\0A input and falls back to a format- and system-specific default if it is\0A\00"
@.str.6 = [302 x i8] c" unable to do so. Otherwise, the encoding names recognized are system-\0A dependent, but they take the form of IANA names and aliases. The specified\0A encoding will be used, even for CIF 2.0 format input (even though the CIF 2.0\0A specifications permit only UTF-8).\0A\0A\00"
@.str.7 = [502 x i8] c" -E <encoding>, --output-encoding=<encoding>\0A Specifies the output character encoding. If given as \22auto\22 (the\0A default) then the program chooses an encoding in a format- and system-specific\0A way. Otherwise, the encoding names recognized are system-\0A dependent, but they take the form of IANA names and aliases. The specified\0A encoding will be used, even for CIF 2.0 format output (even though the CIF 2.0\0A specifications permit only UTF-8).\0A\0A\00"
@.str.8 = [432 x i8] c" -f <format>, --input-format=<format>\0A Specifies the input format. The formats supported are \22auto\22 (the\0A program guesses; this is the default), \22cif10\22 (the program assumes\0A CIF 1.0), \22cif11\22 (the program assumes CIF 1.1), and \22cif20\22 (the\0A program assumes CIF 2.0). A format (other than auto) specified via this\0A option overrides any contradictory indications in the file itself.\0A\0A\00"
@.str.9 = [240 x i8] c" -F <format>, --output-format=<format>\0A Specifies the output format. The formats supported are \22cif11\22 (the\0A program emits CIF 1.1 format) and \22cif20\22 (the program emits CIF 2.0\0A format; this is the default).\0A\0A\00"
@.str.10 = [184 x i8] c" -l 1|0, --input-line-folding=1|0\0A Specifies whether to recognize and decode the CIF line-folding protocol\0A in text fields in the the input. Defaults to 1 (yes).\0A\0A\00"
@.str.11 = [250 x i8] c" -L 1|0, --output-line-folding=1|0\0A Specifies whether to allow line folding of text fields in the output.\0A The program chooses automatically, on a field-by-field basis, whether\0A to perform folding. Defaults to 1 (yes).\0A\0A\00"
@.str.12 = [188 x i8] c" -p 0|1, --input-text-prefixing=0|1\0A Specifies whether to recognize and decode the CIF text-prefixing protocol\0A in text fields in the the input. Defaults to 1 (yes).\0A\0A\00"
@.str.13 = [256 x i8] c" -P 0|1, --output-text-prefixing=0|1\0A Specifies whether to allow line prefixing of text fields in the output.\0A The program chooses automatically, on a field-by-field basis, whether\0A to perform prefixing. Defaults to 1 (yes).\0A\0A\00"
@.str.14 = [141 x i8] c" -q This option suppresses diagnostic output. The exit status will still\0A provide a general idea of the program's success.\0A\0A\00"
@.str.15 = [465 x i8] c" -s This option instructs the program to insist that the input data strictly\0A conform to the chosen CIF format. Any error will cause the program to\0A terminate prematurely. If this option is not given then the program will\0A instead make a best effort at reading and processing the input despite\0A any errors it may encounter. Such error recovery efforts are inherently\0A uncertain, however, and sometimes lossy.\0A\0A\00"
@.str.16 = [122 x i8] c" -- Indicates the end of the option arguments. Any subsequent arguments are\0A interpreted as file names.\0A\0A\00"
@.str.17 = [417 x i8] c"Exit Status:\0AThe program exits with status 0 if the input was parsed without any error and\0Asuccessfully transformed. It exits with status 1 if parse errors were detected,\0Abut the program nevertheless consumed the entire input and produced a\0Atransformation. It exits with status 2 if no parse was attempted. It exits with\0Astatus 3 if parse or transformation is interrupted prior to the full input being\0Aconsumed.\0A\0A\00"
define void @usage(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i32, i32* @stderr
%4 = load i8*, i8** %2
%5 = call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([209 x i8], [209 x i8]* @.str, i64 0, i64 0), i8* %4)
%6 = load i32, i32* @stderr
%7 = call i32 @fputs(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), i32 %6)
%8 = load i32, i32* @stderr
%9 = call i32 @fputs(i8* getelementptr inbounds ([349 x i8], [349 x i8]* @.str.2, i64 0, i64 0), i32 %8)
%10 = load i32, i32* @stderr
%11 = call i32 @fputs(i8* getelementptr inbounds ([158 x i8], [158 x i8]* @.str.3, i64 0, i64 0), i32 %10)
%12 = load i32, i32* @stderr
%13 = call i32 @fputs(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0), i32 %12)
%14 = load i32, i32* @stderr
%15 = call i32 @fputs(i8* getelementptr inbounds ([282 x i8], [282 x i8]* @.str.5, i64 0, i64 0), i32 %14)
%16 = load i32, i32* @stderr
%17 = call i32 @fputs(i8* getelementptr inbounds ([302 x i8], [302 x i8]* @.str.6, i64 0, i64 0), i32 %16)
%18 = load i32, i32* @stderr
%19 = call i32 @fputs(i8* getelementptr inbounds ([502 x i8], [502 x i8]* @.str.7, i64 0, i64 0), i32 %18)
%20 = load i32, i32* @stderr
%21 = call i32 @fputs(i8* getelementptr inbounds ([432 x i8], [432 x i8]* @.str.8, i64 0, i64 0), i32 %20)
%22 = load i32, i32* @stderr
%23 = call i32 @fputs(i8* getelementptr inbounds ([240 x i8], [240 x i8]* @.str.9, i64 0, i64 0), i32 %22)
%24 = load i32, i32* @stderr
%25 = call i32 @fputs(i8* getelementptr inbounds ([184 x i8], [184 x i8]* @.str.10, i64 0, i64 0), i32 %24)
%26 = load i32, i32* @stderr
%27 = call i32 @fputs(i8* getelementptr inbounds ([250 x i8], [250 x i8]* @.str.11, i64 0, i64 0), i32 %26)
%28 = load i32, i32* @stderr
%29 = call i32 @fputs(i8* getelementptr inbounds ([188 x i8], [188 x i8]* @.str.12, i64 0, i64 0), i32 %28)
%30 = load i32, i32* @stderr
%31 = call i32 @fputs(i8* getelementptr inbounds ([256 x i8], [256 x i8]* @.str.13, i64 0, i64 0), i32 %30)
%32 = load i32, i32* @stderr
%33 = call i32 @fputs(i8* getelementptr inbounds ([141 x i8], [141 x i8]* @.str.14, i64 0, i64 0), i32 %32)
%34 = load i32, i32* @stderr
%35 = call i32 @fputs(i8* getelementptr inbounds ([465 x i8], [465 x i8]* @.str.15, i64 0, i64 0), i32 %34)
%36 = load i32, i32* @stderr
%37 = call i32 @fputs(i8* getelementptr inbounds ([122 x i8], [122 x i8]* @.str.16, i64 0, i64 0), i32 %36)
%38 = load i32, i32* @stderr
%39 = call i32 @fputs(i8* getelementptr inbounds ([417 x i8], [417 x i8]* @.str.17, i64 0, i64 0), i32 %38)
%40 = call i32 @exit(i32 2)
unreachable
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [209 x i8] c"\0Ausage: %s [-f <input-format>] [-e <input-encoding>] [-l [1|0]] [-p [1|0]]\0A [-F <output-format>] [-E <output-encoding>] [-L [1|0]] [-P [1|0]]\0A [-q] [-s] [--] [<input-file> [<output-file>]]\0A\0A\00"
@.str.1 = [14 x i8] c"Description:\0A\00"
@.str.2 = [349 x i8] c"Transforms CIF data among CIF formats and dialects.\0AIf no input file is specified, or if input is specified as \22-\22, then input\0Ais read from the standard input, else it is from the specified file. If no\0Aoutput file is specified, or if output is specified as \22-\22, then output is\0Adirected to the standard output, else it goes to the specified file.\0A\0A\00"
@.str.3 = [158 x i8] c"Options that take boolean arguments (described as 1|0 in the synopsis and option\0Adescriptions) will also accept arguments 'yes', 'true', 'no', and 'false'.\0A\0A\00"
@.str.4 = [10 x i8] c"Options:\0A\00"
@.str.5 = [282 x i8] c" -e <encoding>, --input-encoding=<encoding>\0A Specifies the input character encoding. If given as \22auto\22 (the\0A default) then the program attempts to determine the encoding from the\0A input and falls back to a format- and system-specific default if it is\0A\00"
@.str.6 = [302 x i8] c" unable to do so. Otherwise, the encoding names recognized are system-\0A dependent, but they take the form of IANA names and aliases. The specified\0A encoding will be used, even for CIF 2.0 format input (even though the CIF 2.0\0A specifications permit only UTF-8).\0A\0A\00"
@.str.7 = [502 x i8] c" -E <encoding>, --output-encoding=<encoding>\0A Specifies the output character encoding. If given as \22auto\22 (the\0A default) then the program chooses an encoding in a format- and system-specific\0A way. Otherwise, the encoding names recognized are system-\0A dependent, but they take the form of IANA names and aliases. The specified\0A encoding will be used, even for CIF 2.0 format output (even though the CIF 2.0\0A specifications permit only UTF-8).\0A\0A\00"
@.str.8 = [432 x i8] c" -f <format>, --input-format=<format>\0A Specifies the input format. The formats supported are \22auto\22 (the\0A program guesses; this is the default), \22cif10\22 (the program assumes\0A CIF 1.0), \22cif11\22 (the program assumes CIF 1.1), and \22cif20\22 (the\0A program assumes CIF 2.0). A format (other than auto) specified via this\0A option overrides any contradictory indications in the file itself.\0A\0A\00"
@.str.9 = [240 x i8] c" -F <format>, --output-format=<format>\0A Specifies the output format. The formats supported are \22cif11\22 (the\0A program emits CIF 1.1 format) and \22cif20\22 (the program emits CIF 2.0\0A format; this is the default).\0A\0A\00"
@.str.10 = [184 x i8] c" -l 1|0, --input-line-folding=1|0\0A Specifies whether to recognize and decode the CIF line-folding protocol\0A in text fields in the the input. Defaults to 1 (yes).\0A\0A\00"
@.str.11 = [250 x i8] c" -L 1|0, --output-line-folding=1|0\0A Specifies whether to allow line folding of text fields in the output.\0A The program chooses automatically, on a field-by-field basis, whether\0A to perform folding. Defaults to 1 (yes).\0A\0A\00"
@.str.12 = [188 x i8] c" -p 0|1, --input-text-prefixing=0|1\0A Specifies whether to recognize and decode the CIF text-prefixing protocol\0A in text fields in the the input. Defaults to 1 (yes).\0A\0A\00"
@.str.13 = [256 x i8] c" -P 0|1, --output-text-prefixing=0|1\0A Specifies whether to allow line prefixing of text fields in the output.\0A The program chooses automatically, on a field-by-field basis, whether\0A to perform prefixing. Defaults to 1 (yes).\0A\0A\00"
@.str.14 = [141 x i8] c" -q This option suppresses diagnostic output. The exit status will still\0A provide a general idea of the program's success.\0A\0A\00"
@.str.15 = [465 x i8] c" -s This option instructs the program to insist that the input data strictly\0A conform to the chosen CIF format. Any error will cause the program to\0A terminate prematurely. If this option is not given then the program will\0A instead make a best effort at reading and processing the input despite\0A any errors it may encounter. Such error recovery efforts are inherently\0A uncertain, however, and sometimes lossy.\0A\0A\00"
@.str.16 = [122 x i8] c" -- Indicates the end of the option arguments. Any subsequent arguments are\0A interpreted as file names.\0A\0A\00"
@.str.17 = [417 x i8] c"Exit Status:\0AThe program exits with status 0 if the input was parsed without any error and\0Asuccessfully transformed. It exits with status 1 if parse errors were detected,\0Abut the program nevertheless consumed the entire input and produced a\0Atransformation. It exits with status 2 if no parse was attempted. It exits with\0Astatus 3 if parse or transformation is interrupted prior to the full input being\0Aconsumed.\0A\0A\00"
define void @usage(i8* %0) {
%2 = load i32, i32* @stderr
%3 = tail call i32 @fprintf(i32 %2, i8* getelementptr inbounds ([209 x i8], [209 x i8]* @.str, i64 0, i64 0), i8* %0)
%4 = load i32, i32* @stderr
%5 = tail call i32 @fputs(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), i32 %4)
%6 = load i32, i32* @stderr
%7 = tail call i32 @fputs(i8* getelementptr inbounds ([349 x i8], [349 x i8]* @.str.2, i64 0, i64 0), i32 %6)
%8 = load i32, i32* @stderr
%9 = tail call i32 @fputs(i8* getelementptr inbounds ([158 x i8], [158 x i8]* @.str.3, i64 0, i64 0), i32 %8)
%10 = load i32, i32* @stderr
%11 = tail call i32 @fputs(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0), i32 %10)
%12 = load i32, i32* @stderr
%13 = tail call i32 @fputs(i8* getelementptr inbounds ([282 x i8], [282 x i8]* @.str.5, i64 0, i64 0), i32 %12)
%14 = load i32, i32* @stderr
%15 = tail call i32 @fputs(i8* getelementptr inbounds ([302 x i8], [302 x i8]* @.str.6, i64 0, i64 0), i32 %14)
%16 = load i32, i32* @stderr
%17 = tail call i32 @fputs(i8* getelementptr inbounds ([502 x i8], [502 x i8]* @.str.7, i64 0, i64 0), i32 %16)
%18 = load i32, i32* @stderr
%19 = tail call i32 @fputs(i8* getelementptr inbounds ([432 x i8], [432 x i8]* @.str.8, i64 0, i64 0), i32 %18)
%20 = load i32, i32* @stderr
%21 = tail call i32 @fputs(i8* getelementptr inbounds ([240 x i8], [240 x i8]* @.str.9, i64 0, i64 0), i32 %20)
%22 = load i32, i32* @stderr
%23 = tail call i32 @fputs(i8* getelementptr inbounds ([184 x i8], [184 x i8]* @.str.10, i64 0, i64 0), i32 %22)
%24 = load i32, i32* @stderr
%25 = tail call i32 @fputs(i8* getelementptr inbounds ([250 x i8], [250 x i8]* @.str.11, i64 0, i64 0), i32 %24)
%26 = load i32, i32* @stderr
%27 = tail call i32 @fputs(i8* getelementptr inbounds ([188 x i8], [188 x i8]* @.str.12, i64 0, i64 0), i32 %26)
%28 = load i32, i32* @stderr
%29 = tail call i32 @fputs(i8* getelementptr inbounds ([256 x i8], [256 x i8]* @.str.13, i64 0, i64 0), i32 %28)
%30 = load i32, i32* @stderr
%31 = tail call i32 @fputs(i8* getelementptr inbounds ([141 x i8], [141 x i8]* @.str.14, i64 0, i64 0), i32 %30)
%32 = load i32, i32* @stderr
%33 = tail call i32 @fputs(i8* getelementptr inbounds ([465 x i8], [465 x i8]* @.str.15, i64 0, i64 0), i32 %32)
%34 = load i32, i32* @stderr
%35 = tail call i32 @fputs(i8* getelementptr inbounds ([122 x i8], [122 x i8]* @.str.16, i64 0, i64 0), i32 %34)
%36 = load i32, i32* @stderr
%37 = tail call i32 @fputs(i8* getelementptr inbounds ([417 x i8], [417 x i8]* @.str.17, i64 0, i64 0), i32 %36)
%38 = tail call i32 @exit(i32 2)
unreachable
}