#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*/ printf(char *, ...);
int /*<<< orphan*/ strlen(char *);
char *strstr(char *, char *);
int cc_up_parse_version(char *buf, char *ver_type, char *version) {
  char *pos1 = buf;
  char *pos2;
  int i = 0;
  if (pos1 = strstr(buf, ver_type)) {
    pos1 += strlen(ver_type);
    if (pos2 = strstr(pos1, ver_type)) {
      while (pos1 < pos2) {
        if (*pos1 == ' ') {
          pos1++;
          continue;
        }
        if (i >= 10) {
          printf("VERSION length is error, %d \n", i);
          return -1;
        }
        version[i++] = *pos1++;
      }
      version[i] = 0;
      printf("parse version type:%s, value:%s \n", ver_type, version);
      return 0;
    }
  }
  return -1;
}


x86 assembly (clang, -O0):
<cc_up_parse_version>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1050 <strstr@plt>
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
je     125b <cc_up_parse_version+0x12b>
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1050 <strstr@plt>
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
je     1256 <cc_up_parse_version+0x126>
jmp    11a7 <cc_up_parse_version+0x77>
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    1228 <cc_up_parse_version+0xf8>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    11d6 <cc_up_parse_version+0xa6>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11a7 <cc_up_parse_version+0x77>
cmpl   $0xa,-0x34(%rbp)
jl     11fd <cc_up_parse_version+0xcd>
mov    -0x34(%rbp),%esi
lea    0xe16(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1262 <cc_up_parse_version+0x132>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11a7 <cc_up_parse_version+0x77>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
lea    0xddb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1262 <cc_up_parse_version+0x132>
jmp    125b <cc_up_parse_version+0x12b>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cc_up_parse_version>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %rsi,%r12
call   1050 <strstr@plt>
mov    $0xffffffff,%r15d
test   %rax,%rax
je     13d2 <cc_up_parse_version+0x2a2>
mov    %rax,%rbx
mov    %r12,%rdi
call   1030 <strlen@plt>
movslq %eax,%rbp
lea    (%rbx,%rbp,1),%r13
mov    %r13,%rdi
mov    %r12,%rsi
call   1050 <strstr@plt>
test   %rax,%rax
je     13d2 <cc_up_parse_version+0x2a2>
xor    %r15d,%r15d
cmp    %rax,%r13
jae    11b3 <cc_up_parse_version+0x83>
mov    %rax,%rsi
sub    %rbx,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rbp,1),%edx
cmp    $0x20,%dl
jne    11ba <cc_up_parse_version+0x8a>
add    $0xffffffffffffffff,%rsi
lea    (%rbx,%rbp,1),%rcx
add    $0x1,%rcx
add    $0x1,%rbx
cmp    %rax,%rcx
jb     1190 <cc_up_parse_version+0x60>
jmp    13b9 <cc_up_parse_version+0x289>
xor    %edi,%edi
jmp    13b9 <cc_up_parse_version+0x289>
mov    %dl,(%r14)
lea    (%rbx,%rbp,1),%rcx
add    $0x1,%rcx
mov    $0x1,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
lea    0x1(%rbp),%rdx
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%rbx,%rbp,1),%ecx
cmp    $0x20,%cl
jne    11fc <cc_up_parse_version+0xcc>
add    $0x1,%rbx
add    $0xffffffffffffffff,%rsi
cmp    %rsi,%rdx
jne    11e0 <cc_up_parse_version+0xb0>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x1(%r14)
lea    (%rbx,%rbp,1),%rcx
add    $0x2,%rcx
mov    $0x2,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
lea    (%rbx,%rbp,1),%rdx
add    $0x5,%rdx
sub    %rsi,%rbp
add    $0xa,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rdx),%ecx
cmp    $0x20,%cl
jne    124c <cc_up_parse_version+0x11c>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x8,%rbp
jne    1230 <cc_up_parse_version+0x100>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x2(%r14)
lea    -0x2(%rdx),%rcx
mov    $0x3,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
movzbl -0x2(%rdx),%ecx
cmp    $0x20,%cl
jne    127e <cc_up_parse_version+0x14e>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x7,%rbp
jne    1262 <cc_up_parse_version+0x132>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x3(%r14)
lea    -0x1(%rdx),%rcx
mov    $0x4,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
movzbl -0x1(%rdx),%ecx
cmp    $0x20,%cl
jne    12b0 <cc_up_parse_version+0x180>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x6,%rbp
jne    1294 <cc_up_parse_version+0x164>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x4(%r14)
mov    $0x5,%edi
cmp    %rax,%rdx
jae    13b9 <cc_up_parse_version+0x289>
add    $0x5,%rdx
movzbl -0x5(%rdx),%ecx
cmp    $0x20,%cl
jne    12e2 <cc_up_parse_version+0x1b2>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x5,%rbp
jne    12c6 <cc_up_parse_version+0x196>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x5(%r14)
lea    -0x4(%rdx),%rcx
mov    $0x6,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
movzbl -0x4(%rdx),%ecx
cmp    $0x20,%cl
jne    1314 <cc_up_parse_version+0x1e4>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x4,%rbp
jne    12f8 <cc_up_parse_version+0x1c8>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x6(%r14)
lea    -0x3(%rdx),%rcx
mov    $0x7,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
movzbl -0x3(%rdx),%ecx
cmp    $0x20,%cl
jne    1343 <cc_up_parse_version+0x213>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x3,%rbp
jne    132a <cc_up_parse_version+0x1fa>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x7(%r14)
lea    -0x2(%rdx),%rcx
mov    $0x8,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
movzbl -0x2(%rdx),%ecx
cmp    $0x20,%cl
jne    136e <cc_up_parse_version+0x23e>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x2,%rbp
jne    1355 <cc_up_parse_version+0x225>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x8(%r14)
lea    -0x1(%rdx),%rcx
mov    $0x9,%edi
cmp    %rax,%rcx
jae    13b9 <cc_up_parse_version+0x289>
movzbl -0x1(%rdx),%ecx
cmp    $0x20,%cl
jne    1399 <cc_up_parse_version+0x269>
add    $0x1,%rbp
add    $0x1,%rdx
cmp    $0x1,%rbp
jne    1380 <cc_up_parse_version+0x250>
jmp    13b9 <cc_up_parse_version+0x289>
mov    %cl,0x9(%r14)
mov    $0xa,%edi
cmp    %rax,%rdx
jae    13b9 <cc_up_parse_version+0x289>
neg    %rbp
cmpb   $0x20,(%rdx)
jne    13e4 <cc_up_parse_version+0x2b4>
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbp
jne    13aa <cc_up_parse_version+0x27a>
movb   $0x0,(%r14,%rdi,1)
lea    0xc59(%rip),%rdi
mov    %r12,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xc15(%rip),%rdi
mov    $0xa,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffff,%r15d
jmp    13d2 <cc_up_parse_version+0x2a2>

