double strcmp95(char *ying, char *yang, long y_length, int *ind_c[]) {
  static int pass = 0, adjwt[91][91];
  static char sp[39][2] = {
      'A', 'E', 'A', 'I', 'A', 'O', 'A', 'U', 'B', 'V', 'E', 'I', 'E',
      'O', 'E', 'U', 'I', 'O', 'I', 'U', 'O', 'U', 'I', 'Y', 'E', 'Y',
      'C', 'G', 'E', 'F', 'W', 'U', 'W', 'V', 'X', 'K', 'S', 'Z', 'X',
      'S', 'Q', 'C', 'U', 'V', 'M', 'N', 'L', 'I', 'Q', 'O', 'P', 'R',
      'I', 'J', '2', 'Z', '5', 'S', '8', 'B', '1', 'I', '1', 'L', '0',
      'O', '0', 'Q', 'C', 'K', 'G', 'J', 'E', ' ', 'Y', ' ', 'S', ' '};
  char ying_hold[61], yang_hold[61], ying_flag[61], yang_flag[61];
  double weight, Num_sim;
  long minv, search_range, lowlim, ying_length, hilim, N_trans, Num_com,
      yang_length;
  int yl1, yi_st, N_simi;
  register int i, j, k;
  if (!pass) {
    pass++;
    for (i = 0; i < 91; i++)
      for (j = 0; j < 91; j++)
        adjwt[i][j] = 0;
    for (i = 0; i < 36; i++) {
      char i0 = sp[i][0];
      char i1 = sp[i][1];
      adjwt[sp[i][0]][sp[i][1]] = 3;
      adjwt[sp[i][1]][sp[i][0]] = 3;
    }
  }
  if (!strncmp(ying,
               "                                                            ",
               y_length))
    return (0.0);
  if (!strncmp(yang,
               "                                                            ",
               y_length))
    return (0.0);
  k = y_length - 1;
  for (j = 0; ((ying[j] == ' ') && (j < k)); j++)
    ;
  for (i = k; ((ying[i] == ' ') && (i > 0)); i--)
    ;
  ying_length = i + 1 - j;
  yi_st = j;
  printf("\n");
  printf("ying start: %d\n", yi_st);
  printf("ying length: %ld\n", ying_length);
  for (j = 0; ((yang[j] == ' ') && (j < k)); j++)
    ;
  for (i = k; ((yang[i] == ' ') && (i > 0)); i--)
    ;
  yang_length = i + 1 - j;
  printf("yang start: %d\n", j);
  printf("yang length: %ld\n", yang_length);
  ying_hold[0] = yang_hold[0] = 0;
  strncat(ying_hold, &ying[yi_st], ying_length);
  strncat(yang_hold, &yang[j], yang_length);
  if (ying_length > yang_length) {
    search_range = ying_length;
    minv = yang_length;
  } else {
    search_range = yang_length;
    minv = ying_length;
  }
  ying_flag[0] = yang_flag[0] = 0;
  strncat(ying_flag,
          "                                                            ",
          search_range);
  strncat(yang_flag,
          "                                                            ",
          search_range);
  search_range = (search_range / 2) - 1;
  if (search_range < 0)
    search_range = 0;
  if (!ind_c[1]) {
    for (i = 0; i < ying_length; i++)
      if (islower(ying_hold[i]))
        ying_hold[i] -= 32;
    for (j = 0; j < yang_length; j++)
      if (islower(yang_hold[j]))
        yang_hold[j] -= 32;
  }
  printf("Search range: %ld\n", search_range);
  printf("Minv: %ld\n", minv);
  printf("ying hold: '%s'\n", ying_hold);
  printf("yang hold: '%s'\n", yang_hold);
  printf("\n");
  Num_com = 0;
  yl1 = yang_length - 1;
  for (i = 0; i < ying_length; i++) {
    lowlim = (i >= search_range) ? i - search_range : 0;
    hilim = ((i + search_range) <= yl1) ? (i + search_range) : yl1;
    printf("%d. Looking for char %c in range [%ld, %ld (incl)]\n", i,
           ying_hold[i], lowlim, hilim);
    for (j = lowlim; j <= hilim; j++) {
      printf("   j:%2d   char: %c\n", j, yang_hold[j]);
      if ((yang_flag[j] != '1') && (yang_hold[j] == ying_hold[i])) {
        yang_flag[j] = '1';
        ying_flag[i] = '1';
        Num_com++;
        break;
      }
    }
  }
  printf("Num com: %ld\n", Num_com);
  printf("ying flag: '%s'\n", ying_flag);
  printf("yang flag: '%s'\n", yang_flag);
  if (!Num_com)
    return (0.0);
  k = N_trans = 0;
  for (i = 0; i < ying_length; i++) {
    if (ying_flag[i] == '1') {
      for (j = k; j < yang_length; j++) {
        if (yang_flag[j] == '1') {
          k = j + 1;
          break;
        }
      }
      if (ying_hold[i] != yang_hold[j])
        N_trans++;
    }
  }
  printf("Transpositions: %ld\n", N_trans);
  N_trans = N_trans / 2;
  weight = Num_com / ((double)ying_length) + Num_com / ((double)yang_length) +
           ((double)(Num_com - N_trans)) / ((double)Num_com);
  weight = weight / 3.0;
  printf("First weight: %.6f\n", weight);
  N_simi = 0;
  if (minv > Num_com) {
    for (i = 0; i < ying_length; i++) {
      if (ying_flag[i] == ' ' && ((ying_hold[i] > 0) && (ying_hold[i] < 91))) {
        for (j = 0; j < yang_length; j++) {
          if (yang_flag[j] == ' ' &&
              ((yang_hold[j] > 0) && (yang_hold[j] < 91))) {
            if (adjwt[ying_hold[i]][yang_hold[j]] > 0) {
              N_simi += adjwt[ying_hold[i]][yang_hold[j]];
              yang_flag[j] = '2';
              break;
            }
          }
        }
      }
    }
  }
  Num_sim = ((double)N_simi) / 10.0 + Num_com;
  printf("N_simi : %d\n", N_simi);
  printf("Num sim: %.6f\n", Num_sim);
  printf("ying flag: '%s'\n", ying_flag);
  printf("yang flag: '%s'\n", yang_flag);
  weight = Num_sim / ((double)ying_length) + Num_sim / ((double)yang_length) +
           ((double)(Num_com - N_trans)) / ((double)Num_com);
  weight = weight / 3.0;
  printf("Weight: %.6f\n", weight);
  if (weight > 0.7) {
    j = (minv >= 4) ? 4 : minv;
    for (i = 0; ((i < j) && (ying_hold[i] == yang_hold[i]) &&
                 (((ying_hold[i] > 57) || (ying_hold[i] < 48))));
         i++)
      printf("pre-match: %d\n", i);
    if (i) {
      printf("final pre-match: %d\n", i);
      weight += i * 0.1 * (1.0 - weight);
    }
    printf("Adjusted weight: %.6f\n", weight);
    if ((!ind_c[0]) && (minv > 4) && (Num_com > i + 1) &&
        (2 * Num_com >= minv + i))
      if (((ying_hold[0] > 57) || (ying_hold[0] < 48))) {
        weight += (double)(1.0 - weight) *
                  ((double)(Num_com - i - 1) /
                   ((double)(ying_length + yang_length - i * 2 + 2)));
        printf("Re-adjusted weight: %.6f\n", weight);
      }
  }
  return (weight);
}


