int extract_args(s1, i0, ie, narg, args)
char args[20][10 + 1];
int *narg, *ie, i0;
char *s1;
{
  int k, i = i0, n = strlen(s1);
  int type, na = 0, i1;
  while (i < n) {
    type = find_char(s1, ",)", i, &i1);
    if (type == 0) {
      for (k = i; k < i1; k++)
        args[na][k - i] = s1[k];
      args[na][i1 - i] = 0;
      na++;
      i = i1 + 1;
    }
    if (type == 1) {
      for (k = i; k < i1; k++)
        args[na][k - i] = s1[k];
      args[na][i1 - i] = 0;
      na++;
      i = i1 + 1;
      find_char(s1, "=", i, &i1);
      *ie = i1 + 1;
      *narg = na;
      return 1;
    }
  }
  return (0);
}


x86 assembly (clang, -O0):
<extract_args>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    12b7 <extract_args+0x197>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%edx
lea    0xe92(%rip),%rsi
lea    -0x48(%rbp),%rcx
mov    $0x0,%al
call   1040 <find_char@plt>
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jne    11fa <extract_args+0xda>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    11cc <extract_args+0xac>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xb,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118c <extract_args+0x6c>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xb,%rcx,%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x1,-0x40(%rbp)
jne    12b2 <extract_args+0x192>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    124a <extract_args+0x12a>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xb,%rcx,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120a <extract_args+0xea>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0xb,%rcx,%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%edx
lea    0xd7d(%rip),%rsi
lea    -0x48(%rbp),%rcx
mov    $0x0,%al
call   1040 <find_char@plt>
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x44(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    12be <extract_args+0x19e>
jmp    1154 <extract_args+0x34>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<extract_args>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,%r14
mov    %rcx,0x28(%rsp)
mov    %rdx,0x30(%rsp)
mov    %esi,%r15d
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %rax,%r13
lea    0x30(%rbx),%rax
mov    %rax,0x20(%rsp)
lea    0x30(%r14),%rax
mov    %rax,0x18(%rsp)
mov    %r14,0x10(%rsp)
lea    0x3(%r14),%rax
mov    %rax,0x38(%rsp)
lea    0xe90(%rip),%r14
lea    0xc(%rsp),%rbp
xor    %r12d,%r12d
mov    %r13,0x40(%rsp)
jmp    11bf <extract_args+0x9f>
nop
mov    %r9d,%ecx
sub    %r15d,%ecx
movslq %ecx,%rcx
lea    (%r12,%r12,4),%rdx
lea    (%r12,%rdx,2),%rdx
add    0x10(%rsp),%rdx
movb   $0x0,(%rcx,%rdx,1)
add    $0x1,%r12d
add    $0x1,%r9d
mov    %r9d,%r15d
mov    0x40(%rsp),%r13
lea    0xe4f(%rip),%r14
lea    0xc(%rsp),%rbp
cmp    $0x1,%eax
je     13b7 <extract_args+0x297>
cmp    %r13d,%r15d
jge    13b0 <extract_args+0x290>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15d,%edx
mov    %rbp,%rcx
xor    %eax,%eax
call   1040 <find_char@plt>
test   %eax,%eax
jne    11b6 <extract_args+0x96>
movslq 0xc(%rsp),%r9
movslq %r12d,%r12
cmp    %r15d,%r9d
jle    1180 <extract_args+0x60>
movslq %r15d,%r8
mov    %r9,%rcx
sub    %r8,%rcx
mov    %r8,%rsi
cmp    $0x8,%rcx
jb     131f <extract_args+0x1ff>
lea    (%r12,%r12,4),%rdx
lea    (%r12,%rdx,2),%rdx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,1),%r14
lea    (%rbx,%r8,1),%r10
lea    (%rbx,%r9,1),%rsi
cmp    %rsi,%r14
jae    1230 <extract_args+0x110>
lea    (%r14,%rcx,1),%rbp
mov    %r8,%rsi
cmp    %rbp,%r10
jb     131f <extract_args+0x1ff>
cmp    $0x20,%rcx
jae    123d <extract_args+0x11d>
xor    %ebp,%ebp
jmp    12e1 <extract_args+0x1c1>
mov    %rcx,%rbp
and    $0xffffffffffffffe0,%rbp
lea    -0x20(%rbp),%rdi
mov    %rdi,%r11
shr    $0x5,%r11
add    $0x1,%r11
test   %rdi,%rdi
je     130c <extract_args+0x1ec>
mov    %r11,%rdi
and    $0xfffffffffffffffe,%r11
mov    0x20(%rsp),%rsi
lea    (%rsi,%r8,1),%r13
add    0x18(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r13,%rsi,1),%xmm0
movups -0x20(%r13,%rsi,1),%xmm1
movups %xmm0,-0x30(%rdx,%rsi,1)
movups %xmm1,-0x20(%rdx,%rsi,1)
movups -0x10(%r13,%rsi,1),%xmm0
movups 0x0(%r13,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%r11
jne    1280 <extract_args+0x160>
test   $0x1,%dil
je     12d3 <extract_args+0x1b3>
lea    (%rsi,%r8,1),%rdx
movups (%rbx,%rdx,1),%xmm0
movups 0x10(%rbx,%rdx,1),%xmm1
movups %xmm0,(%rsi,%r14,1)
movups %xmm1,0x10(%rsi,%r14,1)
cmp    %rbp,%rcx
je     1180 <extract_args+0x60>
test   $0x18,%cl
je     1319 <extract_args+0x1f9>
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rdx,%r8,1),%rsi
nopl   0x0(%rax)
mov    (%r10,%rbp,1),%rdi
mov    %rdi,(%r14,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%rdx
jne    12f0 <extract_args+0x1d0>
cmp    %rdx,%rcx
je     1180 <extract_args+0x60>
jmp    131f <extract_args+0x1ff>
mov    %r11,%rdi
xor    %esi,%esi
test   $0x1,%dil
jne    12bb <extract_args+0x19b>
jmp    12d3 <extract_args+0x1b3>
add    %r8,%rbp
mov    %rbp,%rsi
mov    %r9d,%edi
sub    %esi,%edi
mov    %rsi,%rcx
not    %rcx
add    %r9,%rcx
and    $0x3,%rdi
je     1362 <extract_args+0x242>
lea    (%r12,%r12,4),%rbp
lea    (%r12,%rbp,2),%rbp
add    0x10(%rsp),%rbp
sub    %r8,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx,%rsi,1),%edx
mov    %dl,0x0(%rbp,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1350 <extract_args+0x230>
cmp    $0x3,%rcx
jb     1180 <extract_args+0x60>
lea    (%r12,%r12,4),%rdx
lea    (%r12,%rdx,2),%rdx
sub    %r8,%rdx
add    0x38(%rsp),%rdx
nopl   0x0(%rax)
movzbl (%rbx,%rsi,1),%ecx
mov    %cl,-0x3(%rdx,%rsi,1)
movzbl 0x1(%rbx,%rsi,1),%ecx
mov    %cl,-0x2(%rdx,%rsi,1)
movzbl 0x2(%rbx,%rsi,1),%ecx
mov    %cl,-0x1(%rdx,%rsi,1)
movzbl 0x3(%rbx,%rsi,1),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1380 <extract_args+0x260>
jmp    1180 <extract_args+0x60>
xor    %eax,%eax
jmp    15ce <extract_args+0x4ae>
movslq 0xc(%rsp),%rdx
movslq %r12d,%r14
cmp    %r15d,%edx
jle    157b <extract_args+0x45b>
movslq %r15d,%r8
mov    %rdx,%r9
sub    %r8,%r9
mov    %r8,%rax
cmp    $0x8,%r9
jb     14f1 <extract_args+0x3d1>
lea    (%r14,%r14,4),%rax
lea    (%r14,%rax,2),%rbp
mov    0x10(%rsp),%rax
lea    (%rax,%rbp,1),%r12
lea    (%rbx,%r8,1),%r11
lea    (%rbx,%rdx,1),%rax
cmp    %rax,%r12
jae    140c <extract_args+0x2ec>
lea    (%r12,%r9,1),%rcx
mov    %r8,%rax
cmp    %rcx,%r11
jb     14f1 <extract_args+0x3d1>
cmp    $0x20,%r9
jae    1419 <extract_args+0x2f9>
xor    %ecx,%ecx
jmp    14c2 <extract_args+0x3a2>
mov    %r9,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rax
mov    %rax,%r10
shr    $0x5,%r10
add    $0x1,%r10
test   %rax,%rax
je     1492 <extract_args+0x372>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rbx,%r8,1),%rdi
add    $0x30,%rdi
mov    0x10(%rsp),%rsi
add    %rbp,%rsi
add    $0x30,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdi,%rbp,1),%xmm0
movups -0x20(%rdi,%rbp,1),%xmm1
movups %xmm0,-0x30(%rsi,%rbp,1)
movups %xmm1,-0x20(%rsi,%rbp,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x40,%rbp
add    $0xfffffffffffffffe,%rax
jne    1460 <extract_args+0x340>
jmp    1494 <extract_args+0x374>
xor    %ebp,%ebp
test   $0x1,%r10b
je     14b3 <extract_args+0x393>
lea    (%r8,%rbp,1),%rax
movups (%rbx,%rax,1),%xmm0
movups 0x10(%rbx,%rax,1),%xmm1
movups %xmm0,0x0(%rbp,%r12,1)
movups %xmm1,0x10(%rbp,%r12,1)
cmp    %rcx,%r9
je     157b <extract_args+0x45b>
test   $0x18,%r9b
je     14eb <extract_args+0x3cb>
mov    %r9,%rsi
and    $0xfffffffffffffff8,%rsi
lea    (%rsi,%r8,1),%rax
nopl   (%rax)
mov    (%r11,%rcx,1),%rdi
mov    %rdi,(%r12,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    14d0 <extract_args+0x3b0>
cmp    %rsi,%r9
jne    14f1 <extract_args+0x3d1>
jmp    157b <extract_args+0x45b>
add    %r8,%rcx
mov    %rcx,%rax
mov    %edx,%esi
sub    %eax,%esi
mov    %rax,%rbp
not    %rbp
add    %rdx,%rbp
and    $0x3,%rsi
je     1531 <extract_args+0x411>
lea    (%r14,%r14,4),%rdi
lea    (%r14,%rdi,2),%rdi
add    0x10(%rsp),%rdi
sub    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%rax,1),%ecx
mov    %cl,(%rdi,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1520 <extract_args+0x400>
cmp    $0x3,%rbp
jb     157b <extract_args+0x45b>
lea    (%r14,%r14,4),%rcx
lea    (%r14,%rcx,2),%rcx
sub    %r8,%rcx
mov    0x10(%rsp),%rsi
add    %rcx,%rsi
add    $0x3,%rsi
xchg   %ax,%ax
movzbl (%rbx,%rax,1),%ecx
mov    %cl,-0x3(%rsi,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
mov    %cl,-0x2(%rsi,%rax,1)
movzbl 0x2(%rbx,%rax,1),%ecx
mov    %cl,-0x1(%rsi,%rax,1)
movzbl 0x3(%rbx,%rax,1),%ecx
mov    %cl,(%rsi,%rax,1)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1550 <extract_args+0x430>
mov    %edx,%eax
sub    %r15d,%eax
cltq
lea    (%r14,%r14,4),%rcx
lea    (%r14,%rcx,2),%rcx
mov    0x10(%rsp),%rsi
add    %rcx,%rsi
movb   $0x0,(%rax,%rsi,1)
add    $0x1,%r14d
add    $0x1,%edx
lea    0xa5f(%rip),%rsi
lea    0xc(%rsp),%rcx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <find_char@plt>
mov    0xc(%rsp),%eax
add    $0x1,%eax
mov    0x30(%rsp),%rcx
mov    %eax,(%rcx)
mov    0x28(%rsp),%rax
mov    %r14d,(%rax)
mov    $0x1,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c",)\00"
@.str.1 = [2 x i8] c"=\00"
define i32 @extract_args(i8* %0, i32 %1, i32* %2, i32* %3, [11 x i8]* %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca [11 x i8]*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
store i8* %0, i8** %7
store i32 %1, i32* %8
store i32* %2, i32** %9
store i32* %3, i32** %10
store [11 x i8]* %4, [11 x i8]** %11
%18 = load i32, i32* %8
store i32 %18, i32* %13
%19 = load i8*, i8** %7
%20 = call i64 @strlen(i8* %19)
%21 = trunc i64 %20 to i32
store i32 %21, i32* %14
store i32 0, i32* %16
br label %22
22: ; preds = %119, %5
%23 = load i32, i32* %13
%24 = load i32, i32* %14
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %120
26: ; preds = %22
%27 = load i8*, i8** %7
%28 = load i32, i32* %13
%29 = call i32 (i8*, i8*, i32, i32*, ...) bitcast (i32 (...)* @find_char to i32 (i8*, i8*, i32, i32*, ...)*)(i8* %27, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32 %28, i32* %17)
store i32 %29, i32* %15
%30 = load i32, i32* %15
%31 = icmp eq i32 %30, 0
br i1 %31, label %32, label %70
32: ; preds = %26
%33 = load i32, i32* %13
store i32 %33, i32* %12
br label %34
34: ; preds = %53, %32
%35 = load i32, i32* %12
%36 = load i32, i32* %17
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %56
38: ; preds = %34
%39 = load i8*, i8** %7
%40 = load i32, i32* %12
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
%43 = load i8, i8* %42
%44 = load [11 x i8]*, [11 x i8]** %11
%45 = load i32, i32* %16
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [11 x i8], [11 x i8]* %44, i64 %46
%48 = load i32, i32* %12
%49 = load i32, i32* %13
%50 = sub nsw i32 %48, %49
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [11 x i8], [11 x i8]* %47, i64 0, i64 %51
store i8 %43, i8* %52
br label %53
53: ; preds = %38
%54 = load i32, i32* %12
%55 = add nsw i32 %54, 1
store i32 %55, i32* %12
br label %34
56: ; preds = %34
%57 = load [11 x i8]*, [11 x i8]** %11
%58 = load i32, i32* %16
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [11 x i8], [11 x i8]* %57, i64 %59
%61 = load i32, i32* %17
%62 = load i32, i32* %13
%63 = sub nsw i32 %61, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [11 x i8], [11 x i8]* %60, i64 0, i64 %64
store i8 0, i8* %65
%66 = load i32, i32* %16
%67 = add nsw i32 %66, 1
store i32 %67, i32* %16
%68 = load i32, i32* %17
%69 = add nsw i32 %68, 1
store i32 %69, i32* %13
br label %70
70: ; preds = %56, %26
%71 = load i32, i32* %15
%72 = icmp eq i32 %71, 1
br i1 %72, label %73, label %119
73: ; preds = %70
%74 = load i32, i32* %13
store i32 %74, i32* %12
br label %75
75: ; preds = %94, %73
%76 = load i32, i32* %12
%77 = load i32, i32* %17
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %97
79: ; preds = %75
%80 = load i8*, i8** %7
%81 = load i32, i32* %12
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i8, i8* %80, i64 %82
%84 = load i8, i8* %83
%85 = load [11 x i8]*, [11 x i8]** %11
%86 = load i32, i32* %16
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [11 x i8], [11 x i8]* %85, i64 %87
%89 = load i32, i32* %12
%90 = load i32, i32* %13
%91 = sub nsw i32 %89, %90
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [11 x i8], [11 x i8]* %88, i64 0, i64 %92
store i8 %84, i8* %93
br label %94
94: ; preds = %79
%95 = load i32, i32* %12
%96 = add nsw i32 %95, 1
store i32 %96, i32* %12
br label %75
97: ; preds = %75
%98 = load [11 x i8]*, [11 x i8]** %11
%99 = load i32, i32* %16
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [11 x i8], [11 x i8]* %98, i64 %100
%102 = load i32, i32* %17
%103 = load i32, i32* %13
%104 = sub nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [11 x i8], [11 x i8]* %101, i64 0, i64 %105
store i8 0, i8* %106
%107 = load i32, i32* %16
%108 = add nsw i32 %107, 1
store i32 %108, i32* %16
%109 = load i32, i32* %17
%110 = add nsw i32 %109, 1
store i32 %110, i32* %13
%111 = load i8*, i8** %7
%112 = load i32, i32* %13
%113 = call i32 (i8*, i8*, i32, i32*, ...) bitcast (i32 (...)* @find_char to i32 (i8*, i8*, i32, i32*, ...)*)(i8* %111, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i32 %112, i32* %17)
%114 = load i32, i32* %17
%115 = add nsw i32 %114, 1
%116 = load i32*, i32** %9
store i32 %115, i32* %116
%117 = load i32, i32* %16
%118 = load i32*, i32** %10
store i32 %117, i32* %118
store i32 1, i32* %6
br label %121
119: ; preds = %70
br label %22
120: ; preds = %22
store i32 0, i32* %6
br label %121
121: ; preds = %120, %97
%122 = load i32, i32* %6
ret i32 %122
}

LLVM IR (-O2):
@.str = [3 x i8] c",)\00"
@.str.1 = [2 x i8] c"=\00"
define i32 @extract_args(i8* %0, i32 %1, i32* nocapture writeonly %2, i32* nocapture writeonly %3, [11 x i8]* nocapture writeonly %4) {
%6 = alloca i32
%7 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%8 = trunc i64 %7 to i32
%9 = bitcast i32* %6 to i8*
br label %10
10: ; preds = %163, %5
%11 = phi i32 [ %1, %5 ], [ %164, %163 ]
%12 = phi i32 [ 0, %5 ], [ %165, %163 ]
%13 = icmp slt i32 %11, %8
br i1 %13, label %14, label %315
14: ; preds = %10
%15 = call i32 (i8*, i8*, i32, i32*, ...) bitcast (i32 (...)* @find_char to i32 (i8*, i8*, i32, i32*, ...)*)(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32 %11, i32* %6)
%16 = icmp eq i32 %15, 0
br i1 %16, label %17, label %163
17: ; preds = %14
%18 = load i32, i32* %6
%19 = icmp sgt i32 %18, %11
%20 = sext i32 %12 to i64
br i1 %19, label %21, label %157
21: ; preds = %17
%22 = sext i32 %11 to i64
%23 = sext i32 %18 to i64
%24 = sub nsw i64 %23, %22
%25 = icmp ult i64 %24, 8
br i1 %25, label %114, label %26
26: ; preds = %21
%27 = getelementptr [11 x i8], [11 x i8]* %4, i64 %20, i64 0
%28 = sub nsw i64 %23, %22
%29 = getelementptr [11 x i8], [11 x i8]* %4, i64 %20, i64 %28
%30 = getelementptr i8, i8* %0, i64 %22
%31 = getelementptr i8, i8* %0, i64 %23
%32 = icmp ult i8* %27, %31
%33 = icmp ult i8* %30, %29
%34 = and i1 %32, %33
br i1 %34, label %114, label %35
35: ; preds = %26
%36 = icmp ult i64 %24, 32
br i1 %36, label %96, label %37
37: ; preds = %35
%38 = and i64 %24, -32
%39 = add nsw i64 %38, -32
%40 = lshr exact i64 %39, 5
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 1
%43 = icmp eq i64 %39, 0
br i1 %43, label %75, label %44
44: ; preds = %37
%45 = and i64 %41, 1152921504606846974
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %72, %46 ]
%48 = phi i64 [ 0, %44 ], [ %73, %46 ]
%49 = add i64 %47, %22
%50 = getelementptr inbounds i8, i8* %0, i64 %49
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = getelementptr inbounds i8, i8* %50, i64 16
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %47
%57 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %57
%58 = getelementptr inbounds i8, i8* %56, i64 16
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %55, <16 x i8>* %59
%60 = or i64 %47, 32
%61 = add i64 %60, %22
%62 = getelementptr inbounds i8, i8* %0, i64 %61
%63 = bitcast i8* %62 to <16 x i8>*
%64 = load <16 x i8>, <16 x i8>* %63
%65 = getelementptr inbounds i8, i8* %62, i64 16
%66 = bitcast i8* %65 to <16 x i8>*
%67 = load <16 x i8>, <16 x i8>* %66
%68 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %60
%69 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %64, <16 x i8>* %69
%70 = getelementptr inbounds i8, i8* %68, i64 16
%71 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %67, <16 x i8>* %71
%72 = add nuw i64 %47, 64
%73 = add i64 %48, 2
%74 = icmp eq i64 %73, %45
br i1 %74, label %75, label %46
75: ; preds = %46, %37
%76 = phi i64 [ 0, %37 ], [ %72, %46 ]
%77 = icmp eq i64 %42, 0
br i1 %77, label %90, label %78
78: ; preds = %75
%79 = add i64 %76, %22
%80 = getelementptr inbounds i8, i8* %0, i64 %79
%81 = bitcast i8* %80 to <16 x i8>*
%82 = load <16 x i8>, <16 x i8>* %81
%83 = getelementptr inbounds i8, i8* %80, i64 16
%84 = bitcast i8* %83 to <16 x i8>*
%85 = load <16 x i8>, <16 x i8>* %84
%86 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %76
%87 = bitcast i8* %86 to <16 x i8>*
store <16 x i8> %82, <16 x i8>* %87
%88 = getelementptr inbounds i8, i8* %86, i64 16
%89 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %85, <16 x i8>* %89
br label %90
90: ; preds = %75, %78
%91 = icmp eq i64 %24, %38
br i1 %91, label %157, label %92
92: ; preds = %90
%93 = add nsw i64 %38, %22
%94 = and i64 %24, 24
%95 = icmp eq i64 %94, 0
br i1 %95, label %114, label %96
96: ; preds = %35, %92
%97 = phi i64 [ %38, %92 ], [ 0, %35 ]
%98 = sext i32 %11 to i64
%99 = sub nsw i64 %23, %98
%100 = and i64 %99, -8
%101 = add nsw i64 %100, %22
br label %102
102: ; preds = %102, %96
%103 = phi i64 [ %97, %96 ], [ %110, %102 ]
%104 = add i64 %103, %22
%105 = getelementptr inbounds i8, i8* %0, i64 %104
%106 = bitcast i8* %105 to <8 x i8>*
%107 = load <8 x i8>, <8 x i8>* %106
%108 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %103
%109 = bitcast i8* %108 to <8 x i8>*
store <8 x i8> %107, <8 x i8>* %109
%110 = add nuw i64 %103, 8
%111 = icmp eq i64 %110, %100
br i1 %111, label %112, label %102
112: ; preds = %102
%113 = icmp eq i64 %99, %100
br i1 %113, label %157, label %114
114: ; preds = %26, %21, %92, %112
%115 = phi i64 [ %22, %21 ], [ %22, %26 ], [ %93, %92 ], [ %101, %112 ]
%116 = sub nsw i64 %23, %115
%117 = xor i64 %115, -1
%118 = add nsw i64 %117, %23
%119 = and i64 %116, 3
%120 = icmp eq i64 %119, 0
br i1 %120, label %131, label %121
121: ; preds = %114, %121
%122 = phi i64 [ %128, %121 ], [ %115, %114 ]
%123 = phi i64 [ %129, %121 ], [ 0, %114 ]
%124 = getelementptr inbounds i8, i8* %0, i64 %122
%125 = load i8, i8* %124
%126 = sub nsw i64 %122, %22
%127 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %126
store i8 %125, i8* %127
%128 = add nsw i64 %122, 1
%129 = add i64 %123, 1
%130 = icmp eq i64 %129, %119
br i1 %130, label %131, label %121
131: ; preds = %121, %114
%132 = phi i64 [ %115, %114 ], [ %128, %121 ]
%133 = icmp ult i64 %118, 3
br i1 %133, label %157, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %155, %134 ], [ %132, %131 ]
%136 = getelementptr inbounds i8, i8* %0, i64 %135
%137 = load i8, i8* %136
%138 = sub nsw i64 %135, %22
%139 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %138
store i8 %137, i8* %139
%140 = add nsw i64 %135, 1
%141 = getelementptr inbounds i8, i8* %0, i64 %140
%142 = load i8, i8* %141
%143 = sub nsw i64 %140, %22
%144 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %143
store i8 %142, i8* %144
%145 = add nsw i64 %135, 2
%146 = getelementptr inbounds i8, i8* %0, i64 %145
%147 = load i8, i8* %146
%148 = sub nsw i64 %145, %22
%149 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %148
store i8 %147, i8* %149
%150 = add nsw i64 %135, 3
%151 = getelementptr inbounds i8, i8* %0, i64 %150
%152 = load i8, i8* %151
%153 = sub nsw i64 %150, %22
%154 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %153
store i8 %152, i8* %154
%155 = add nsw i64 %135, 4
%156 = icmp eq i64 %155, %23
br i1 %156, label %157, label %134
157: ; preds = %131, %134, %90, %112, %17
%158 = sub nsw i32 %18, %11
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %20, i64 %159
store i8 0, i8* %160
%161 = add nsw i32 %12, 1
%162 = add nsw i32 %18, 1
br label %163
163: ; preds = %157, %14
%164 = phi i32 [ %162, %157 ], [ %11, %14 ]
%165 = phi i32 [ %161, %157 ], [ %12, %14 ]
%166 = icmp eq i32 %15, 1
br i1 %166, label %167, label %10
167: ; preds = %163
%168 = load i32, i32* %6
%169 = icmp sgt i32 %168, %164
%170 = sext i32 %165 to i64
br i1 %169, label %171, label %306
171: ; preds = %167
%172 = sext i32 %164 to i64
%173 = sext i32 %168 to i64
%174 = sub nsw i64 %173, %172
%175 = icmp ult i64 %174, 8
br i1 %175, label %263, label %176
176: ; preds = %171
%177 = getelementptr [11 x i8], [11 x i8]* %4, i64 %170, i64 0
%178 = sub nsw i64 %173, %172
%179 = getelementptr [11 x i8], [11 x i8]* %4, i64 %170, i64 %178
%180 = getelementptr i8, i8* %0, i64 %172
%181 = getelementptr i8, i8* %0, i64 %173
%182 = icmp ult i8* %177, %181
%183 = icmp ult i8* %180, %179
%184 = and i1 %182, %183
br i1 %184, label %263, label %185
185: ; preds = %176
%186 = icmp ult i64 %174, 32
br i1 %186, label %246, label %187
187: ; preds = %185
%188 = and i64 %174, -32
%189 = add nsw i64 %188, -32
%190 = lshr exact i64 %189, 5
%191 = add nuw nsw i64 %190, 1
%192 = and i64 %191, 1
%193 = icmp eq i64 %189, 0
br i1 %193, label %225, label %194
194: ; preds = %187
%195 = and i64 %191, 1152921504606846974
br label %196
196: ; preds = %196, %194
%197 = phi i64 [ 0, %194 ], [ %222, %196 ]
%198 = phi i64 [ 0, %194 ], [ %223, %196 ]
%199 = add i64 %197, %172
%200 = getelementptr inbounds i8, i8* %0, i64 %199
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = getelementptr inbounds i8, i8* %200, i64 16
%204 = bitcast i8* %203 to <16 x i8>*
%205 = load <16 x i8>, <16 x i8>* %204
%206 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %197
%207 = bitcast i8* %206 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %207
%208 = getelementptr inbounds i8, i8* %206, i64 16
%209 = bitcast i8* %208 to <16 x i8>*
store <16 x i8> %205, <16 x i8>* %209
%210 = or i64 %197, 32
%211 = add i64 %210, %172
%212 = getelementptr inbounds i8, i8* %0, i64 %211
%213 = bitcast i8* %212 to <16 x i8>*
%214 = load <16 x i8>, <16 x i8>* %213
%215 = getelementptr inbounds i8, i8* %212, i64 16
%216 = bitcast i8* %215 to <16 x i8>*
%217 = load <16 x i8>, <16 x i8>* %216
%218 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %210
%219 = bitcast i8* %218 to <16 x i8>*
store <16 x i8> %214, <16 x i8>* %219
%220 = getelementptr inbounds i8, i8* %218, i64 16
%221 = bitcast i8* %220 to <16 x i8>*
store <16 x i8> %217, <16 x i8>* %221
%222 = add nuw i64 %197, 64
%223 = add i64 %198, 2
%224 = icmp eq i64 %223, %195
br i1 %224, label %225, label %196
225: ; preds = %196, %187
%226 = phi i64 [ 0, %187 ], [ %222, %196 ]
%227 = icmp eq i64 %192, 0
br i1 %227, label %240, label %228
228: ; preds = %225
%229 = add i64 %226, %172
%230 = getelementptr inbounds i8, i8* %0, i64 %229
%231 = bitcast i8* %230 to <16 x i8>*
%232 = load <16 x i8>, <16 x i8>* %231
%233 = getelementptr inbounds i8, i8* %230, i64 16
%234 = bitcast i8* %233 to <16 x i8>*
%235 = load <16 x i8>, <16 x i8>* %234
%236 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %226
%237 = bitcast i8* %236 to <16 x i8>*
store <16 x i8> %232, <16 x i8>* %237
%238 = getelementptr inbounds i8, i8* %236, i64 16
%239 = bitcast i8* %238 to <16 x i8>*
store <16 x i8> %235, <16 x i8>* %239
br label %240
240: ; preds = %225, %228
%241 = icmp eq i64 %174, %188
br i1 %241, label %306, label %242
242: ; preds = %240
%243 = add nsw i64 %188, %172
%244 = and i64 %174, 24
%245 = icmp eq i64 %244, 0
br i1 %245, label %263, label %246
246: ; preds = %185, %242
%247 = phi i64 [ %188, %242 ], [ 0, %185 ]
%248 = sub nsw i64 %173, %172
%249 = and i64 %248, -8
%250 = add nsw i64 %249, %172
br label %251
251: ; preds = %251, %246
%252 = phi i64 [ %247, %246 ], [ %259, %251 ]
%253 = add i64 %252, %172
%254 = getelementptr inbounds i8, i8* %0, i64 %253
%255 = bitcast i8* %254 to <8 x i8>*
%256 = load <8 x i8>, <8 x i8>* %255
%257 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %252
%258 = bitcast i8* %257 to <8 x i8>*
store <8 x i8> %256, <8 x i8>* %258
%259 = add nuw i64 %252, 8
%260 = icmp eq i64 %259, %249
br i1 %260, label %261, label %251
261: ; preds = %251
%262 = icmp eq i64 %248, %249
br i1 %262, label %306, label %263
263: ; preds = %176, %171, %242, %261
%264 = phi i64 [ %172, %171 ], [ %172, %176 ], [ %243, %242 ], [ %250, %261 ]
%265 = sub nsw i64 %173, %264
%266 = xor i64 %264, -1
%267 = add nsw i64 %266, %173
%268 = and i64 %265, 3
%269 = icmp eq i64 %268, 0
br i1 %269, label %280, label %270
270: ; preds = %263, %270
%271 = phi i64 [ %277, %270 ], [ %264, %263 ]
%272 = phi i64 [ %278, %270 ], [ 0, %263 ]
%273 = getelementptr inbounds i8, i8* %0, i64 %271
%274 = load i8, i8* %273
%275 = sub nsw i64 %271, %172
%276 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %275
store i8 %274, i8* %276
%277 = add nsw i64 %271, 1
%278 = add i64 %272, 1
%279 = icmp eq i64 %278, %268
br i1 %279, label %280, label %270
280: ; preds = %270, %263
%281 = phi i64 [ %264, %263 ], [ %277, %270 ]
%282 = icmp ult i64 %267, 3
br i1 %282, label %306, label %283
283: ; preds = %280, %283
%284 = phi i64 [ %304, %283 ], [ %281, %280 ]
%285 = getelementptr inbounds i8, i8* %0, i64 %284
%286 = load i8, i8* %285
%287 = sub nsw i64 %284, %172
%288 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %287
store i8 %286, i8* %288
%289 = add nsw i64 %284, 1
%290 = getelementptr inbounds i8, i8* %0, i64 %289
%291 = load i8, i8* %290
%292 = sub nsw i64 %289, %172
%293 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %292
store i8 %291, i8* %293
%294 = add nsw i64 %284, 2
%295 = getelementptr inbounds i8, i8* %0, i64 %294
%296 = load i8, i8* %295
%297 = sub nsw i64 %294, %172
%298 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %297
store i8 %296, i8* %298
%299 = add nsw i64 %284, 3
%300 = getelementptr inbounds i8, i8* %0, i64 %299
%301 = load i8, i8* %300
%302 = sub nsw i64 %299, %172
%303 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %302
store i8 %301, i8* %303
%304 = add nsw i64 %284, 4
%305 = icmp eq i64 %304, %173
br i1 %305, label %306, label %283
306: ; preds = %280, %283, %240, %261, %167
%307 = sub nsw i32 %168, %164
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 %170, i64 %308
store i8 0, i8* %309
%310 = add nsw i32 %165, 1
%311 = add nsw i32 %168, 1
%312 = call i32 (i8*, i8*, i32, i32*, ...) bitcast (i32 (...)* @find_char to i32 (i8*, i8*, i32, i32*, ...)*)(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i32 %311, i32* %6)
%313 = load i32, i32* %6
%314 = add nsw i32 %313, 1
store i32 %314, i32* %2
store i32 %310, i32* %3
br label %315
315: ; preds = %10, %306
%316 = phi i32 [ 1, %306 ], [ 0, %10 ]
ret i32 %316
}