int search_array(old, new, i1, i2, flag)
char *old, *new;
int *i1, *i2, *flag;
{
  int i, j, k, l;
  int ileft, iright;
  int n = strlen(old);
  char num1[20], num2[20];
  char ch, chp;
  ileft = n - 1;
  iright = -1;
  *i1 = 0;
  *i2 = 0;
  *flag = 0;
  strcpy(num1, "0");
  strcpy(num2, "0");
  if (old[0] == '#' || old[1] == '#') {
    strcpy(new, old);
    return 1;
  }
  if (check_if_ic(old) == 1) {
    extract_ic_data(old);
    strcpy(new, old);
    return 1;
  }
  for (i = 0; i < n; i++) {
    ch = old[i];
    chp = old[i + 1];
    if (ch == '.' && chp == '.') {
      j = 0;
      *flag = 1;
      if (old[0] == '%')
        *flag = 2;
      while (1) {
        ch = old[i + j];
        if (ch == '[') {
          ileft = i + j;
          l = 0;
          for (k = i + j + 1; k < i; k++) {
            num1[l] = old[k];
            l++;
          }
          num1[l] = 0;
          break;
        }
        j--;
        if ((i + j) <= 0) {
          *i1 = 0;
          *i2 = 0;
          strcpy(new, old);
          plintf(" Possible error in array %s -- ignoring it \n", old);
          return (0);
        }
      }
      j = 2;
      while (1) {
        ch = old[i + j];
        if (ch == ']') {
          iright = i + j;
          l = 0;
          for (k = 2; k < j; k++) {
            num2[l] = old[i + k];
            l++;
          }
          num2[l] = 0;
          break;
        }
        j++;
        if ((i + j) >= n) {
          *i1 = 0;
          *i2 = 0;
          strcpy(new, old);
          plintf(" Possible error in array  %s -- ignoring it \n", old);
          return (0);
        }
      }
    }
  }
  *i1 = atoi(num1);
  *i2 = atoi(num2);
  l = 0;
  for (i = 0; i <= ileft; i++) {
    new[l] = old[i];
    l++;
  }
  if (iright > 0) {
    new[l] = 'j';
    l++;
    for (i = iright; i < n; i++) {
      new[l] = old[i];
      l++;
    }
  }
  new[l] = 0;
  return 1;
}


