#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 */
typedef int /*<<< orphan*/ str;
typedef int /*<<< orphan*/ buf2;
typedef int /*<<< orphan*/ buf;
typedef int /*<<< orphan*/ bigone;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char const *const, ...);
int /*<<< orphan*/ hex_dump(char const *, int, char *, int);
int /*<<< orphan*/ stderr;
scalar_t__ strcmp(char const *const, char *);
int test_hex_dump(void) {
  char str[512];
  size_t i, str_len = sizeof(str);
  const char buf[] = {'a', 'b', 'c'};
  const char buf2[] = {'X'};
  char bigone[24];
  const char *const bigone_out = "00 01 02 03 00 01 02 03\n"
                                 "00 01 02 03 00 01 02 03\n"
                                 "00 01 02 03 00 01 02 03\n";
  hex_dump(buf, sizeof(buf), str, str_len);
  if (strcmp("61 62 63 ", str)) {
    fprintf(stderr, "expected '61 62 63'; got '%s'\n", str);
    return 1;
  }
  hex_dump(buf2, sizeof(buf2), str, str_len);
  if (strcmp("58 ", str)) {
    fprintf(stderr, "expected '58 '; got '%s'\n", str);
    return 1;
  }
  hex_dump(buf, 0, str, str_len);
  if (strcmp("", str)) {
    fprintf(stderr, "expected ''; got '%s'\n", str);
    return 1;
  }
  for (i = 0; i < sizeof(bigone); ++i) {
    bigone[i] = i % 4;
  }
  hex_dump(bigone, sizeof(bigone), str, str_len);
  if (strcmp(bigone_out, str)) {
    fprintf(stderr, "expected '%s'; got '%s'\n", bigone_out, str);
    return 1;
  }
  hex_dump(bigone, sizeof(bigone), str, 6);
  if (strcmp("00 ...", str)) {
    fprintf(stderr, "expected '00 ...'; got '%s'\n", str);
    return 1;
  }
  return 0;
}


