#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 *, ...);
int /*<<< orphan*/ stdout;
void print_help(int exit_value) {
  fprintf(stdout, "glistcompare version %u.%u.%u (%s)\n", 4, 2, 6, "stable");
  fprintf(stdout,
          "Usage: glistcompare INPUTLIST1 [INPUTLIST2...] METHOD [OPTIONS]\n");
  fprintf(stdout, "Options:\n");
  fprintf(
      stdout,
      "    -v, --version            - print version information and exit\n");
  fprintf(stdout,
          "    -h, --help               - print this usage screen and exit\n");
  fprintf(stdout, "    -u, --union              - union of input lists\n");
  fprintf(stdout,
          "    -i, --intersection       - intersection of input lists\n");
  fprintf(stdout, "    -d, --difference         - difference of input lists\n");
  fprintf(stdout,
          "    -dd, --double_difference - double difference of input lists\n");
  fprintf(stdout, "    -du, --diff_union        - subtract first list from the "
                  "second and finds difference\n");
  fprintf(stdout, "    -mm, --mismatch   NUMBER - specify number of mismatches "
                  "(default 0, can be used with -diff and -ddiff)\n");
  fprintf(
      stdout,
      "    -c, --cutoff NUMBER      - specify frequency cut-off (default 1)\n");
  fprintf(
      stdout,
      "    -o, --outputname STRING  - specify output name (default \"out\")\n");
  fprintf(
      stdout,
      "    -r, --rule STRING        - specify rule how final frequencies are "
      "calculated (default, add, subtract, min, max, first, second, 1, 2)\n");
  fprintf(stdout,
          "                               NOTE: rules min, subtract, first and "
          "second can only be used with finding the intersection.\n");
  fprintf(stdout, "    -ss, --subset METHOD SIZE - make subset with given "
                  "method (rand, rand_unique, rand_weighted_unique)\n");
  fprintf(stdout, "    --seed INTEGER           - Set seed of random number "
                  "generator (default uses start time)\n");
  fprintf(stdout, "    --count_only             - output count of k-mers "
                  "instead of k-mers themself\n");
  fprintf(stdout, "    --disable_scouts         - disable list read-ahead in "
                  "background thread\n");
  fprintf(stdout, "    --stream                 - read input as stream (do not "
                  "memory map files)\n");
  fprintf(stdout, "    -D                       - increase debug level\n");
  exit(exit_value);
}


