int main(int argc, char **argv) {
  int total_dev_size_mb = 0;
  int total_dev_size_cyls = 0;
  int def_pref_percent_size_alloc = 0;
  int total_pref_percent_size_alloc = 0;
  int dev_percent_size_mb = 0;
  int num_partitions = 0;
  int part_min_size[4 + 1];
  int def_part_min_size[4 + 1];
  int sum_min_sizes = 0;
  int part_pref_size_percent[4 + 1];
  int def_part_pref_size_percent[4 + 1];
  int sum_pref_sizes = 0;
  int num_partitions_percent_unspecified = 0;
  int per_unspec_partition_percent_alloc = 0;
  int part_actual_size_mb[4 + 1];
  int part_actual_size_cyls[4 + 1];
  int idx = 0;
  for (idx = 0; idx <= 4; idx++) {
    part_min_size[idx] = 0;
    def_part_min_size[idx] = 1;
    part_pref_size_percent[idx] = -1;
    def_part_pref_size_percent[idx] = 1;
    part_actual_size_mb[idx] = -1;
    part_actual_size_cyls[idx] = -1;
  }
  if (argc < 5) {
    printf("ERROR %s: called with less than 4 arguments\n", argv[0]);
    return 1;
  }
  total_dev_size_mb = atoi(argv[1]);
  if (total_dev_size_mb <= 0) {
    printf("ERROR Parameter 1 (Total device size in MB) %s\n", "should be > 0");
    return 1;
  }
  total_dev_size_cyls = atoi(argv[2]);
  if (total_dev_size_cyls <= 0) {
    printf("ERROR Parameter 2 (Total device size in cylinders) %s\n",
           "should be > 0");
    return 1;
  }
  if (strcasecmp(argv[3], "x") == 0) {
    total_pref_percent_size_alloc = 100;
    def_pref_percent_size_alloc = 1;
  } else {
    total_pref_percent_size_alloc = atoi(argv[3]);
    if ((total_pref_percent_size_alloc <= 0) ||
        (total_pref_percent_size_alloc > 100)) {
      printf("ERROR Parameter 3 (%s) should be in the range 0-100\n",
             "Preferred total % allocation of device");
      return 1;
    }
  }
  num_partitions = atoi(argv[4]);
  if ((num_partitions < 1) || (num_partitions > 4)) {
    printf("ERROR Parameter 4 (%s) should be in the range 1-%d\n",
           "Number of partitions", 4);
    return 1;
  }
  if (argc != (5 + (2 * num_partitions))) {
    printf("ERROR For each partitions, %s\n",
           "exactly 2 parameters must be specified.");
    return 1;
  }
  for (idx = 1; idx <= num_partitions; idx++) {
    if (strcasecmp(argv[idx + idx + 3], "x") == 0) {
    } else {
      part_pref_size_percent[idx] = atoi(argv[idx + idx + 3]);
      def_part_pref_size_percent[idx] = 0;
      if ((part_pref_size_percent[idx] <= 0) ||
          (part_pref_size_percent[idx] > 100)) {
        printf("ERROR Preferred size percentage for partition ");
        printf("%d should be in range 1-100\n", idx);
        return 1;
      }
    }
    if (strcasecmp(argv[idx + idx + 4], "x") == 0) {
    } else {
      part_min_size[idx] = atoi(argv[idx + idx + 4]);
      def_part_min_size[idx] = 0;
      if (part_min_size[idx] <= 0) {
        printf("ERROR Minimum size for partition %d %s\n", idx,
               "should be >= 0");
        return 1;
      }
    }
  }
  for (idx = 1; idx <= num_partitions; idx++)
    sum_min_sizes += part_min_size[idx];
  dev_percent_size_mb = total_dev_size_mb * total_pref_percent_size_alloc / 100;
  if (sum_min_sizes > dev_percent_size_mb) {
    printf("ERROR Sum of partition minimum sizes > %s\n",
           "Preferred total size percentage allocation for device");
    return 1;
  }
  for (idx = 1; idx <= num_partitions; idx++)
    if (part_pref_size_percent[idx] >= 0)
      sum_pref_sizes += part_pref_size_percent[idx];
    else
      num_partitions_percent_unspecified++;
  if (sum_pref_sizes > total_pref_percent_size_alloc) {
    printf("ERROR Sum of partition preferred size percentages ");
    printf("> device total preferred percentage allocation\n");
    return 1;
  }
  if (num_partitions_percent_unspecified > 0) {
    per_unspec_partition_percent_alloc =
        (total_pref_percent_size_alloc - sum_pref_sizes) /
        num_partitions_percent_unspecified;
    if (per_unspec_partition_percent_alloc <= 0) {
      printf("ERROR Remaining %s too small\n", "size percentage allocation");
      return 1;
    }
  }
  if (num_partitions_percent_unspecified > 0) {
    int idx2 = 0;
    int remaining_percent_alloc =
        total_pref_percent_size_alloc - sum_pref_sizes;
    int curr_num_partitions_percent_unspecified =
        num_partitions_percent_unspecified;
    for (idx2 = 1; idx2 <= num_partitions; idx2++) {
      if (part_pref_size_percent[idx2] < 0) {
        curr_num_partitions_percent_unspecified--;
        def_part_pref_size_percent[idx2] = 1;
        if (curr_num_partitions_percent_unspecified > 0) {
          part_pref_size_percent[idx2] = per_unspec_partition_percent_alloc;
          remaining_percent_alloc -= per_unspec_partition_percent_alloc;
        } else {
          part_pref_size_percent[idx2] = remaining_percent_alloc;
        }
      }
    }
  }
  printf("OK\n");
  printf("Total Device Size is %d MB\n", total_dev_size_mb);
  printf("Total Device Size (in cylinders) is %d\n", total_dev_size_cyls);
  if (def_pref_percent_size_alloc) {
    printf("Total Preferred Size Percentage Allocation for device ");
    printf("was unspecified,  so was set to %d %%\n",
           total_pref_percent_size_alloc);
  } else
    printf("%s for device is %d %%\n",
           "Total Preferred Size Percentage Allocation",
           total_pref_percent_size_alloc);
  printf("Number of partitions is %d\n", num_partitions);
  for (idx = 1; idx <= num_partitions; idx++) {
    if (def_part_pref_size_percent[idx]) {
      printf("Partition %d preferred size percentage unspecified,", idx);
      printf(" was set to %d %%\n", part_pref_size_percent[idx]);
    } else
      printf("Partition %d preferred size percentage is %d %%\n", idx,
             part_pref_size_percent[idx]);
    if (def_part_min_size[idx])
      printf("Partition %d %s %d MB\n", idx,
             "minimum size unspecified, was set to", part_min_size[idx]);
    else
      printf("Partition %d minimum size is %d MB\n", idx, part_min_size[idx]);
  }
  printf("Calculating actual space allocation...\n");
  for (idx = 1; idx <= num_partitions; idx++) {
    int part_preferred_size_mb =
        part_pref_size_percent[idx] * total_dev_size_mb / 100;
    if (part_min_size[idx] > part_preferred_size_mb) {
      printf("Partition %d minimum size is larger than the ", idx);
      printf("preferred %% allocation\n");
      part_actual_size_mb[idx] = part_min_size[idx];
    }
  }
  {
    int remaining_mb_toalloc = dev_percent_size_mb;
    int curr_remaining_mb_toalloc = 0;
    int remaining_percents_toalloc = 0;
    int num_nonset_partitions = 0;
    for (idx = 1; idx <= num_partitions; idx++)
      if (part_actual_size_mb[idx] > 0) {
        remaining_mb_toalloc -= part_actual_size_mb[idx];
      } else {
        num_nonset_partitions++;
        remaining_percents_toalloc += part_pref_size_percent[idx];
      }
    curr_remaining_mb_toalloc = remaining_mb_toalloc;
    for (idx = 1; idx <= num_partitions; idx++)
      if (part_actual_size_mb[idx] < 0) {
        num_nonset_partitions--;
        if (num_nonset_partitions > 0) {
          part_actual_size_mb[idx] = remaining_mb_toalloc *
                                     part_pref_size_percent[idx] /
                                     remaining_percents_toalloc;
          curr_remaining_mb_toalloc -= part_actual_size_mb[idx];
        } else {
          part_actual_size_mb[idx] = curr_remaining_mb_toalloc;
        }
      }
  }
  {
    int remaining_cyls =
        total_dev_size_cyls * total_pref_percent_size_alloc / 100;
    for (idx = 1; idx <= num_partitions; idx++) {
      if (idx != num_partitions) {
        part_actual_size_cyls[idx] =
            part_actual_size_mb[idx] * total_dev_size_cyls / total_dev_size_mb;
        remaining_cyls -= part_actual_size_cyls[idx];
      } else
        part_actual_size_cyls[idx] = remaining_cyls;
    }
  }
  printf("Space calculation results:\n");
  for (idx = 1; idx <= num_partitions; idx++) {
    printf("Partition %d size is %d MB, %d cylinders\n", idx,
           part_actual_size_mb[idx], part_actual_size_cyls[idx]);
  }
  for (idx = 1; idx <= num_partitions; idx++) {
    printf("OUTPUT %d %d %d\n", idx, part_actual_size_mb[idx],
           part_actual_size_cyls[idx]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
movl   $0x0,-0xe4(%rbp)
movl   $0x0,-0xe4(%rbp)
cmpl   $0x4,-0xe4(%rbp)
jg     1230 <main+0x100>
movslq -0xe4(%rbp),%rax
movl   $0x0,-0x40(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
movl   $0x1,-0x60(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
movl   $0xffffffff,-0x80(%rbp,%rax,4)
ff
movslq -0xe4(%rbp),%rax
movl   $0x1,-0xa0(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
movl   $0xffffffff,-0xc0(%rbp,%rax,4)
ff ff ff ff
movslq -0xe4(%rbp),%rax
movl   $0xffffffff,-0xe0(%rbp,%rax,4)
ff ff ff ff
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    11ac <main+0x7c>
cmpl   $0x5,-0x8(%rbp)
jge    125b <main+0x12b>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xdb8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
mov    $0x0,%al
call   1050 <atoi@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     1298 <main+0x168>
lea    0xdaf(%rip),%rdi
lea    0xdd8(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
mov    $0x0,%al
call   1050 <atoi@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jg     12d5 <main+0x1a5>
lea    0xdb0(%rip),%rdi
lea    0xd9b(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
lea    0xdbe(%rip),%rsi
call   1030 <strcasecmp@plt>
cmp    $0x0,%eax
jne    1305 <main+0x1d5>
movl   $0x64,-0x20(%rbp)
movl   $0x1,-0x1c(%rbp)
jmp    1351 <main+0x221>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
mov    $0x0,%al
call   1050 <atoi@plt>
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    132b <main+0x1fb>
cmpl   $0x64,-0x20(%rbp)
jle    134c <main+0x21c>
lea    0xd72(%rip),%rdi
lea    0xda0(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
jmp    1351 <main+0x221>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rdi
mov    $0x0,%al
call   1050 <atoi@plt>
mov    %eax,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jl     1377 <main+0x247>
cmpl   $0x4,-0x28(%rbp)
jle    139d <main+0x26d>
lea    0xd82(%rip),%rdi
lea    0xdaf(%rip),%rsi
mov    $0x4,%edx
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
mov    -0x8(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    $0x5,%ecx
cmp    %ecx,%eax
je     13d2 <main+0x2a2>
lea    0xd91(%rip),%rdi
lea    0xda9(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     157e <main+0x44e>
mov    -0x10(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc96(%rip),%rsi
call   1030 <strcasecmp@plt>
cmp    $0x0,%eax
jne    141f <main+0x2ef>
jmp    14b6 <main+0x386>
mov    -0x10(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1050 <atoi@plt>
mov    %eax,%ecx
movslq -0xe4(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
movl   $0x0,-0xa0(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
cmpl   $0x0,-0x80(%rbp,%rax,4)
jle    1483 <main+0x353>
movslq -0xe4(%rbp),%rax
cmpl   $0x64,-0x80(%rbp,%rax,4)
jle    14b1 <main+0x381>
lea    0xd06(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xe4(%rbp),%esi
lea    0xd21(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
jmp    14b6 <main+0x386>
mov    -0x10(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbcb(%rip),%rsi
call   1030 <strcasecmp@plt>
cmp    $0x0,%eax
jne    14ea <main+0x3ba>
jmp    1565 <main+0x435>
mov    -0x10(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1050 <atoi@plt>
mov    %eax,%ecx
movslq -0xe4(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
movl   $0x0,-0x60(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
cmpl   $0x0,-0x40(%rbp,%rax,4)
jg     1560 <main+0x430>
mov    -0xe4(%rbp),%esi
lea    0xc96(%rip),%rdi
lea    0xcb7(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
jmp    1565 <main+0x435>
jmp    156a <main+0x43a>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    13dc <main+0x2ac>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     15bc <main+0x48c>
movslq -0xe4(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1588 <main+0x458>
mov    -0x14(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    15fb <main+0x4cb>
lea    0xc32(%rip),%rdi
lea    0xc56(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     166a <main+0x53a>
movslq -0xe4(%rbp),%rax
cmpl   $0x0,-0x80(%rbp,%rax,4)
jl     1642 <main+0x512>
movslq -0xe4(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    1651 <main+0x521>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1656 <main+0x526>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1605 <main+0x4d5>
mov    -0xa4(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    16a1 <main+0x571>
lea    0xbf4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xc19(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
cmpl   $0x0,-0xa8(%rbp)
jle    16f7 <main+0x5c7>
mov    -0x20(%rbp),%eax
sub    -0xa4(%rbp),%eax
cltd
idivl  -0xa8(%rbp)
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0xac(%rbp)
jg     16f2 <main+0x5c2>
lea    0xbff(%rip),%rdi
lea    0xc16(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1d11 <main+0xbe1>
jmp    16f7 <main+0x5c7>
cmpl   $0x0,-0xa8(%rbp)
jle    17e0 <main+0x6b0>
movl   $0x0,-0xe8(%rbp)
mov    -0x20(%rbp),%eax
sub    -0xa4(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xa8(%rbp),%eax
mov    %eax,-0xf0(%rbp)
movl   $0x1,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     17db <main+0x6ab>
movslq -0xe8(%rbp),%rax
cmpl   $0x0,-0x80(%rbp,%rax,4)
jge    17c2 <main+0x692>
mov    -0xf0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xf0(%rbp)
movslq -0xe8(%rbp),%rax
movl   $0x1,-0xa0(%rbp,%rax,4)
cmpl   $0x0,-0xf0(%rbp)
jle    17ac <main+0x67c>
mov    -0xac(%rbp),%ecx
movslq -0xe8(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0xac(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
jmp    17bd <main+0x68d>
mov    -0xec(%rbp),%ecx
movslq -0xe8(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
jmp    17c2 <main+0x692>
jmp    17c7 <main+0x697>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    1733 <main+0x603>
jmp    17e0 <main+0x6b0>
lea    0xb29(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%esi
lea    0xb1c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%esi
lea    0xb27(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x1c(%rbp)
je     183e <main+0x70e>
lea    0xb37(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x20(%rbp),%esi
lea    0xb5d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1856 <main+0x726>
mov    -0x20(%rbp),%edx
lea    0xb6e(%rip),%rdi
lea    0xb7f(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%esi
lea    0xb99(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     195b <main+0x82b>
movslq -0xe4(%rbp),%rax
cmpl   $0x0,-0xa0(%rbp,%rax,4)
je     18c7 <main+0x797>
mov    -0xe4(%rbp),%esi
lea    0xb73(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0xe4(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%esi
lea    0xae8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    18e6 <main+0x7b6>
mov    -0xe4(%rbp),%esi
movslq -0xe4(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%edx
lea    0xb6a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0xe4(%rbp),%rax
cmpl   $0x0,-0x60(%rbp,%rax,4)
je     1923 <main+0x7f3>
mov    -0xe4(%rbp),%esi
movslq -0xe4(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%ecx
lea    0xb6a(%rip),%rdi
lea    0xb7a(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1942 <main+0x812>
mov    -0xe4(%rbp),%esi
movslq -0xe4(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%edx
lea    0xb7b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1947 <main+0x817>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1871 <main+0x741>
lea    0xb78(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1a0a <main+0x8da>
movslq -0xe4(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
imul   -0x14(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,-0xf4(%rbp)
movslq -0xe4(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
cmp    -0xf4(%rbp),%eax
jle    19f1 <main+0x8c1>
mov    -0xe4(%rbp),%esi
lea    0xb3f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xb5f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0xe4(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%ecx
movslq -0xe4(%rbp),%rax
mov    %ecx,-0xc0(%rbp,%rax,4)
jmp    19f6 <main+0x8c6>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1973 <main+0x843>
mov    -0x24(%rbp),%eax
mov    %eax,-0xf8(%rbp)
movl   $0x0,-0xfc(%rbp)
movl   $0x0,-0x100(%rbp)
movl   $0x0,-0x104(%rbp)
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1abf <main+0x98f>
movslq -0xe4(%rbp),%rax
cmpl   $0x0,-0xc0(%rbp,%rax,4)
jle    1a80 <main+0x950>
movslq -0xe4(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%ecx
mov    -0xf8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf8(%rbp)
jmp    1aa6 <main+0x976>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
movslq -0xe4(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
add    -0x100(%rbp),%eax
mov    %eax,-0x100(%rbp)
jmp    1aab <main+0x97b>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1a3b <main+0x90b>
mov    -0xf8(%rbp),%eax
mov    %eax,-0xfc(%rbp)
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1b91 <main+0xa61>
movslq -0xe4(%rbp),%rax
cmpl   $0x0,-0xc0(%rbp,%rax,4)
jge    1b78 <main+0xa48>
mov    -0x104(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x104(%rbp)
cmpl   $0x0,-0x104(%rbp)
jle    1b5f <main+0xa2f>
mov    -0xf8(%rbp),%eax
movslq -0xe4(%rbp),%rcx
imul   -0x80(%rbp,%rcx,4),%eax
cltd
idivl  -0x100(%rbp)
mov    %eax,%ecx
movslq -0xe4(%rbp),%rax
mov    %ecx,-0xc0(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%ecx
mov    -0xfc(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xfc(%rbp)
jmp    1b73 <main+0xa43>
mov    -0xfc(%rbp),%ecx
movslq -0xe4(%rbp),%rax
mov    %ecx,-0xc0(%rbp,%rax,4)
jmp    1b78 <main+0xa48>
jmp    1b7d <main+0xa4d>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1ad5 <main+0x9a5>
mov    -0x18(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,-0x108(%rbp)
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1c42 <main+0xb12>
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1c15 <main+0xae5>
movslq -0xe4(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%eax
imul   -0x18(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %eax,%ecx
movslq -0xe4(%rbp),%rax
mov    %ecx,-0xe0(%rbp,%rax,4)
movslq -0xe4(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%ecx
mov    -0x108(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x108(%rbp)
jmp    1c29 <main+0xaf9>
mov    -0x108(%rbp),%ecx
movslq -0xe4(%rbp),%rax
mov    %ecx,-0xe0(%rbp,%rax,4)
jmp    1c2e <main+0xafe>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1bb0 <main+0xa80>
lea    0x900(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1cad <main+0xb7d>
mov    -0xe4(%rbp),%esi
movslq -0xe4(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%edx
movslq -0xe4(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%ecx
lea    0x8d3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1c5a <main+0xb2a>
movl   $0x1,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1d0a <main+0xbda>
mov    -0xe4(%rbp),%esi
movslq -0xe4(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%edx
movslq -0xe4(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%ecx
lea    0x8a0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1cb7 <main+0xb87>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %rsi,%r13
pxor   %xmm0,%xmm0
movdqa %xmm0,0x70(%rsp)
movl   $0x0,0x80(%rsp)
pcmpeqd %xmm0,%xmm0
movdqa %xmm0,0x10(%rsp)
movl   $0xffffffff,0x20(%rsp)
ff
movdqa %xmm0,0x30(%rsp)
movl   $0xffffffff,0x40(%rsp)
ff
movdqa %xmm0,0x90(%rsp)
movl   $0xffffffff,0xa0(%rsp)
ff ff ff ff
movaps 0xe5c(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xb0(%rsp)
movl   $0x1,0xe0(%rsp)
movl   $0x1,0xc0(%rsp)
cmp    $0x4,%edi
jg     11dc <main+0x9c>
mov    0x0(%r13),%rsi
lea    0xe36(%rip),%rdi
jmp    1257 <main+0x117>
mov    %edi,%r15d
mov    0x8(%r13),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
test   %eax,%eax
jle    1240 <main+0x100>
mov    %eax,%ebp
mov    0x10(%r13),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
test   %eax,%eax
jle    1249 <main+0x109>
mov    %eax,%r14d
mov    0x18(%r13),%rbx
lea    0xea5(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcasecmp@plt>
mov    %eax,%r12d
test   %eax,%eax
je     1277 <main+0x137>
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
mov    %eax,%ebx
add    $0xffffff9b,%eax
cmp    $0xffffff9b,%eax
ja     127c <main+0x13c>
lea    0xe7d(%rip),%rdi
lea    0xeab(%rip),%rsi
jmp    1257 <main+0x117>
lea    0xdf6(%rip),%rdi
jmp    1250 <main+0x110>
lea    0xe2b(%rip),%rdi
lea    0xe16(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%ebx
mov    %ebx,%eax
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x64,%ebx
mov    0x20(%r13),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
lea    -0x5(%rax),%ecx
cmp    $0xfffffffb,%ecx
ja     12ab <main+0x16b>
lea    0xe7a(%rip),%rdi
lea    0xea7(%rip),%rsi
mov    $0x4,%edx
xor    %eax,%eax
call   1050 <printf@plt>
jmp    125e <main+0x11e>
lea    (%rax,%rax,1),%ecx
add    $0x5,%ecx
cmp    %r15d,%ecx
jne    13aa <main+0x26a>
mov    %r12d,0x6c(%rsp)
mov    %ebx,0xc(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebp,0x4(%rsp)
mov    %eax,%ecx
mov    %eax,0x68(%rsp)
mov    %rax,0x58(%rsp)
mov    %eax,%eax
lea    0x4(,%rax,4),%r14
mov    %rax,0x88(%rsp)
add    $0x1,%rax
mov    %rax,0x60(%rsp)
add    $0xfffffffffffffffc,%r14
mov    $0x1,%ebx
lea    0xdb0(%rip),%r15
xor    %r12d,%r12d
jmp    1320 <main+0x1e0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ebx
add    $0x4,%r12
cmp    %r12,%r14
je     13bd <main+0x27d>
mov    0x28(%r13,%r12,4),%rbp
mov    %rbp,%rdi
mov    %r15,%rsi
call   1030 <strcasecmp@plt>
test   %eax,%eax
je     135b <main+0x21b>
mov    %rbp,%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
mov    %eax,0x14(%rsp,%r12,1)
movl   $0x0,0xb4(%rsp,%r12,1)
add    $0xffffff9b,%eax
cmp    $0xffffff9b,%eax
jbe    13dc <main+0x29c>
mov    0x30(%r13,%r12,4),%rbp
mov    %rbp,%rdi
mov    %r15,%rsi
call   1030 <strcasecmp@plt>
test   %eax,%eax
je     1310 <main+0x1d0>
mov    %rbp,%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
mov    %eax,0x74(%rsp,%r12,1)
movl   $0x0,0xd4(%rsp,%r12,1)
test   %eax,%eax
jg     1310 <main+0x1d0>
lea    0xe57(%rip),%rdi
lea    0xe78(%rip),%rdx
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    125e <main+0x11e>
lea    0xda8(%rip),%rdi
lea    0xdc0(%rip),%rsi
jmp    1257 <main+0x117>
mov    0x58(%rsp),%r14
add    $0x1,%r14d
mov    0x74(%rsp),%eax
cmp    $0x2,%r14d
jne    13ff <main+0x2bf>
mov    0xc(%rsp),%r12d
mov    0x60(%rsp),%r8
jmp    1424 <main+0x2e4>
lea    0xdbd(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdde(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    125e <main+0x11e>
add    0x78(%rsp),%eax
cmp    $0x3,%r14d
mov    0xc(%rsp),%r12d
mov    0x60(%rsp),%r8
je     1424 <main+0x2e4>
add    0x7c(%rsp),%eax
cmp    $0x4,%r14d
je     1424 <main+0x2e4>
add    0x80(%rsp),%eax
mov    0x4(%rsp),%ecx
imul   %r12d,%ecx
movslq %ecx,%rcx
imul   $0x51eb851f,%rcx,%r15
mov    %r15,%rcx
shr    $0x3f,%rcx
sar    $0x25,%r15
add    %ecx,%r15d
cmp    %r15d,%eax
jle    145c <main+0x31c>
lea    0xdd3(%rip),%rdi
lea    0xdf7(%rip),%rsi
jmp    1257 <main+0x117>
lea    -0x1(%r8),%r13
mov    %r8,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0xc8(%rsp)
je     14c4 <main+0x384>
mov    %r13,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
xor    %edi,%edi
mov    $0x1,%ecx
xor    %eax,%eax
mov    0x10(%rsp,%rcx,4),%ebp
mov    0x14(%rsp,%rcx,4),%esi
test   %ebp,%ebp
mov    $0x0,%ebx
cmovns %ebp,%ebx
add    %eax,%ebx
shr    $0x1f,%ebp
add    %edi,%ebp
test   %esi,%esi
mov    $0x0,%eax
cmovns %esi,%eax
add    %ebx,%eax
shr    $0x1f,%esi
add    %ebp,%esi
lea    (%rdx,%rcx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rcx
mov    %esi,%edi
cmp    $0x1,%rbp
jne    1484 <main+0x344>
jmp    14cd <main+0x38d>
xor    %esi,%esi
mov    $0x1,%ecx
xor    %eax,%eax
test   $0x1,%r13b
je     14e5 <main+0x3a5>
mov    0x10(%rsp,%rcx,4),%ecx
xor    %edx,%edx
test   %ecx,%ecx
cmovns %ecx,%edx
add    %edx,%eax
shr    $0x1f,%ecx
add    %ecx,%esi
mov    %r12d,%ecx
sub    %eax,%ecx
jge    150b <main+0x3cb>
lea    0xd91(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x107c(%rip),%rdi
call   1040 <puts@plt>
jmp    125e <main+0x11e>
test   %esi,%esi
je     1558 <main+0x418>
mov    %ecx,%eax
cltd
idiv   %esi
test   %eax,%eax
jle    1798 <main+0x658>
mov    $0x1,%edx
jmp    1530 <main+0x3f0>
mov    %esi,%edi
add    $0x1,%rdx
mov    %edi,%esi
cmp    %rdx,%r8
je     1558 <main+0x418>
cmpl   $0x0,0x10(%rsp,%rdx,4)
jns    1523 <main+0x3e3>
lea    -0x1(%rsi),%edi
movl   $0x1,0xb0(%rsp,%rdx,4)
cmp    $0x2,%esi
jl     1552 <main+0x412>
mov    %eax,0x10(%rsp,%rdx,4)
sub    %eax,%ecx
jmp    1525 <main+0x3e5>
mov    %ecx,0x10(%rsp,%rdx,4)
jmp    1525 <main+0x3e5>
lea    0xfd9(%rip),%rdi
call   1040 <puts@plt>
lea    0xd85(%rip),%rdi
mov    0x4(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xd8f(%rip),%rdi
mov    0x8(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x6c(%rsp)
mov    %r13,0x50(%rsp)
je     15ae <main+0x46e>
lea    0xdf7(%rip),%rdi
lea    0xe08(%rip),%rsi
mov    %r12d,%edx
xor    %eax,%eax
call   1050 <printf@plt>
jmp    15cd <main+0x48d>
lea    0xd7f(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xda8(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r14,0x58(%rsp)
lea    0xdfc(%rip),%rdi
mov    0x68(%rsp),%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%ebx
lea    0xe35(%rip),%r12
lea    0xe76(%rip),%r14
lea    0xdf3(%rip),%rbp
lea    0xd7a(%rip),%r13
jmp    1624 <main+0x4e4>
lea    0xe84(%rip),%rdi
mov    %ebx,%esi
mov    %ecx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,0x60(%rsp)
je     167d <main+0x53d>
cmpl   $0x0,0xb0(%rsp,%rbx,4)
je     164a <main+0x50a>
mov    %rbp,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp,%rbx,4),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    165a <main+0x51a>
mov    0x10(%rsp,%rbx,4),%edx
mov    %r12,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0xd0(%rsp,%rbx,4)
mov    0x70(%rsp,%rbx,4),%ecx
je     1607 <main+0x4c7>
lea    0xde7(%rip),%rdi
mov    %ebx,%esi
mov    %r14,%rdx
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1619 <main+0x4d9>
lea    0xeb7(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%ebx
lea    0xe21(%rip),%r14
lea    0xe48(%rip),%r12
mov    0x60(%rsp),%r13
jmp    16ac <main+0x56c>
add    $0x1,%rbx
cmp    %rbx,%r13
je     16ef <main+0x5af>
mov    0x10(%rsp,%rbx,4),%eax
imul   0x4(%rsp),%eax
cltq
imul   $0x51eb851f,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
mov    0x70(%rsp,%rbx,4),%ebp
cmp    %eax,%ebp
jle    16a3 <main+0x563>
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %ebp,0x30(%rsp,%rbx,4)
jmp    16a3 <main+0x563>
mov    0xc8(%rsp),%rbx
test   %rbx,%rbx
je     1764 <main+0x624>
mov    0x50(%rsp),%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xor    %eax,%eax
mov    $0x1,%edx
xor    %ecx,%ecx
mov    0x58(%rsp),%r12
mov    0x4(%rsp),%r8d
mov    0x8(%rsp),%r9d
mov    0x88(%rsp),%r10
jmp    173f <main+0x5ff>
sub    %edi,%r15d
lea    (%rsi,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
cmp    $0x1,%rdi
je     1784 <main+0x644>
mov    0x30(%rsp,%rdx,4),%edi
test   %edi,%edi
jle    174c <main+0x60c>
sub    %edi,%r15d
jmp    1753 <main+0x613>
add    $0x1,%eax
add    0x10(%rsp,%rdx,4),%ecx
mov    0x34(%rsp,%rdx,4),%edi
test   %edi,%edi
jg     172a <main+0x5ea>
add    $0x1,%eax
add    0x14(%rsp,%rdx,4),%ecx
jmp    172d <main+0x5ed>
xor    %eax,%eax
mov    $0x1,%edx
xor    %ecx,%ecx
mov    0x58(%rsp),%r12
mov    0x4(%rsp),%r8d
mov    0x8(%rsp),%r9d
mov    0x88(%rsp),%r10
testb  $0x1,0x50(%rsp)
je     17b2 <main+0x672>
mov    0x30(%rsp,%rdx,4),%esi
test   %esi,%esi
jle    17ab <main+0x66b>
sub    %esi,%r15d
jmp    17b2 <main+0x672>
lea    0xb18(%rip),%rdi
lea    0xb2f(%rip),%rsi
jmp    1257 <main+0x117>
add    $0x1,%eax
add    0x10(%rsp,%rdx,4),%ecx
mov    $0x1,%esi
mov    %r15d,%edi
jmp    17c9 <main+0x689>
mov    %eax,%ebp
add    $0x1,%rsi
mov    %ebp,%eax
cmp    %rsi,%r13
je     17f1 <main+0x6b1>
cmpl   $0x0,0x30(%rsp,%rsi,4)
jns    17bc <main+0x67c>
lea    -0x1(%rax),%ebp
cmp    $0x2,%eax
jl     17eb <main+0x6ab>
mov    0x10(%rsp,%rsi,4),%eax
imul   %r15d,%eax
cltd
idiv   %ecx
mov    %eax,0x30(%rsp,%rsi,4)
sub    %eax,%edi
jmp    17be <main+0x67e>
mov    %edi,0x30(%rsp,%rsi,4)
jmp    17be <main+0x67e>
mov    0xc(%rsp),%eax
imul   %r9d,%eax
cltq
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rax
shr    $0x3f,%rax
sar    $0x25,%rcx
add    %eax,%ecx
test   %rbx,%rbx
je     1881 <main+0x741>
mov    0x50(%rsp),%r11
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%eax
jmp    1849 <main+0x709>
mov    0x34(%rsp,%rsi,4),%eax
imul   %r9d,%eax
cltd
idiv   %r8d
mov    %ebp,%ecx
sub    %eax,%ecx
mov    %eax,%ebp
mov    %ebp,0x94(%rsp,%rsi,4)
lea    0x1(%rbx),%rax
cmp    %rdi,%rbx
je     187b <main+0x73b>
mov    %rax,%rsi
cmp    %rax,%r10
jne    1855 <main+0x715>
mov    %ecx,%ebp
jmp    1867 <main+0x727>
mov    0x30(%rsp,%rsi,4),%eax
imul   %r9d,%eax
cltd
idiv   %r8d
mov    %ecx,%ebp
sub    %eax,%ebp
mov    %eax,%ecx
mov    %ecx,0x90(%rsp,%rsi,4)
lea    0x1(%rsi),%rbx
cmp    %r10,%rbx
jne    1827 <main+0x6e7>
mov    %ebp,%ecx
jmp    1839 <main+0x6f9>
add    $0x2,%rsi
jmp    188b <main+0x74b>
mov    $0x1,%esi
mov    0x50(%rsp),%r11
test   $0x1,%r11b
je     18ab <main+0x76b>
cmp    %r10,%rsi
je     18a4 <main+0x764>
mov    0x30(%rsp,%rsi,4),%eax
imul   %r9d,%eax
cltd
idiv   %r8d
mov    %eax,%ecx
mov    %ecx,0x90(%rsp,%rsi,4)
lea    0xcb0(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%ebx
lea    0xc3a(%rip),%rbp
mov    0x30(%rsp,%rbx,4),%edx
mov    0x90(%rsp,%rbx,4),%ecx
mov    %rbp,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    18c3 <main+0x783>
mov    $0x1,%ebp
lea    0xc38(%rip),%r14
xor    %ebx,%ebx
mov    0x30(%rsp,%rbp,4),%edx
mov    0x90(%rsp,%rbp,4),%ecx
mov    %r14,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
jne    18f1 <main+0x7b1>
jmp    1263 <main+0x123>

LLVM IR (-O0):
@.str = [45 x i8] c"ERROR %s: called with less than 4 arguments\0A\00"
@.str.1 = [48 x i8] c"ERROR Parameter 1 (Total device size in MB) %s\0A\00"
@.str.2 = [14 x i8] c"should be > 0\00"
@.str.3 = [55 x i8] c"ERROR Parameter 2 (Total device size in cylinders) %s\0A\00"
@.str.4 = [2 x i8] c"x\00"
@.str.5 = [53 x i8] c"ERROR Parameter 3 (%s) should be in the range 0-100\0A\00"
@.str.6 = [39 x i8] c"Preferred total % allocation of device\00"
@.str.7 = [52 x i8] c"ERROR Parameter 4 (%s) should be in the range 1-%d\0A\00"
@.str.8 = [21 x i8] c"Number of partitions\00"
@.str.9 = [31 x i8] c"ERROR For each partitions, %s\0A\00"
@.str.10 = [40 x i8] c"exactly 2 parameters must be specified.\00"
@.str.11 = [47 x i8] c"ERROR Preferred size percentage for partition \00"
@.str.12 = [29 x i8] c"%d should be in range 1-100\0A\00"
@.str.13 = [40 x i8] c"ERROR Minimum size for partition %d %s\0A\00"
@.str.14 = [15 x i8] c"should be >= 0\00"
@.str.15 = [43 x i8] c"ERROR Sum of partition minimum sizes > %s\0A\00"
@.str.16 = [54 x i8] c"Preferred total size percentage allocation for device\00"
@.str.17 = [51 x i8] c"ERROR Sum of partition preferred size percentages \00"
@.str.18 = [48 x i8] c"> device total preferred percentage allocation\0A\00"
@.str.19 = [30 x i8] c"ERROR Remaining %s too small\0A\00"
@.str.20 = [27 x i8] c"size percentage allocation\00"
@.str.21 = [4 x i8] c"OK\0A\00"
@.str.22 = [28 x i8] c"Total Device Size is %d MB\0A\00"
@.str.23 = [40 x i8] c"Total Device Size (in cylinders) is %d\0A\00"
@.str.24 = [55 x i8] c"Total Preferred Size Percentage Allocation for device \00"
@.str.25 = [39 x i8] c"was unspecified, so was set to %d %%\0A\00"
@.str.26 = [24 x i8] c"%s for device is %d %%\0A\00"
@.str.27 = [43 x i8] c"Total Preferred Size Percentage Allocation\00"
@.str.28 = [28 x i8] c"Number of partitions is %d\0A\00"
@.str.29 = [52 x i8] c"Partition %d preferred size percentage unspecified,\00"
@.str.30 = [19 x i8] c" was set to %d %%\0A\00"
@.str.31 = [49 x i8] c"Partition %d preferred size percentage is %d %%\0A\00"
@.str.32 = [23 x i8] c"Partition %d %s %d MB\0A\00"
@.str.33 = [37 x i8] c"minimum size unspecified, was set to\00"
@.str.34 = [36 x i8] c"Partition %d minimum size is %d MB\0A\00"
@.str.35 = [40 x i8] c"Calculating actual space allocation...\0A\00"
@.str.36 = [46 x i8] c"Partition %d minimum size is larger than the \00"
@.str.37 = [25 x i8] c"preferred %% allocation\0A\00"
@.str.38 = [28 x i8] c"Space calculation results:\0A\00"
@.str.39 = [42 x i8] c"Partition %d size is %d MB, %d cylinders\0A\00"
@.str.40 = [17 x i8] c"OUTPUT %d %d %d\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca [5 x i32]
%13 = alloca [5 x i32]
%14 = alloca i32
%15 = alloca [5 x i32]
%16 = alloca [5 x i32]
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca [5 x i32]
%21 = alloca [5 x i32]
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %14
store i32 0, i32* %17
store i32 0, i32* %18
store i32 0, i32* %19
store i32 0, i32* %22
store i32 0, i32* %22
br label %32
32: ; preds = %54, %2
%33 = load i32, i32* %22
%34 = icmp sle i32 %33, 4
br i1 %34, label %35, label %57
35: ; preds = %32
%36 = load i32, i32* %22
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %37
store i32 0, i32* %38
%39 = load i32, i32* %22
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [5 x i32], [5 x i32]* %13, i64 0, i64 %40
store i32 1, i32* %41
%42 = load i32, i32* %22
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %43
store i32 -1, i32* %44
%45 = load i32, i32* %22
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [5 x i32], [5 x i32]* %16, i64 0, i64 %46
store i32 1, i32* %47
%48 = load i32, i32* %22
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %49
store i32 -1, i32* %50
%51 = load i32, i32* %22
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [5 x i32], [5 x i32]* %21, i64 0, i64 %52
store i32 -1, i32* %53
br label %54
54: ; preds = %35
%55 = load i32, i32* %22
%56 = add nsw i32 %55, 1
store i32 %56, i32* %22
br label %32
57: ; preds = %32
%58 = load i32, i32* %4
%59 = icmp slt i32 %58, 5
br i1 %59, label %60, label %65
60: ; preds = %57
%61 = load i8**, i8*** %5
%62 = getelementptr inbounds i8*, i8** %61, i64 0
%63 = load i8*, i8** %62
%64 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0), i8* %63)
store i32 1, i32* %3
br label %588
65: ; preds = %57
%66 = load i8**, i8*** %5
%67 = getelementptr inbounds i8*, i8** %66, i64 1
%68 = load i8*, i8** %67
%69 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %68)
store i32 %69, i32* %6
%70 = load i32, i32* %6
%71 = icmp sle i32 %70, 0
br i1 %71, label %72, label %74
72: ; preds = %65
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0))
store i32 1, i32* %3
br label %588
74: ; preds = %65
%75 = load i8**, i8*** %5
%76 = getelementptr inbounds i8*, i8** %75, i64 2
%77 = load i8*, i8** %76
%78 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %77)
store i32 %78, i32* %7
%79 = load i32, i32* %7
%80 = icmp sle i32 %79, 0
br i1 %80, label %81, label %83
81: ; preds = %74
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0))
store i32 1, i32* %3
br label %588
83: ; preds = %74
%84 = load i8**, i8*** %5
%85 = getelementptr inbounds i8*, i8** %84, i64 3
%86 = load i8*, i8** %85
%87 = call i32 @strcasecmp(i8* %86, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %90
89: ; preds = %83
store i32 100, i32* %9
store i32 1, i32* %8
br label %103
90: ; preds = %83
%91 = load i8**, i8*** %5
%92 = getelementptr inbounds i8*, i8** %91, i64 3
%93 = load i8*, i8** %92
%94 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %93)
store i32 %94, i32* %9
%95 = load i32, i32* %9
%96 = icmp sle i32 %95, 0
br i1 %96, label %100, label %97
97: ; preds = %90
%98 = load i32, i32* %9
%99 = icmp sgt i32 %98, 100
br i1 %99, label %100, label %102
100: ; preds = %97, %90
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.6, i64 0, i64 0))
store i32 1, i32* %3
br label %588
102: ; preds = %97
br label %103
103: ; preds = %102, %89
%104 = load i8**, i8*** %5
%105 = getelementptr inbounds i8*, i8** %104, i64 4
%106 = load i8*, i8** %105
%107 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %106)
store i32 %107, i32* %11
%108 = load i32, i32* %11
%109 = icmp slt i32 %108, 1
br i1 %109, label %113, label %110
110: ; preds = %103
%111 = load i32, i32* %11
%112 = icmp sgt i32 %111, 4
br i1 %112, label %113, label %115
113: ; preds = %110, %103
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0), i32 4)
store i32 1, i32* %3
br label %588
115: ; preds = %110
%116 = load i32, i32* %4
%117 = load i32, i32* %11
%118 = mul nsw i32 2, %117
%119 = add nsw i32 5, %118
%120 = icmp ne i32 %116, %119
br i1 %120, label %121, label %123
121: ; preds = %115
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.10, i64 0, i64 0))
store i32 1, i32* %3
br label %588
123: ; preds = %115
store i32 1, i32* %22
br label %124
124: ; preds = %210, %123
%125 = load i32, i32* %22
%126 = load i32, i32* %11
%127 = icmp sle i32 %125, %126
br i1 %127, label %128, label %213
128: ; preds = %124
%129 = load i8**, i8*** %5
%130 = load i32, i32* %22
%131 = load i32, i32* %22
%132 = add nsw i32 %130, %131
%133 = add nsw i32 %132, 3
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i8*, i8** %129, i64 %134
%136 = load i8*, i8** %135
%137 = call i32 @strcasecmp(i8* %136, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%138 = icmp eq i32 %137, 0
br i1 %138, label %139, label %140
139: ; preds = %128
br label %172
140: ; preds = %128
%141 = load i8**, i8*** %5
%142 = load i32, i32* %22
%143 = load i32, i32* %22
%144 = add nsw i32 %142, %143
%145 = add nsw i32 %144, 3
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i8*, i8** %141, i64 %146
%148 = load i8*, i8** %147
%149 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %148)
%150 = load i32, i32* %22
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %151
store i32 %149, i32* %152
%153 = load i32, i32* %22
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [5 x i32], [5 x i32]* %16, i64 0, i64 %154
store i32 0, i32* %155
%156 = load i32, i32* %22
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %157
%159 = load i32, i32* %158
%160 = icmp sle i32 %159, 0
br i1 %160, label %167, label %161
161: ; preds = %140
%162 = load i32, i32* %22
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %163
%165 = load i32, i32* %164
%166 = icmp sgt i32 %165, 100
br i1 %166, label %167, label %171
167: ; preds = %161, %140
%168 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.11, i64 0, i64 0))
%169 = load i32, i32* %22
%170 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.12, i64 0, i64 0), i32 %169)
store i32 1, i32* %3
br label %588
171: ; preds = %161
br label %172
172: ; preds = %171, %139
%173 = load i8**, i8*** %5
%174 = load i32, i32* %22
%175 = load i32, i32* %22
%176 = add nsw i32 %174, %175
%177 = add nsw i32 %176, 4
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i8*, i8** %173, i64 %178
%180 = load i8*, i8** %179
%181 = call i32 @strcasecmp(i8* %180, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%182 = icmp eq i32 %181, 0
br i1 %182, label %183, label %184
183: ; preds = %172
br label %209
184: ; preds = %172
%185 = load i8**, i8*** %5
%186 = load i32, i32* %22
%187 = load i32, i32* %22
%188 = add nsw i32 %186, %187
%189 = add nsw i32 %188, 4
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8*, i8** %185, i64 %190
%192 = load i8*, i8** %191
%193 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %192)
%194 = load i32, i32* %22
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %195
store i32 %193, i32* %196
%197 = load i32, i32* %22
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [5 x i32], [5 x i32]* %13, i64 0, i64 %198
store i32 0, i32* %199
%200 = load i32, i32* %22
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %201
%203 = load i32, i32* %202
%204 = icmp sle i32 %203, 0
br i1 %204, label %205, label %208
205: ; preds = %184
%206 = load i32, i32* %22
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.13, i64 0, i64 0), i32 %206, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.14, i64 0, i64 0))
store i32 1, i32* %3
br label %588
208: ; preds = %184
br label %209
209: ; preds = %208, %183
br label %210
210: ; preds = %209
%211 = load i32, i32* %22
%212 = add nsw i32 %211, 1
store i32 %212, i32* %22
br label %124
213: ; preds = %124
store i32 1, i32* %22
br label %214
214: ; preds = %225, %213
%215 = load i32, i32* %22
%216 = load i32, i32* %11
%217 = icmp sle i32 %215, %216
br i1 %217, label %218, label %228
218: ; preds = %214
%219 = load i32, i32* %22
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %220
%222 = load i32, i32* %221
%223 = load i32, i32* %14
%224 = add nsw i32 %223, %222
store i32 %224, i32* %14
br label %225
225: ; preds = %218
%226 = load i32, i32* %22
%227 = add nsw i32 %226, 1
store i32 %227, i32* %22
br label %214
228: ; preds = %214
%229 = load i32, i32* %6
%230 = load i32, i32* %9
%231 = mul nsw i32 %229, %230
%232 = sdiv i32 %231, 100
store i32 %232, i32* %10
%233 = load i32, i32* %14
%234 = load i32, i32* %10
%235 = icmp sgt i32 %233, %234
br i1 %235, label %236, label %238
236: ; preds = %228
%237 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.16, i64 0, i64 0))
store i32 1, i32* %3
br label %588
238: ; preds = %228
store i32 1, i32* %22
br label %239
239: ; preds = %260, %238
%240 = load i32, i32* %22
%241 = load i32, i32* %11
%242 = icmp sle i32 %240, %241
br i1 %242, label %243, label %263
243: ; preds = %239
%244 = load i32, i32* %22
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %245
%247 = load i32, i32* %246
%248 = icmp sge i32 %247, 0
br i1 %248, label %249, label %256
249: ; preds = %243
%250 = load i32, i32* %22
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %251
%253 = load i32, i32* %252
%254 = load i32, i32* %17
%255 = add nsw i32 %254, %253
store i32 %255, i32* %17
br label %259
256: ; preds = %243
%257 = load i32, i32* %18
%258 = add nsw i32 %257, 1
store i32 %258, i32* %18
br label %259
259: ; preds = %256, %249
br label %260
260: ; preds = %259
%261 = load i32, i32* %22
%262 = add nsw i32 %261, 1
store i32 %262, i32* %22
br label %239
263: ; preds = %239
%264 = load i32, i32* %17
%265 = load i32, i32* %9
%266 = icmp sgt i32 %264, %265
br i1 %266, label %267, label %270
267: ; preds = %263
%268 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.17, i64 0, i64 0))
%269 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.18, i64 0, i64 0))
store i32 1, i32* %3
br label %588
270: ; preds = %263
%271 = load i32, i32* %18
%272 = icmp sgt i32 %271, 0
br i1 %272, label %273, label %284
273: ; preds = %270
%274 = load i32, i32* %9
%275 = load i32, i32* %17
%276 = sub nsw i32 %274, %275
%277 = load i32, i32* %18
%278 = sdiv i32 %276, %277
store i32 %278, i32* %19
%279 = load i32, i32* %19
%280 = icmp sle i32 %279, 0
br i1 %280, label %281, label %283
281: ; preds = %273
%282 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.20, i64 0, i64 0))
store i32 1, i32* %3
br label %588
283: ; preds = %273
br label %284
284: ; preds = %283, %270
%285 = load i32, i32* %18
%286 = icmp sgt i32 %285, 0
br i1 %286, label %287, label %329
287: ; preds = %284
store i32 0, i32* %23
%288 = load i32, i32* %9
%289 = load i32, i32* %17
%290 = sub nsw i32 %288, %289
store i32 %290, i32* %24
%291 = load i32, i32* %18
store i32 %291, i32* %25
store i32 1, i32* %23
br label %292
292: ; preds = %325, %287
%293 = load i32, i32* %23
%294 = load i32, i32* %11
%295 = icmp sle i32 %293, %294
br i1 %295, label %296, label %328
296: ; preds = %292
%297 = load i32, i32* %23
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %298
%300 = load i32, i32* %299
%301 = icmp slt i32 %300, 0
br i1 %301, label %302, label %324
302: ; preds = %296
%303 = load i32, i32* %25
%304 = add nsw i32 %303, -1
store i32 %304, i32* %25
%305 = load i32, i32* %23
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds [5 x i32], [5 x i32]* %16, i64 0, i64 %306
store i32 1, i32* %307
%308 = load i32, i32* %25
%309 = icmp sgt i32 %308, 0
br i1 %309, label %310, label %318
310: ; preds = %302
%311 = load i32, i32* %19
%312 = load i32, i32* %23
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %313
store i32 %311, i32* %314
%315 = load i32, i32* %19
%316 = load i32, i32* %24
%317 = sub nsw i32 %316, %315
store i32 %317, i32* %24
br label %323
318: ; preds = %302
%319 = load i32, i32* %24
%320 = load i32, i32* %23
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %321
store i32 %319, i32* %322
br label %323
323: ; preds = %318, %310
br label %324
324: ; preds = %323, %296
br label %325
325: ; preds = %324
%326 = load i32, i32* %23
%327 = add nsw i32 %326, 1
store i32 %327, i32* %23
br label %292
328: ; preds = %292
br label %329
329: ; preds = %328, %284
%330 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0))
%331 = load i32, i32* %6
%332 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.22, i64 0, i64 0), i32 %331)
%333 = load i32, i32* %7
%334 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.23, i64 0, i64 0), i32 %333)
%335 = load i32, i32* %8
%336 = icmp ne i32 %335, 0
br i1 %336, label %337, label %341
337: ; preds = %329
%338 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.24, i64 0, i64 0))
%339 = load i32, i32* %9
%340 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.25, i64 0, i64 0), i32 %339)
br label %344
341: ; preds = %329
%342 = load i32, i32* %9
%343 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.26, i64 0, i64 0), i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.27, i64 0, i64 0), i32 %342)
br label %344
344: ; preds = %341, %337
%345 = load i32, i32* %11
%346 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.28, i64 0, i64 0), i32 %345)
store i32 1, i32* %22
br label %347
347: ; preds = %393, %344
%348 = load i32, i32* %22
%349 = load i32, i32* %11
%350 = icmp sle i32 %348, %349
br i1 %350, label %351, label %396
351: ; preds = %347
%352 = load i32, i32* %22
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds [5 x i32], [5 x i32]* %16, i64 0, i64 %353
%355 = load i32, i32* %354
%356 = icmp ne i32 %355, 0
br i1 %356, label %357, label %365
357: ; preds = %351
%358 = load i32, i32* %22
%359 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.29, i64 0, i64 0), i32 %358)
%360 = load i32, i32* %22
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %361
%363 = load i32, i32* %362
%364 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.30, i64 0, i64 0), i32 %363)
br label %372
365: ; preds = %351
%366 = load i32, i32* %22
%367 = load i32, i32* %22
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %368
%370 = load i32, i32* %369
%371 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.31, i64 0, i64 0), i32 %366, i32 %370)
br label %372
372: ; preds = %365, %357
%373 = load i32, i32* %22
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds [5 x i32], [5 x i32]* %13, i64 0, i64 %374
%376 = load i32, i32* %375
%377 = icmp ne i32 %376, 0
br i1 %377, label %378, label %385
378: ; preds = %372
%379 = load i32, i32* %22
%380 = load i32, i32* %22
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %381
%383 = load i32, i32* %382
%384 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.32, i64 0, i64 0), i32 %379, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.33, i64 0, i64 0), i32 %383)
br label %392
385: ; preds = %372
%386 = load i32, i32* %22
%387 = load i32, i32* %22
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %388
%390 = load i32, i32* %389
%391 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.34, i64 0, i64 0), i32 %386, i32 %390)
br label %392
392: ; preds = %385, %378
br label %393
393: ; preds = %392
%394 = load i32, i32* %22
%395 = add nsw i32 %394, 1
store i32 %395, i32* %22
br label %347
396: ; preds = %347
%397 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.35, i64 0, i64 0))
store i32 1, i32* %22
br label %398
398: ; preds = %428, %396
%399 = load i32, i32* %22
%400 = load i32, i32* %11
%401 = icmp sle i32 %399, %400
br i1 %401, label %402, label %431
402: ; preds = %398
%403 = load i32, i32* %22
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %404
%406 = load i32, i32* %405
%407 = load i32, i32* %6
%408 = mul nsw i32 %406, %407
%409 = sdiv i32 %408, 100
store i32 %409, i32* %26
%410 = load i32, i32* %22
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %411
%413 = load i32, i32* %412
%414 = load i32, i32* %26
%415 = icmp sgt i32 %413, %414
br i1 %415, label %416, label %427
416: ; preds = %402
%417 = load i32, i32* %22
%418 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.36, i64 0, i64 0), i32 %417)
%419 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.37, i64 0, i64 0))
%420 = load i32, i32* %22
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %421
%423 = load i32, i32* %422
%424 = load i32, i32* %22
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %425
store i32 %423, i32* %426
br label %427
427: ; preds = %416, %402
br label %428
428: ; preds = %427
%429 = load i32, i32* %22
%430 = add nsw i32 %429, 1
store i32 %430, i32* %22
br label %398
431: ; preds = %398
%432 = load i32, i32* %10
store i32 %432, i32* %27
store i32 0, i32* %28
store i32 0, i32* %29
store i32 0, i32* %30
store i32 1, i32* %22
br label %433
433: ; preds = %460, %431
%434 = load i32, i32* %22
%435 = load i32, i32* %11
%436 = icmp sle i32 %434, %435
br i1 %436, label %437, label %463
437: ; preds = %433
%438 = load i32, i32* %22
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %439
%441 = load i32, i32* %440
%442 = icmp sgt i32 %441, 0
br i1 %442, label %443, label %450
443: ; preds = %437
%444 = load i32, i32* %22
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %445
%447 = load i32, i32* %446
%448 = load i32, i32* %27
%449 = sub nsw i32 %448, %447
store i32 %449, i32* %27
br label %459
450: ; preds = %437
%451 = load i32, i32* %30
%452 = add nsw i32 %451, 1
store i32 %452, i32* %30
%453 = load i32, i32* %22
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %454
%456 = load i32, i32* %455
%457 = load i32, i32* %29
%458 = add nsw i32 %457, %456
store i32 %458, i32* %29
br label %459
459: ; preds = %450, %443
br label %460
460: ; preds = %459
%461 = load i32, i32* %22
%462 = add nsw i32 %461, 1
store i32 %462, i32* %22
br label %433
463: ; preds = %433
%464 = load i32, i32* %27
store i32 %464, i32* %28
store i32 1, i32* %22
br label %465
465: ; preds = %505, %463
%466 = load i32, i32* %22
%467 = load i32, i32* %11
%468 = icmp sle i32 %466, %467
br i1 %468, label %469, label %508
469: ; preds = %465
%470 = load i32, i32* %22
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %471
%473 = load i32, i32* %472
%474 = icmp slt i32 %473, 0
br i1 %474, label %475, label %504
475: ; preds = %469
%476 = load i32, i32* %30
%477 = add nsw i32 %476, -1
store i32 %477, i32* %30
%478 = load i32, i32* %30
%479 = icmp sgt i32 %478, 0
br i1 %479, label %480, label %498
480: ; preds = %475
%481 = load i32, i32* %27
%482 = load i32, i32* %22
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds [5 x i32], [5 x i32]* %15, i64 0, i64 %483
%485 = load i32, i32* %484
%486 = mul nsw i32 %481, %485
%487 = load i32, i32* %29
%488 = sdiv i32 %486, %487
%489 = load i32, i32* %22
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %490
store i32 %488, i32* %491
%492 = load i32, i32* %22
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %493
%495 = load i32, i32* %494
%496 = load i32, i32* %28
%497 = sub nsw i32 %496, %495
store i32 %497, i32* %28
br label %503
498: ; preds = %475
%499 = load i32, i32* %28
%500 = load i32, i32* %22
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %501
store i32 %499, i32* %502
br label %503
503: ; preds = %498, %480
br label %504
504: ; preds = %503, %469
br label %505
505: ; preds = %504
%506 = load i32, i32* %22
%507 = add nsw i32 %506, 1
store i32 %507, i32* %22
br label %465
508: ; preds = %465
%509 = load i32, i32* %7
%510 = load i32, i32* %9
%511 = mul nsw i32 %509, %510
%512 = sdiv i32 %511, 100
store i32 %512, i32* %31
store i32 1, i32* %22
br label %513
513: ; preds = %545, %508
%514 = load i32, i32* %22
%515 = load i32, i32* %11
%516 = icmp sle i32 %514, %515
br i1 %516, label %517, label %548
517: ; preds = %513
%518 = load i32, i32* %22
%519 = load i32, i32* %11
%520 = icmp ne i32 %518, %519
br i1 %520, label %521, label %539
521: ; preds = %517
%522 = load i32, i32* %22
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %523
%525 = load i32, i32* %524
%526 = load i32, i32* %7
%527 = mul nsw i32 %525, %526
%528 = load i32, i32* %6
%529 = sdiv i32 %527, %528
%530 = load i32, i32* %22
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds [5 x i32], [5 x i32]* %21, i64 0, i64 %531
store i32 %529, i32* %532
%533 = load i32, i32* %22
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds [5 x i32], [5 x i32]* %21, i64 0, i64 %534
%536 = load i32, i32* %535
%537 = load i32, i32* %31
%538 = sub nsw i32 %537, %536
store i32 %538, i32* %31
br label %544
539: ; preds = %517
%540 = load i32, i32* %31
%541 = load i32, i32* %22
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds [5 x i32], [5 x i32]* %21, i64 0, i64 %542
store i32 %540, i32* %543
br label %544
544: ; preds = %539, %521
br label %545
545: ; preds = %544
%546 = load i32, i32* %22
%547 = add nsw i32 %546, 1
store i32 %547, i32* %22
br label %513
548: ; preds = %513
%549 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.38, i64 0, i64 0))
store i32 1, i32* %22
br label %550
550: ; preds = %565, %548
%551 = load i32, i32* %22
%552 = load i32, i32* %11
%553 = icmp sle i32 %551, %552
br i1 %553, label %554, label %568
554: ; preds = %550
%555 = load i32, i32* %22
%556 = load i32, i32* %22
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %557
%559 = load i32, i32* %558
%560 = load i32, i32* %22
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds [5 x i32], [5 x i32]* %21, i64 0, i64 %561
%563 = load i32, i32* %562
%564 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.39, i64 0, i64 0), i32 %555, i32 %559, i32 %563)
br label %565
565: ; preds = %554
%566 = load i32, i32* %22
%567 = add nsw i32 %566, 1
store i32 %567, i32* %22
br label %550
568: ; preds = %550
store i32 1, i32* %22
br label %569
569: ; preds = %584, %568
%570 = load i32, i32* %22
%571 = load i32, i32* %11
%572 = icmp sle i32 %570, %571
br i1 %572, label %573, label %587
573: ; preds = %569
%574 = load i32, i32* %22
%575 = load i32, i32* %22
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds [5 x i32], [5 x i32]* %20, i64 0, i64 %576
%578 = load i32, i32* %577
%579 = load i32, i32* %22
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds [5 x i32], [5 x i32]* %21, i64 0, i64 %580
%582 = load i32, i32* %581
%583 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.40, i64 0, i64 0), i32 %574, i32 %578, i32 %582)
br label %584
584: ; preds = %573
%585 = load i32, i32* %22
%586 = add nsw i32 %585, 1
store i32 %586, i32* %22
br label %569
587: ; preds = %569
store i32 0, i32* %3
br label %588
588: ; preds = %587, %281, %267, %236, %205, %167, %121, %113, %100, %81, %72, %60
%589 = load i32, i32* %3
ret i32 %589
}

LLVM IR (-O2):
@.str = [45 x i8] c"ERROR %s: called with less than 4 arguments\0A\00"
@.str.1 = [48 x i8] c"ERROR Parameter 1 (Total device size in MB) %s\0A\00"
@.str.2 = [14 x i8] c"should be > 0\00"
@.str.3 = [55 x i8] c"ERROR Parameter 2 (Total device size in cylinders) %s\0A\00"
@.str.4 = [2 x i8] c"x\00"
@.str.5 = [53 x i8] c"ERROR Parameter 3 (%s) should be in the range 0-100\0A\00"
@.str.6 = [39 x i8] c"Preferred total % allocation of device\00"
@.str.7 = [52 x i8] c"ERROR Parameter 4 (%s) should be in the range 1-%d\0A\00"
@.str.8 = [21 x i8] c"Number of partitions\00"
@.str.9 = [31 x i8] c"ERROR For each partitions, %s\0A\00"
@.str.10 = [40 x i8] c"exactly 2 parameters must be specified.\00"
@.str.11 = [47 x i8] c"ERROR Preferred size percentage for partition \00"
@.str.12 = [29 x i8] c"%d should be in range 1-100\0A\00"
@.str.13 = [40 x i8] c"ERROR Minimum size for partition %d %s\0A\00"
@.str.14 = [15 x i8] c"should be >= 0\00"
@.str.15 = [43 x i8] c"ERROR Sum of partition minimum sizes > %s\0A\00"
@.str.16 = [54 x i8] c"Preferred total size percentage allocation for device\00"
@.str.17 = [51 x i8] c"ERROR Sum of partition preferred size percentages \00"
@.str.19 = [30 x i8] c"ERROR Remaining %s too small\0A\00"
@.str.20 = [27 x i8] c"size percentage allocation\00"
@.str.22 = [28 x i8] c"Total Device Size is %d MB\0A\00"
@.str.23 = [40 x i8] c"Total Device Size (in cylinders) is %d\0A\00"
@.str.24 = [55 x i8] c"Total Preferred Size Percentage Allocation for device \00"
@.str.25 = [39 x i8] c"was unspecified, so was set to %d %%\0A\00"
@.str.26 = [24 x i8] c"%s for device is %d %%\0A\00"
@.str.27 = [43 x i8] c"Total Preferred Size Percentage Allocation\00"
@.str.28 = [28 x i8] c"Number of partitions is %d\0A\00"
@.str.29 = [52 x i8] c"Partition %d preferred size percentage unspecified,\00"
@.str.30 = [19 x i8] c" was set to %d %%\0A\00"
@.str.31 = [49 x i8] c"Partition %d preferred size percentage is %d %%\0A\00"
@.str.32 = [23 x i8] c"Partition %d %s %d MB\0A\00"
@.str.33 = [37 x i8] c"minimum size unspecified, was set to\00"
@.str.34 = [36 x i8] c"Partition %d minimum size is %d MB\0A\00"
@.str.36 = [46 x i8] c"Partition %d minimum size is larger than the \00"
@.str.37 = [25 x i8] c"preferred %% allocation\0A\00"
@.str.39 = [42 x i8] c"Partition %d size is %d MB, %d cylinders\0A\00"
@.str.40 = [17 x i8] c"OUTPUT %d %d %d\0A\00"
@str = [3 x i8] c"OK\00"
@str.41 = [39 x i8] c"Calculating actual space allocation...\00"
@str.42 = [27 x i8] c"Space calculation results:\00"
@str.43 = [47 x i8] c"> device total preferred percentage allocation\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [5 x i32]
%4 = bitcast [5 x i32]* %3 to i8*
%5 = alloca [5 x i32]
%6 = alloca [5 x i32]
%7 = bitcast [5 x i32]* %6 to i8*
%8 = alloca [5 x i32]
%9 = alloca [5 x i32]
%10 = bitcast [5 x i32]* %9 to i8*
%11 = alloca [5 x i32]
%12 = bitcast [5 x i32]* %11 to i8*
%13 = bitcast [5 x i32]* %5 to i8*
%14 = bitcast [5 x i32]* %8 to i8*
%15 = bitcast [5 x i32]* %5 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %15
%16 = bitcast [5 x i32]* %8 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %16
%17 = getelementptr inbounds [5 x i32], [5 x i32]* %5, i64 0, i64 4
store i32 1, i32* %17
%18 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 4
store i32 1, i32* %18
%19 = icmp slt i32 %0, 5
br i1 %19, label %20, label %23
20: ; preds = %2
%21 = load i8*, i8** %1
%22 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0), i8* %21)
br label %447
23: ; preds = %2
%24 = getelementptr inbounds i8*, i8** %1, i64 1
%25 = load i8*, i8** %24
%26 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %25)
%27 = icmp slt i32 %26, 1
br i1 %27, label %28, label %30
28: ; preds = %23
%29 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0))
br label %447
30: ; preds = %23
%31 = getelementptr inbounds i8*, i8** %1, i64 2
%32 = load i8*, i8** %31
%33 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %32)
%34 = icmp slt i32 %33, 1
br i1 %34, label %35, label %37
35: ; preds = %30
%36 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0))
br label %447
37: ; preds = %30
%38 = getelementptr inbounds i8*, i8** %1, i64 3
%39 = load i8*, i8** %38
%40 = tail call i32 @strcasecmp(i8* %39, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%41 = icmp eq i32 %40, 0
br i1 %41, label %48, label %42
42: ; preds = %37
%43 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %39)
%44 = add i32 %43, -101
%45 = icmp ult i32 %44, -100
br i1 %45, label %46, label %48
46: ; preds = %42
%47 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.6, i64 0, i64 0))
br label %447
48: ; preds = %37, %42
%49 = phi i32 [ %43, %42 ], [ 100, %37 ]
%50 = getelementptr inbounds i8*, i8** %1, i64 4
%51 = load i8*, i8** %50
%52 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %51)
%53 = add i32 %52, -5
%54 = icmp ult i32 %53, -4
br i1 %54, label %55, label %57
55: ; preds = %48
%56 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0), i32 4)
br label %447
57: ; preds = %48
%58 = shl nuw nsw i32 %52, 1
%59 = add nuw nsw i32 %58, 5
%60 = icmp eq i32 %59, %0
br i1 %60, label %61, label %64
61: ; preds = %57
%62 = add nuw nsw i32 %52, 1
%63 = zext i32 %62 to i64
br label %71
64: ; preds = %57
%65 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.10, i64 0, i64 0))
br label %447
66: ; preds = %104
%67 = add i32 %52, 1
%68 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 1
%69 = load i32, i32* %68
%70 = icmp eq i32 %67, 2
br i1 %70, label %121, label %107
71: ; preds = %61, %104
%72 = phi i64 [ 1, %61 ], [ %105, %104 ]
%73 = shl nuw nsw i64 %72, 1
%74 = add nuw nsw i64 %73, 3
%75 = getelementptr inbounds i8*, i8** %1, i64 %74
%76 = load i8*, i8** %75
%77 = tail call i32 @strcasecmp(i8* %76, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%78 = icmp eq i32 %77, 0
br i1 %78, label %89, label %79
79: ; preds = %71
%80 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %76)
%81 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %72
store i32 %80, i32* %81
%82 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %72
store i32 0, i32* %82
%83 = add i32 %80, -101
%84 = icmp ult i32 %83, -100
br i1 %84, label %85, label %89
85: ; preds = %79
%86 = trunc i64 %72 to i32
%87 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.11, i64 0, i64 0))
%88 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.12, i64 0, i64 0), i32 %86)
br label %447
89: ; preds = %79, %71
%90 = add nuw i64 %73, 4
%91 = and i64 %90, 4294967294
%92 = getelementptr inbounds i8*, i8** %1, i64 %91
%93 = load i8*, i8** %92
%94 = tail call i32 @strcasecmp(i8* %93, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%95 = icmp eq i32 %94, 0
br i1 %95, label %104, label %96
96: ; preds = %89
%97 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %93)
%98 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %72
store i32 %97, i32* %98
%99 = getelementptr inbounds [5 x i32], [5 x i32]* %5, i64 0, i64 %72
store i32 0, i32* %99
%100 = icmp slt i32 %97, 1
br i1 %100, label %101, label %104
101: ; preds = %96
%102 = trunc i64 %72 to i32
%103 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.13, i64 0, i64 0), i32 %102, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.14, i64 0, i64 0))
br label %447
104: ; preds = %89, %96
%105 = add nuw nsw i64 %72, 1
%106 = icmp eq i64 %105, %63
br i1 %106, label %66, label %71
107: ; preds = %66
%108 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 2
%109 = load i32, i32* %108
%110 = add nsw i32 %109, %69
%111 = icmp eq i32 %67, 3
br i1 %111, label %121, label %112
112: ; preds = %107
%113 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 3
%114 = load i32, i32* %113
%115 = add nsw i32 %114, %110
%116 = icmp eq i32 %67, 4
br i1 %116, label %121, label %117
117: ; preds = %112
%118 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 4
%119 = load i32, i32* %118
%120 = add nsw i32 %119, %115
br label %121
121: ; preds = %117, %112, %107, %66
%122 = phi i32 [ %69, %66 ], [ %110, %107 ], [ %115, %112 ], [ %120, %117 ]
%123 = mul nsw i32 %49, %26
%124 = sdiv i32 %123, 100
%125 = icmp sgt i32 %122, %124
br i1 %125, label %133, label %126
126: ; preds = %121
%127 = add nsw i64 %63, -1
%128 = add nsw i64 %63, -2
%129 = and i64 %127, 1
%130 = icmp eq i64 %128, 0
br i1 %130, label %160, label %131
131: ; preds = %126
%132 = and i64 %127, -2
br label %135
133: ; preds = %121
%134 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.16, i64 0, i64 0))
br label %447
135: ; preds = %135, %131
%136 = phi i64 [ 1, %131 ], [ %157, %135 ]
%137 = phi i32 [ 0, %131 ], [ %156, %135 ]
%138 = phi i32 [ 0, %131 ], [ %153, %135 ]
%139 = phi i64 [ 0, %131 ], [ %158, %135 ]
%140 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %136
%141 = load i32, i32* %140
%142 = icmp sgt i32 %141, -1
%143 = select i1 %142, i32 %141, i32 0
%144 = add nsw i32 %143, %138
%145 = xor i1 %142, true
%146 = zext i1 %145 to i32
%147 = add nuw nsw i32 %137, %146
%148 = add nuw nsw i64 %136, 1
%149 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %148
%150 = load i32, i32* %149
%151 = icmp sgt i32 %150, -1
%152 = select i1 %151, i32 %150, i32 0
%153 = add nsw i32 %152, %144
%154 = xor i1 %151, true
%155 = zext i1 %154 to i32
%156 = add nuw nsw i32 %147, %155
%157 = add nuw nsw i64 %136, 2
%158 = add i64 %139, 2
%159 = icmp eq i64 %158, %132
br i1 %159, label %160, label %135
160: ; preds = %135, %126
%161 = phi i32 [ undef, %126 ], [ %153, %135 ]
%162 = phi i32 [ undef, %126 ], [ %156, %135 ]
%163 = phi i64 [ 1, %126 ], [ %157, %135 ]
%164 = phi i32 [ 0, %126 ], [ %156, %135 ]
%165 = phi i32 [ 0, %126 ], [ %153, %135 ]
%166 = icmp eq i64 %129, 0
br i1 %166, label %176, label %167
167: ; preds = %160
%168 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %163
%169 = load i32, i32* %168
%170 = icmp sgt i32 %169, -1
%171 = select i1 %170, i32 %169, i32 0
%172 = add nsw i32 %171, %165
%173 = xor i1 %170, true
%174 = zext i1 %173 to i32
%175 = add nuw nsw i32 %164, %174
br label %176
176: ; preds = %160, %167
%177 = phi i32 [ %161, %160 ], [ %172, %167 ]
%178 = phi i32 [ %162, %160 ], [ %175, %167 ]
%179 = icmp slt i32 %49, %177
br i1 %179, label %180, label %183
180: ; preds = %176
%181 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.17, i64 0, i64 0))
%182 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.43, i64 0, i64 0))
br label %447
183: ; preds = %176
%184 = icmp eq i32 %178, 0
br i1 %184, label %213, label %185
185: ; preds = %183
%186 = sub nsw i32 %49, %177
%187 = sdiv i32 %186, %178
%188 = icmp slt i32 %187, 1
br i1 %188, label %189, label %191
189: ; preds = %185
%190 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.20, i64 0, i64 0))
br label %447
191: ; preds = %185
%192 = add i32 %52, 1
%193 = zext i32 %192 to i64
br label %194
194: ; preds = %191, %208
%195 = phi i64 [ 1, %191 ], [ %211, %208 ]
%196 = phi i32 [ %178, %191 ], [ %210, %208 ]
%197 = phi i32 [ %186, %191 ], [ %209, %208 ]
%198 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %195
%199 = load i32, i32* %198
%200 = icmp slt i32 %199, 0
br i1 %200, label %201, label %208
201: ; preds = %194
%202 = add nsw i32 %196, -1
%203 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %195
store i32 1, i32* %203
%204 = icmp sgt i32 %196, 1
br i1 %204, label %205, label %207
205: ; preds = %201
store i32 %187, i32* %198
%206 = sub nsw i32 %197, %187
br label %208
207: ; preds = %201
store i32 %197, i32* %198
br label %208
208: ; preds = %194, %207, %205
%209 = phi i32 [ %206, %205 ], [ %197, %207 ], [ %197, %194 ]
%210 = phi i32 [ %202, %205 ], [ %202, %207 ], [ %196, %194 ]
%211 = add nuw nsw i64 %195, 1
%212 = icmp eq i64 %211, %193
br i1 %212, label %213, label %194
213: ; preds = %208, %183
%214 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str, i64 0, i64 0))
%215 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.22, i64 0, i64 0), i32 %26)
%216 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.23, i64 0, i64 0), i32 %33)
br i1 %41, label %217, label %220
217: ; preds = %213
%218 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([55 x i8], [55 x i8]* @.str.24, i64 0, i64 0))
%219 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.25, i64 0, i64 0), i32 %49)
br label %222
220: ; preds = %213
%221 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.26, i64 0, i64 0), i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.27, i64 0, i64 0), i32 %49)
br label %222
222: ; preds = %217, %220
%223 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.28, i64 0, i64 0), i32 %52)
%224 = add i32 %52, 1
%225 = zext i32 %224 to i64
br label %226
226: ; preds = %222, %253
%227 = phi i64 [ 1, %222 ], [ %254, %253 ]
%228 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %227
%229 = load i32, i32* %228
%230 = icmp eq i32 %229, 0
br i1 %230, label %237, label %231
231: ; preds = %226
%232 = trunc i64 %227 to i32
%233 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.29, i64 0, i64 0), i32 %232)
%234 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %227
%235 = load i32, i32* %234
%236 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.30, i64 0, i64 0), i32 %235)
br label %242
237: ; preds = %226
%238 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %227
%239 = load i32, i32* %238
%240 = trunc i64 %227 to i32
%241 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.31, i64 0, i64 0), i32 %240, i32 %239)
br label %242
242: ; preds = %237, %231
%243 = getelementptr inbounds [5 x i32], [5 x i32]* %5, i64 0, i64 %227
%244 = load i32, i32* %243
%245 = icmp eq i32 %244, 0
%246 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %227
%247 = load i32, i32* %246
%248 = trunc i64 %227 to i32
br i1 %245, label %251, label %249
249: ; preds = %242
%250 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.32, i64 0, i64 0), i32 %248, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.33, i64 0, i64 0), i32 %247)
br label %253
251: ; preds = %242
%252 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.34, i64 0, i64 0), i32 %248, i32 %247)
br label %253
253: ; preds = %249, %251
%254 = add nuw nsw i64 %227, 1
%255 = icmp eq i64 %254, %225
br i1 %255, label %256, label %226
256: ; preds = %253
%257 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.41, i64 0, i64 0))
%258 = add i32 %52, 1
%259 = zext i32 %258 to i64
br label %265
260: ; preds = %279
%261 = and i64 %127, 1
%262 = icmp eq i64 %128, 0
br i1 %262, label %282, label %263
263: ; preds = %260
%264 = and i64 %127, -2
br label %308
265: ; preds = %256, %279
%266 = phi i64 [ 1, %256 ], [ %280, %279 ]
%267 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %266
%268 = load i32, i32* %267
%269 = mul nsw i32 %268, %26
%270 = sdiv i32 %269, 100
%271 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %266
%272 = load i32, i32* %271
%273 = icmp sgt i32 %272, %270
br i1 %273, label %274, label %279
274: ; preds = %265
%275 = trunc i64 %266 to i32
%276 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.36, i64 0, i64 0), i32 %275)
%277 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.37, i64 0, i64 0))
%278 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %266
store i32 %272, i32* %278
br label %279
279: ; preds = %274, %265
%280 = add nuw nsw i64 %266, 1
%281 = icmp eq i64 %280, %259
br i1 %281, label %260, label %265
282: ; preds = %339, %260
%283 = phi i32 [ undef, %260 ], [ %340, %339 ]
%284 = phi i32 [ undef, %260 ], [ %341, %339 ]
%285 = phi i32 [ undef, %260 ], [ %342, %339 ]
%286 = phi i64 [ 1, %260 ], [ %343, %339 ]
%287 = phi i32 [ 0, %260 ], [ %342, %339 ]
%288 = phi i32 [ 0, %260 ], [ %341, %339 ]
%289 = phi i32 [ %124, %260 ], [ %340, %339 ]
%290 = icmp eq i64 %261, 0
br i1 %290, label %302, label %291
291: ; preds = %282
%292 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %286
%293 = load i32, i32* %292
%294 = icmp sgt i32 %293, 0
br i1 %294, label %300, label %295
295: ; preds = %291
%296 = add nsw i32 %287, 1
%297 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %286
%298 = load i32, i32* %297
%299 = add nsw i32 %298, %288
br label %302
300: ; preds = %291
%301 = sub nsw i32 %289, %293
br label %302
302: ; preds = %295, %300, %282
%303 = phi i32 [ %283, %282 ], [ %301, %300 ], [ %289, %295 ]
%304 = phi i32 [ %284, %282 ], [ %288, %300 ], [ %299, %295 ]
%305 = phi i32 [ %285, %282 ], [ %287, %300 ], [ %296, %295 ]
%306 = add i32 %52, 1
%307 = zext i32 %306 to i64
br label %346
308: ; preds = %339, %263
%309 = phi i64 [ 1, %263 ], [ %343, %339 ]
%310 = phi i32 [ 0, %263 ], [ %342, %339 ]
%311 = phi i32 [ 0, %263 ], [ %341, %339 ]
%312 = phi i32 [ %124, %263 ], [ %340, %339 ]
%313 = phi i64 [ 0, %263 ], [ %344, %339 ]
%314 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %309
%315 = load i32, i32* %314
%316 = icmp sgt i32 %315, 0
br i1 %316, label %317, label %319
317: ; preds = %308
%318 = sub nsw i32 %312, %315
br label %324
319: ; preds = %308
%320 = add nsw i32 %310, 1
%321 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %309
%322 = load i32, i32* %321
%323 = add nsw i32 %322, %311
br label %324
324: ; preds = %317, %319
%325 = phi i32 [ %318, %317 ], [ %312, %319 ]
%326 = phi i32 [ %311, %317 ], [ %323, %319 ]
%327 = phi i32 [ %310, %317 ], [ %320, %319 ]
%328 = add nuw nsw i64 %309, 1
%329 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %328
%330 = load i32, i32* %329
%331 = icmp sgt i32 %330, 0
br i1 %331, label %337, label %332
332: ; preds = %324
%333 = add nsw i32 %327, 1
%334 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %328
%335 = load i32, i32* %334
%336 = add nsw i32 %335, %326
br label %339
337: ; preds = %324
%338 = sub nsw i32 %325, %330
br label %339
339: ; preds = %337, %332
%340 = phi i32 [ %338, %337 ], [ %325, %332 ]
%341 = phi i32 [ %326, %337 ], [ %336, %332 ]
%342 = phi i32 [ %327, %337 ], [ %333, %332 ]
%343 = add nuw nsw i64 %309, 2
%344 = add i64 %313, 2
%345 = icmp eq i64 %344, %264
br i1 %345, label %282, label %308
346: ; preds = %302, %363
%347 = phi i64 [ 1, %302 ], [ %366, %363 ]
%348 = phi i32 [ %305, %302 ], [ %365, %363 ]
%349 = phi i32 [ %303, %302 ], [ %364, %363 ]
%350 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %347
%351 = load i32, i32* %350
%352 = icmp slt i32 %351, 0
br i1 %352, label %353, label %363
353: ; preds = %346
%354 = add nsw i32 %348, -1
%355 = icmp sgt i32 %348, 1
br i1 %355, label %356, label %362
356: ; preds = %353
%357 = getelementptr inbounds [5 x i32], [5 x i32]* %6, i64 0, i64 %347
%358 = load i32, i32* %357
%359 = mul nsw i32 %358, %303
%360 = sdiv i32 %359, %304
store i32 %360, i32* %350
%361 = sub nsw i32 %349, %360
br label %363
362: ; preds = %353
store i32 %349, i32* %350
br label %363
363: ; preds = %346, %362, %356
%364 = phi i32 [ %361, %356 ], [ %349, %362 ], [ %349, %346 ]
%365 = phi i32 [ %354, %356 ], [ %354, %362 ], [ %348, %346 ]
%366 = add nuw nsw i64 %347, 1
%367 = icmp eq i64 %366, %307
br i1 %367, label %368, label %346
368: ; preds = %363
%369 = mul nsw i32 %49, %33
%370 = sdiv i32 %369, 100
%371 = zext i32 %52 to i64
%372 = and i64 %127, 1
%373 = icmp eq i64 %128, 0
br i1 %373, label %406, label %374
374: ; preds = %368
%375 = and i64 %127, -2
br label %376
376: ; preds = %399, %374
%377 = phi i64 [ 1, %374 ], [ %403, %399 ]
%378 = phi i32 [ %370, %374 ], [ %401, %399 ]
%379 = phi i64 [ 0, %374 ], [ %404, %399 ]
%380 = icmp eq i64 %377, %371
br i1 %380, label %387, label %381
381: ; preds = %376
%382 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %377
%383 = load i32, i32* %382
%384 = mul nsw i32 %383, %33
%385 = sdiv i32 %384, %26
%386 = sub nsw i32 %378, %385
br label %387
387: ; preds = %376, %381
%388 = phi i32 [ %385, %381 ], [ %378, %376 ]
%389 = phi i32 [ %386, %381 ], [ %378, %376 ]
%390 = getelementptr inbounds [5 x i32], [5 x i32]* %11, i64 0, i64 %377
store i32 %388, i32* %390
%391 = add nuw nsw i64 %377, 1
%392 = icmp eq i64 %391, %371
br i1 %392, label %399, label %393
393: ; preds = %387
%394 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %391
%395 = load i32, i32* %394
%396 = mul nsw i32 %395, %33
%397 = sdiv i32 %396, %26
%398 = sub nsw i32 %389, %397
br label %399
399: ; preds = %393, %387
%400 = phi i32 [ %397, %393 ], [ %389, %387 ]
%401 = phi i32 [ %398, %393 ], [ %389, %387 ]
%402 = getelementptr inbounds [5 x i32], [5 x i32]* %11, i64 0, i64 %391
store i32 %400, i32* %402
%403 = add nuw nsw i64 %377, 2
%404 = add i64 %379, 2
%405 = icmp eq i64 %404, %375
br i1 %405, label %406, label %376
406: ; preds = %399, %368
%407 = phi i64 [ 1, %368 ], [ %403, %399 ]
%408 = phi i32 [ %370, %368 ], [ %401, %399 ]
%409 = icmp eq i64 %372, 0
br i1 %409, label %420, label %410
410: ; preds = %406
%411 = icmp eq i64 %407, %371
br i1 %411, label %417, label %412
412: ; preds = %410
%413 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %407
%414 = load i32, i32* %413
%415 = mul nsw i32 %414, %33
%416 = sdiv i32 %415, %26
br label %417
417: ; preds = %412, %410
%418 = phi i32 [ %416, %412 ], [ %408, %410 ]
%419 = getelementptr inbounds [5 x i32], [5 x i32]* %11, i64 0, i64 %407
store i32 %418, i32* %419
br label %420
420: ; preds = %406, %417
%421 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.42, i64 0, i64 0))
%422 = add i32 %52, 1
%423 = zext i32 %422 to i64
br label %427
424: ; preds = %427
%425 = add i32 %52, 1
%426 = zext i32 %425 to i64
br label %437
427: ; preds = %420, %427
%428 = phi i64 [ 1, %420 ], [ %435, %427 ]
%429 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %428
%430 = load i32, i32* %429
%431 = getelementptr inbounds [5 x i32], [5 x i32]* %11, i64 0, i64 %428
%432 = load i32, i32* %431
%433 = trunc i64 %428 to i32
%434 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.39, i64 0, i64 0), i32 %433, i32 %430, i32 %432)
%435 = add nuw nsw i64 %428, 1
%436 = icmp eq i64 %435, %423
br i1 %436, label %424, label %427
437: ; preds = %424, %437
%438 = phi i64 [ 1, %424 ], [ %445, %437 ]
%439 = getelementptr inbounds [5 x i32], [5 x i32]* %9, i64 0, i64 %438
%440 = load i32, i32* %439
%441 = getelementptr inbounds [5 x i32], [5 x i32]* %11, i64 0, i64 %438
%442 = load i32, i32* %441
%443 = trunc i64 %438 to i32
%444 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.40, i64 0, i64 0), i32 %443, i32 %440, i32 %442)
%445 = add nuw nsw i64 %438, 1
%446 = icmp eq i64 %445, %426
br i1 %446, label %447, label %437
447: ; preds = %437, %189, %180, %133, %101, %85, %64, %55, %46, %35, %28, %20
%448 = phi i32 [ 1, %20 ], [ 1, %28 ], [ 1, %35 ], [ 1, %55 ], [ 1, %64 ], [ 1, %101 ], [ 1, %85 ], [ 1, %133 ], [ 1, %180 ], [ 1, %189 ], [ 1, %46 ], [ 0, %437 ]
ret i32 %448
}