x86 assembly (clang, -O0):
<test_hex_dump>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
movq   $0x200,-0x220(%rbp)
mov    0xeb3(%rip),%ax
mov    %ax,-0x223(%rbp)
mov    0xea8(%rip),%al
mov    %al,-0x221(%rbp)
mov    0xe9d(%rip),%al
mov    %al,-0x224(%rbp)
lea    0xe91(%rip),%rax
mov    %rax,-0x248(%rbp)
lea    -0x223(%rbp),%rdi
lea    -0x210(%rbp),%rdx
mov    -0x220(%rbp),%rax
mov    %eax,%ecx
mov    $0x3,%esi
call   1050 <hex_dump@plt>
lea    -0x210(%rbp),%rsi
lea    0xea4(%rip),%rdi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     11e2 <test_hex_dump+0xb2>
mov    0x2e21(%rip),%rax
mov    (%rax),%edi
lea    -0x210(%rbp),%rdx
lea    0xe88(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    13d4 <test_hex_dump+0x2a4>
lea    -0x224(%rbp),%rdi
lea    -0x210(%rbp),%rdx
mov    -0x220(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%esi
call   1050 <hex_dump@plt>
lea    -0x210(%rbp),%rsi
lea    0xe65(%rip),%rdi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     124a <test_hex_dump+0x11a>
mov    0x2db9(%rip),%rax
mov    (%rax),%edi
lea    -0x210(%rbp),%rdx
lea    0xe43(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    13d4 <test_hex_dump+0x2a4>
lea    -0x223(%rbp),%rdi
lea    -0x210(%rbp),%rdx
mov    -0x220(%rbp),%rax
mov    %eax,%ecx
xor    %esi,%esi
call   1050 <hex_dump@plt>
lea    -0x210(%rbp),%rsi
lea    0xe1d(%rip),%rdi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     12af <test_hex_dump+0x17f>
mov    0x2d54(%rip),%rax
mov    (%rax),%edi
lea    -0x210(%rbp),%rdx
lea    0xdf8(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    13d4 <test_hex_dump+0x2a4>
movq   $0x0,-0x218(%rbp)
cmpq   $0x18,-0x218(%rbp)
18
jae    12fa <test_hex_dump+0x1ca>
mov    -0x218(%rbp),%rax
and    $0x3,%rax
mov    %al,%cl
mov    -0x218(%rbp),%rax
mov    %cl,-0x240(%rbp,%rax,1)
mov    -0x218(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x218(%rbp)
jmp    12ba <test_hex_dump+0x18a>
lea    -0x240(%rbp),%rdi
lea    -0x210(%rbp),%rdx
mov    -0x220(%rbp),%rax
mov    %eax,%ecx
mov    $0x18,%esi
call   1050 <hex_dump@plt>
lea    -0x210(%rbp),%rsi
lea    0xcdb(%rip),%rdi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1369 <test_hex_dump+0x239>
mov    0x2ca1(%rip),%rax
mov    (%rax),%edi
lea    -0x210(%rbp),%rcx
lea    0xd5c(%rip),%rsi
lea    0xcae(%rip),%rdx
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    13d4 <test_hex_dump+0x2a4>
lea    -0x240(%rbp),%rdi
lea    -0x210(%rbp),%rdx
mov    $0x18,%esi
mov    $0x6,%ecx
call   1050 <hex_dump@plt>
lea    -0x210(%rbp),%rsi
lea    0xd30(%rip),%rdi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     13cd <test_hex_dump+0x29d>
mov    0x2c36(%rip),%rax
mov    (%rax),%edi
lea    -0x210(%rbp),%rdx
lea    0xd11(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    13d4 <test_hex_dump+0x2a4>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_hex_dump>:
push   %rbp
push   %rbx
sub    $0x238,%rsp
movb   $0x63,0xe(%rsp)
movw   $0x6261,0xc(%rsp)
movb   $0x58,0xb(%rsp)
lea    0xc(%rsp),%rdi
lea    0x30(%rsp),%rbx
mov    $0x3,%esi
mov    %rbx,%rdx
mov    $0x200,%ecx
call   1050 <hex_dump@plt>
lea    0xeef(%rip),%rdi
mov    %rbx,%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     11a0 <test_hex_dump+0x70>
mov    0x2e5f(%rip),%rax
mov    (%rax),%edi
lea    0xedc(%rip),%rsi
lea    0x30(%rsp),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    $0x1,%ebp
jmp    1230 <test_hex_dump+0x100>
lea    0xb(%rsp),%rdi
mov    $0x1,%ebp
lea    0x30(%rsp),%rbx
mov    $0x1,%esi
mov    %rbx,%rdx
mov    $0x200,%ecx
call   1050 <hex_dump@plt>
lea    0xebd(%rip),%rdi
mov    %rbx,%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     11e7 <test_hex_dump+0xb7>
mov    0x2e04(%rip),%rax
mov    (%rax),%edi
lea    0xea4(%rip),%rsi
jmp    1224 <test_hex_dump+0xf4>
lea    0xc(%rsp),%rdi
lea    0x30(%rsp),%rbx
xor    %esi,%esi
mov    %rbx,%rdx
mov    $0x200,%ecx
call   1050 <hex_dump@plt>
lea    0xe9b(%rip),%rdi
mov    %rbx,%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     123c <test_hex_dump+0x10c>
mov    0x2dc5(%rip),%rax
mov    (%rax),%edi
lea    0xe7f(%rip),%rsi
lea    0x30(%rsp),%rdx
xor    %eax,%eax
call   1040 <fprintf@plt>
mov    %ebp,%eax
add    $0x238,%rsp
pop    %rbx
pop    %rbp
ret
movaps 0xdbd(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movabs $0x302010003020100,%rax
01 02 03
mov    %rax,0x20(%rsp)
lea    0x10(%rsp),%rdi
lea    0x30(%rsp),%rbx
mov    $0x18,%esi
mov    %rbx,%rdx
mov    $0x200,%ecx
call   1050 <hex_dump@plt>
lea    0xd99(%rip),%rdi
mov    %rbx,%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     12ac <test_hex_dump+0x17c>
mov    0x2d52(%rip),%rax
mov    (%rax),%edi
lea    0xe23(%rip),%rsi
lea    0xd75(%rip),%rdx
lea    0x30(%rsp),%rcx
xor    %eax,%eax
call   1040 <fprintf@plt>
jmp    1230 <test_hex_dump+0x100>
lea    0x10(%rsp),%rdi
lea    0x30(%rsp),%rbx
mov    $0x18,%esi
mov    %rbx,%rdx
mov    $0x6,%ecx
call   1050 <hex_dump@plt>
lea    0xe04(%rip),%rdi
mov    %rbx,%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     12f1 <test_hex_dump+0x1c1>
mov    0x2cfd(%rip),%rax
mov    (%rax),%edi
lea    0xdee(%rip),%rsi
jmp    1224 <test_hex_dump+0xf4>
xor    %ebp,%ebp
jmp    1230 <test_hex_dump+0x100>

LLVM IR (-O0):
@__const.test_hex_dump.buf = [3 x i8] c"abc"
@__const.test_hex_dump.buf2 = [1 x i8] c"X"
@.str = [73 x i8] c"00 01 02 03 00 01 02 03\0A00 01 02 03 00 01 02 03\0A00 01 02 03 00 01 02 03\0A\00"
@.str.1 = [10 x i8] c"61 62 63 \00"
@stderr = global i32 0
@.str.2 = [31 x i8] c"expected '61 62 63'; got '%s'\0A\00"
@.str.3 = [4 x i8] c"58 \00"
@.str.4 = [26 x i8] c"expected '58 '; got '%s'\0A\00"
@.str.5 = [1 x i8] zeroinitializer
@.str.6 = [23 x i8] c"expected ''; got '%s'\0A\00"
@.str.7 = [25 x i8] c"expected '%s'; got '%s'\0A\00"
@.str.8 = [7 x i8] c"00 ...\00"
@.str.9 = [29 x i8] c"expected '00 ...'; got '%s'\0A\00"
define i32 @test_hex_dump() {
%1 = alloca i32
%2 = alloca [512 x i8]
%3 = alloca i64
%4 = alloca i64
%5 = alloca [3 x i8]
%6 = alloca [1 x i8]
%7 = alloca [24 x i8]
%8 = alloca i8*
store i64 512, i64* %4
%9 = bitcast [3 x i8]* %5 to i8*
%10 = bitcast [1 x i8]* %6 to i8*
store i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0), i8** %8
%11 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 0
%12 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%13 = load i64, i64* %4
%14 = trunc i64 %13 to i32
%15 = call i32 @hex_dump(i8* %11, i32 3, i8* %12, i32 %14)
%16 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%17 = call i64 @strcmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i8* %16)
%18 = icmp ne i64 %17, 0
br i1 %18, label %19, label %23
19: ; preds = %0
%20 = load i32, i32* @stderr
%21 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%22 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %20, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0), i8* %21)
store i32 1, i32* %1
br label %87
23: ; preds = %0
%24 = getelementptr inbounds [1 x i8], [1 x i8]* %6, i64 0, i64 0
%25 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%26 = load i64, i64* %4
%27 = trunc i64 %26 to i32
%28 = call i32 @hex_dump(i8* %24, i32 1, i8* %25, i32 %27)
%29 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%30 = call i64 @strcmp(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i8* %29)
%31 = icmp ne i64 %30, 0
br i1 %31, label %32, label %36
32: ; preds = %23
%33 = load i32, i32* @stderr
%34 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%35 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %33, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0), i8* %34)
store i32 1, i32* %1
br label %87
36: ; preds = %23
%37 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 0
%38 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%39 = load i64, i64* %4
%40 = trunc i64 %39 to i32
%41 = call i32 @hex_dump(i8* %37, i32 0, i8* %38, i32 %40)
%42 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%43 = call i64 @strcmp(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0), i8* %42)
%44 = icmp ne i64 %43, 0
br i1 %44, label %45, label %49
45: ; preds = %36
%46 = load i32, i32* @stderr
%47 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%48 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %46, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i8* %47)
store i32 1, i32* %1
br label %87
49: ; preds = %36
store i64 0, i64* %3
br label %50
50: ; preds = %59, %49
%51 = load i64, i64* %3
%52 = icmp ult i64 %51, 24
br i1 %52, label %53, label %62
53: ; preds = %50
%54 = load i64, i64* %3
%55 = urem i64 %54, 4
%56 = trunc i64 %55 to i8
%57 = load i64, i64* %3
%58 = getelementptr inbounds [24 x i8], [24 x i8]* %7, i64 0, i64 %57
store i8 %56, i8* %58
br label %59
59: ; preds = %53
%60 = load i64, i64* %3
%61 = add i64 %60, 1
store i64 %61, i64* %3
br label %50
62: ; preds = %50
%63 = getelementptr inbounds [24 x i8], [24 x i8]* %7, i64 0, i64 0
%64 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%65 = load i64, i64* %4
%66 = trunc i64 %65 to i32
%67 = call i32 @hex_dump(i8* %63, i32 24, i8* %64, i32 %66)
%68 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%69 = call i64 @strcmp(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i32 0, i32 0), i8* %68)
%70 = icmp ne i64 %69, 0
br i1 %70, label %71, label %75
71: ; preds = %62
%72 = load i32, i32* @stderr
%73 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%74 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %72, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i32 0, i32 0), i8* %73)
store i32 1, i32* %1
br label %87
75: ; preds = %62
%76 = getelementptr inbounds [24 x i8], [24 x i8]* %7, i64 0, i64 0
%77 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%78 = call i32 @hex_dump(i8* %76, i32 24, i8* %77, i32 6)
%79 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%80 = call i64 @strcmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8* %79)
%81 = icmp ne i64 %80, 0
br i1 %81, label %82, label %86
82: ; preds = %75
%83 = load i32, i32* @stderr
%84 = getelementptr inbounds [512 x i8], [512 x i8]* %2, i64 0, i64 0
%85 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %83, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.9, i64 0, i64 0), i8* %84)
store i32 1, i32* %1
br label %87
86: ; preds = %75
store i32 0, i32* %1
br label %87
87: ; preds = %86, %82, %71, %45, %32, %19
%88 = load i32, i32* %1
ret i32 %88
}