LLVM IR (-O0):
@.str = [30 x i8] c"VERSION length is error, %d \0A\00"
@.str.1 = [34 x i8] c"parse version type:%s, value:%s \0A\00"
define i32 @cc_up_parse_version(i8* %0, i8* %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
%11 = load i8*, i8** %5
store i8* %11, i8** %8
store i32 0, i32* %10
%12 = load i8*, i8** %5
%13 = load i8*, i8** %6
%14 = call i8* @strstr(i8* %12, i8* %13)
store i8* %14, i8** %8
%15 = icmp ne i8* %14, null
br i1 %15, label %16, label %63
16: ; preds = %3
%17 = load i8*, i8** %6
%18 = call i32 @strlen(i8* %17)
%19 = load i8*, i8** %8
%20 = sext i32 %18 to i64
%21 = getelementptr inbounds i8, i8* %19, i64 %20
store i8* %21, i8** %8
%22 = load i8*, i8** %8
%23 = load i8*, i8** %6
%24 = call i8* @strstr(i8* %22, i8* %23)
store i8* %24, i8** %9
%25 = icmp ne i8* %24, null
br i1 %25, label %26, label %62
26: ; preds = %16
br label %27
27: ; preds = %45, %36, %26
%28 = load i8*, i8** %8
%29 = load i8*, i8** %9
%30 = icmp ult i8* %28, %29
br i1 %30, label %31, label %54
31: ; preds = %27
%32 = load i8*, i8** %8
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %34, 32
br i1 %35, label %36, label %39
36: ; preds = %31
%37 = load i8*, i8** %8
%38 = getelementptr inbounds i8, i8* %37, i32 1
store i8* %38, i8** %8
br label %27
39: ; preds = %31
%40 = load i32, i32* %10
%41 = icmp sge i32 %40, 10
br i1 %41, label %42, label %45
42: ; preds = %39
%43 = load i32, i32* %10
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i32 %43)
store i32 -1, i32* %4
br label %64
45: ; preds = %39
%46 = load i8*, i8** %8
%47 = getelementptr inbounds i8, i8* %46, i32 1
store i8* %47, i8** %8
%48 = load i8, i8* %46
%49 = load i8*, i8** %7
%50 = load i32, i32* %10
%51 = add nsw i32 %50, 1
store i32 %51, i32* %10
%52 = sext i32 %50 to i64
%53 = getelementptr inbounds i8, i8* %49, i64 %52
store i8 %48, i8* %53
br label %27
54: ; preds = %27
%55 = load i8*, i8** %7
%56 = load i32, i32* %10
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %55, i64 %57
store i8 0, i8* %58
%59 = load i8*, i8** %6
%60 = load i8*, i8** %7
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), i8* %59, i8* %60)
store i32 0, i32* %4
br label %64
62: ; preds = %16
br label %63
63: ; preds = %62, %3
store i32 -1, i32* %4
br label %64
64: ; preds = %63, %54, %42
%65 = load i32, i32* %4
ret i32 %65
}