x86 assembly (clang, -O0):
<print_help>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    0x2eae(%rip),%rax
mov    (%rax),%edi
lea    0xec5(%rip),%rsi
mov    $0x4,%edx
mov    $0x2,%ecx
mov    $0x6,%r8d
lea    0xed2(%rip),%r9
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e80(%rip),%rax
mov    (%rax),%edi
lea    0xec2(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e69(%rip),%rax
mov    (%rax),%edi
lea    0xeec(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e52(%rip),%rax
mov    (%rax),%edi
lea    0xedf(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e3b(%rip),%rax
mov    (%rax),%edi
lea    0xf0b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e24(%rip),%rax
mov    (%rax),%edi
lea    0xf35(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e0d(%rip),%rax
mov    (%rax),%edi
lea    0xf53(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2df6(%rip),%rax
mov    (%rax),%edi
lea    0xf78(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ddf(%rip),%rax
mov    (%rax),%edi
lea    0xf9b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2dc8(%rip),%rax
mov    (%rax),%edi
lea    0xfc5(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2db1(%rip),%rax
mov    (%rax),%edi
lea    0x1007(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d9a(%rip),%rax
mov    (%rax),%edi
lea    0x105c(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d83(%rip),%rax
mov    (%rax),%edi
lea    0x108b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d6c(%rip),%rax
mov    (%rax),%edi
lea    0x10b8(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d55(%rip),%rax
mov    (%rax),%edi
lea    0x112b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d3e(%rip),%rax
mov    (%rax),%edi
lea    0x1190(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d27(%rip),%rax
mov    (%rax),%edi
lea    0x11e2(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d10(%rip),%rax
mov    (%rax),%edi
lea    0x1229(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2cf9(%rip),%rax
mov    (%rax),%edi
lea    0x1264(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ce2(%rip),%rax
mov    (%rax),%edi
lea    0x129a(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ccb(%rip),%rax
mov    (%rax),%edi
lea    0x12d2(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    -0x4(%rbp),%edi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<print_help>:
push   %rbp
push   %rbx
push   %rax
mov    %edi,%ebp
mov    0x2eb4(%rip),%rbx
mov    (%rbx),%edi
lea    0xecb(%rip),%rsi
lea    0xee8(%rip),%r9
mov    $0x4,%edx
mov    $0x2,%ecx
mov    $0x6,%r8d
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xecf(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf00(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xefa(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf2d(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf5e(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf83(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfaf(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfd9(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x100a(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1053(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10af(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10e5(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1119(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1193(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11ff(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1258(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12a6(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12e8(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1325(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1364(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    %ebp,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@stdout = global i32 0
@.str = [36 x i8] c"glistcompare version %u.%u.%u (%s)\0A\00"
@.str.1 = [7 x i8] c"stable\00"
@.str.2 = [65 x i8] c"Usage: glistcompare INPUTLIST1 [INPUTLIST2...] METHOD [OPTIONS]\0A\00"
@.str.3 = [10 x i8] c"Options:\0A\00"
@.str.4 = [67 x i8] c" -v, --version - print version information and exit\0A\00"
@.str.5 = [65 x i8] c" -h, --help - print this usage screen and exit\0A\00"
@.str.6 = [53 x i8] c" -u, --union - union of input lists\0A\00"
@.str.7 = [60 x i8] c" -i, --intersection - intersection of input lists\0A\00"
@.str.8 = [58 x i8] c" -d, --difference - difference of input lists\0A\00"
@.str.9 = [65 x i8] c" -dd, --double_difference - double difference of input lists\0A\00"
@.str.10 = [89 x i8] c" -du, --diff_union - subtract first list from the second and finds difference\0A\00"
@.str.11 = [108 x i8] c" -mm, --mismatch NUMBER - specify number of mismatches (default 0, can be used with -diff and -ddiff)\0A\00"
@.str.12 = [70 x i8] c" -c, --cutoff NUMBER - specify frequency cut-off (default 1)\0A\00"
@.str.13 = [68 x i8] c" -o, --outputname STRING - specify output name (default \22out\22)\0A\00"
@.str.14 = [138 x i8] c" -r, --rule STRING - specify rule how final frequencies are calculated (default, add, subtract, min, max, first, second, 1, 2)\0A\00"
@.str.15 = [124 x i8] c" NOTE: rules min, subtract, first and second can only be used with finding the intersection.\0A\00"
@.str.16 = [105 x i8] c" -ss, --subset METHOD SIZE - make subset with given method (rand, rand_unique, rand_weighted_unique)\0A\00"
@.str.17 = [94 x i8] c" --seed INTEGER - Set seed of random number generator (default uses start time)\0A\00"
@.str.18 = [82 x i8] c" --count_only - output count of k-mers instead of k-mers themself\0A\00"
@.str.19 = [77 x i8] c" --disable_scouts - disable list read-ahead in background thread\0A\00"
@.str.20 = [79 x i8] c" --stream - read input as stream (do not memory map files)\0A\00"
@.str.21 = [53 x i8] c" -D - increase debug level\0A\00"
define void @print_help(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* @stdout
%4 = call i32 (i32, i8*, ...) @fprintf(i32 %3, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0), i32 4, i32 2, i32 6, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stdout
%6 = call i32 (i32, i8*, ...) @fprintf(i32 %5, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stdout
%8 = call i32 (i32, i8*, ...) @fprintf(i32 %7, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stdout
%10 = call i32 (i32, i8*, ...) @fprintf(i32 %9, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.4, i64 0, i64 0))
%11 = load i32, i32* @stdout
%12 = call i32 (i32, i8*, ...) @fprintf(i32 %11, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.5, i64 0, i64 0))
%13 = load i32, i32* @stdout
%14 = call i32 (i32, i8*, ...) @fprintf(i32 %13, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.6, i64 0, i64 0))
%15 = load i32, i32* @stdout
%16 = call i32 (i32, i8*, ...) @fprintf(i32 %15, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.7, i64 0, i64 0))
%17 = load i32, i32* @stdout
%18 = call i32 (i32, i8*, ...) @fprintf(i32 %17, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.8, i64 0, i64 0))
%19 = load i32, i32* @stdout
%20 = call i32 (i32, i8*, ...) @fprintf(i32 %19, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.9, i64 0, i64 0))
%21 = load i32, i32* @stdout
%22 = call i32 (i32, i8*, ...) @fprintf(i32 %21, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.10, i64 0, i64 0))
%23 = load i32, i32* @stdout
%24 = call i32 (i32, i8*, ...) @fprintf(i32 %23, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.11, i64 0, i64 0))
%25 = load i32, i32* @stdout
%26 = call i32 (i32, i8*, ...) @fprintf(i32 %25, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.12, i64 0, i64 0))
%27 = load i32, i32* @stdout
%28 = call i32 (i32, i8*, ...) @fprintf(i32 %27, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.13, i64 0, i64 0))
%29 = load i32, i32* @stdout
%30 = call i32 (i32, i8*, ...) @fprintf(i32 %29, i8* getelementptr inbounds ([138 x i8], [138 x i8]* @.str.14, i64 0, i64 0))
%31 = load i32, i32* @stdout
%32 = call i32 (i32, i8*, ...) @fprintf(i32 %31, i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.15, i64 0, i64 0))
%33 = load i32, i32* @stdout
%34 = call i32 (i32, i8*, ...) @fprintf(i32 %33, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.16, i64 0, i64 0))
%35 = load i32, i32* @stdout
%36 = call i32 (i32, i8*, ...) @fprintf(i32 %35, i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.17, i64 0, i64 0))
%37 = load i32, i32* @stdout
%38 = call i32 (i32, i8*, ...) @fprintf(i32 %37, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.18, i64 0, i64 0))
%39 = load i32, i32* @stdout
%40 = call i32 (i32, i8*, ...) @fprintf(i32 %39, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.19, i64 0, i64 0))
%41 = load i32, i32* @stdout
%42 = call i32 (i32, i8*, ...) @fprintf(i32 %41, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0))
%43 = load i32, i32* @stdout
%44 = call i32 (i32, i8*, ...) @fprintf(i32 %43, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.21, i64 0, i64 0))
%45 = load i32, i32* %2
%46 = call i32 @exit(i32 %45)
unreachable
}

LLVM IR (-O2):
@stdout = global i32 0
@.str = [36 x i8] c"glistcompare version %u.%u.%u (%s)\0A\00"
@.str.1 = [7 x i8] c"stable\00"
@.str.2 = [65 x i8] c"Usage: glistcompare INPUTLIST1 [INPUTLIST2...] METHOD [OPTIONS]\0A\00"
@.str.3 = [10 x i8] c"Options:\0A\00"
@.str.4 = [67 x i8] c" -v, --version - print version information and exit\0A\00"
@.str.5 = [65 x i8] c" -h, --help - print this usage screen and exit\0A\00"
@.str.6 = [53 x i8] c" -u, --union - union of input lists\0A\00"
@.str.7 = [60 x i8] c" -i, --intersection - intersection of input lists\0A\00"
@.str.8 = [58 x i8] c" -d, --difference - difference of input lists\0A\00"
@.str.9 = [65 x i8] c" -dd, --double_difference - double difference of input lists\0A\00"
@.str.10 = [89 x i8] c" -du, --diff_union - subtract first list from the second and finds difference\0A\00"
@.str.11 = [108 x i8] c" -mm, --mismatch NUMBER - specify number of mismatches (default 0, can be used with -diff and -ddiff)\0A\00"
@.str.12 = [70 x i8] c" -c, --cutoff NUMBER - specify frequency cut-off (default 1)\0A\00"
@.str.13 = [68 x i8] c" -o, --outputname STRING - specify output name (default \22out\22)\0A\00"
@.str.14 = [138 x i8] c" -r, --rule STRING - specify rule how final frequencies are calculated (default, add, subtract, min, max, first, second, 1, 2)\0A\00"
@.str.15 = [124 x i8] c" NOTE: rules min, subtract, first and second can only be used with finding the intersection.\0A\00"
@.str.16 = [105 x i8] c" -ss, --subset METHOD SIZE - make subset with given method (rand, rand_unique, rand_weighted_unique)\0A\00"
@.str.17 = [94 x i8] c" --seed INTEGER - Set seed of random number generator (default uses start time)\0A\00"
@.str.18 = [82 x i8] c" --count_only - output count of k-mers instead of k-mers themself\0A\00"
@.str.19 = [77 x i8] c" --disable_scouts - disable list read-ahead in background thread\0A\00"
@.str.20 = [79 x i8] c" --stream - read input as stream (do not memory map files)\0A\00"
@.str.21 = [53 x i8] c" -D - increase debug level\0A\00"
define void @print_help(i32 %0) {
%2 = load i32, i32* @stdout
%3 = tail call i32 (i32, i8*, ...) @fprintf(i32 %2, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0), i32 4, i32 2, i32 6, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%4 = load i32, i32* @stdout
%5 = tail call i32 (i32, i8*, ...) @fprintf(i32 %4, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.2, i64 0, i64 0))
%6 = load i32, i32* @stdout
%7 = tail call i32 (i32, i8*, ...) @fprintf(i32 %6, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0))
%8 = load i32, i32* @stdout
%9 = tail call i32 (i32, i8*, ...) @fprintf(i32 %8, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.4, i64 0, i64 0))
%10 = load i32, i32* @stdout
%11 = tail call i32 (i32, i8*, ...) @fprintf(i32 %10, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.5, i64 0, i64 0))
%12 = load i32, i32* @stdout
%13 = tail call i32 (i32, i8*, ...) @fprintf(i32 %12, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.6, i64 0, i64 0))
%14 = load i32, i32* @stdout
%15 = tail call i32 (i32, i8*, ...) @fprintf(i32 %14, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.7, i64 0, i64 0))
%16 = load i32, i32* @stdout
%17 = tail call i32 (i32, i8*, ...) @fprintf(i32 %16, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.8, i64 0, i64 0))
%18 = load i32, i32* @stdout
%19 = tail call i32 (i32, i8*, ...) @fprintf(i32 %18, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.9, i64 0, i64 0))
%20 = load i32, i32* @stdout
%21 = tail call i32 (i32, i8*, ...) @fprintf(i32 %20, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.10, i64 0, i64 0))
%22 = load i32, i32* @stdout
%23 = tail call i32 (i32, i8*, ...) @fprintf(i32 %22, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.11, i64 0, i64 0))
%24 = load i32, i32* @stdout
%25 = tail call i32 (i32, i8*, ...) @fprintf(i32 %24, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.12, i64 0, i64 0))
%26 = load i32, i32* @stdout
%27 = tail call i32 (i32, i8*, ...) @fprintf(i32 %26, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.13, i64 0, i64 0))
%28 = load i32, i32* @stdout
%29 = tail call i32 (i32, i8*, ...) @fprintf(i32 %28, i8* getelementptr inbounds ([138 x i8], [138 x i8]* @.str.14, i64 0, i64 0))
%30 = load i32, i32* @stdout
%31 = tail call i32 (i32, i8*, ...) @fprintf(i32 %30, i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.15, i64 0, i64 0))
%32 = load i32, i32* @stdout
%33 = tail call i32 (i32, i8*, ...) @fprintf(i32 %32, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.16, i64 0, i64 0))
%34 = load i32, i32* @stdout
%35 = tail call i32 (i32, i8*, ...) @fprintf(i32 %34, i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.17, i64 0, i64 0))
%36 = load i32, i32* @stdout
%37 = tail call i32 (i32, i8*, ...) @fprintf(i32 %36, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.18, i64 0, i64 0))
%38 = load i32, i32* @stdout
%39 = tail call i32 (i32, i8*, ...) @fprintf(i32 %38, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.19, i64 0, i64 0))
%40 = load i32, i32* @stdout
%41 = tail call i32 (i32, i8*, ...) @fprintf(i32 %40, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0))
%42 = load i32, i32* @stdout
%43 = tail call i32 (i32, i8*, ...) @fprintf(i32 %42, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.21, i64 0, i64 0))
%44 = tail call i32 @exit(i32 %0)
unreachable
}