x86 assembly (clang, -O0):
<search_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0xffffffff,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
lea    -0x60(%rbp),%rdi
lea    0xe3c(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x80(%rbp),%rdi
lea    0xe2c(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
je     11fa <search_array+0x9a>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x23,%eax
jne    1213 <search_array+0xb3>
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <strcpy@plt>
movl   $0x1,-0x4(%rbp)
jmp    159b <search_array+0x43b>
mov    -0x10(%rbp),%rdi
mov    $0x0,%al
call   1060 <check_if_ic@plt>
cmp    $0x1,%eax
jne    124b <search_array+0xeb>
mov    -0x10(%rbp),%rdi
mov    $0x0,%al
call   1050 <extract_ic_data@plt>
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <strcpy@plt>
movl   $0x1,-0x4(%rbp)
jmp    159b <search_array+0x43b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    14b8 <search_array+0x358>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x81(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x82(%rbp)
movsbl -0x81(%rbp),%eax
cmp    $0x2e,%eax
jne    14a5 <search_array+0x345>
movsbl -0x82(%rbp),%eax
cmp    $0x2e,%eax
jne    14a5 <search_array+0x345>
movl   $0x0,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x25,%eax
jne    12d0 <search_array+0x170>
mov    -0x30(%rbp),%rax
movl   $0x2,(%rax)
jmp    12d5 <search_array+0x175>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x81(%rbp)
movsbl -0x81(%rbp),%eax
cmp    $0x5b,%eax
jne    135b <search_array+0x1fb>
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    134d <search_array+0x1ed>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x40(%rbp),%rax
mov    %cl,-0x60(%rbp,%rax,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1317 <search_array+0x1b7>
movslq -0x40(%rbp),%rax
movb   $0x0,-0x60(%rbp,%rax,1)
jmp    13b7 <search_array+0x257>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
cmp    $0x0,%eax
jg     13b2 <search_array+0x252>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rsi
lea    0xc63(%rip),%rdi
mov    $0x0,%al
call   1070 <plintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    159b <search_array+0x43b>
jmp    12d5 <search_array+0x175>
movl   $0x2,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x81(%rbp)
movsbl -0x81(%rbp),%eax
cmp    $0x5d,%eax
jne    1444 <search_array+0x2e4>
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x2,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1436 <search_array+0x2d6>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x40(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13fb <search_array+0x29b>
movslq -0x40(%rbp),%rax
movb   $0x0,-0x80(%rbp,%rax,1)
jmp    14a0 <search_array+0x340>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jl     149b <search_array+0x33b>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rsi
lea    0xba7(%rip),%rdi
mov    $0x0,%al
call   1070 <plintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    159b <search_array+0x43b>
jmp    13be <search_array+0x25e>
jmp    14a5 <search_array+0x345>
jmp    14aa <search_array+0x34a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1252 <search_array+0xf2>
lea    -0x60(%rbp),%rdi
mov    $0x0,%al
call   1080 <atoi@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
lea    -0x80(%rbp),%rdi
mov    $0x0,%al
call   1080 <atoi@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1525 <search_array+0x3c5>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14ec <search_array+0x38c>
cmpl   $0x0,-0x48(%rbp)
jle    1588 <search_array+0x428>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x6a,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1583 <search_array+0x423>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    154a <search_array+0x3ea>
jmp    1588 <search_array+0x428>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<search_array>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r8,%rbp
mov    %rcx,%r13
mov    %rdx,%rbx
mov    %rsi,%r12
mov    %rdi,%r14
call   1040 <strlen@plt>
movl   $0x0,(%rbx)
movl   $0x0,0x0(%r13)
movl   $0x0,0x0(%rbp)
movw   $0x30,0x70(%rsp)
movw   $0x30,0x50(%rsp)
cmpb   $0x23,(%r14)
je     11e1 <search_array+0x71>
cmpb   $0x23,0x1(%r14)
je     11e1 <search_array+0x71>
mov    %rax,%r15
mov    %r14,%rdi
xor    %eax,%eax
call   1070 <check_if_ic@plt>
cmp    $0x1,%eax
jne    1205 <search_array+0x95>
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <extract_ic_data@plt>
mov    %r12,%rdi
mov    %r14,%rsi
call   1030 <strcpy@plt>
mov    $0x1,%ebp
mov    %ebp,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbp,0x48(%rsp)
mov    %r15,%r9
add    $0xffffffff,%r15d
test   %r9d,%r9d
mov    %r13,0x28(%rsp)
mov    %r12,0x20(%rsp)
mov    %rbx,0x18(%rsp)
jle    125b <search_array+0xeb>
movabs $0x100000000,%rdi
mov    %r9d,%edx
mov    $0xffffffff,%r8d
xor    %r12d,%r12d
lea    -0x2(%rdi),%rsi
lea    0x70(%rsp),%r10
movabs $0xffffffff00000000,%rbx
ff ff ff
mov    %rdi,%r11
mov    %r9,0x40(%rsp)
jmp    146d <search_array+0x2fd>
mov    $0xffffffff,%r8d
mov    %r9,%r13
xor    %ebp,%ebp
lea    0x70(%rsp),%rdi
xor    %eax,%eax
mov    %r8,%r12
call   1090 <atoi@plt>
mov    0x18(%rsp),%rcx
mov    %eax,(%rcx)
lea    0x50(%rsp),%rdi
xor    %eax,%eax
call   1090 <atoi@plt>
mov    %r12,%r8
mov    0x28(%rsp),%rcx
mov    %eax,(%rcx)
test   %r15d,%r15d
mov    0x20(%rsp),%rbx
js     132f <search_array+0x1bf>
lea    0x1(%r15),%ebp
cmp    $0x7,%r15d
jb     12c4 <search_array+0x154>
lea    (%r14,%rbp,1),%rax
cmp    %rbx,%rax
jbe    15d5 <search_array+0x465>
lea    (%rbx,%rbp,1),%rax
cmp    %r14,%rax
jbe    15d5 <search_array+0x465>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbp,%rsi
mov    %rbp,%rdx
and    $0x3,%rdx
je     12f2 <search_array+0x182>
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ecx
mov    %cl,(%rbx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    12e0 <search_array+0x170>
cmp    $0x3,%rsi
jb     132f <search_array+0x1bf>
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ecx
mov    %cl,(%rbx,%rax,1)
movzbl 0x1(%r14,%rax,1),%ecx
mov    %cl,0x1(%rbx,%rax,1)
movzbl 0x2(%r14,%rax,1),%ecx
mov    %cl,0x2(%rbx,%rax,1)
movzbl 0x3(%r14,%rax,1),%ecx
mov    %cl,0x3(%rbx,%rax,1)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1300 <search_array+0x190>
test   %r8d,%r8d
jle    1773 <search_array+0x603>
mov    %r13,%rsi
mov    %ebp,%edi
movb   $0x6a,(%rbx,%rdi,1)
cmp    %esi,%r8d
jge    1403 <search_array+0x293>
lea    0x1(%rdi),%rbp
mov    %r8d,%eax
movslq %esi,%r11
mov    %r11,%r10
sub    %rax,%r10
cmp    $0x20,%r10
jb     170b <search_array+0x59b>
lea    (%rbx,%rbp,1),%rcx
lea    (%r14,%r11,1),%rdx
cmp    %rdx,%rcx
jae    138c <search_array+0x21c>
lea    (%r11,%rdi,1),%rcx
sub    %rax,%rcx
add    %rbx,%rcx
add    $0x1,%rcx
lea    (%r14,%rax,1),%rdx
cmp    %rcx,%rdx
jb     170b <search_array+0x59b>
mov    %r10,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     16da <search_array+0x56a>
movabs $0xffffffffffffffc,%rsi
ff ff 0f
or     $0x2,%rsi
and    %r9,%rsi
lea    (%rax,%r14,1),%rdx
add    $0x30,%rdx
lea    (%rdi,%rbx,1),%rcx
add    $0x31,%rcx
xor    %edi,%edi
movups -0x30(%rdx,%rdi,1),%xmm0
movups -0x20(%rdx,%rdi,1),%xmm1
movups %xmm0,-0x30(%rcx,%rdi,1)
movups %xmm1,-0x20(%rcx,%rdi,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rsi
jne    13ce <search_array+0x25e>
jmp    16dc <search_array+0x56c>
add    $0x1,%ebp
jmp    1773 <search_array+0x603>
mov    %eax,%r13d
add    $0x1,%r13
lea    0x50(%rsp),%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
mov    %r8,0x8(%rsp)
mov    %r10,%rbp
mov    %r11,0x10(%rsp)
call   1060 <memcpy@plt>
mov    0x10(%rsp),%r11
mov    %rbp,%r10
movabs $0x100000000,%rdi
mov    0x40(%rsp),%r9
mov    0x8(%rsp),%r8
mov    0x38(%rsp),%rdx
mov    0x30(%rsp),%rsi
mov    %r13d,%eax
movb   $0x0,0x50(%rsp,%rax,1)
add    $0x1,%r12
add    %rdi,%r11
cmp    %rdx,%r12
je     1261 <search_array+0xf1>
cmpb   $0x2e,(%r14,%r12,1)
jne    145d <search_array+0x2ed>
cmpb   $0x2e,0x1(%r14,%r12,1)
jne    145d <search_array+0x2ed>
lea    (%r14,%r12,1),%rbp
add    $0x2,%rbp
mov    0x48(%rsp),%rcx
movl   $0x1,(%rcx)
xor    %eax,%eax
cmpb   $0x25,(%r14)
sete   %al
add    $0x1,%eax
mov    %eax,(%rcx)
mov    $0xffffffff,%r13d
mov    %r12,%r15
mov    %r11,%rcx
mov    %rsi,%rax
nopl   0x0(%rax)
cmpb   $0x5b,(%r14,%r15,1)
je     14cd <search_array+0x35d>
add    $0x1,%rax
add    %rbx,%rcx
add    $0x1,%r13d
add    $0xffffffffffffffff,%r15
jg     14b0 <search_array+0x340>
jmp    156e <search_array+0x3fe>
mov    %rsi,0x30(%rsp)
mov    %rdx,0x38(%rsp)
sar    $0x20,%rcx
xor    %edx,%edx
cmp    %r12,%rcx
jge    151f <search_array+0x3af>
lea    (%r14,%r15,1),%rsi
add    $0x1,%rsi
mov    %eax,%edx
add    $0x1,%rdx
mov    %r10,%rdi
mov    %rbp,0x8(%rsp)
mov    %r10,%rbp
mov    %r11,0x10(%rsp)
call   1060 <memcpy@plt>
mov    0x10(%rsp),%r11
mov    %rbp,%r10
mov    0x8(%rsp),%rbp
movabs $0x100000000,%rdi
mov    %r13d,%edx
mov    %edx,%eax
movb   $0x0,0x70(%rsp,%rax,1)
lea    (%r14,%r12,1),%rdx
lea    -0x1(%rdi),%rax
mov    $0x2,%ecx
mov    0x40(%rsp),%r9
nopl   0x0(%rax,%rax,1)
cmpb   $0x5d,(%rdx,%rcx,1)
je     1559 <search_array+0x3e9>
add    $0x1,%rcx
add    $0x1,%rax
lea    (%rcx,%r12,1),%esi
cmp    %r9d,%esi
jl     1540 <search_array+0x3d0>
jmp    159a <search_array+0x42a>
lea    (%r12,%rcx,1),%r8
cmp    $0x3,%ecx
jae    140b <search_array+0x29b>
xor    %r13d,%r13d
jmp    144b <search_array+0x2db>
mov    0x18(%rsp),%rax
movl   $0x0,(%rax)
mov    0x28(%rsp),%rax
movl   $0x0,(%rax)
mov    0x20(%rsp),%rdi
mov    %r14,%rsi
call   1030 <strcpy@plt>
lea    0xa68(%rip),%rdi
jmp    15c4 <search_array+0x454>
mov    0x18(%rsp),%rax
movl   $0x0,(%rax)
mov    0x28(%rsp),%rax
movl   $0x0,(%rax)
mov    0x20(%rsp),%rdi
mov    %r14,%rsi
call   1030 <strcpy@plt>
lea    0xa69(%rip),%rdi
xor    %ebp,%ebp
mov    %r14,%rsi
xor    %eax,%eax
call   1080 <plintf@plt>
jmp    11f1 <search_array+0x81>
cmp    $0x1f,%r15d
jae    15e2 <search_array+0x472>
xor    %eax,%eax
jmp    16b3 <search_array+0x543>
mov    %ebp,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1605 <search_array+0x495>
xor    %esi,%esi
jmp    166b <search_array+0x4fb>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm1,0x30(%rbx,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm1,0x50(%rbx,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm1,0x70(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    160b <search_array+0x49b>
test   %rcx,%rcx
je     16a0 <search_array+0x530>
lea    (%rbx,%rsi,1),%rdx
add    $0x10,%rdx
add    %r14,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1685 <search_array+0x515>
cmp    %rbp,%rax
je     132f <search_array+0x1bf>
test   $0x18,%bpl
je     12c6 <search_array+0x156>
mov    %rax,%rcx
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    (%r14,%rcx,1),%rdx
mov    %rdx,(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    16bb <search_array+0x54b>
cmp    %rbp,%rax
je     132f <search_array+0x1bf>
jmp    12c6 <search_array+0x156>
xor    %edi,%edi
test   $0x1,%r9b
je     16fd <search_array+0x58d>
lea    (%rdi,%rbp,1),%rcx
add    %rax,%rdi
movups (%r14,%rdi,1),%xmm0
movups 0x10(%r14,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rcx,1)
movups %xmm1,0x10(%rbx,%rcx,1)
add    %r8,%rbp
cmp    %r8,%r10
je     1773 <search_array+0x603>
mov    %r13,%rsi
add    %r8,%rax
sub    %eax,%esi
mov    %rax,%rdx
not    %rdx
add    %r11,%rdx
and    $0x3,%rsi
je     1736 <search_array+0x5c6>
nopl   0x0(%rax)
movzbl (%r14,%rax,1),%ecx
mov    %cl,(%rbx,%rbp,1)
add    $0x1,%rax
add    $0x1,%rbp
add    $0xffffffffffffffff,%rsi
jne    1720 <search_array+0x5b0>
cmp    $0x3,%rdx
jb     1773 <search_array+0x603>
nopl   0x0(%rax)
movzbl (%r14,%rax,1),%ecx
mov    %cl,(%rbx,%rbp,1)
movzbl 0x1(%r14,%rax,1),%ecx
mov    %cl,0x1(%rbx,%rbp,1)
movzbl 0x2(%r14,%rax,1),%ecx
mov    %cl,0x2(%rbx,%rbp,1)
movzbl 0x3(%r14,%rax,1),%ecx
mov    %cl,0x3(%rbx,%rbp,1)
add    $0x4,%rax
add    $0x4,%rbp
cmp    %rax,%r11
jne    1740 <search_array+0x5d0>
movslq %ebp,%rax
movb   $0x0,(%rbx,%rax,1)
jmp    11ec <search_array+0x7c>

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

LLVM IR (-O2):
@.str.1 = [45 x i8] c" Possible error in array %s -- ignoring it \0A\00"
@.str.2 = [46 x i8] c" Possible error in array %s -- ignoring it \0A\00"
define i32 @search_array(i8* %0, i8* %1, i32* nocapture writeonly %2, i32* nocapture writeonly %3, i32* nocapture writeonly %4) {
%6 = alloca [20 x i8]
%7 = getelementptr inbounds [20 x i8], [20 x i8]* %6, i64 0, i64 0
%8 = alloca [20 x i8]
%9 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 0
%10 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%11 = trunc i64 %10 to i32
%12 = getelementptr inbounds [20 x i8], [20 x i8]* %6, i64 0, i64 0
%13 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 0
%14 = add nsw i32 %11, -1
store i32 0, i32* %2
store i32 0, i32* %3
store i32 0, i32* %4
%15 = bitcast [20 x i8]* %6 to i16*
store i16 48, i16* %15
%16 = bitcast [20 x i8]* %8 to i16*
store i16 48, i16* %16
%17 = load i8, i8* %0
%18 = icmp eq i8 %17, 35
br i1 %18, label %23, label %19
19: ; preds = %5
%20 = getelementptr i8, i8* %0, i64 1
%21 = load i8, i8* %20
%22 = icmp eq i8 %21, 35
br i1 %22, label %23, label %25
23: ; preds = %19, %5
%24 = tail call i8* @strcpy(i8* dereferenceable(1) %1, i8* %0)
br label %407
25: ; preds = %19
%26 = tail call i32 (i8*, ...) bitcast (i32 (...)* @check_if_ic to i32 (i8*, ...)*)(i8* %0)
%27 = icmp eq i32 %26, 1
br i1 %27, label %32, label %28
28: ; preds = %25
%29 = icmp sgt i32 %11, 0
br i1 %29, label %30, label %115
30: ; preds = %28
%31 = and i64 %10, 4294967295
br label %35
32: ; preds = %25
%33 = tail call i32 (i8*, ...) bitcast (i32 (...)* @extract_ic_data to i32 (i8*, ...)*)(i8* %0)
%34 = tail call i8* @strcpy(i8* dereferenceable(1) %1, i8* %0)
br label %407
35: ; preds = %30, %110
%36 = phi i64 [ 0, %30 ], [ %44, %110 ]
%37 = phi i32 [ -1, %30 ], [ %113, %110 ]
%38 = phi i32 [ -1, %30 ], [ %112, %110 ]
%39 = phi i32 [ %14, %30 ], [ %111, %110 ]
%40 = add nuw nsw i64 %36, 2
%41 = getelementptr i8, i8* %0, i64 %40
%42 = getelementptr inbounds i8, i8* %0, i64 %36
%43 = load i8, i8* %42
%44 = add nuw nsw i64 %36, 1
%45 = getelementptr inbounds i8, i8* %0, i64 %44
%46 = load i8, i8* %45
%47 = icmp eq i8 %43, 46
%48 = icmp eq i8 %46, 46
%49 = select i1 %47, i1 %48, i1 false
br i1 %49, label %50, label %110
50: ; preds = %35
store i32 1, i32* %4
%51 = load i8, i8* %0
%52 = icmp eq i8 %51, 37
%53 = select i1 %52, i32 2, i32 1
store i32 %53, i32* %4
br label %54
54: ; preds = %77, %50
%55 = phi i64 [ %78, %77 ], [ 0, %50 ]
%56 = add nsw i64 %55, %36
%57 = getelementptr inbounds i8, i8* %0, i64 %56
%58 = load i8, i8* %57
%59 = icmp eq i8 %58, 91
br i1 %59, label %60, label %77
60: ; preds = %54
%61 = trunc i64 %56 to i32
%62 = shl i64 %56, 32
%63 = add i64 %62, 4294967296
%64 = ashr exact i64 %63, 32
%65 = icmp slt i64 %64, %36
br i1 %65, label %66, label %73
66: ; preds = %60
%67 = getelementptr i8, i8* %20, i64 %56
%68 = add nuw i64 %36, 4294967294
%69 = sub i64 %68, %56
%70 = and i64 %69, 4294967295
%71 = add nuw nsw i64 %70, 1
%72 = sub i32 %37, %61
br label %73
73: ; preds = %66, %60
%74 = phi i32 [ 0, %60 ], [ %72, %66 ]
%75 = zext i32 %74 to i64
%76 = getelementptr inbounds [20 x i8], [20 x i8]* %6, i64 0, i64 %75
store i8 0, i8* %76
br label %84
77: ; preds = %54
%78 = add nsw i64 %55, -1
%79 = add nsw i64 %78, %36
%80 = icmp slt i64 %79, 1
br i1 %80, label %81, label %54
81: ; preds = %77
store i32 0, i32* %2
store i32 0, i32* %3
%82 = tail call i8* @strcpy(i8* dereferenceable(1) %1, i8* %0)
%83 = tail call i32 (i8*, i8*, ...) bitcast (i32 (...)* @plintf to i32 (i8*, i8*, ...)*)(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.1, i64 0, i64 0), i8* %0)
br label %407
84: ; preds = %102, %73
%85 = phi i64 [ %103, %102 ], [ 2, %73 ]
%86 = add nuw nsw i64 %85, %36
%87 = getelementptr inbounds i8, i8* %0, i64 %86
%88 = load i8, i8* %87
%89 = icmp eq i8 %88, 93
br i1 %89, label %90, label %102
90: ; preds = %84
%91 = trunc i64 %85 to i32
%92 = trunc i64 %86 to i32
%93 = icmp ugt i32 %91, 2
br i1 %93, label %94, label %98
94: ; preds = %90
%95 = add nuw i64 %85, 4294967293
%96 = and i64 %95, 4294967295
%97 = add nuw nsw i64 %96, 1
br label %98
98: ; preds = %94, %90
%99 = phi i64 [ 0, %90 ], [ %97, %94 ]
%100 = and i64 %99, 4294967295
%101 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 %100
store i8 0, i8* %101
br label %110
102: ; preds = %84
%103 = add nuw nsw i64 %85, 1
%104 = add nuw nsw i64 %103, %36
%105 = trunc i64 %104 to i32
%106 = icmp slt i32 %105, %11
br i1 %106, label %84, label %107
107: ; preds = %102
store i32 0, i32* %2
store i32 0, i32* %3
%108 = tail call i8* @strcpy(i8* dereferenceable(1) %1, i8* %0)
%109 = tail call i32 (i8*, i8*, ...) bitcast (i32 (...)* @plintf to i32 (i8*, i8*, ...)*)(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.2, i64 0, i64 0), i8* %0)
br label %407
110: ; preds = %35, %98
%111 = phi i32 [ %61, %98 ], [ %39, %35 ]
%112 = phi i32 [ %92, %98 ], [ %38, %35 ]
%113 = add nsw i32 %37, 1
%114 = icmp eq i64 %44, %31
br i1 %114, label %115, label %35
115: ; preds = %110, %28
%116 = phi i32 [ %14, %28 ], [ %111, %110 ]
%117 = phi i32 [ -1, %28 ], [ %112, %110 ]
%118 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %12)
store i32 %118, i32* %2
%119 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %13)
store i32 %119, i32* %3
%120 = icmp slt i32 %116, 0
br i1 %120, label %266, label %121
121: ; preds = %115
%122 = add nuw i32 %116, 1
%123 = zext i32 %122 to i64
%124 = icmp ult i32 %116, 7
br i1 %124, label %229, label %125
125: ; preds = %121
%126 = getelementptr i8, i8* %1, i64 %123
%127 = getelementptr i8, i8* %0, i64 %123
%128 = icmp ugt i8* %127, %1
%129 = icmp ugt i8* %126, %0
%130 = and i1 %128, %129
br i1 %130, label %229, label %131
131: ; preds = %125
%132 = icmp ult i32 %116, 31
br i1 %132, label %215, label %133
133: ; preds = %131
%134 = and i64 %123, 4294967264
%135 = add nsw i64 %134, -32
%136 = lshr exact i64 %135, 5
%137 = add nuw nsw i64 %136, 1
%138 = and i64 %137, 3
%139 = icmp ult i64 %135, 96
br i1 %139, label %191, label %140
140: ; preds = %133
%141 = and i64 %137, 1152921504606846972
br label %142
142: ; preds = %142, %140
%143 = phi i64 [ 0, %140 ], [ %188, %142 ]
%144 = phi i64 [ 0, %140 ], [ %189, %142 ]
%145 = getelementptr inbounds i8, i8* %0, i64 %143
%146 = bitcast i8* %145 to <16 x i8>*
%147 = load <16 x i8>, <16 x i8>* %146
%148 = getelementptr inbounds i8, i8* %145, i64 16
%149 = bitcast i8* %148 to <16 x i8>*
%150 = load <16 x i8>, <16 x i8>* %149
%151 = getelementptr inbounds i8, i8* %1, i64 %143
%152 = bitcast i8* %151 to <16 x i8>*
store <16 x i8> %147, <16 x i8>* %152
%153 = getelementptr inbounds i8, i8* %151, i64 16
%154 = bitcast i8* %153 to <16 x i8>*
store <16 x i8> %150, <16 x i8>* %154
%155 = or i64 %143, 32
%156 = getelementptr inbounds i8, i8* %0, i64 %155
%157 = bitcast i8* %156 to <16 x i8>*
%158 = load <16 x i8>, <16 x i8>* %157
%159 = getelementptr inbounds i8, i8* %156, i64 16
%160 = bitcast i8* %159 to <16 x i8>*
%161 = load <16 x i8>, <16 x i8>* %160
%162 = getelementptr inbounds i8, i8* %1, i64 %155
%163 = bitcast i8* %162 to <16 x i8>*
store <16 x i8> %158, <16 x i8>* %163
%164 = getelementptr inbounds i8, i8* %162, i64 16
%165 = bitcast i8* %164 to <16 x i8>*
store <16 x i8> %161, <16 x i8>* %165
%166 = or i64 %143, 64
%167 = getelementptr inbounds i8, i8* %0, i64 %166
%168 = bitcast i8* %167 to <16 x i8>*
%169 = load <16 x i8>, <16 x i8>* %168
%170 = getelementptr inbounds i8, i8* %167, i64 16
%171 = bitcast i8* %170 to <16 x i8>*
%172 = load <16 x i8>, <16 x i8>* %171
%173 = getelementptr inbounds i8, i8* %1, i64 %166
%174 = bitcast i8* %173 to <16 x i8>*
store <16 x i8> %169, <16 x i8>* %174
%175 = getelementptr inbounds i8, i8* %173, i64 16
%176 = bitcast i8* %175 to <16 x i8>*
store <16 x i8> %172, <16 x i8>* %176
%177 = or i64 %143, 96
%178 = getelementptr inbounds i8, i8* %0, i64 %177
%179 = bitcast i8* %178 to <16 x i8>*
%180 = load <16 x i8>, <16 x i8>* %179
%181 = getelementptr inbounds i8, i8* %178, i64 16
%182 = bitcast i8* %181 to <16 x i8>*
%183 = load <16 x i8>, <16 x i8>* %182
%184 = getelementptr inbounds i8, i8* %1, i64 %177
%185 = bitcast i8* %184 to <16 x i8>*
store <16 x i8> %180, <16 x i8>* %185
%186 = getelementptr inbounds i8, i8* %184, i64 16
%187 = bitcast i8* %186 to <16 x i8>*
store <16 x i8> %183, <16 x i8>* %187
%188 = add nuw i64 %143, 128
%189 = add i64 %144, 4
%190 = icmp eq i64 %189, %141
br i1 %190, label %191, label %142
191: ; preds = %142, %133
%192 = phi i64 [ 0, %133 ], [ %188, %142 ]
%193 = icmp eq i64 %138, 0
br i1 %193, label %210, label %194
194: ; preds = %191, %194
%195 = phi i64 [ %207, %194 ], [ %192, %191 ]
%196 = phi i64 [ %208, %194 ], [ 0, %191 ]
%197 = getelementptr inbounds i8, i8* %0, i64 %195
%198 = bitcast i8* %197 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = getelementptr inbounds i8, i8* %197, i64 16
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = getelementptr inbounds i8, i8* %1, i64 %195
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %199, <16 x i8>* %204
%205 = getelementptr inbounds i8, i8* %203, i64 16
%206 = bitcast i8* %205 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %206
%207 = add nuw i64 %195, 32
%208 = add i64 %196, 1
%209 = icmp eq i64 %208, %138
br i1 %209, label %210, label %194
210: ; preds = %194, %191
%211 = icmp eq i64 %134, %123
br i1 %211, label %266, label %212
212: ; preds = %210
%213 = and i64 %123, 24
%214 = icmp eq i64 %213, 0
br i1 %214, label %229, label %215
215: ; preds = %131, %212
%216 = phi i64 [ %134, %212 ], [ 0, %131 ]
%217 = and i64 %123, 4294967288
br label %218
218: ; preds = %218, %215
%219 = phi i64 [ %216, %215 ], [ %225, %218 ]
%220 = getelementptr inbounds i8, i8* %0, i64 %219
%221 = bitcast i8* %220 to <8 x i8>*
%222 = load <8 x i8>, <8 x i8>* %221
%223 = getelementptr inbounds i8, i8* %1, i64 %219
%224 = bitcast i8* %223 to <8 x i8>*
store <8 x i8> %222, <8 x i8>* %224
%225 = add nuw i64 %219, 8
%226 = icmp eq i64 %225, %217
br i1 %226, label %227, label %218
227: ; preds = %218
%228 = icmp eq i64 %217, %123
br i1 %228, label %266, label %229
229: ; preds = %125, %121, %212, %227
%230 = phi i64 [ 0, %121 ], [ 0, %125 ], [ %134, %212 ], [ %217, %227 ]
%231 = xor i64 %230, -1
%232 = add nsw i64 %231, %123
%233 = and i64 %123, 3
%234 = icmp eq i64 %233, 0
br i1 %234, label %244, label %235
235: ; preds = %229, %235
%236 = phi i64 [ %241, %235 ], [ %230, %229 ]
%237 = phi i64 [ %242, %235 ], [ 0, %229 ]
%238 = getelementptr inbounds i8, i8* %0, i64 %236
%239 = load i8, i8* %238
%240 = getelementptr inbounds i8, i8* %1, i64 %236
store i8 %239, i8* %240
%241 = add nuw nsw i64 %236, 1
%242 = add i64 %237, 1
%243 = icmp eq i64 %242, %233
br i1 %243, label %244, label %235
244: ; preds = %235, %229
%245 = phi i64 [ %230, %229 ], [ %241, %235 ]
%246 = icmp ult i64 %232, 3
br i1 %246, label %266, label %247
247: ; preds = %244, %247
%248 = phi i64 [ %264, %247 ], [ %245, %244 ]
%249 = getelementptr inbounds i8, i8* %0, i64 %248
%250 = load i8, i8* %249
%251 = getelementptr inbounds i8, i8* %1, i64 %248
store i8 %250, i8* %251
%252 = add nuw nsw i64 %248, 1
%253 = getelementptr inbounds i8, i8* %0, i64 %252
%254 = load i8, i8* %253
%255 = getelementptr inbounds i8, i8* %1, i64 %252
store i8 %254, i8* %255
%256 = add nuw nsw i64 %248, 2
%257 = getelementptr inbounds i8, i8* %0, i64 %256
%258 = load i8, i8* %257
%259 = getelementptr inbounds i8, i8* %1, i64 %256
store i8 %258, i8* %259
%260 = add nuw nsw i64 %248, 3
%261 = getelementptr inbounds i8, i8* %0, i64 %260
%262 = load i8, i8* %261
%263 = getelementptr inbounds i8, i8* %1, i64 %260
store i8 %262, i8* %263
%264 = add nuw nsw i64 %248, 4
%265 = icmp eq i64 %264, %123
br i1 %265, label %266, label %247
266: ; preds = %244, %247, %210, %227, %115
%267 = phi i32 [ 0, %115 ], [ %122, %227 ], [ %122, %210 ], [ %122, %247 ], [ %122, %244 ]
%268 = icmp sgt i32 %117, 0
br i1 %268, label %269, label %403
269: ; preds = %266
%270 = zext i32 %267 to i64
%271 = getelementptr inbounds i8, i8* %1, i64 %270
store i8 106, i8* %271
%272 = add nuw nsw i32 %267, 1
%273 = icmp slt i32 %117, %11
br i1 %273, label %274, label %403
274: ; preds = %269
%275 = add nuw nsw i64 %270, 1
%276 = zext i32 %117 to i64
%277 = shl i64 %10, 32
%278 = ashr exact i64 %277, 32
%279 = sub nsw i64 %278, %276
%280 = icmp ult i64 %279, 32
br i1 %280, label %352, label %281
281: ; preds = %274
%282 = getelementptr i8, i8* %1, i64 %275
%283 = add nsw i64 %278, %270
%284 = add nsw i64 %283, 1
%285 = sub nsw i64 %284, %276
%286 = getelementptr i8, i8* %1, i64 %285
%287 = getelementptr i8, i8* %0, i64 %276
%288 = getelementptr i8, i8* %0, i64 %278
%289 = icmp ult i8* %282, %288
%290 = icmp ult i8* %287, %286
%291 = and i1 %289, %290
br i1 %291, label %352, label %292
292: ; preds = %281
%293 = and i64 %279, -32
%294 = add nsw i64 %293, %276
%295 = add nsw i64 %275, %293
%296 = add nsw i64 %293, -32
%297 = lshr exact i64 %296, 5
%298 = add nuw nsw i64 %297, 1
%299 = and i64 %298, 1
%300 = icmp eq i64 %296, 0
br i1 %300, label %334, label %301
301: ; preds = %292
%302 = and i64 %298, 1152921504606846974
br label %303
303: ; preds = %303, %301
%304 = phi i64 [ 0, %301 ], [ %331, %303 ]
%305 = phi i64 [ 0, %301 ], [ %332, %303 ]
%306 = add i64 %304, %276
%307 = add i64 %275, %304
%308 = getelementptr inbounds i8, i8* %0, i64 %306
%309 = bitcast i8* %308 to <16 x i8>*
%310 = load <16 x i8>, <16 x i8>* %309
%311 = getelementptr inbounds i8, i8* %308, i64 16
%312 = bitcast i8* %311 to <16 x i8>*
%313 = load <16 x i8>, <16 x i8>* %312
%314 = getelementptr inbounds i8, i8* %1, i64 %307
%315 = bitcast i8* %314 to <16 x i8>*
store <16 x i8> %310, <16 x i8>* %315
%316 = getelementptr inbounds i8, i8* %314, i64 16
%317 = bitcast i8* %316 to <16 x i8>*
store <16 x i8> %313, <16 x i8>* %317
%318 = or i64 %304, 32
%319 = add i64 %318, %276
%320 = add i64 %275, %318
%321 = getelementptr inbounds i8, i8* %0, i64 %319
%322 = bitcast i8* %321 to <16 x i8>*
%323 = load <16 x i8>, <16 x i8>* %322
%324 = getelementptr inbounds i8, i8* %321, i64 16
%325 = bitcast i8* %324 to <16 x i8>*
%326 = load <16 x i8>, <16 x i8>* %325
%327 = getelementptr inbounds i8, i8* %1, i64 %320
%328 = bitcast i8* %327 to <16 x i8>*
store <16 x i8> %323, <16 x i8>* %328
%329 = getelementptr inbounds i8, i8* %327, i64 16
%330 = bitcast i8* %329 to <16 x i8>*
store <16 x i8> %326, <16 x i8>* %330
%331 = add nuw i64 %304, 64
%332 = add i64 %305, 2
%333 = icmp eq i64 %332, %302
br i1 %333, label %334, label %303
334: ; preds = %303, %292
%335 = phi i64 [ 0, %292 ], [ %331, %303 ]
%336 = icmp eq i64 %299, 0
br i1 %336, label %350, label %337
337: ; preds = %334
%338 = add i64 %335, %276
%339 = add i64 %275, %335
%340 = getelementptr inbounds i8, i8* %0, i64 %338
%341 = bitcast i8* %340 to <16 x i8>*
%342 = load <16 x i8>, <16 x i8>* %341
%343 = getelementptr inbounds i8, i8* %340, i64 16
%344 = bitcast i8* %343 to <16 x i8>*
%345 = load <16 x i8>, <16 x i8>* %344
%346 = getelementptr inbounds i8, i8* %1, i64 %339
%347 = bitcast i8* %346 to <16 x i8>*
store <16 x i8> %342, <16 x i8>* %347
%348 = getelementptr inbounds i8, i8* %346, i64 16
%349 = bitcast i8* %348 to <16 x i8>*
store <16 x i8> %345, <16 x i8>* %349
br label %350
350: ; preds = %334, %337
%351 = icmp eq i64 %279, %293
br i1 %351, label %400, label %352
352: ; preds = %281, %274, %350
%353 = phi i64 [ %276, %281 ], [ %276, %274 ], [ %294, %350 ]
%354 = phi i64 [ %275, %281 ], [ %275, %274 ], [ %295, %350 ]
%355 = sub i64 %10, %353
%356 = xor i64 %353, -1
%357 = add nsw i64 %278, %356
%358 = and i64 %355, 3
%359 = icmp eq i64 %358, 0
br i1 %359, label %371, label %360
360: ; preds = %352, %360
%361 = phi i64 [ %367, %360 ], [ %353, %352 ]
%362 = phi i64 [ %368, %360 ], [ %354, %352 ]
%363 = phi i64 [ %369, %360 ], [ 0, %352 ]
%364 = getelementptr inbounds i8, i8* %0, i64 %361
%365 = load i8, i8* %364
%366 = getelementptr inbounds i8, i8* %1, i64 %362
store i8 %365, i8* %366
%367 = add nuw nsw i64 %361, 1
%368 = add nuw nsw i64 %362, 1
%369 = add i64 %363, 1
%370 = icmp eq i64 %369, %358
br i1 %370, label %371, label %360
371: ; preds = %360, %352
%372 = phi i64 [ undef, %352 ], [ %368, %360 ]
%373 = phi i64 [ %353, %352 ], [ %367, %360 ]
%374 = phi i64 [ %354, %352 ], [ %368, %360 ]
%375 = icmp ult i64 %357, 3
br i1 %375, label %400, label %376
376: ; preds = %371, %376
%377 = phi i64 [ %397, %376 ], [ %373, %371 ]
%378 = phi i64 [ %398, %376 ], [ %374, %371 ]
%379 = getelementptr inbounds i8, i8* %0, i64 %377
%380 = load i8, i8* %379
%381 = getelementptr inbounds i8, i8* %1, i64 %378
store i8 %380, i8* %381
%382 = add nuw nsw i64 %377, 1
%383 = add nuw nsw i64 %378, 1
%384 = getelementptr inbounds i8, i8* %0, i64 %382
%385 = load i8, i8* %384
%386 = getelementptr inbounds i8, i8* %1, i64 %383
store i8 %385, i8* %386
%387 = add nuw nsw i64 %377, 2
%388 = add nuw nsw i64 %378, 2
%389 = getelementptr inbounds i8, i8* %0, i64 %387
%390 = load i8, i8* %389
%391 = getelementptr inbounds i8, i8* %1, i64 %388
store i8 %390, i8* %391
%392 = add nuw nsw i64 %377, 3
%393 = add nuw nsw i64 %378, 3
%394 = getelementptr inbounds i8, i8* %0, i64 %392
%395 = load i8, i8* %394
%396 = getelementptr inbounds i8, i8* %1, i64 %393
store i8 %395, i8* %396
%397 = add nuw nsw i64 %377, 4
%398 = add nuw nsw i64 %378, 4
%399 = icmp eq i64 %397, %278
br i1 %399, label %400, label %376
400: ; preds = %371, %376, %350
%401 = phi i64 [ %295, %350 ], [ %372, %371 ], [ %398, %376 ]
%402 = trunc i64 %401 to i32
br label %403
403: ; preds = %400, %269, %266
%404 = phi i32 [ %267, %266 ], [ %272, %269 ], [ %402, %400 ]
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds i8, i8* %1, i64 %405
store i8 0, i8* %406
br label %407
407: ; preds = %403, %107, %81, %32, %23
%408 = phi i32 [ 1, %23 ], [ 1, %32 ], [ 0, %107 ], [ 0, %81 ], [ 1, %403 ]
ret i32 %408
}