LLVM IR (-O2):
@.str = [30 x i8] c"VERSION length is error, %d \0A\00"
@.str.1 = [34 x i8] c"parse version type:%s, value:%s \0A\00"
define i32 @cc_up_parse_version(i8* %0, i8* %1, i8* %2) {
%4 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) %1)
%5 = icmp eq i8* %4, null
br i1 %5, label %167, label %6
6: ; preds = %3
%7 = tail call i32 @strlen(i8* %1)
%8 = sext i32 %7 to i64
%9 = getelementptr inbounds i8, i8* %4, i64 %8
%10 = tail call i8* @strstr(i8* %9, i8* dereferenceable(1) %1)
%11 = ptrtoint i8* %10 to i64
%12 = icmp eq i8* %10, null
br i1 %12, label %167, label %13
13: ; preds = %6
%14 = icmp ult i8* %9, %10
br i1 %14, label %15, label %163
15: ; preds = %13, %20
%16 = phi i8* [ %19, %20 ], [ %9, %13 ]
%17 = load i8, i8* %16
%18 = icmp eq i8 %17, 32
%19 = getelementptr inbounds i8, i8* %16, i64 1
br i1 %18, label %20, label %22
20: ; preds = %15
%21 = icmp ult i8* %19, %10
br i1 %21, label %15, label %163
22: ; preds = %15
store i8 %17, i8* %2
%23 = icmp ult i8* %19, %10
br i1 %23, label %26, label %163
24: ; preds = %156
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i32 10)
br label %167
26: ; preds = %22
%27 = ptrtoint i8* %16 to i64
%28 = sub i64 %11, %27
%29 = getelementptr i8, i8* %16, i64 %28
br label %30
30: ; preds = %38, %26
%31 = phi i8* [ %19, %26 ], [ %34, %38 ]
%32 = load i8, i8* %31
%33 = icmp eq i8 %32, 32
%34 = getelementptr inbounds i8, i8* %31, i64 1
br i1 %33, label %38, label %35
35: ; preds = %30
%36 = getelementptr inbounds i8, i8* %2, i64 1
store i8 %32, i8* %36
%37 = icmp ult i8* %34, %10
br i1 %37, label %40, label %163
38: ; preds = %30
%39 = icmp eq i8* %34, %29
br i1 %39, label %163, label %30
40: ; preds = %35
%41 = ptrtoint i8* %31 to i64
%42 = sub i64 %11, %41
%43 = getelementptr i8, i8* %31, i64 %42
br label %44
44: ; preds = %52, %40
%45 = phi i8* [ %34, %40 ], [ %48, %52 ]
%46 = load i8, i8* %45
%47 = icmp eq i8 %46, 32
%48 = getelementptr inbounds i8, i8* %45, i64 1
br i1 %47, label %52, label %49
49: ; preds = %44
%50 = getelementptr inbounds i8, i8* %2, i64 2
store i8 %46, i8* %50
%51 = icmp ult i8* %48, %10
br i1 %51, label %54, label %163
52: ; preds = %44
%53 = icmp eq i8* %48, %43
br i1 %53, label %163, label %44
54: ; preds = %49
%55 = ptrtoint i8* %45 to i64
%56 = sub i64 %11, %55
%57 = getelementptr i8, i8* %45, i64 %56
br label %58
58: ; preds = %66, %54
%59 = phi i8* [ %48, %54 ], [ %62, %66 ]
%60 = load i8, i8* %59
%61 = icmp eq i8 %60, 32
%62 = getelementptr inbounds i8, i8* %59, i64 1
br i1 %61, label %66, label %63
63: ; preds = %58
%64 = getelementptr inbounds i8, i8* %2, i64 3
store i8 %60, i8* %64
%65 = icmp ult i8* %62, %10
br i1 %65, label %68, label %163
66: ; preds = %58
%67 = icmp eq i8* %62, %57
br i1 %67, label %163, label %58
68: ; preds = %63
%69 = ptrtoint i8* %59 to i64
%70 = sub i64 %11, %69
%71 = getelementptr i8, i8* %59, i64 %70
br label %72
72: ; preds = %80, %68
%73 = phi i8* [ %62, %68 ], [ %76, %80 ]
%74 = load i8, i8* %73
%75 = icmp eq i8 %74, 32
%76 = getelementptr inbounds i8, i8* %73, i64 1
br i1 %75, label %80, label %77
77: ; preds = %72
%78 = getelementptr inbounds i8, i8* %2, i64 4
store i8 %74, i8* %78
%79 = icmp ult i8* %76, %10
br i1 %79, label %82, label %163
80: ; preds = %72
%81 = icmp eq i8* %76, %71
br i1 %81, label %163, label %72
82: ; preds = %77
%83 = ptrtoint i8* %73 to i64
%84 = sub i64 %11, %83
%85 = getelementptr i8, i8* %73, i64 %84
br label %86
86: ; preds = %94, %82
%87 = phi i8* [ %76, %82 ], [ %90, %94 ]
%88 = load i8, i8* %87
%89 = icmp eq i8 %88, 32
%90 = getelementptr inbounds i8, i8* %87, i64 1
br i1 %89, label %94, label %91
91: ; preds = %86
%92 = getelementptr inbounds i8, i8* %2, i64 5
store i8 %88, i8* %92
%93 = icmp ult i8* %90, %10
br i1 %93, label %96, label %163
94: ; preds = %86
%95 = icmp eq i8* %90, %85
br i1 %95, label %163, label %86
96: ; preds = %91
%97 = ptrtoint i8* %87 to i64
%98 = sub i64 %11, %97
%99 = getelementptr i8, i8* %87, i64 %98
br label %100
100: ; preds = %108, %96
%101 = phi i8* [ %90, %96 ], [ %104, %108 ]
%102 = load i8, i8* %101
%103 = icmp eq i8 %102, 32
%104 = getelementptr inbounds i8, i8* %101, i64 1
br i1 %103, label %108, label %105
105: ; preds = %100
%106 = getelementptr inbounds i8, i8* %2, i64 6
store i8 %102, i8* %106
%107 = icmp ult i8* %104, %10
br i1 %107, label %110, label %163
108: ; preds = %100
%109 = icmp eq i8* %104, %99
br i1 %109, label %163, label %100
110: ; preds = %105
%111 = ptrtoint i8* %101 to i64
%112 = sub i64 %11, %111
%113 = getelementptr i8, i8* %101, i64 %112
br label %114
114: ; preds = %122, %110
%115 = phi i8* [ %104, %110 ], [ %118, %122 ]
%116 = load i8, i8* %115
%117 = icmp eq i8 %116, 32
%118 = getelementptr inbounds i8, i8* %115, i64 1
br i1 %117, label %122, label %119
119: ; preds = %114
%120 = getelementptr inbounds i8, i8* %2, i64 7
store i8 %116, i8* %120
%121 = icmp ult i8* %118, %10
br i1 %121, label %124, label %163
122: ; preds = %114
%123 = icmp eq i8* %118, %113
br i1 %123, label %163, label %114
124: ; preds = %119
%125 = ptrtoint i8* %115 to i64
%126 = sub i64 %11, %125
%127 = getelementptr i8, i8* %115, i64 %126
br label %128
128: ; preds = %136, %124
%129 = phi i8* [ %118, %124 ], [ %132, %136 ]
%130 = load i8, i8* %129
%131 = icmp eq i8 %130, 32
%132 = getelementptr inbounds i8, i8* %129, i64 1
br i1 %131, label %136, label %133
133: ; preds = %128
%134 = getelementptr inbounds i8, i8* %2, i64 8
store i8 %130, i8* %134
%135 = icmp ult i8* %132, %10
br i1 %135, label %138, label %163
136: ; preds = %128
%137 = icmp eq i8* %132, %127
br i1 %137, label %163, label %128
138: ; preds = %133
%139 = ptrtoint i8* %129 to i64
%140 = sub i64 %11, %139
%141 = getelementptr i8, i8* %129, i64 %140
br label %142
142: ; preds = %150, %138
%143 = phi i8* [ %132, %138 ], [ %146, %150 ]
%144 = load i8, i8* %143
%145 = icmp eq i8 %144, 32
%146 = getelementptr inbounds i8, i8* %143, i64 1
br i1 %145, label %150, label %147
147: ; preds = %142
%148 = getelementptr inbounds i8, i8* %2, i64 9
store i8 %144, i8* %148
%149 = icmp ult i8* %146, %10
br i1 %149, label %152, label %163
150: ; preds = %142
%151 = icmp eq i8* %146, %141
br i1 %151, label %163, label %142
152: ; preds = %147
%153 = ptrtoint i8* %143 to i64
%154 = sub i64 %11, %153
%155 = getelementptr i8, i8* %143, i64 %154
br label %156
156: ; preds = %160, %152
%157 = phi i8* [ %146, %152 ], [ %161, %160 ]
%158 = load i8, i8* %157
%159 = icmp eq i8 %158, 32
br i1 %159, label %160, label %24
160: ; preds = %156
%161 = getelementptr inbounds i8, i8* %157, i64 1
%162 = icmp eq i8* %161, %155
br i1 %162, label %163, label %156
163: ; preds = %20, %38, %52, %66, %80, %94, %108, %122, %136, %150, %160, %22, %35, %49, %63, %77, %91, %105, %119, %133, %147, %13
%164 = phi i64 [ 0, %13 ], [ 1, %22 ], [ 2, %35 ], [ 3, %49 ], [ 4, %63 ], [ 5, %77 ], [ 6, %91 ], [ 7, %105 ], [ 8, %119 ], [ 9, %133 ], [ 10, %147 ], [ 10, %160 ], [ 9, %150 ], [ 8, %136 ], [ 7, %122 ], [ 6, %108 ], [ 5, %94 ], [ 4, %80 ], [ 3, %66 ], [ 2, %52 ], [ 1, %38 ], [ 0, %20 ]
%165 = getelementptr inbounds i8, i8* %2, i64 %164
store i8 0, i8* %165
%166 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), i8* %1, i8* %2)
br label %167
167: ; preds = %3, %6, %163, %24
%168 = phi i32 [ -1, %24 ], [ 0, %163 ], [ -1, %6 ], [ -1, %3 ]
ret i32 %168
}