LLVM IR (-O2):
@__const.test_hex_dump.buf = [3 x i8] c"abc"
@.str = [73 x i8] c"00 01 02 03 00 01 02 03\0A00 01 02 03 00 01 02 03\0A00 01 02 03 00 01 02 03\0A\00"
@.str.1 = [10 x i8] c"61 62 63 \00"
@stderr = global i32 0
@.str.2 = [31 x i8] c"expected '61 62 63'; got '%s'\0A\00"
@.str.3 = [4 x i8] c"58 \00"
@.str.4 = [26 x i8] c"expected '58 '; got '%s'\0A\00"
@.str.5 = [1 x i8] zeroinitializer
@.str.6 = [23 x i8] c"expected ''; got '%s'\0A\00"
@.str.7 = [25 x i8] c"expected '%s'; got '%s'\0A\00"
@.str.8 = [7 x i8] c"00 ...\00"
@.str.9 = [29 x i8] c"expected '00 ...'; got '%s'\0A\00"
define i32 @test_hex_dump() {
%1 = alloca [512 x i8]
%2 = alloca [3 x i8]
%3 = alloca [1 x i8]
%4 = alloca [24 x i8]
%5 = getelementptr inbounds [512 x i8], [512 x i8]* %1, i64 0, i64 0
%6 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 0
%7 = getelementptr inbounds [1 x i8], [1 x i8]* %3, i64 0, i64 0
store i8 88, i8* %7
%8 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 0
%9 = call i32 @hex_dump(i8* %6, i32 3, i8* %5, i32 512)
%10 = call i64 @strcmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i8* %5)
%11 = icmp eq i64 %10, 0
br i1 %11, label %15, label %12
12: ; preds = %0
%13 = load i32, i32* @stderr
%14 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %13, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0), i8* %5)
br label %52
15: ; preds = %0
%16 = call i32 @hex_dump(i8* %7, i32 1, i8* %5, i32 512)
%17 = call i64 @strcmp(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i8* %5)
%18 = icmp eq i64 %17, 0
br i1 %18, label %22, label %19
19: ; preds = %15
%20 = load i32, i32* @stderr
%21 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %20, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0), i8* %5)
br label %52
22: ; preds = %15
%23 = call i32 @hex_dump(i8* %6, i32 0, i8* %5, i32 512)
%24 = call i64 @strcmp(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0), i8* %5)
%25 = icmp eq i64 %24, 0
br i1 %25, label %26, label %39
26: ; preds = %22
%27 = bitcast [24 x i8]* %4 to <16 x i8>*
store <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 0, i8 1, i8 2, i8 3, i8 0, i8 1, i8 2, i8 3, i8 0, i8 1, i8 2, i8 3>, <16 x i8>* %27
%28 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 16
store i8 0, i8* %28
%29 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 17
store i8 1, i8* %29
%30 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 18
store i8 2, i8* %30
%31 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 19
store i8 3, i8* %31
%32 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 20
store i8 0, i8* %32
%33 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 21
store i8 1, i8* %33
%34 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 22
store i8 2, i8* %34
%35 = getelementptr inbounds [24 x i8], [24 x i8]* %4, i64 0, i64 23
store i8 3, i8* %35
%36 = call i32 @hex_dump(i8* %8, i32 24, i8* %5, i32 512)
%37 = call i64 @strcmp(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0), i8* %5)
%38 = icmp eq i64 %37, 0
br i1 %38, label %45, label %42
39: ; preds = %22
%40 = load i32, i32* @stderr
%41 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %40, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i8* %5)
br label %52
42: ; preds = %26
%43 = load i32, i32* @stderr
%44 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %43, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str, i64 0, i64 0), i8* %5)
br label %52
45: ; preds = %26
%46 = call i32 @hex_dump(i8* %8, i32 24, i8* %5, i32 6)
%47 = call i64 @strcmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8* %5)
%48 = icmp eq i64 %47, 0
br i1 %48, label %52, label %49
49: ; preds = %45
%50 = load i32, i32* @stderr
%51 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %50, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.9, i64 0, i64 0), i8* %5)
br label %52
52: ; preds = %45, %49, %42, %39, %19, %12
%53 = phi i32 [ 1, %12 ], [ 1, %19 ], [ 1, %39 ], [ 1, %42 ], [ 1, %49 ], [ 0, %45 ]
ret i32 %53
}