x86 assembly (clang, -O0):
<strcmp95>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
cmpl   $0x0,0x3f4e(%rip)
jne    12d5 <strcmp95+0x195>
mov    0x3f42(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3f39(%rip)
movl   $0x0,-0x190(%rbp)
cmpl   $0x5b,-0x190(%rbp)
jge    11f8 <strcmp95+0xb8>
movl   $0x0,-0x194(%rbp)
cmpl   $0x5b,-0x194(%rbp)
jge    11df <strcmp95+0x9f>
movslq -0x190(%rbp),%rcx
lea    0x3f0d(%rip),%rax
imul   $0x16c,%rcx,%rcx
add    %rcx,%rax
movslq -0x194(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1198 <strcmp95+0x58>
jmp    11e4 <strcmp95+0xa4>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    1181 <strcmp95+0x41>
movl   $0x0,-0x190(%rbp)
cmpl   $0x24,-0x190(%rbp)
jge    12d0 <strcmp95+0x190>
movslq -0x190(%rbp),%rcx
lea    0x3e33(%rip),%rax
mov    (%rax,%rcx,2),%al
mov    %al,-0x199(%rbp)
movslq -0x190(%rbp),%rcx
lea    0x3e1c(%rip),%rax
mov    0x1(%rax,%rcx,2),%al
mov    %al,-0x19a(%rbp)
movslq -0x190(%rbp),%rcx
lea    0x3e04(%rip),%rax
movsbq (%rax,%rcx,2),%rcx
lea    0x3e68(%rip),%rax
imul   $0x16c,%rcx,%rcx
add    %rcx,%rax
movslq -0x190(%rbp),%rdx
lea    0x3de0(%rip),%rcx
movsbq 0x1(%rcx,%rdx,2),%rcx
movl   $0x3,(%rax,%rcx,4)
movslq -0x190(%rbp),%rcx
lea    0x3dc5(%rip),%rax
movsbq 0x1(%rax,%rcx,2),%rcx
lea    0x3e28(%rip),%rax
imul   $0x16c,%rcx,%rcx
add    %rcx,%rax
movslq -0x190(%rbp),%rdx
lea    0x3da0(%rip),%rcx
movsbq (%rcx,%rdx,2),%rcx
movl   $0x3,(%rax,%rcx,4)
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    1202 <strcmp95+0xc2>
jmp    12d5 <strcmp95+0x195>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x1d44(%rip),%rsi
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    12ff <strcmp95+0x1bf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    212c <strcmp95+0xfec>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x1d1a(%rip),%rsi
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    1329 <strcmp95+0x1e9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    212c <strcmp95+0xfec>
mov    -0x20(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x198(%rbp)
movl   $0x0,-0x194(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x19b(%rbp)
jne    1376 <strcmp95+0x236>
mov    -0x194(%rbp),%eax
cmp    -0x198(%rbp),%eax
setl   %al
mov    %al,-0x19b(%rbp)
mov    -0x19b(%rbp),%al
test   $0x1,%al
jne    1389 <strcmp95+0x249>
jmp    13a2 <strcmp95+0x262>
jmp    138e <strcmp95+0x24e>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1341 <strcmp95+0x201>
mov    -0x198(%rbp),%eax
mov    %eax,-0x190(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x190(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x19c(%rbp)
jne    13de <strcmp95+0x29e>
cmpl   $0x0,-0x190(%rbp)
setg   %al
mov    %al,-0x19c(%rbp)
mov    -0x19c(%rbp),%al
test   $0x1,%al
jne    13f1 <strcmp95+0x2b1>
jmp    140a <strcmp95+0x2ca>
jmp    13f6 <strcmp95+0x2b6>
mov    -0x190(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x190(%rbp)
jmp    13ae <strcmp95+0x26e>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
sub    -0x194(%rbp),%eax
cltq
mov    %rax,-0x160(%rbp)
mov    -0x194(%rbp),%eax
mov    %eax,-0x188(%rbp)
lea    0x1cb2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x188(%rbp),%esi
lea    0x1c1c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x160(%rbp),%rsi
lea    0x1c17(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x194(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x194(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x19d(%rbp)
jne    14a4 <strcmp95+0x364>
mov    -0x194(%rbp),%eax
cmp    -0x198(%rbp),%eax
setl   %al
mov    %al,-0x19d(%rbp)
mov    -0x19d(%rbp),%al
test   $0x1,%al
jne    14b7 <strcmp95+0x377>
jmp    14d0 <strcmp95+0x390>
jmp    14bc <strcmp95+0x37c>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    146f <strcmp95+0x32f>
mov    -0x198(%rbp),%eax
mov    %eax,-0x190(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x190(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x19e(%rbp)
jne    150c <strcmp95+0x3cc>
cmpl   $0x0,-0x190(%rbp)
setg   %al
mov    %al,-0x19e(%rbp)
mov    -0x19e(%rbp),%al
test   $0x1,%al
jne    151f <strcmp95+0x3df>
jmp    1538 <strcmp95+0x3f8>
jmp    1524 <strcmp95+0x3e4>
mov    -0x190(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x190(%rbp)
jmp    14dc <strcmp95+0x39c>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
sub    -0x194(%rbp),%eax
cltq
mov    %rax,-0x180(%rbp)
mov    -0x194(%rbp),%esi
lea    0x1b2a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x180(%rbp),%rsi
lea    0x1b25(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movb   $0x0,-0xb0(%rbp)
movb   $0x0,-0x70(%rbp)
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movslq -0x188(%rbp),%rax
add    %rax,%rsi
mov    -0x160(%rbp),%rdx
call   1060 <strncat@plt>
lea    -0xb0(%rbp),%rdi
mov    -0x18(%rbp),%rsi
movslq -0x194(%rbp),%rax
add    %rax,%rsi
mov    -0x180(%rbp),%rdx
call   1060 <strncat@plt>
mov    -0x160(%rbp),%rax
cmp    -0x180(%rbp),%rax
jle    15f8 <strcmp95+0x4b8>
mov    -0x160(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x180(%rbp),%rax
mov    %rax,-0x148(%rbp)
jmp    1614 <strcmp95+0x4d4>
mov    -0x180(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x160(%rbp),%rax
mov    %rax,-0x148(%rbp)
movb   $0x0,-0x130(%rbp)
movb   $0x0,-0xf0(%rbp)
lea    -0xf0(%rbp),%rdi
mov    -0x150(%rbp),%rdx
lea    0x19f1(%rip),%rsi
call   1060 <strncat@plt>
lea    -0x130(%rbp),%rdi
mov    -0x150(%rbp),%rdx
lea    0x19d7(%rip),%rsi
call   1060 <strncat@plt>
mov    -0x150(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
sub    $0x1,%rax
mov    %rax,-0x150(%rbp)
cmpq   $0x0,-0x150(%rbp)
jge    168b <strcmp95+0x54b>
movq   $0x0,-0x150(%rbp)
mov    -0x28(%rbp),%rax
cmpq   $0x0,0x8(%rax)
jne    1770 <strcmp95+0x630>
movl   $0x0,-0x190(%rbp)
movslq -0x190(%rbp),%rax
cmp    -0x160(%rbp),%rax
jge    16fe <strcmp95+0x5be>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     16e5 <strcmp95+0x5a5>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%ecx
sub    $0x20,%ecx
mov    %cl,-0x70(%rbp,%rax,1)
jmp    16ea <strcmp95+0x5aa>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    16a4 <strcmp95+0x564>
movl   $0x0,-0x194(%rbp)
movslq -0x194(%rbp),%rax
cmp    -0x180(%rbp),%rax
jge    176b <strcmp95+0x62b>
movslq -0x194(%rbp),%rax
movsbl -0xb0(%rbp,%rax,1),%edi
ff
call   1040 <islower@plt>
cmp    $0x0,%eax
je     1752 <strcmp95+0x612>
movslq -0x194(%rbp),%rax
movsbl -0xb0(%rbp,%rax,1),%ecx
ff
sub    $0x20,%ecx
mov    %cl,-0xb0(%rbp,%rax,1)
jmp    1757 <strcmp95+0x617>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1708 <strcmp95+0x5c8>
jmp    1770 <strcmp95+0x630>
mov    -0x150(%rbp),%rsi
lea    0x192b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x148(%rbp),%rsi
lea    0x1929(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x70(%rbp),%rsi
lea    0x1922(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xb0(%rbp),%rsi
lea    0x191e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x191f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movq   $0x0,-0x178(%rbp)
mov    -0x180(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x184(%rbp)
movl   $0x0,-0x190(%rbp)
movslq -0x190(%rbp),%rax
cmp    -0x160(%rbp),%rax
jge    19bb <strcmp95+0x87b>
movslq -0x190(%rbp),%rax
cmp    -0x150(%rbp),%rax
jl     1837 <strcmp95+0x6f7>
movslq -0x190(%rbp),%rax
sub    -0x150(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
jmp    1845 <strcmp95+0x705>
xor    %eax,%eax
mov    %rax,-0x1a8(%rbp)
jmp    1845 <strcmp95+0x705>
mov    -0x1a8(%rbp),%rax
mov    %rax,-0x158(%rbp)
movslq -0x190(%rbp),%rax
add    -0x150(%rbp),%rax
movslq -0x184(%rbp),%rcx
cmp    %rcx,%rax
jg     188b <strcmp95+0x74b>
movslq -0x190(%rbp),%rax
add    -0x150(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
jmp    1899 <strcmp95+0x759>
movslq -0x184(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x1b0(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x190(%rbp),%esi
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%edx
mov    -0x158(%rbp),%rcx
mov    -0x168(%rbp),%r8
lea    0x181b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x158(%rbp),%rax
mov    %eax,-0x194(%rbp)
movslq -0x194(%rbp),%rax
cmp    -0x168(%rbp),%rax
jg     19a2 <strcmp95+0x862>
mov    -0x194(%rbp),%esi
movslq -0x194(%rbp),%rax
movsbl -0xb0(%rbp,%rax,1),%edx
ff
lea    0x180b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x194(%rbp),%rax
movsbl -0x130(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
je     1989 <strcmp95+0x849>
movslq -0x194(%rbp),%rax
movsbl -0xb0(%rbp,%rax,1),%eax
ff
movslq -0x190(%rbp),%rcx
movsbl -0x70(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    1989 <strcmp95+0x849>
movslq -0x194(%rbp),%rax
movb   $0x31,-0x130(%rbp,%rax,1)
31
movslq -0x190(%rbp),%rax
movb   $0x31,-0xf0(%rbp,%rax,1)
31
mov    -0x178(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x178(%rbp)
jmp    19a2 <strcmp95+0x862>
jmp    198e <strcmp95+0x84e>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    18e2 <strcmp95+0x7a2>
jmp    19a7 <strcmp95+0x867>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    17f5 <strcmp95+0x6b5>
mov    -0x178(%rbp),%rsi
lea    0x1769(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rsi
lea    0x1762(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x130(%rbp),%rsi
lea    0x175e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpq   $0x0,-0x178(%rbp)
jne    1a15 <strcmp95+0x8d5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    212c <strcmp95+0xfec>
movq   $0x0,-0x170(%rbp)
movl   $0x0,-0x198(%rbp)
movl   $0x0,-0x190(%rbp)
movslq -0x190(%rbp),%rax
cmp    -0x160(%rbp),%rax
jge    1b18 <strcmp95+0x9d8>
movslq -0x190(%rbp),%rax
movsbl -0xf0(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    1aff <strcmp95+0x9bf>
mov    -0x198(%rbp),%eax
mov    %eax,-0x194(%rbp)
movslq -0x194(%rbp),%rax
cmp    -0x180(%rbp),%rax
jge    1ac5 <strcmp95+0x985>
movslq -0x194(%rbp),%rax
movsbl -0x130(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    1aac <strcmp95+0x96c>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    1ac5 <strcmp95+0x985>
jmp    1ab1 <strcmp95+0x971>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1a6c <strcmp95+0x92c>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
movslq -0x194(%rbp),%rcx
movsbl -0xb0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     1afa <strcmp95+0x9ba>
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1aff <strcmp95+0x9bf>
jmp    1b04 <strcmp95+0x9c4>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    1a34 <strcmp95+0x8f4>
mov    -0x170(%rbp),%rsi
lea    0x163c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x170(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x170(%rbp)
cvtsi2sdq -0x178(%rbp),%xmm0
ff ff
cvtsi2sdq -0x160(%rbp),%xmm1
ff ff
divsd  %xmm1,%xmm0
cvtsi2sdq -0x178(%rbp),%xmm1
ff ff
cvtsi2sdq -0x180(%rbp),%xmm2
ff ff
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x178(%rbp),%rax
sub    -0x170(%rbp),%rax
cvtsi2sd %rax,%xmm1
cvtsi2sdq -0x178(%rbp),%xmm2
ff ff
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  0x144f(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
lea    0x15ab(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movl   $0x0,-0x18c(%rbp)
mov    -0x148(%rbp),%rax
cmp    -0x178(%rbp),%rax
jle    1d81 <strcmp95+0xc41>
movl   $0x0,-0x190(%rbp)
movslq -0x190(%rbp),%rax
cmp    -0x160(%rbp),%rax
jge    1d7c <strcmp95+0xc3c>
movslq -0x190(%rbp),%rax
movsbl -0xf0(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    1d63 <strcmp95+0xc23>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x0,%eax
jle    1d63 <strcmp95+0xc23>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x5b,%eax
jge    1d63 <strcmp95+0xc23>
movl   $0x0,-0x194(%rbp)
movslq -0x194(%rbp),%rax
cmp    -0x180(%rbp),%rax
jge    1d5e <strcmp95+0xc1e>
movslq -0x194(%rbp),%rax
movsbl -0x130(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    1d45 <strcmp95+0xc05>
movslq -0x194(%rbp),%rax
movsbl -0xb0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jle    1d45 <strcmp95+0xc05>
movslq -0x194(%rbp),%rax
movsbl -0xb0(%rbp,%rax,1),%eax
ff
cmp    $0x5b,%eax
jge    1d45 <strcmp95+0xc05>
movslq -0x190(%rbp),%rax
movsbq -0x70(%rbp,%rax,1),%rcx
lea    0x33f5(%rip),%rax
imul   $0x16c,%rcx,%rcx
add    %rcx,%rax
movslq -0x194(%rbp),%rcx
movsbq -0xb0(%rbp,%rcx,1),%rcx
ff ff
cmpl   $0x0,(%rax,%rcx,4)
jle    1d40 <strcmp95+0xc00>
movslq -0x190(%rbp),%rax
movsbq -0x70(%rbp,%rax,1),%rcx
lea    0x33bd(%rip),%rax
imul   $0x16c,%rcx,%rcx
add    %rcx,%rax
movslq -0x194(%rbp),%rcx
movsbq -0xb0(%rbp,%rcx,1),%rcx
ff ff
mov    (%rax,%rcx,4),%eax
add    -0x18c(%rbp),%eax
mov    %eax,-0x18c(%rbp)
movslq -0x194(%rbp),%rax
movb   $0x32,-0x130(%rbp,%rax,1)
32
jmp    1d5e <strcmp95+0xc1e>
jmp    1d45 <strcmp95+0xc05>
jmp    1d4a <strcmp95+0xc0a>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1c5b <strcmp95+0xb1b>
jmp    1d63 <strcmp95+0xc23>
jmp    1d68 <strcmp95+0xc28>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    1bfb <strcmp95+0xabb>
jmp    1d81 <strcmp95+0xc41>
cvtsi2sdl -0x18c(%rbp),%xmm0
ff
movsd  0x127f(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsi2sdq -0x178(%rbp),%xmm1
ff ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x18c(%rbp),%esi
lea    0x13d4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movsd  -0x140(%rbp),%xmm0
ff
lea    0x13cb(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rsi
lea    0x135e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x130(%rbp),%rsi
lea    0x135a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movsd  -0x140(%rbp),%xmm0
ff
cvtsi2sdq -0x160(%rbp),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  -0x140(%rbp),%xmm1
ff
cvtsi2sdq -0x180(%rbp),%xmm2
ff ff
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x178(%rbp),%rax
sub    -0x170(%rbp),%rax
cvtsi2sd %rax,%xmm1
cvtsi2sdq -0x178(%rbp),%xmm2
ff ff
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  0x1198(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
lea    0x1324(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  -0x138(%rbp),%xmm0
ff
movsd  0x116e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    211f <strcmp95+0xfdf>
cmpq   $0x4,-0x148(%rbp)
04
jl     1ec3 <strcmp95+0xd83>
mov    $0x4,%eax
mov    %rax,-0x1b8(%rbp)
jmp    1ed1 <strcmp95+0xd91>
mov    -0x148(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1b8(%rbp),%rax
mov    %eax,-0x194(%rbp)
movl   $0x0,-0x190(%rbp)
mov    -0x190(%rbp),%ecx
xor    %eax,%eax
cmp    -0x194(%rbp),%ecx
mov    %al,-0x1b9(%rbp)
jge    1f6e <strcmp95+0xe2e>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%ecx
movslq -0x190(%rbp),%rax
movsbl -0xb0(%rbp,%rax,1),%edx
ff
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x1b9(%rbp)
jne    1f6e <strcmp95+0xe2e>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%ecx
mov    $0x1,%al
cmp    $0x39,%ecx
mov    %al,-0x1ba(%rbp)
jg     1f62 <strcmp95+0xe22>
movslq -0x190(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x30,%eax
setl   %al
mov    %al,-0x1ba(%rbp)
mov    -0x1ba(%rbp),%al
mov    %al,-0x1b9(%rbp)
mov    -0x1b9(%rbp),%al
test   $0x1,%al
jne    1f81 <strcmp95+0xe41>
jmp    1fa9 <strcmp95+0xe69>
mov    -0x190(%rbp),%esi
lea    0x122d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    1ee8 <strcmp95+0xda8>
cmpl   $0x0,-0x190(%rbp)
je     2006 <strcmp95+0xec6>
mov    -0x190(%rbp),%esi
lea    0x11f2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cvtsi2sdl -0x190(%rbp),%xmm0
ff
movsd  0x1046(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1032(%rip),%xmm2
subsd  -0x138(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
movsd  -0x138(%rbp),%xmm0
lea    0x11b5(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x28(%rbp),%rax
cmpq   $0x0,(%rax)
jne    211a <strcmp95+0xfda>
cmpq   $0x4,-0x148(%rbp)
04
jle    211a <strcmp95+0xfda>
mov    -0x178(%rbp),%rax
mov    -0x190(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jle    211a <strcmp95+0xfda>
mov    -0x178(%rbp),%rax
shl    $0x1,%rax
mov    -0x148(%rbp),%rcx
movslq -0x190(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jl     211a <strcmp95+0xfda>
movsbl -0x70(%rbp),%eax
cmp    $0x39,%eax
jg     2093 <strcmp95+0xf53>
movsbl -0x70(%rbp),%eax
cmp    $0x30,%eax
jge    2115 <strcmp95+0xfd5>
movsd  0xf7d(%rip),%xmm0
subsd  -0x138(%rbp),%xmm0
ff
mov    -0x178(%rbp),%rax
movslq -0x190(%rbp),%rcx
sub    %rcx,%rax
sub    $0x1,%rax
cvtsi2sd %rax,%xmm2
mov    -0x160(%rbp),%rax
add    -0x180(%rbp),%rax
mov    -0x190(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
sub    %rcx,%rax
add    $0x2,%rax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm2
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
lea    0x10d3(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
jmp    211a <strcmp95+0xfda>
jmp    211f <strcmp95+0xfdf>
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strcmp95>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %rcx,%r13
mov    %rdx,%rbp
mov    %rsi,%r14
mov    %rdi,%r15
cmpb   $0x0,0x2edc(%rip)
jne    1215 <strcmp95+0xb5>
movb   $0x1,0x2ecf(%rip)
lea    0x2ed8(%rip),%r12
xor    %ebx,%ebx
mov    $0x8164,%edx
mov    %r12,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
lea    0xe80(%rip),%rax
movsbq (%rax,%rbx,2),%rcx
movsbq 0x1(%rax,%rbx,2),%rdx
imul   $0x16c,%rcx,%rsi
add    %r12,%rsi
movl   $0x3,(%rsi,%rdx,4)
imul   $0x16c,%rdx,%rdx
add    %r12,%rdx
movl   $0x3,(%rdx,%rcx,4)
movsbq 0x2(%rax,%rbx,2),%rcx
movsbq 0x3(%rax,%rbx,2),%rdx
imul   $0x16c,%rcx,%rsi
add    %r12,%rsi
movl   $0x3,(%rsi,%rdx,4)
imul   $0x16c,%rdx,%rdx
add    %r12,%rdx
movl   $0x3,(%rdx,%rcx,4)
add    $0x2,%rbx
cmp    $0x24,%rbx
jne    11b0 <strcmp95+0x50>
lea    0xe62(%rip),%rsi
mov    %r15,%rdi
mov    %rbp,%rdx
call   1040 <strncmp@plt>
xorpd  %xmm0,%xmm0
test   %eax,%eax
je     1b03 <strcmp95+0x9a3>
lea    0xe44(%rip),%rsi
mov    %r14,%rdi
mov    %rbp,%rdx
call   1040 <strncmp@plt>
test   %eax,%eax
je     15e4 <strcmp95+0x484>
mov    %r13,0x30(%rsp)
lea    -0x1(%rbp),%eax
movslq %eax,%rbx
add    $0x2,%ebp
mov    $0x1,%r12d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffff,%ebp
add    $0xffffffffffffffff,%r12
cmpb   $0x20,(%r15,%rax,1)
jne    128a <strcmp95+0x12a>
lea    0x1(%rax),%rcx
cmp    %rbx,%rax
mov    %rcx,%rax
jl     1270 <strcmp95+0x110>
mov    %r12,%r13
neg    %r13
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffff,%ebp
cmpb   $0x20,(%r15,%rax,1)
jne    12b6 <strcmp95+0x156>
lea    -0x1(%rax),%rcx
test   %rax,%rax
mov    %rcx,%rax
jg     12a0 <strcmp95+0x140>
mov    %rbp,0x58(%rsp)
movslq %ebp,%rbp
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xdec(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xdeb(%rip),%rdi
mov    %rbp,0x38(%rsp)
mov    %rbp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
add    $0x1,%rcx
cmpb   $0x20,(%r14,%rsi,1)
jne    1313 <strcmp95+0x1b3>
cmp    %rbx,%rsi
jl     1300 <strcmp95+0x1a0>
mov    %esi,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rbx),%rdx
cmpb   $0x20,(%r14,%rbx,1)
jne    1333 <strcmp95+0x1d3>
test   %rbx,%rbx
mov    %rdx,%rbx
jg     1320 <strcmp95+0x1c0>
sub    %r12,%r15
add    %rax,%r14
mov    %rdx,0x48(%rsp)
mov    %rdx,%rax
mov    %rcx,0x50(%rsp)
sub    %rcx,%rax
add    $0x3,%rax
mov    %rax,0x10(%rsp)
movslq %eax,%rbx
lea    0xd81(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xd83(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
movb   $0x0,0xc0(%rsp)
movb   $0x0,0x80(%rsp)
lea    0x80(%rsp),%rdi
mov    %r15,%rsi
mov    0x38(%rsp),%r15
mov    %r15,%rdx
call   1080 <strncat@plt>
lea    0xc0(%rsp),%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1080 <strncat@plt>
cmp    %ebx,%r15d
mov    %ebx,%eax
mov    0x58(%rsp),%r12
cmovg  %r12d,%eax
mov    %rbx,0x70(%rsp)
mov    %ebx,%ecx
cmovl  %r12d,%ecx
movslq %eax,%rbp
mov    %ecx,0x44(%rsp)
movslq %ecx,%r13
movb   $0x0,0x100(%rsp)
movb   $0x0,0x140(%rsp)
lea    0xc95(%rip),%r14
lea    0x140(%rsp),%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1080 <strncat@plt>
lea    0x100(%rsp),%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1080 <strncat@plt>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
sar    %eax
cltq
test   %rax,%rax
mov    $0x1,%ecx
cmovg  %rax,%rcx
mov    %rcx,0x20(%rsp)
lea    -0x1(%rcx),%rax
mov    %rax,(%rsp)
mov    0x30(%rsp),%rax
cmpq   $0x0,0x8(%rax)
je     15ed <strcmp95+0x48d>
lea    0xcb5(%rip),%rdi
mov    (%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xcb6(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xcb0(%rip),%rdi
lea    0x80(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xcab(%rip),%rdi
lea    0xc0(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %r12d,%r12d
mov    %r13,0x18(%rsp)
jle    1630 <strcmp95+0x4d0>
mov    0x48(%rsp),%rax
sub    0x50(%rsp),%eax
add    $0x2,%eax
movslq %eax,%r14
mov    $0x1,%ecx
mov    0x20(%rsp),%rax
sub    %eax,%ecx
mov    %rcx,0x78(%rsp)
neg    %eax
mov    %rax,0x20(%rsp)
xor    %r13d,%r13d
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    %r14,0x60(%rsp)
jmp    1507 <strcmp95+0x3a7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x60(%rsp),%r14
add    $0x1,%r13
mov    0x38(%rsp),%r15
cmp    %r15,%r13
je     1637 <strcmp95+0x4d7>
mov    %r13,%rax
mov    (%rsp),%rcx
sub    %rcx,%rax
mov    %rcx,%r12
cmovg  %r13,%r12
mov    $0x0,%ebp
cmovae %rax,%rbp
lea    (%rcx,%r13,1),%r15
cmp    %r14,%r15
cmovg  %r14,%r15
movsbl 0x80(%rsp,%r13,1),%edx
lea    0xc03(%rip),%rdi
mov    %r13d,%esi
mov    %rbp,%rcx
mov    %r15,%r8
xor    %eax,%eax
call   1060 <printf@plt>
movslq %ebp,%rbx
cmp    %rbx,%r15
jl     14f5 <strcmp95+0x395>
mov    0x78(%rsp),%rax
lea    (%rax,%r12,1),%r14d
add    0x20(%rsp),%r12d
movslq %r12d,%rax
add    $0x2,%rax
lea    0xc03(%rip),%r12
jmp    1594 <strcmp95+0x434>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14d
lea    0x1(%rbp),%rax
mov    %rbp,%rbx
cmp    %rbp,%r15
jl     14f0 <strcmp95+0x390>
mov    %rax,%rbp
movsbl 0xc0(%rsp,%rbx,1),%edx
mov    %r12,%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmpb   $0x31,0x100(%rsp,%rbx,1)
31
je     1580 <strcmp95+0x420>
movzbl 0xc0(%rsp,%rbx,1),%eax
cmp    0x80(%rsp,%r13,1),%al
jne    1580 <strcmp95+0x420>
movb   $0x31,0x100(%rsp,%rbx,1)
31
movb   $0x31,0x140(%rsp,%r13,1)
addq   $0x1,0x8(%rsp)
jmp    14f0 <strcmp95+0x390>
xorpd  %xmm0,%xmm0
jmp    1b03 <strcmp95+0x9a3>
test   %r12d,%r12d
jle    171f <strcmp95+0x5bf>
xor    %ebx,%ebx
jmp    160d <strcmp95+0x4ad>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r15
je     171f <strcmp95+0x5bf>
movzbl 0x80(%rsp,%rbx,1),%ebp
movsbl %bpl,%edi
call   1050 <islower@plt>
test   %eax,%eax
je     1600 <strcmp95+0x4a0>
add    $0xe0,%bpl
mov    %bpl,0x80(%rsp,%rbx,1)
jmp    1600 <strcmp95+0x4a0>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
lea    0xb4a(%rip),%rdi
mov    0x8(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xb42(%rip),%rdi
lea    0x140(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xb3d(%rip),%rdi
lea    0x100(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
test   %rbx,%rbx
xorpd  %xmm0,%xmm0
je     1b03 <strcmp95+0x9a3>
xor    %r14d,%r14d
mov    0x58(%rsp),%r13
test   %r13d,%r13d
jle    176d <strcmp95+0x60d>
mov    0x50(%rsp),%r9
sub    0x48(%rsp),%r9
add    $0xfffffffffffffffd,%r9
xor    %eax,%eax
xor    %ecx,%ecx
xor    %ebp,%ebp
mov    0x30(%rsp),%r12
mov    0x10(%rsp),%r8
jmp    16e6 <strcmp95+0x586>
nopw   0x0(%rax,%rax,1)
mov    %esi,%ecx
mov    0x80(%rsp,%rax,1),%bl
xor    %esi,%esi
cmp    0xc0(%rsp,%rdx,1),%bl
setne  %sil
add    %rsi,%rbp
add    $0x1,%rax
cmp    %r15,%rax
je     1779 <strcmp95+0x619>
cmpb   $0x31,0x140(%rsp,%rax,1)
31
jne    16d9 <strcmp95+0x579>
mov    %ecx,%esi
movslq %ecx,%rdx
cmp    %r8d,%edx
jge    16c0 <strcmp95+0x560>
lea    (%r9,%rcx,1),%ebx
xor    %edi,%edi
cmpb   $0x31,0x100(%rsp,%rdx,1)
31
je     1718 <strcmp95+0x5b8>
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
cmp    %edi,%ebx
jne    1700 <strcmp95+0x5a0>
jmp    16c0 <strcmp95+0x560>
sub    %edi,%ecx
add    $0x1,%ecx
jmp    16c2 <strcmp95+0x562>
cmpl   $0x0,0x10(%rsp)
jle    1443 <strcmp95+0x2e3>
movslq 0x10(%rsp),%r14
xor    %ebp,%ebp
jmp    174d <strcmp95+0x5ed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbp
cmp    %rbp,%r14
je     1443 <strcmp95+0x2e3>
movzbl 0xc0(%rsp,%rbp,1),%ebx
movsbl %bl,%edi
call   1050 <islower@plt>
test   %eax,%eax
je     1740 <strcmp95+0x5e0>
add    $0xe0,%bl
mov    %bl,0xc0(%rsp,%rbp,1)
jmp    1740 <strcmp95+0x5e0>
xor    %ebp,%ebp
mov    0x30(%rsp),%r12
mov    0x10(%rsp),%r8
lea    0xa38(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
mov    %r8,%rbx
call   1060 <printf@plt>
mov    %rbp,%rax
shr    $0x3f,%rax
add    %rbp,%rax
mov    0x8(%rsp),%rbp
cvtsi2sd %rbp,%xmm2
movd   %r13d,%xmm0
movd   %ebx,%xmm1
punpckldq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm0
sar    %rax
movapd %xmm2,%xmm1
unpcklpd %xmm2,%xmm1
movapd %xmm0,0x60(%rsp)
divpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
mov    %rbp,%rcx
sub    %rax,%rcx
xorps  %xmm1,%xmm1
cvtsi2sd %rcx,%xmm1
movapd %xmm2,0x20(%rsp)
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rsp)
addsd  %xmm1,%xmm0
divsd  0x804(%rip),%xmm0
lea    0x9ca(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
cmp    0x18(%rsp),%rbp
jge    18b3 <strcmp95+0x753>
test   %r13d,%r13d
mov    0x10(%rsp),%r8
movapd 0x20(%rsp),%xmm0
jle    18b9 <strcmp95+0x759>
movslq %r8d,%rax
xor    %ecx,%ecx
lea    0x283b(%rip),%rdx
xor    %r14d,%r14d
jmp    1849 <strcmp95+0x6e9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r15,%rcx
je     18b9 <strcmp95+0x759>
cmpb   $0x20,0x140(%rsp,%rcx,1)
20
jne    1840 <strcmp95+0x6e0>
movzbl 0x80(%rsp,%rcx,1),%esi
lea    -0x5b(%rsi),%edi
cmp    $0xa6,%dil
jb     1840 <strcmp95+0x6e0>
test   %r8d,%r8d
jle    1840 <strcmp95+0x6e0>
xor    %edi,%edi
jmp    1879 <strcmp95+0x719>
nopl   (%rax)
add    $0x1,%rdi
cmp    %rdi,%rax
je     1840 <strcmp95+0x6e0>
cmpb   $0x20,0x100(%rsp,%rdi,1)
20
jne    1870 <strcmp95+0x710>
movzbl 0xc0(%rsp,%rdi,1),%ebp
lea    -0x1(%rbp),%ebx
cmp    $0x59,%bl
ja     1870 <strcmp95+0x710>
imul   $0x16c,%rsi,%rbx
add    %rdx,%rbx
mov    (%rbx,%rbp,4),%ebp
test   %ebp,%ebp
jle    1870 <strcmp95+0x710>
mov    %edi,%esi
add    %ebp,%r14d
movb   $0x32,0x100(%rsp,%rsi,1)
32
jmp    1840 <strcmp95+0x6e0>
movapd 0x20(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
divsd  0x73f(%rip),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x20(%rsp)
lea    0x907(%rip),%rdi
xor    %r15d,%r15d
mov    %r14d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x900(%rip),%rdi
movaps 0x20(%rsp),%xmm0
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x895(%rip),%rdi
lea    0x140(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x890(%rip),%rdi
lea    0x100(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
movapd 0x20(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
divpd  0x60(%rsp),%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
movsd  (%rsp),%xmm0
addsd  %xmm2,%xmm0
divsd  0x6ad(%rip),%xmm0
movsd  %xmm0,(%rsp)
lea    0x89e(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  (%rsp),%xmm0
ucomisd 0x69d(%rip),%xmm0
jbe    1b03 <strcmp95+0x9a3>
mov    0x44(%rsp),%r14d
test   %r14d,%r14d
jle    1a49 <strcmp95+0x8e9>
cmp    $0x4,%r14d
mov    $0x4,%eax
mov    $0x4,%r15d
cmovb  %r14d,%r15d
mov    0x10(%rsp),%rcx
cmp    %ecx,%r13d
cmovl  %r13d,%ecx
cmp    $0x4,%ecx
cmovae %eax,%ecx
lea    0x85e(%rip),%r13
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x80(%rsp,%rbx,1),%eax
cmp    0xc0(%rsp,%rbx,1),%al
jne    19f4 <strcmp95+0x894>
add    $0xc6,%al
cmp    $0xf5,%al
ja     19f4 <strcmp95+0x894>
mov    %r13,%rdi
mov    %ebx,%esi
xor    %eax,%eax
mov    %rcx,%rbp
call   1060 <printf@plt>
mov    %rbp,%rcx
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    19c0 <strcmp95+0x860>
jmp    19fb <strcmp95+0x89b>
test   %ebx,%ebx
je     1a41 <strcmp95+0x8e1>
mov    %ebx,%r15d
mov    0x18(%rsp),%rbx
mov    0x8(%rsp),%rbp
lea    0x7ff(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm2,%xmm2
cvtsi2sd %r15d,%xmm2
mulsd  0x5f2(%rip),%xmm2
movsd  0x5f2(%rip),%xmm1
movsd  (%rsp),%xmm0
subsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
jmp    1a53 <strcmp95+0x8f3>
xor    %r15d,%r15d
movsd  (%rsp),%xmm0
mov    0x18(%rsp),%rbx
mov    0x8(%rsp),%rbp
lea    0x7c6(%rip),%rdi
movsd  %xmm0,(%rsp)
mov    $0x1,%al
call   1060 <printf@plt>
cmpq   $0x0,(%r12)
jne    1afe <strcmp95+0x99e>
cmp    $0x5,%r14d
jl     1afe <strcmp95+0x99e>
lea    0x1(%r15),%eax
cmp    %rax,%rbp
movsd  (%rsp),%xmm0
jle    1b03 <strcmp95+0x9a3>
mov    %rbp,%rcx
add    %rbp,%rcx
mov    %r15d,%eax
add    %rax,%rbx
cmp    %rbx,%rcx
jl     1b03 <strcmp95+0x9a3>
mov    0x80(%rsp),%cl
add    $0xc6,%cl
cmp    $0xf5,%cl
ja     1b03 <strcmp95+0x9a3>
movsd  0x56f(%rip),%xmm3
not    %rax
add    %rax,%rbp
xorps  %xmm1,%xmm1
cvtsi2sd %rbp,%xmm1
add    %r15d,%r15d
mov    0x38(%rsp),%rax
add    0x70(%rsp),%rax
sub    %r15,%rax
add    $0x2,%rax
xorps  %xmm2,%xmm2
cvtsi2sd %rax,%xmm2
subsd  %xmm0,%xmm3
divsd  %xmm2,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
lea    0x740(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  (%rsp),%xmm0
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@strcmp95.pass = internal global i32 0
@strcmp95.adjwt = internal global [91 x [91 x i32]] zeroinitializer
@strcmp95.sp = internal global [39 x [2 x i8]] [[2 x i8] c"AE", [2 x i8] c"AI", [2 x i8] c"AO", [2 x i8] c"AU", [2 x i8] c"BV", [2 x i8] c"EI", [2 x i8] c"EO", [2 x i8] c"EU", [2 x i8] c"IO", [2 x i8] c"IU", [2 x i8] c"OU", [2 x i8] c"IY", [2 x i8] c"EY", [2 x i8] c"CG", [2 x i8] c"EF", [2 x i8] c"WU", [2 x i8] c"WV", [2 x i8] c"XK", [2 x i8] c"SZ", [2 x i8] c"XS", [2 x i8] c"QC", [2 x i8] c"UV", [2 x i8] c"MN", [2 x i8] c"LI", [2 x i8] c"QO", [2 x i8] c"PR", [2 x i8] c"IJ", [2 x i8] c"2Z", [2 x i8] c"5S", [2 x i8] c"8B", [2 x i8] c"1I", [2 x i8] c"1L", [2 x i8] c"0O", [2 x i8] c"0Q", [2 x i8] c"CK", [2 x i8] c"GJ", [2 x i8] c"E ", [2 x i8] c"Y ", [2 x i8] c"S "]
@.str = [61 x i8] c" \00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [16 x i8] c"ying start: %d\0A\00"
@.str.3 = [18 x i8] c"ying length: %ld\0A\00"
@.str.4 = [16 x i8] c"yang start: %d\0A\00"
@.str.5 = [18 x i8] c"yang length: %ld\0A\00"
@.str.6 = [19 x i8] c"Search range: %ld\0A\00"
@.str.7 = [11 x i8] c"Minv: %ld\0A\00"
@.str.8 = [17 x i8] c"ying hold: '%s'\0A\00"
@.str.9 = [17 x i8] c"yang hold: '%s'\0A\00"
@.str.10 = [52 x i8] c"%d. Looking for char %c in range [%ld, %ld (incl)]\0A\00"
@.str.11 = [21 x i8] c" j:%2d char: %c\0A\00"
@.str.12 = [14 x i8] c"Num com: %ld\0A\00"
@.str.13 = [17 x i8] c"ying flag: '%s'\0A\00"
@.str.14 = [17 x i8] c"yang flag: '%s'\0A\00"
@.str.15 = [21 x i8] c"Transpositions: %ld\0A\00"
@.str.16 = [20 x i8] c"First weight: %.6f\0A\00"
@.str.17 = [13 x i8] c"N_simi : %d\0A\00"
@.str.18 = [15 x i8] c"Num sim: %.6f\0A\00"
@.str.19 = [14 x i8] c"Weight: %.6f\0A\00"
@.str.20 = [15 x i8] c"pre-match: %d\0A\00"
@.str.21 = [21 x i8] c"final pre-match: %d\0A\00"
@.str.22 = [23 x i8] c"Adjusted weight: %.6f\0A\00"
@.str.23 = [26 x i8] c"Re-adjusted weight: %.6f\0A\00"
define double @strcmp95(i8* %0, i8* %1, i64 %2, i32** %3) {
%5 = alloca double
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i32**
%10 = alloca [61 x i8]
%11 = alloca [61 x i8]
%12 = alloca [61 x i8]
%13 = alloca [61 x i8]
%14 = alloca double
%15 = alloca double
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i8
%31 = alloca i8
store i8* %0, i8** %6
store i8* %1, i8** %7
store i64 %2, i64* %8
store i32** %3, i32*** %9
%32 = load i32, i32* @strcmp95.pass
%33 = icmp ne i32 %32, 0
br i1 %33, label %105, label %34
34: ; preds = %4
%35 = load i32, i32* @strcmp95.pass
%36 = add nsw i32 %35, 1
store i32 %36, i32* @strcmp95.pass
store i32 0, i32* %27
br label %37
37: ; preds = %55, %34
%38 = load i32, i32* %27
%39 = icmp slt i32 %38, 91
br i1 %39, label %40, label %58
40: ; preds = %37
store i32 0, i32* %28
br label %41
41: ; preds = %51, %40
%42 = load i32, i32* %28
%43 = icmp slt i32 %42, 91
br i1 %43, label %44, label %54
44: ; preds = %41
%45 = load i32, i32* %27
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %46
%48 = load i32, i32* %28
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [91 x i32], [91 x i32]* %47, i64 0, i64 %49
store i32 0, i32* %50
br label %51
51: ; preds = %44
%52 = load i32, i32* %28
%53 = add nsw i32 %52, 1
store i32 %53, i32* %28
br label %41
54: ; preds = %41
br label %55
55: ; preds = %54
%56 = load i32, i32* %27
%57 = add nsw i32 %56, 1
store i32 %57, i32* %27
br label %37
58: ; preds = %37
store i32 0, i32* %27
br label %59
59: ; preds = %101, %58
%60 = load i32, i32* %27
%61 = icmp slt i32 %60, 36
br i1 %61, label %62, label %104
62: ; preds = %59
%63 = load i32, i32* %27
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %64
%66 = getelementptr inbounds [2 x i8], [2 x i8]* %65, i64 0, i64 0
%67 = load i8, i8* %66
store i8 %67, i8* %30
%68 = load i32, i32* %27
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %69
%71 = getelementptr inbounds [2 x i8], [2 x i8]* %70, i64 0, i64 1
%72 = load i8, i8* %71
store i8 %72, i8* %31
%73 = load i32, i32* %27
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %74
%76 = getelementptr inbounds [2 x i8], [2 x i8]* %75, i64 0, i64 0
%77 = load i8, i8* %76
%78 = sext i8 %77 to i64
%79 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %78
%80 = load i32, i32* %27
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %81
%83 = getelementptr inbounds [2 x i8], [2 x i8]* %82, i64 0, i64 1
%84 = load i8, i8* %83
%85 = sext i8 %84 to i64
%86 = getelementptr inbounds [91 x i32], [91 x i32]* %79, i64 0, i64 %85
store i32 3, i32* %86
%87 = load i32, i32* %27
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %88
%90 = getelementptr inbounds [2 x i8], [2 x i8]* %89, i64 0, i64 1
%91 = load i8, i8* %90
%92 = sext i8 %91 to i64
%93 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %92
%94 = load i32, i32* %27
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %95
%97 = getelementptr inbounds [2 x i8], [2 x i8]* %96, i64 0, i64 0
%98 = load i8, i8* %97
%99 = sext i8 %98 to i64
%100 = getelementptr inbounds [91 x i32], [91 x i32]* %93, i64 0, i64 %99
store i32 3, i32* %100
br label %101
101: ; preds = %62
%102 = load i32, i32* %27
%103 = add nsw i32 %102, 1
store i32 %103, i32* %27
br label %59
104: ; preds = %59
br label %105
105: ; preds = %104, %4
%106 = load i8*, i8** %6
%107 = load i64, i64* %8
%108 = call i32 @strncmp(i8* %106, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %107)
%109 = icmp ne i32 %108, 0
br i1 %109, label %111, label %110
110: ; preds = %105
store double 0.000000e+00, double* %5
br label %777
111: ; preds = %105
%112 = load i8*, i8** %7
%113 = load i64, i64* %8
%114 = call i32 @strncmp(i8* %112, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %113)
%115 = icmp ne i32 %114, 0
br i1 %115, label %117, label %116
116: ; preds = %111
store double 0.000000e+00, double* %5
br label %777
117: ; preds = %111
%118 = load i64, i64* %8
%119 = sub nsw i64 %118, 1
%120 = trunc i64 %119 to i32
store i32 %120, i32* %29
store i32 0, i32* %28
br label %121
121: ; preds = %136, %117
%122 = load i8*, i8** %6
%123 = load i32, i32* %28
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i8, i8* %122, i64 %124
%126 = load i8, i8* %125
%127 = sext i8 %126 to i32
%128 = icmp eq i32 %127, 32
br i1 %128, label %129, label %133
129: ; preds = %121
%130 = load i32, i32* %28
%131 = load i32, i32* %29
%132 = icmp slt i32 %130, %131
br label %133
133: ; preds = %129, %121
%134 = phi i1 [ false, %121 ], [ %132, %129 ]
br i1 %134, label %135, label %139
135: ; preds = %133
br label %136
136: ; preds = %135
%137 = load i32, i32* %28
%138 = add nsw i32 %137, 1
store i32 %138, i32* %28
br label %121
139: ; preds = %133
%140 = load i32, i32* %29
store i32 %140, i32* %27
br label %141
141: ; preds = %155, %139
%142 = load i8*, i8** %6
%143 = load i32, i32* %27
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i8, i8* %142, i64 %144
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = icmp eq i32 %147, 32
br i1 %148, label %149, label %152
149: ; preds = %141
%150 = load i32, i32* %27
%151 = icmp sgt i32 %150, 0
br label %152
152: ; preds = %149, %141
%153 = phi i1 [ false, %141 ], [ %151, %149 ]
br i1 %153, label %154, label %158
154: ; preds = %152
br label %155
155: ; preds = %154
%156 = load i32, i32* %27
%157 = add nsw i32 %156, -1
store i32 %157, i32* %27
br label %141
158: ; preds = %152
%159 = load i32, i32* %27
%160 = add nsw i32 %159, 1
%161 = load i32, i32* %28
%162 = sub nsw i32 %160, %161
%163 = sext i32 %162 to i64
store i64 %163, i64* %19
%164 = load i32, i32* %28
store i32 %164, i32* %25
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%166 = load i32, i32* %25
%167 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i32 %166)
%168 = load i64, i64* %19
%169 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i64 %168)
store i32 0, i32* %28
br label %170
170: ; preds = %185, %158
%171 = load i8*, i8** %7
%172 = load i32, i32* %28
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i8, i8* %171, i64 %173
%175 = load i8, i8* %174
%176 = sext i8 %175 to i32
%177 = icmp eq i32 %176, 32
br i1 %177, label %178, label %182
178: ; preds = %170
%179 = load i32, i32* %28
%180 = load i32, i32* %29
%181 = icmp slt i32 %179, %180
br label %182
182: ; preds = %178, %170
%183 = phi i1 [ false, %170 ], [ %181, %178 ]
br i1 %183, label %184, label %188
184: ; preds = %182
br label %185
185: ; preds = %184
%186 = load i32, i32* %28
%187 = add nsw i32 %186, 1
store i32 %187, i32* %28
br label %170
188: ; preds = %182
%189 = load i32, i32* %29
store i32 %189, i32* %27
br label %190
190: ; preds = %204, %188
%191 = load i8*, i8** %7
%192 = load i32, i32* %27
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %191, i64 %193
%195 = load i8, i8* %194
%196 = sext i8 %195 to i32
%197 = icmp eq i32 %196, 32
br i1 %197, label %198, label %201
198: ; preds = %190
%199 = load i32, i32* %27
%200 = icmp sgt i32 %199, 0
br label %201
201: ; preds = %198, %190
%202 = phi i1 [ false, %190 ], [ %200, %198 ]
br i1 %202, label %203, label %207
203: ; preds = %201
br label %204
204: ; preds = %203
%205 = load i32, i32* %27
%206 = add nsw i32 %205, -1
store i32 %206, i32* %27
br label %190
207: ; preds = %201
%208 = load i32, i32* %27
%209 = add nsw i32 %208, 1
%210 = load i32, i32* %28
%211 = sub nsw i32 %209, %210
%212 = sext i32 %211 to i64
store i64 %212, i64* %23
%213 = load i32, i32* %28
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %213)
%215 = load i64, i64* %23
%216 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i64 %215)
%217 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 0
store i8 0, i8* %217
%218 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 0
store i8 0, i8* %218
%219 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 0
%220 = load i8*, i8** %6
%221 = load i32, i32* %25
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %220, i64 %222
%224 = load i64, i64* %19
%225 = call i8* @strncat(i8* %219, i8* %223, i64 %224)
%226 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 0
%227 = load i8*, i8** %7
%228 = load i32, i32* %28
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i8, i8* %227, i64 %229
%231 = load i64, i64* %23
%232 = call i8* @strncat(i8* %226, i8* %230, i64 %231)
%233 = load i64, i64* %19
%234 = load i64, i64* %23
%235 = icmp sgt i64 %233, %234
br i1 %235, label %236, label %239
236: ; preds = %207
%237 = load i64, i64* %19
store i64 %237, i64* %17
%238 = load i64, i64* %23
store i64 %238, i64* %16
br label %242
239: ; preds = %207
%240 = load i64, i64* %23
store i64 %240, i64* %17
%241 = load i64, i64* %19
store i64 %241, i64* %16
br label %242
242: ; preds = %239, %236
%243 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 0
store i8 0, i8* %243
%244 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 0
store i8 0, i8* %244
%245 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 0
%246 = load i64, i64* %17
%247 = call i8* @strncat(i8* %245, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %246)
%248 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 0
%249 = load i64, i64* %17
%250 = call i8* @strncat(i8* %248, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %249)
%251 = load i64, i64* %17
%252 = sdiv i64 %251, 2
%253 = sub nsw i64 %252, 1
store i64 %253, i64* %17
%254 = load i64, i64* %17
%255 = icmp slt i64 %254, 0
br i1 %255, label %256, label %257
256: ; preds = %242
store i64 0, i64* %17
br label %257
257: ; preds = %256, %242
%258 = load i32**, i32*** %9
%259 = getelementptr inbounds i32*, i32** %258, i64 1
%260 = load i32*, i32** %259
%261 = icmp ne i32* %260, null
br i1 %261, label %315, label %262
262: ; preds = %257
store i32 0, i32* %27
br label %263
263: ; preds = %285, %262
%264 = load i32, i32* %27
%265 = sext i32 %264 to i64
%266 = load i64, i64* %19
%267 = icmp slt i64 %265, %266
br i1 %267, label %268, label %288
268: ; preds = %263
%269 = load i32, i32* %27
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %270
%272 = load i8, i8* %271
%273 = sext i8 %272 to i32
%274 = call i32 @islower(i32 %273)
%275 = icmp ne i32 %274, 0
br i1 %275, label %276, label %284
276: ; preds = %268
%277 = load i32, i32* %27
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %278
%280 = load i8, i8* %279
%281 = sext i8 %280 to i32
%282 = sub nsw i32 %281, 32
%283 = trunc i32 %282 to i8
store i8 %283, i8* %279
br label %284
284: ; preds = %276, %268
br label %285
285: ; preds = %284
%286 = load i32, i32* %27
%287 = add nsw i32 %286, 1
store i32 %287, i32* %27
br label %263
288: ; preds = %263
store i32 0, i32* %28
br label %289
289: ; preds = %311, %288
%290 = load i32, i32* %28
%291 = sext i32 %290 to i64
%292 = load i64, i64* %23
%293 = icmp slt i64 %291, %292
br i1 %293, label %294, label %314
294: ; preds = %289
%295 = load i32, i32* %28
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %296
%298 = load i8, i8* %297
%299 = sext i8 %298 to i32
%300 = call i32 @islower(i32 %299)
%301 = icmp ne i32 %300, 0
br i1 %301, label %302, label %310
302: ; preds = %294
%303 = load i32, i32* %28
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %304
%306 = load i8, i8* %305
%307 = sext i8 %306 to i32
%308 = sub nsw i32 %307, 32
%309 = trunc i32 %308 to i8
store i8 %309, i8* %305
br label %310
310: ; preds = %302, %294
br label %311
311: ; preds = %310
%312 = load i32, i32* %28
%313 = add nsw i32 %312, 1
store i32 %313, i32* %28
br label %289
314: ; preds = %289
br label %315
315: ; preds = %314, %257
%316 = load i64, i64* %17
%317 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i64 %316)
%318 = load i64, i64* %16
%319 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i64 0, i64 0), i64 %318)
%320 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 0
%321 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0), i8* %320)
%322 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 0
%323 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.9, i64 0, i64 0), i8* %322)
%324 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i64 0, i64* %22
%325 = load i64, i64* %23
%326 = sub nsw i64 %325, 1
%327 = trunc i64 %326 to i32
store i32 %327, i32* %24
store i32 0, i32* %27
br label %328
328: ; preds = %419, %315
%329 = load i32, i32* %27
%330 = sext i32 %329 to i64
%331 = load i64, i64* %19
%332 = icmp slt i64 %330, %331
br i1 %332, label %333, label %422
333: ; preds = %328
%334 = load i32, i32* %27
%335 = sext i32 %334 to i64
%336 = load i64, i64* %17
%337 = icmp sge i64 %335, %336
br i1 %337, label %338, label %343
338: ; preds = %333
%339 = load i32, i32* %27
%340 = sext i32 %339 to i64
%341 = load i64, i64* %17
%342 = sub nsw i64 %340, %341
br label %344
343: ; preds = %333
br label %344
344: ; preds = %343, %338
%345 = phi i64 [ %342, %338 ], [ 0, %343 ]
store i64 %345, i64* %18
%346 = load i32, i32* %27
%347 = sext i32 %346 to i64
%348 = load i64, i64* %17
%349 = add nsw i64 %347, %348
%350 = load i32, i32* %24
%351 = sext i32 %350 to i64
%352 = icmp sle i64 %349, %351
br i1 %352, label %353, label %358
353: ; preds = %344
%354 = load i32, i32* %27
%355 = sext i32 %354 to i64
%356 = load i64, i64* %17
%357 = add nsw i64 %355, %356
br label %361
358: ; preds = %344
%359 = load i32, i32* %24
%360 = sext i32 %359 to i64
br label %361
361: ; preds = %358, %353
%362 = phi i64 [ %357, %353 ], [ %360, %358 ]
store i64 %362, i64* %20
%363 = load i32, i32* %27
%364 = load i32, i32* %27
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %365
%367 = load i8, i8* %366
%368 = sext i8 %367 to i32
%369 = load i64, i64* %18
%370 = load i64, i64* %20
%371 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.10, i64 0, i64 0), i32 %363, i32 %368, i64 %369, i64 %370)
%372 = load i64, i64* %18
%373 = trunc i64 %372 to i32
store i32 %373, i32* %28
br label %374
374: ; preds = %415, %361
%375 = load i32, i32* %28
%376 = sext i32 %375 to i64
%377 = load i64, i64* %20
%378 = icmp sle i64 %376, %377
br i1 %378, label %379, label %418
379: ; preds = %374
%380 = load i32, i32* %28
%381 = load i32, i32* %28
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %382
%384 = load i8, i8* %383
%385 = sext i8 %384 to i32
%386 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.11, i64 0, i64 0), i32 %380, i32 %385)
%387 = load i32, i32* %28
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 %388
%390 = load i8, i8* %389
%391 = sext i8 %390 to i32
%392 = icmp ne i32 %391, 49
br i1 %392, label %393, label %414
393: ; preds = %379
%394 = load i32, i32* %28
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %395
%397 = load i8, i8* %396
%398 = sext i8 %397 to i32
%399 = load i32, i32* %27
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %400
%402 = load i8, i8* %401
%403 = sext i8 %402 to i32
%404 = icmp eq i32 %398, %403
br i1 %404, label %405, label %414
405: ; preds = %393
%406 = load i32, i32* %28
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 %407
store i8 49, i8* %408
%409 = load i32, i32* %27
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 %410
store i8 49, i8* %411
%412 = load i64, i64* %22
%413 = add nsw i64 %412, 1
store i64 %413, i64* %22
br label %418
414: ; preds = %393, %379
br label %415
415: ; preds = %414
%416 = load i32, i32* %28
%417 = add nsw i32 %416, 1
store i32 %417, i32* %28
br label %374
418: ; preds = %405, %374
br label %419
419: ; preds = %418
%420 = load i32, i32* %27
%421 = add nsw i32 %420, 1
store i32 %421, i32* %27
br label %328
422: ; preds = %328
%423 = load i64, i64* %22
%424 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0), i64 %423)
%425 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 0
%426 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.13, i64 0, i64 0), i8* %425)
%427 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 0
%428 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.14, i64 0, i64 0), i8* %427)
%429 = load i64, i64* %22
%430 = icmp ne i64 %429, 0
br i1 %430, label %432, label %431
431: ; preds = %422
store double 0.000000e+00, double* %5
br label %777
432: ; preds = %422
store i64 0, i64* %21
store i32 0, i32* %29
store i32 0, i32* %27
br label %433
433: ; preds = %483, %432
%434 = load i32, i32* %27
%435 = sext i32 %434 to i64
%436 = load i64, i64* %19
%437 = icmp slt i64 %435, %436
br i1 %437, label %438, label %486
438: ; preds = %433
%439 = load i32, i32* %27
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 %440
%442 = load i8, i8* %441
%443 = sext i8 %442 to i32
%444 = icmp eq i32 %443, 49
br i1 %444, label %445, label %482
445: ; preds = %438
%446 = load i32, i32* %29
store i32 %446, i32* %28
br label %447
447: ; preds = %463, %445
%448 = load i32, i32* %28
%449 = sext i32 %448 to i64
%450 = load i64, i64* %23
%451 = icmp slt i64 %449, %450
br i1 %451, label %452, label %466
452: ; preds = %447
%453 = load i32, i32* %28
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 %454
%456 = load i8, i8* %455
%457 = sext i8 %456 to i32
%458 = icmp eq i32 %457, 49
br i1 %458, label %459, label %462
459: ; preds = %452
%460 = load i32, i32* %28
%461 = add nsw i32 %460, 1
store i32 %461, i32* %29
br label %466
462: ; preds = %452
br label %463
463: ; preds = %462
%464 = load i32, i32* %28
%465 = add nsw i32 %464, 1
store i32 %465, i32* %28
br label %447
466: ; preds = %459, %447
%467 = load i32, i32* %27
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %468
%470 = load i8, i8* %469
%471 = sext i8 %470 to i32
%472 = load i32, i32* %28
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %473
%475 = load i8, i8* %474
%476 = sext i8 %475 to i32
%477 = icmp ne i32 %471, %476
br i1 %477, label %478, label %481
478: ; preds = %466
%479 = load i64, i64* %21
%480 = add nsw i64 %479, 1
store i64 %480, i64* %21
br label %481
481: ; preds = %478, %466
br label %482
482: ; preds = %481, %438
br label %483
483: ; preds = %482
%484 = load i32, i32* %27
%485 = add nsw i32 %484, 1
store i32 %485, i32* %27
br label %433
486: ; preds = %433
%487 = load i64, i64* %21
%488 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.15, i64 0, i64 0), i64 %487)
%489 = load i64, i64* %21
%490 = sdiv i64 %489, 2
store i64 %490, i64* %21
%491 = load i64, i64* %22
%492 = sitofp i64 %491 to double
%493 = load i64, i64* %19
%494 = sitofp i64 %493 to double
%495 = fdiv double %492, %494
%496 = load i64, i64* %22
%497 = sitofp i64 %496 to double
%498 = load i64, i64* %23
%499 = sitofp i64 %498 to double
%500 = fdiv double %497, %499
%501 = fadd double %495, %500
%502 = load i64, i64* %22
%503 = load i64, i64* %21
%504 = sub nsw i64 %502, %503
%505 = sitofp i64 %504 to double
%506 = load i64, i64* %22
%507 = sitofp i64 %506 to double
%508 = fdiv double %505, %507
%509 = fadd double %501, %508
store double %509, double* %14
%510 = load double, double* %14
%511 = fdiv double %510, 3.000000e+00
store double %511, double* %14
%512 = load double, double* %14
%513 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.16, i64 0, i64 0), double %512)
store i32 0, i32* %26
%514 = load i64, i64* %16
%515 = load i64, i64* %22
%516 = icmp sgt i64 %514, %515
br i1 %516, label %517, label %616
517: ; preds = %486
store i32 0, i32* %27
br label %518
518: ; preds = %612, %517
%519 = load i32, i32* %27
%520 = sext i32 %519 to i64
%521 = load i64, i64* %19
%522 = icmp slt i64 %520, %521
br i1 %522, label %523, label %615
523: ; preds = %518
%524 = load i32, i32* %27
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 %525
%527 = load i8, i8* %526
%528 = sext i8 %527 to i32
%529 = icmp eq i32 %528, 32
br i1 %529, label %530, label %611
530: ; preds = %523
%531 = load i32, i32* %27
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %532
%534 = load i8, i8* %533
%535 = sext i8 %534 to i32
%536 = icmp sgt i32 %535, 0
br i1 %536, label %537, label %611
537: ; preds = %530
%538 = load i32, i32* %27
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %539
%541 = load i8, i8* %540
%542 = sext i8 %541 to i32
%543 = icmp slt i32 %542, 91
br i1 %543, label %544, label %611
544: ; preds = %537
store i32 0, i32* %28
br label %545
545: ; preds = %607, %544
%546 = load i32, i32* %28
%547 = sext i32 %546 to i64
%548 = load i64, i64* %23
%549 = icmp slt i64 %547, %548
br i1 %549, label %550, label %610
550: ; preds = %545
%551 = load i32, i32* %28
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 %552
%554 = load i8, i8* %553
%555 = sext i8 %554 to i32
%556 = icmp eq i32 %555, 32
br i1 %556, label %557, label %606
557: ; preds = %550
%558 = load i32, i32* %28
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %559
%561 = load i8, i8* %560
%562 = sext i8 %561 to i32
%563 = icmp sgt i32 %562, 0
br i1 %563, label %564, label %606
564: ; preds = %557
%565 = load i32, i32* %28
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %566
%568 = load i8, i8* %567
%569 = sext i8 %568 to i32
%570 = icmp slt i32 %569, 91
br i1 %570, label %571, label %606
571: ; preds = %564
%572 = load i32, i32* %27
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %573
%575 = load i8, i8* %574
%576 = sext i8 %575 to i64
%577 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %576
%578 = load i32, i32* %28
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %579
%581 = load i8, i8* %580
%582 = sext i8 %581 to i64
%583 = getelementptr inbounds [91 x i32], [91 x i32]* %577, i64 0, i64 %582
%584 = load i32, i32* %583
%585 = icmp sgt i32 %584, 0
br i1 %585, label %586, label %605
586: ; preds = %571
%587 = load i32, i32* %27
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %588
%590 = load i8, i8* %589
%591 = sext i8 %590 to i64
%592 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %591
%593 = load i32, i32* %28
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %594
%596 = load i8, i8* %595
%597 = sext i8 %596 to i64
%598 = getelementptr inbounds [91 x i32], [91 x i32]* %592, i64 0, i64 %597
%599 = load i32, i32* %598
%600 = load i32, i32* %26
%601 = add nsw i32 %600, %599
store i32 %601, i32* %26
%602 = load i32, i32* %28
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 %603
store i8 50, i8* %604
br label %610
605: ; preds = %571
br label %606
606: ; preds = %605, %564, %557, %550
br label %607
607: ; preds = %606
%608 = load i32, i32* %28
%609 = add nsw i32 %608, 1
store i32 %609, i32* %28
br label %545
610: ; preds = %586, %545
br label %611
611: ; preds = %610, %537, %530, %523
br label %612
612: ; preds = %611
%613 = load i32, i32* %27
%614 = add nsw i32 %613, 1
store i32 %614, i32* %27
br label %518
615: ; preds = %518
br label %616
616: ; preds = %615, %486
%617 = load i32, i32* %26
%618 = sitofp i32 %617 to double
%619 = fdiv double %618, 1.000000e+01
%620 = load i64, i64* %22
%621 = sitofp i64 %620 to double
%622 = fadd double %619, %621
store double %622, double* %15
%623 = load i32, i32* %26
%624 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.17, i64 0, i64 0), i32 %623)
%625 = load double, double* %15
%626 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.18, i64 0, i64 0), double %625)
%627 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 0
%628 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.13, i64 0, i64 0), i8* %627)
%629 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 0
%630 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.14, i64 0, i64 0), i8* %629)
%631 = load double, double* %15
%632 = load i64, i64* %19
%633 = sitofp i64 %632 to double
%634 = fdiv double %631, %633
%635 = load double, double* %15
%636 = load i64, i64* %23
%637 = sitofp i64 %636 to double
%638 = fdiv double %635, %637
%639 = fadd double %634, %638
%640 = load i64, i64* %22
%641 = load i64, i64* %21
%642 = sub nsw i64 %640, %641
%643 = sitofp i64 %642 to double
%644 = load i64, i64* %22
%645 = sitofp i64 %644 to double
%646 = fdiv double %643, %645
%647 = fadd double %639, %646
store double %647, double* %14
%648 = load double, double* %14
%649 = fdiv double %648, 3.000000e+00
store double %649, double* %14
%650 = load double, double* %14
%651 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.19, i64 0, i64 0), double %650)
%652 = load double, double* %14
%653 = fcmp ogt double %652, 0x3FE6666666666666
br i1 %653, label %654, label %775
654: ; preds = %616
%655 = load i64, i64* %16
%656 = icmp sge i64 %655, 4
br i1 %656, label %657, label %658
657: ; preds = %654
br label %660
658: ; preds = %654
%659 = load i64, i64* %16
br label %660
660: ; preds = %658, %657
%661 = phi i64 [ 4, %657 ], [ %659, %658 ]
%662 = trunc i64 %661 to i32
store i32 %662, i32* %28
store i32 0, i32* %27
br label %663
663: ; preds = %700, %660
%664 = load i32, i32* %27
%665 = load i32, i32* %28
%666 = icmp slt i32 %664, %665
br i1 %666, label %667, label %695
667: ; preds = %663
%668 = load i32, i32* %27
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %669
%671 = load i8, i8* %670
%672 = sext i8 %671 to i32
%673 = load i32, i32* %27
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds [61 x i8], [61 x i8]* %11, i64 0, i64 %674
%676 = load i8, i8* %675
%677 = sext i8 %676 to i32
%678 = icmp eq i32 %672, %677
br i1 %678, label %679, label %695
679: ; preds = %667
%680 = load i32, i32* %27
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %681
%683 = load i8, i8* %682
%684 = sext i8 %683 to i32
%685 = icmp sgt i32 %684, 57
br i1 %685, label %693, label %686
686: ; preds = %679
%687 = load i32, i32* %27
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 %688
%690 = load i8, i8* %689
%691 = sext i8 %690 to i32
%692 = icmp slt i32 %691, 48
br label %693
693: ; preds = %686, %679
%694 = phi i1 [ true, %679 ], [ %692, %686 ]
br label %695
695: ; preds = %693, %667, %663
%696 = phi i1 [ false, %667 ], [ false, %663 ], [ %694, %693 ]
br i1 %696, label %697, label %703
697: ; preds = %695
%698 = load i32, i32* %27
%699 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.20, i64 0, i64 0), i32 %698)
br label %700
700: ; preds = %697
%701 = load i32, i32* %27
%702 = add nsw i32 %701, 1
store i32 %702, i32* %27
br label %663
703: ; preds = %695
%704 = load i32, i32* %27
%705 = icmp ne i32 %704, 0
br i1 %705, label %706, label %716
706: ; preds = %703
%707 = load i32, i32* %27
%708 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.21, i64 0, i64 0), i32 %707)
%709 = load i32, i32* %27
%710 = sitofp i32 %709 to double
%711 = fmul double %710, 1.000000e-01
%712 = load double, double* %14
%713 = fsub double 1.000000e+00, %712
%714 = load double, double* %14
%715 = call double @llvm.fmuladd.f64(double %711, double %713, double %714)
store double %715, double* %14
br label %716
716: ; preds = %706, %703
%717 = load double, double* %14
%718 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.22, i64 0, i64 0), double %717)
%719 = load i32**, i32*** %9
%720 = getelementptr inbounds i32*, i32** %719, i64 0
%721 = load i32*, i32** %720
%722 = icmp ne i32* %721, null
br i1 %722, label %774, label %723
723: ; preds = %716
%724 = load i64, i64* %16
%725 = icmp sgt i64 %724, 4
br i1 %725, label %726, label %774
726: ; preds = %723
%727 = load i64, i64* %22
%728 = load i32, i32* %27
%729 = add nsw i32 %728, 1
%730 = sext i32 %729 to i64
%731 = icmp sgt i64 %727, %730
br i1 %731, label %732, label %774
732: ; preds = %726
%733 = load i64, i64* %22
%734 = mul nsw i64 2, %733
%735 = load i64, i64* %16
%736 = load i32, i32* %27
%737 = sext i32 %736 to i64
%738 = add nsw i64 %735, %737
%739 = icmp sge i64 %734, %738
br i1 %739, label %740, label %774
740: ; preds = %732
%741 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 0
%742 = load i8, i8* %741
%743 = sext i8 %742 to i32
%744 = icmp sgt i32 %743, 57
br i1 %744, label %750, label %745
745: ; preds = %740
%746 = getelementptr inbounds [61 x i8], [61 x i8]* %10, i64 0, i64 0
%747 = load i8, i8* %746
%748 = sext i8 %747 to i32
%749 = icmp slt i32 %748, 48
br i1 %749, label %750, label %773
750: ; preds = %745, %740
%751 = load double, double* %14
%752 = fsub double 1.000000e+00, %751
%753 = load i64, i64* %22
%754 = load i32, i32* %27
%755 = sext i32 %754 to i64
%756 = sub nsw i64 %753, %755
%757 = sub nsw i64 %756, 1
%758 = sitofp i64 %757 to double
%759 = load i64, i64* %19
%760 = load i64, i64* %23
%761 = add nsw i64 %759, %760
%762 = load i32, i32* %27
%763 = mul nsw i32 %762, 2
%764 = sext i32 %763 to i64
%765 = sub nsw i64 %761, %764
%766 = add nsw i64 %765, 2
%767 = sitofp i64 %766 to double
%768 = fdiv double %758, %767
%769 = load double, double* %14
%770 = call double @llvm.fmuladd.f64(double %752, double %768, double %769)
store double %770, double* %14
%771 = load double, double* %14
%772 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.23, i64 0, i64 0), double %771)
br label %773
773: ; preds = %750, %745
br label %774
774: ; preds = %773, %732, %726, %723, %716
br label %775
775: ; preds = %774, %616
%776 = load double, double* %14
store double %776, double* %5
br label %777
777: ; preds = %775, %431, %116, %110
%778 = load double, double* %5
ret double %778
}

LLVM IR (-O2):
@strcmp95.pass = internal unnamed_addr global i1 false
@strcmp95.adjwt = internal unnamed_addr global [91 x [91 x i32]] zeroinitializer
@strcmp95.sp = internal unnamed_addr constant [39 x [2 x i8]] [[2 x i8] c"AE", [2 x i8] c"AI", [2 x i8] c"AO", [2 x i8] c"AU", [2 x i8] c"BV", [2 x i8] c"EI", [2 x i8] c"EO", [2 x i8] c"EU", [2 x i8] c"IO", [2 x i8] c"IU", [2 x i8] c"OU", [2 x i8] c"IY", [2 x i8] c"EY", [2 x i8] c"CG", [2 x i8] c"EF", [2 x i8] c"WU", [2 x i8] c"WV", [2 x i8] c"XK", [2 x i8] c"SZ", [2 x i8] c"XS", [2 x i8] c"QC", [2 x i8] c"UV", [2 x i8] c"MN", [2 x i8] c"LI", [2 x i8] c"QO", [2 x i8] c"PR", [2 x i8] c"IJ", [2 x i8] c"2Z", [2 x i8] c"5S", [2 x i8] c"8B", [2 x i8] c"1I", [2 x i8] c"1L", [2 x i8] c"0O", [2 x i8] c"0Q", [2 x i8] c"CK", [2 x i8] c"GJ", [2 x i8] c"E ", [2 x i8] c"Y ", [2 x i8] c"S "]
@.str = [61 x i8] c" \00"
@.str.2 = [16 x i8] c"ying start: %d\0A\00"
@.str.3 = [18 x i8] c"ying length: %ld\0A\00"
@.str.4 = [16 x i8] c"yang start: %d\0A\00"
@.str.5 = [18 x i8] c"yang length: %ld\0A\00"
@.str.6 = [19 x i8] c"Search range: %ld\0A\00"
@.str.7 = [11 x i8] c"Minv: %ld\0A\00"
@.str.8 = [17 x i8] c"ying hold: '%s'\0A\00"
@.str.9 = [17 x i8] c"yang hold: '%s'\0A\00"
@.str.10 = [52 x i8] c"%d. Looking for char %c in range [%ld, %ld (incl)]\0A\00"
@.str.11 = [21 x i8] c" j:%2d char: %c\0A\00"
@.str.12 = [14 x i8] c"Num com: %ld\0A\00"
@.str.13 = [17 x i8] c"ying flag: '%s'\0A\00"
@.str.14 = [17 x i8] c"yang flag: '%s'\0A\00"
@.str.15 = [21 x i8] c"Transpositions: %ld\0A\00"
@.str.16 = [20 x i8] c"First weight: %.6f\0A\00"
@.str.17 = [13 x i8] c"N_simi : %d\0A\00"
@.str.18 = [15 x i8] c"Num sim: %.6f\0A\00"
@.str.19 = [14 x i8] c"Weight: %.6f\0A\00"
@.str.20 = [15 x i8] c"pre-match: %d\0A\00"
@.str.21 = [21 x i8] c"final pre-match: %d\0A\00"
@.str.22 = [23 x i8] c"Adjusted weight: %.6f\0A\00"
@.str.23 = [26 x i8] c"Re-adjusted weight: %.6f\0A\00"
define double @strcmp95(i8* nocapture %0, i8* nocapture %1, i64 %2, i32** nocapture %3) {
%5 = alloca [61 x i8]
%6 = alloca [61 x i8]
%7 = alloca [61 x i8]
%8 = alloca [61 x i8]
%9 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 0
%10 = getelementptr inbounds [61 x i8], [61 x i8]* %6, i64 0, i64 0
%11 = getelementptr inbounds [61 x i8], [61 x i8]* %7, i64 0, i64 0
%12 = getelementptr inbounds [61 x i8], [61 x i8]* %8, i64 0, i64 0
%13 = load i1, i1* @strcmp95.pass
br i1 %13, label %36, label %14
14: ; preds = %4
store i1 true, i1* @strcmp95.pass
br label %15
15: ; preds = %15, %14
%16 = phi i64 [ 0, %14 ], [ %34, %15 ]
%17 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %16, i64 0
%18 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %16, i64 1
%19 = load i8, i8* %17
%20 = sext i8 %19 to i64
%21 = load i8, i8* %18
%22 = sext i8 %21 to i64
%23 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %20, i64 %22
store i32 3, i32* %23
%24 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %22, i64 %20
store i32 3, i32* %24
%25 = or i64 %16, 1
%26 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %25, i64 0
%27 = getelementptr inbounds [39 x [2 x i8]], [39 x [2 x i8]]* @strcmp95.sp, i64 0, i64 %25, i64 1
%28 = load i8, i8* %26
%29 = sext i8 %28 to i64
%30 = load i8, i8* %27
%31 = sext i8 %30 to i64
%32 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %29, i64 %31
store i32 3, i32* %32
%33 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %31, i64 %29
store i32 3, i32* %33
%34 = add nuw nsw i64 %16, 2
%35 = icmp eq i64 %34, 36
br i1 %35, label %36, label %15
36: ; preds = %15, %4
%37 = tail call i32 @strncmp(i8* %0, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %2)
%38 = icmp eq i32 %37, 0
br i1 %38, label %397, label %39
39: ; preds = %36
%40 = tail call i32 @strncmp(i8* %1, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %2)
%41 = icmp eq i32 %40, 0
br i1 %41, label %397, label %42
42: ; preds = %39
%43 = shl i64 %2, 32
%44 = add i64 %43, -4294967296
%45 = ashr exact i64 %44, 32
br label %46
46: ; preds = %46, %42
%47 = phi i64 [ %53, %46 ], [ 0, %42 ]
%48 = getelementptr inbounds i8, i8* %0, i64 %47
%49 = load i8, i8* %48
%50 = icmp eq i8 %49, 32
%51 = icmp slt i64 %47, %45
%52 = select i1 %50, i1 %51, i1 false
%53 = add nuw nsw i64 %47, 1
br i1 %52, label %46, label %54
54: ; preds = %46
%55 = trunc i64 %47 to i32
%56 = and i64 %47, 4294967295
br label %57
57: ; preds = %57, %54
%58 = phi i64 [ %64, %57 ], [ %45, %54 ]
%59 = getelementptr inbounds i8, i8* %0, i64 %58
%60 = load i8, i8* %59
%61 = icmp eq i8 %60, 32
%62 = icmp sgt i64 %58, 0
%63 = select i1 %61, i1 %62, i1 false
%64 = add nsw i64 %58, -1
br i1 %63, label %57, label %65
65: ; preds = %57
%66 = trunc i64 %58 to i32
%67 = sub nsw i32 1, %55
%68 = add i32 %67, %66
%69 = sext i32 %68 to i64
%70 = tail call i32 @putchar(i32 10)
%71 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i32 %55)
%72 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i64 %69)
br label %73
73: ; preds = %73, %65
%74 = phi i64 [ %80, %73 ], [ 0, %65 ]
%75 = getelementptr inbounds i8, i8* %1, i64 %74
%76 = load i8, i8* %75
%77 = icmp eq i8 %76, 32
%78 = icmp slt i64 %74, %45
%79 = select i1 %77, i1 %78, i1 false
%80 = add nuw nsw i64 %74, 1
br i1 %79, label %73, label %81
81: ; preds = %73
%82 = trunc i64 %74 to i32
%83 = and i64 %74, 4294967295
br label %84
84: ; preds = %84, %81
%85 = phi i64 [ %91, %84 ], [ %45, %81 ]
%86 = getelementptr inbounds i8, i8* %1, i64 %85
%87 = load i8, i8* %86
%88 = icmp eq i8 %87, 32
%89 = icmp sgt i64 %85, 0
%90 = select i1 %88, i1 %89, i1 false
%91 = add nsw i64 %85, -1
br i1 %90, label %84, label %92
92: ; preds = %84
%93 = getelementptr inbounds i8, i8* %0, i64 %56
%94 = getelementptr inbounds i8, i8* %1, i64 %83
%95 = trunc i64 %85 to i32
%96 = sub nsw i32 1, %82
%97 = add i32 %96, %95
%98 = sext i32 %97 to i64
%99 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %82)
%100 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i64 %98)
store i8 0, i8* %10
store i8 0, i8* %9
%101 = call i8* @strncat(i8* %9, i8* %93, i64 %69)
%102 = call i8* @strncat(i8* %10, i8* %94, i64 %98)
%103 = icmp sgt i32 %68, %97
%104 = select i1 %103, i32 %68, i32 %97
%105 = sext i32 %104 to i64
%106 = icmp slt i32 %68, %97
%107 = select i1 %106, i32 %68, i32 %97
%108 = sext i32 %107 to i64
store i8 0, i8* %12
store i8 0, i8* %11
%109 = call i8* @strncat(i8* %11, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %105)
%110 = call i8* @strncat(i8* %12, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i64 %105)
%111 = sdiv i32 %104, 2
%112 = sext i32 %111 to i64
%113 = icmp sgt i64 %112, 1
%114 = select i1 %113, i64 %112, i64 1
%115 = add nsw i64 %114, -1
%116 = getelementptr inbounds i32*, i32** %3, i64 1
%117 = load i32*, i32** %116
%118 = icmp eq i32* %117, null
br i1 %118, label %119, label %147
119: ; preds = %92
%120 = icmp sgt i32 %68, 0
br i1 %120, label %123, label %121
121: ; preds = %132, %119
%122 = icmp sgt i32 %97, 0
br i1 %122, label %135, label %147
123: ; preds = %119, %132
%124 = phi i64 [ %133, %132 ], [ 0, %119 ]
%125 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %124
%126 = load i8, i8* %125
%127 = sext i8 %126 to i32
%128 = call i32 @islower(i32 %127)
%129 = icmp eq i32 %128, 0
br i1 %129, label %132, label %130
130: ; preds = %123
%131 = add i8 %126, -32
store i8 %131, i8* %125
br label %132
132: ; preds = %123, %130
%133 = add nuw nsw i64 %124, 1
%134 = icmp eq i64 %133, %69
br i1 %134, label %121, label %123
135: ; preds = %121, %144
%136 = phi i64 [ %145, %144 ], [ 0, %121 ]
%137 = getelementptr inbounds [61 x i8], [61 x i8]* %6, i64 0, i64 %136
%138 = load i8, i8* %137
%139 = sext i8 %138 to i32
%140 = call i32 @islower(i32 %139)
%141 = icmp eq i32 %140, 0
br i1 %141, label %144, label %142
142: ; preds = %135
%143 = add i8 %138, -32
store i8 %143, i8* %137
br label %144
144: ; preds = %135, %142
%145 = add nuw nsw i64 %136, 1
%146 = icmp eq i64 %145, %98
br i1 %146, label %147, label %135
147: ; preds = %144, %121, %92
%148 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i64 %115)
%149 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i64 0, i64 0), i64 %108)
%150 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0), i8* %9)
%151 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.9, i64 0, i64 0), i8* %10)
%152 = call i32 @putchar(i32 10)
%153 = icmp sgt i32 %68, 0
br i1 %153, label %154, label %204
154: ; preds = %147
%155 = add i32 %97, -1
%156 = sext i32 %155 to i64
br label %157
157: ; preds = %154, %200
%158 = phi i64 [ 0, %154 ], [ %202, %200 ]
%159 = phi i64 [ 0, %154 ], [ %201, %200 ]
%160 = call i64 @llvm.usub.sat.i64(i64 %158, i64 %115)
%161 = add nuw nsw i64 %158, %115
%162 = icmp sgt i64 %161, %156
%163 = select i1 %162, i64 %156, i64 %161
%164 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %158
%165 = load i8, i8* %164
%166 = sext i8 %165 to i32
%167 = trunc i64 %158 to i32
%168 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.10, i64 0, i64 0), i32 %167, i32 %166, i64 %160, i64 %163)
%169 = shl i64 %160, 32
%170 = ashr exact i64 %169, 32
%171 = icmp slt i64 %163, %170
br i1 %171, label %200, label %172
172: ; preds = %157
%173 = call i64 @llvm.smax.i64(i64 %158, i64 %115)
%174 = sub nsw i64 %173, %114
%175 = shl i64 %174, 32
%176 = ashr exact i64 %175, 32
%177 = add nsw i64 %176, 1
br label %178
178: ; preds = %172, %197
%179 = phi i64 [ %177, %172 ], [ %198, %197 ]
%180 = phi i64 [ %170, %172 ], [ %198, %197 ]
%181 = getelementptr inbounds [61 x i8], [61 x i8]* %6, i64 0, i64 %180
%182 = load i8, i8* %181
%183 = sext i8 %182 to i32
%184 = trunc i64 %179 to i32
%185 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.11, i64 0, i64 0), i32 %184, i32 %183)
%186 = getelementptr inbounds [61 x i8], [61 x i8]* %8, i64 0, i64 %180
%187 = load i8, i8* %186
%188 = icmp eq i8 %187, 49
br i1 %188, label %197, label %189
189: ; preds = %178
%190 = load i8, i8* %181
%191 = load i8, i8* %164
%192 = icmp eq i8 %190, %191
br i1 %192, label %193, label %197
193: ; preds = %189
%194 = getelementptr inbounds [61 x i8], [61 x i8]* %8, i64 0, i64 %180
store i8 49, i8* %194
%195 = getelementptr inbounds [61 x i8], [61 x i8]* %7, i64 0, i64 %158
store i8 49, i8* %195
%196 = add nsw i64 %159, 1
br label %200
197: ; preds = %178, %189
%198 = add i64 %179, 1
%199 = icmp slt i64 %163, %198
br i1 %199, label %200, label %178
200: ; preds = %197, %157, %193
%201 = phi i64 [ %196, %193 ], [ %159, %157 ], [ %159, %197 ]
%202 = add nuw nsw i64 %158, 1
%203 = icmp eq i64 %202, %69
br i1 %203, label %204, label %157
204: ; preds = %200, %147
%205 = phi i64 [ 0, %147 ], [ %201, %200 ]
%206 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0), i64 %205)
%207 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.13, i64 0, i64 0), i8* %11)
%208 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.14, i64 0, i64 0), i8* %12)
%209 = icmp eq i64 %205, 0
br i1 %209, label %397, label %210
210: ; preds = %204
br i1 %153, label %211, label %248
211: ; preds = %210, %243
%212 = phi i64 [ %246, %243 ], [ 0, %210 ]
%213 = phi i32 [ %245, %243 ], [ 0, %210 ]
%214 = phi i64 [ %244, %243 ], [ 0, %210 ]
%215 = getelementptr inbounds [61 x i8], [61 x i8]* %7, i64 0, i64 %212
%216 = load i8, i8* %215
%217 = icmp eq i8 %216, 49
br i1 %217, label %218, label %243
218: ; preds = %211
%219 = sext i32 %213 to i64
%220 = icmp slt i32 %213, %97
br i1 %220, label %221, label %233
221: ; preds = %218, %229
%222 = phi i64 [ %230, %229 ], [ %219, %218 ]
%223 = getelementptr inbounds [61 x i8], [61 x i8]* %8, i64 0, i64 %222
%224 = load i8, i8* %223
%225 = icmp eq i8 %224, 49
br i1 %225, label %226, label %229
226: ; preds = %221
%227 = trunc i64 %222 to i32
%228 = add nsw i32 %227, 1
br label %233
229: ; preds = %221
%230 = add nsw i64 %222, 1
%231 = trunc i64 %230 to i32
%232 = icmp eq i32 %97, %231
br i1 %232, label %233, label %221
233: ; preds = %229, %218, %226
%234 = phi i64 [ %222, %226 ], [ %219, %218 ], [ %230, %229 ]
%235 = phi i32 [ %228, %226 ], [ %213, %218 ], [ %213, %229 ]
%236 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %212
%237 = load i8, i8* %236
%238 = getelementptr inbounds [61 x i8], [61 x i8]* %6, i64 0, i64 %234
%239 = load i8, i8* %238
%240 = icmp ne i8 %237, %239
%241 = zext i1 %240 to i64
%242 = add nsw i64 %214, %241
br label %243
243: ; preds = %233, %211
%244 = phi i64 [ %214, %211 ], [ %242, %233 ]
%245 = phi i32 [ %213, %211 ], [ %235, %233 ]
%246 = add nuw nsw i64 %212, 1
%247 = icmp eq i64 %246, %69
br i1 %247, label %248, label %211
248: ; preds = %243, %210
%249 = phi i64 [ 0, %210 ], [ %244, %243 ]
%250 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.15, i64 0, i64 0), i64 %249)
%251 = sdiv i64 %249, -2
%252 = sitofp i64 %205 to double
%253 = insertelement <2 x i32> poison, i32 %68, i64 0
%254 = insertelement <2 x i32> %253, i32 %97, i64 1
%255 = sitofp <2 x i32> %254 to <2 x double>
%256 = insertelement <2 x double> poison, double %252, i64 0
%257 = shufflevector <2 x double> %256, <2 x double> poison, <2 x i32> zeroinitializer
%258 = fdiv <2 x double> %257, %255
%259 = shufflevector <2 x double> %258, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%260 = fadd <2 x double> %258, %259
%261 = extractelement <2 x double> %260, i64 0
%262 = add i64 %251, %205
%263 = sitofp i64 %262 to double
%264 = fdiv double %263, %252
%265 = fadd double %261, %264
%266 = fdiv double %265, 3.000000e+00
%267 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.16, i64 0, i64 0), double %266)
%268 = icmp slt i64 %205, %108
%269 = select i1 %268, i1 %153, i1 false
br i1 %269, label %270, label %312
270: ; preds = %248
%271 = icmp slt i32 %97, 1
br label %272
272: ; preds = %270, %308
%273 = phi i64 [ 0, %270 ], [ %310, %308 ]
%274 = phi i32 [ 0, %270 ], [ %309, %308 ]
%275 = getelementptr inbounds [61 x i8], [61 x i8]* %7, i64 0, i64 %273
%276 = load i8, i8* %275
%277 = icmp eq i8 %276, 32
br i1 %277, label %278, label %308
278: ; preds = %272
%279 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %273
%280 = load i8, i8* %279
%281 = add i8 %280, -91
%282 = icmp ult i8 %281, -90
%283 = select i1 %282, i1 true, i1 %271
br i1 %283, label %308, label %284
284: ; preds = %278
%285 = zext i8 %280 to i64
br label %286
286: ; preds = %284, %305
%287 = phi i64 [ 0, %284 ], [ %306, %305 ]
%288 = getelementptr inbounds [61 x i8], [61 x i8]* %8, i64 0, i64 %287
%289 = load i8, i8* %288
%290 = icmp eq i8 %289, 32
br i1 %290, label %291, label %305
291: ; preds = %286
%292 = getelementptr inbounds [61 x i8], [61 x i8]* %6, i64 0, i64 %287
%293 = load i8, i8* %292
%294 = add i8 %293, -1
%295 = icmp ult i8 %294, 90
br i1 %295, label %296, label %305
296: ; preds = %291
%297 = zext i8 %293 to i64
%298 = getelementptr inbounds [91 x [91 x i32]], [91 x [91 x i32]]* @strcmp95.adjwt, i64 0, i64 %285, i64 %297
%299 = load i32, i32* %298
%300 = icmp sgt i32 %299, 0
br i1 %300, label %301, label %305
301: ; preds = %296
%302 = and i64 %287, 4294967295
%303 = getelementptr inbounds [61 x i8], [61 x i8]* %8, i64 0, i64 %302
%304 = add nsw i32 %299, %274
store i8 50, i8* %303
br label %308
305: ; preds = %286, %291, %296
%306 = add nuw nsw i64 %287, 1
%307 = icmp eq i64 %306, %98
br i1 %307, label %308, label %286
308: ; preds = %305, %278, %272, %301
%309 = phi i32 [ %304, %301 ], [ %274, %278 ], [ %274, %272 ], [ %274, %305 ]
%310 = add nuw nsw i64 %273, 1
%311 = icmp eq i64 %310, %69
br i1 %311, label %312, label %272
312: ; preds = %308, %248
%313 = phi i32 [ 0, %248 ], [ %309, %308 ]
%314 = sitofp i32 %313 to double
%315 = fdiv double %314, 1.000000e+01
%316 = fadd double %315, %252
%317 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.17, i64 0, i64 0), i32 %313)
%318 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.18, i64 0, i64 0), double %316)
%319 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.13, i64 0, i64 0), i8* %11)
%320 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.14, i64 0, i64 0), i8* %12)
%321 = insertelement <2 x double> poison, double %316, i64 0
%322 = shufflevector <2 x double> %321, <2 x double> poison, <2 x i32> zeroinitializer
%323 = fdiv <2 x double> %322, %255
%324 = shufflevector <2 x double> %323, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%325 = fadd <2 x double> %323, %324
%326 = extractelement <2 x double> %325, i64 0
%327 = fadd double %264, %326
%328 = fdiv double %327, 3.000000e+00
%329 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.19, i64 0, i64 0), double %328)
%330 = fcmp ogt double %328, 0x3FE6666666666666
br i1 %330, label %331, label %397
331: ; preds = %312
%332 = icmp sgt i32 %107, 0
br i1 %332, label %333, label %362
333: ; preds = %331
%334 = icmp ult i32 %107, 4
%335 = select i1 %334, i32 %107, i32 4
%336 = zext i32 %335 to i64
br label %337
337: ; preds = %333, %348
%338 = phi i64 [ 0, %333 ], [ %350, %348 ]
%339 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %338
%340 = load i8, i8* %339
%341 = getelementptr inbounds [61 x i8], [61 x i8]* %6, i64 0, i64 %338
%342 = load i8, i8* %341
%343 = icmp eq i8 %340, %342
%344 = add i8 %340, -58
%345 = icmp ult i8 %344, -10
%346 = and i1 %343, %345
%347 = trunc i64 %338 to i32
br i1 %346, label %348, label %352
348: ; preds = %337
%349 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.20, i64 0, i64 0), i32 %347)
%350 = add nuw nsw i64 %338, 1
%351 = icmp eq i64 %350, %336
br i1 %351, label %355, label %337
352: ; preds = %337
%353 = trunc i64 %338 to i32
%354 = icmp eq i32 %353, 0
br i1 %354, label %362, label %355
355: ; preds = %348, %352
%356 = phi i32 [ %353, %352 ], [ %335, %348 ]
%357 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.21, i64 0, i64 0), i32 %356)
%358 = sitofp i32 %356 to double
%359 = fmul double %358, 1.000000e-01
%360 = fsub double 1.000000e+00, %328
%361 = call double @llvm.fmuladd.f64(double %359, double %360, double %328)
br label %362
362: ; preds = %331, %355, %352
%363 = phi i32 [ %356, %355 ], [ 0, %352 ], [ 0, %331 ]
%364 = phi double [ %361, %355 ], [ %328, %352 ], [ %328, %331 ]
%365 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.22, i64 0, i64 0), double %364)
%366 = load i32*, i32** %3
%367 = icmp eq i32* %366, null
%368 = icmp sgt i32 %107, 4
%369 = select i1 %367, i1 %368, i1 false
%370 = add nuw nsw i32 %363, 1
%371 = zext i32 %370 to i64
%372 = icmp sgt i64 %205, %371
%373 = select i1 %369, i1 %372, i1 false
br i1 %373, label %374, label %397
374: ; preds = %362
%375 = shl nsw i64 %205, 1
%376 = zext i32 %363 to i64
%377 = add nuw nsw i64 %376, %108
%378 = icmp slt i64 %375, %377
br i1 %378, label %397, label %379
379: ; preds = %374
%380 = load i8, i8* %9
%381 = add i8 %380, -58
%382 = icmp ult i8 %381, -10
br i1 %382, label %383, label %397
383: ; preds = %379
%384 = fsub double 1.000000e+00, %364
%385 = xor i64 %376, -1
%386 = add i64 %205, %385
%387 = sitofp i64 %386 to double
%388 = shl nuw nsw i32 %363, 1
%389 = zext i32 %388 to i64
%390 = add nsw i64 %69, 2
%391 = add nsw i64 %390, %98
%392 = sub nsw i64 %391, %389
%393 = sitofp i64 %392 to double
%394 = fdiv double %387, %393
%395 = call double @llvm.fmuladd.f64(double %384, double %394, double %364)
%396 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.23, i64 0, i64 0), double %395)
br label %397
397: ; preds = %312, %383, %379, %374, %362, %204, %39, %36
%398 = phi double [ 0.000000e+00, %36 ], [ 0.000000e+00, %39 ], [ 0.000000e+00, %204 ], [ %395, %383 ], [ %364, %379 ], [ %364, %374 ], [ %364, %362 ], [ %328, %312 ]
ret double %398
}