#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int int8_t;
typedef int int64_t;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ SEEK_CUR;
int /*<<< orphan*/ _mm_free(int *);
scalar_t__ _mm_malloc(int, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, int);
int /*<<< orphan*/ fread(int *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, int, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, int, int, int);
int /*<<< orphan*/ rewind(int /*<<< orphan*/ *);
void convert_result(FILE *fp_input, FILE *fp_info, FILE *fp_output) {
  int i, j, k, m, temp, temp2;
  int block_num = 0;
  int64_t ref_count = 0;
  int total_device_number = 0;
  int ref_bucket_num;
  int ref_start, ref_end;
  int distance;
  int last_ref_bucket_count;
  int64_t max_block_size = 0;
  int8_t *buffer;
  fread(&block_num, sizeof(int), 1, fp_info);
  fread(&total_device_number, sizeof(int), 1, fp_info);
  fread(&ref_count, sizeof(int64_t), 1, fp_info);
  int64_t device_read_counts[block_num][total_device_number];
  int extra_counts[block_num];
  for (i = 0; i < block_num; i++) {
    fread(device_read_counts[i], sizeof(int64_t), total_device_number, fp_info);
    fread(&extra_counts[i], sizeof(int), 1, fp_info);
  }
  for (i = 0; i < block_num; i++) {
    for (j = 0; j < total_device_number; j++) {
      if (max_block_size < device_read_counts[i][j]) {
        max_block_size = device_read_counts[i][j];
      }
    }
  }
  buffer = (int8_t *)_mm_malloc(sizeof(int8_t) * max_block_size, 64);
  for (i = 0; i < block_num; i++) {
    for (j = 0; j < total_device_number; j++) {
      printf("subject_count[%d][%d] is %d\n", i, j, device_read_counts[i][j]);
    }
  }
  last_ref_bucket_count = ref_count % 100;
  ref_bucket_num = ref_count / 100;
  if (last_ref_bucket_count == 0) {
    last_ref_bucket_count = 100;
  } else {
    ref_bucket_num++;
  }
  for (m = 0; m < ref_bucket_num; m++) {
    if (m == ref_bucket_num - 1) {
      ref_start = m * 100;
      ref_end = ref_count;
    } else {
      ref_start = m * 100;
      ref_end = (m + 1) * 100;
    }
    for (i = ref_start; i < ref_end; i++) {
      rewind(fp_input);
      for (j = 0; j < block_num; j++) {
        for (temp = 0; temp < m; temp++) {
          distance = 0;
          for (temp2 = 0; temp2 < total_device_number; temp2++) {
            distance += 100 * device_read_counts[j][temp2] * sizeof(int8_t);
          }
          fseek(fp_input, distance, SEEK_CUR);
        }
        for (temp2 = 0; temp2 < total_device_number; temp2++) {
          int extra_tmp = 0;
          fseek(fp_input,
                (i - ref_start) * device_read_counts[j][temp2] * sizeof(int8_t),
                SEEK_CUR);
          fread(buffer, sizeof(int8_t), device_read_counts[j][temp2], fp_input);
          if (temp2 == total_device_number - 1) {
            extra_tmp = extra_counts[j];
          }
          for (k = 0; k < device_read_counts[j][temp2] - extra_tmp; k++) {
            fprintf(fp_output, "%d\n", buffer[k]);
          }
          distance =
              (ref_end - 1 - i) * device_read_counts[j][temp2] * sizeof(int8_t);
          fseek(fp_input, distance, SEEK_CUR);
        }
        for (temp = m + 1; temp < ref_bucket_num; temp++) {
          distance = 0;
          for (temp2 = 0; temp2 < total_device_number; temp2++) {
            if (temp == ref_bucket_num - 1) {
              distance += last_ref_bucket_count * device_read_counts[j][temp2] *
                          sizeof(int8_t);
            } else {
              distance += 100 * device_read_counts[j][temp2] * sizeof(int8_t);
            }
          }
          fseek(fp_input, distance, SEEK_CUR);
        }
      }
    }
  }
  _mm_free(buffer);
}


x86 assembly (clang, -O0):
<convert_result>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x10(%rbp),%rcx
lea    -0x34(%rbp),%rdi
mov    $0x4,%esi
mov    %esi,-0xa8(%rbp)
mov    $0x1,%edx
mov    %edx,-0xa4(%rbp)
call   1030 <fread@plt>
mov    -0xa8(%rbp),%esi
mov    -0xa4(%rbp),%edx
mov    -0x10(%rbp),%rcx
lea    -0x3c(%rbp),%rdi
call   1030 <fread@plt>
mov    -0xa8(%rbp),%esi
mov    -0xa4(%rbp),%edx
mov    -0x10(%rbp),%rcx
lea    -0x38(%rbp),%rdi
call   1030 <fread@plt>
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
mov    %rax,-0xa0(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x68(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x98(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x70(%rbp)
mov    %rax,-0x78(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x90(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    12d0 <convert_result+0x160>
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rcx
movslq -0x1c(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x3c(%rbp),%edx
mov    -0x10(%rbp),%rcx
mov    $0x4,%esi
call   1030 <fread@plt>
mov    -0x90(%rbp),%rdi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rcx
mov    $0x4,%esi
mov    $0x1,%edx
call   1030 <fread@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1263 <convert_result+0xf3>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1370 <convert_result+0x200>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    135d <convert_result+0x1ed>
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
mov    -0x54(%rbp),%eax
movslq -0x1c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    134a <convert_result+0x1da>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
jmp    134f <convert_result+0x1df>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12ea <convert_result+0x17a>
jmp    1362 <convert_result+0x1f2>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12d7 <convert_result+0x167>
movslq -0x54(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
mov    $0x40,%esi
call   1080 <_mm_malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1405 <convert_result+0x295>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13f2 <convert_result+0x282>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
movslq -0x1c(%rbp),%rcx
imul   %rdi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
lea    0xc21(%rip),%rdi
call   1040 <printf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13a2 <convert_result+0x232>
jmp    13f7 <convert_result+0x287>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    138f <convert_result+0x21f>
mov    -0x38(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %edx,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x50(%rbp)
jne    1437 <convert_result+0x2c7>
movl   $0x64,-0x50(%rbp)
jmp    1440 <convert_result+0x2d0>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    17ea <convert_result+0x67a>
mov    -0x28(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1476 <convert_result+0x306>
imul   $0x64,-0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1489 <convert_result+0x319>
imul   $0x64,-0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
imul   $0x64,%eax,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    17d7 <convert_result+0x667>
mov    -0x8(%rbp),%rdi
call   1050 <rewind@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    17c4 <convert_result+0x654>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    154b <convert_result+0x3db>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1528 <convert_result+0x3b8>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x64,(%rax,%rcx,4),%eax
movslq %eax,%rcx
shl    $0x2,%rcx
movslq -0x4c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14d8 <convert_result+0x368>
mov    -0x8(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    0x2ab2(%rip),%rax
mov    (%rax),%edx
call   1070 <fseek@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14be <convert_result+0x34e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    16c7 <convert_result+0x557>
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
movl   $0x0,-0x84(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%eax
sub    -0x44(%rbp),%eax
movslq -0x20(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x30(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cltq
shl    $0x2,%rax
mov    %eax,%esi
mov    0x2a42(%rip),%rax
mov    (%rax),%edx
call   1070 <fseek@plt>
mov    -0xa0(%rbp),%rdx
mov    -0x98(%rbp),%rax
mov    -0x60(%rbp),%rdi
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rcx
mov    $0x4,%esi
call   1030 <fread@plt>
mov    -0x30(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1608 <convert_result+0x498>
mov    -0x90(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
mov    -0x24(%rbp),%eax
movslq -0x20(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x84(%rbp),%ecx
cmp    %ecx,%eax
jge    166d <convert_result+0x4fd>
mov    -0x18(%rbp),%rdi
mov    -0x60(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0x9bf(%rip),%rsi
call   1060 <fprintf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    160f <convert_result+0x49f>
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
sub    -0x1c(%rbp),%eax
movslq -0x20(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x30(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
cltq
shl    $0x2,%rax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    0x2936(%rip),%rax
mov    (%rax),%edx
call   1070 <fseek@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1552 <convert_result+0x3e2>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    17b1 <convert_result+0x641>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    178e <convert_result+0x61e>
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1745 <convert_result+0x5d5>
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%rsi
mov    -0x50(%rbp),%eax
movslq -0x20(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x30(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
movslq %eax,%rcx
shl    $0x2,%rcx
movslq -0x4c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x4c(%rbp)
jmp    177b <convert_result+0x60b>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0x64,(%rax,%rcx,4),%eax
movslq %eax,%rcx
shl    $0x2,%rcx
movslq -0x4c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x4c(%rbp)
jmp    1780 <convert_result+0x610>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16ea <convert_result+0x57a>
mov    -0x8(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    0x284c(%rip),%rax
mov    (%rax),%edx
call   1070 <fseek@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16d0 <convert_result+0x560>
jmp    17b6 <convert_result+0x646>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14ab <convert_result+0x33b>
jmp    17c9 <convert_result+0x659>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    148f <convert_result+0x31f>
jmp    17dc <convert_result+0x66c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1447 <convert_result+0x2d7>
mov    -0x60(%rbp),%rdi
call   1090 <_mm_free@plt>
mov    -0x68(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convert_result>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rdx,-0x118(%rbp)
mov    %rsi,%rbx
mov    %rdi,%r13
movabs $0x3ffffffffffffffe,%r15
ff ff 3f
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x68(%rbp)
lea    -0x70(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1030 <fread@plt>
lea    -0x68(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1030 <fread@plt>
lea    -0x6c(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,-0x60(%rbp)
mov    %rbx,%rcx
call   1030 <fread@plt>
mov    %rsp,-0xd8(%rbp)
mov    -0x70(%rbp),%r12d
mov    -0x68(%rbp),%eax
mov    %rax,-0x30(%rbp)
imul   %r12,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
lea    0xf(,%r12,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0xb0(%rbp)
mov    %rcx,%rsp
test   %r12d,%r12d
mov    %r12,-0x88(%rbp)
mov    %r13,-0xd0(%rbp)
jle    1498 <convert_result+0x328>
mov    -0x30(%rbp),%rax
lea    0x0(,%rax,4),%rbx
mov    %r12,%r15
mov    %rbx,%r12
mov    -0x38(%rbp),%r14
mov    -0xb0(%rbp),%r13
mov    -0x60(%rbp),%rbx
nopl   0x0(%rax)
mov    %r14,%rdi
mov    $0x4,%esi
mov    -0x30(%rbp),%rdx
mov    %rbx,%rcx
call   1030 <fread@plt>
mov    %r13,%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1030 <fread@plt>
add    $0x4,%r13
add    %r12,%r14
add    $0xffffffffffffffff,%r15
jne    1280 <convert_result+0x110>
mov    %r12,-0x80(%rbp)
mov    -0x88(%rbp),%r12
test   %r12d,%r12d
mov    -0xd0(%rbp),%r13
movabs $0x3ffffffffffffffe,%r15
ff ff 3f
jle    1498 <convert_result+0x328>
mov    -0x30(%rbp),%rbx
mov    %ebx,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10,%r8
and    %r15,%r8
mov    -0x38(%rbp),%rdx
lea    0x30(%rdx),%rsi
xor    %r14d,%r14d
xor    %edi,%edi
jmp    1327 <convert_result+0x1b7>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    -0x80(%rbp),%rax
add    %rax,%rsi
add    %rax,%rdx
cmp    %r12,%r14
je     1c19 <convert_result+0xaa9>
test   %ebx,%ebx
jle    1310 <convert_result+0x1a0>
cmp    $0x8,%ebx
jae    1340 <convert_result+0x1d0>
xor    %eax,%eax
jmp    1470 <convert_result+0x300>
nopw   0x0(%rax,%rax,1)
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
test   %r9,%r9
je     1486 <convert_result+0x316>
mov    %r8,%rax
xor    %edi,%edi
movdqa %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rdi,4),%xmm2
movdqu -0x20(%rsi,%rdi,4),%xmm3
movdqu -0x10(%rsi,%rdi,4),%xmm4
movdqu (%rsi,%rdi,4),%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm2,%xmm6
pand   %xmm6,%xmm0
pandn  %xmm2,%xmm6
por    %xmm0,%xmm6
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm1,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm6
pandn  %xmm4,%xmm0
por    %xmm6,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rax
jne    1360 <convert_result+0x1f0>
test   $0x1,%r10b
je     1419 <convert_result+0x2a9>
mov    %r14,%rax
imul   %rbx,%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rax
movdqu (%rax,%rdi,4),%xmm2
movdqu 0x10(%rax,%rdi,4),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm0
pandn  %xmm2,%xmm4
por    %xmm4,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%edi
mov    %r11,%rax
cmp    %rbx,%r11
je     1310 <convert_result+0x1a0>
nop
mov    (%rdx,%rax,4),%ecx
cmp    %ecx,%edi
cmovl  %ecx,%edi
add    $0x1,%rax
cmp    %rax,%rbx
jne    1470 <convert_result+0x300>
jmp    1310 <convert_result+0x1a0>
xor    %edi,%edi
movdqa %xmm0,%xmm1
test   $0x1,%r10b
jne    13d7 <convert_result+0x267>
jmp    1419 <convert_result+0x2a9>
xor    %edi,%edi
mov    $0x40,%esi
call   1080 <_mm_malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%rbx
movslq -0x6c(%rbp),%rsi
imul   $0x51eb851f,%rsi,%rcx
mov    %rcx,%rax
shr    $0x3f,%rax
sar    $0x25,%rcx
add    %eax,%ecx
imul   $0x64,%ecx,%edx
xor    %edi,%edi
mov    %esi,%eax
sub    %edx,%eax
setne  %dil
add    %ecx,%edi
mov    %rdi,-0x78(%rbp)
jle    1bfa <convert_result+0xa8a>
mov    -0x78(%rbp),%rcx
add    $0xffffffff,%ecx
mov    %ecx,-0x3c(%rbp)
lea    -0x1(%rbx),%ecx
mov    %rcx,-0x110(%rbp)
lea    0x0(,%rax,4),%ecx
test   %eax,%eax
mov    $0x190,%eax
cmove  %eax,%ecx
mov    %ebx,%eax
and    $0xfffffff8,%eax
mov    %rax,-0xc8(%rbp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0xc0(%rbp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,%rdx
mov    %rax,-0xb8(%rbp)
and    %rax,%r15
mov    %ecx,-0x9c(%rbp)
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,-0x130(%rbp)
ff
mov    -0x38(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0xe8(%rbp)
lea    0x0(,%rbx,4),%rax
mov    %rax,-0xf8(%rbp)
xor    %eax,%eax
mov    %r15,-0x100(%rbp)
mov    %rsi,-0xe0(%rbp)
jmp    1595 <convert_result+0x425>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0xe0(%rbp),%rsi
mov    -0x44(%rbp),%ecx
mov    %ecx,%eax
cmp    -0x78(%rbp),%ecx
je     1bfa <convert_result+0xa8a>
imul   $0x64,%eax,%ecx
lea    0x64(%rcx),%edx
cmp    -0x3c(%rbp),%eax
cmove  %esi,%edx
mov    %edx,-0x64(%rbp)
cmp    %edx,%ecx
jge    1bf0 <convert_result+0xa80>
mov    %rax,-0x108(%rbp)
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    %rcx,-0xf0(%rbp)
mov    %ecx,%eax
mov    %ecx,-0x40(%rbp)
jmp    15de <convert_result+0x46e>
nopw   0x0(%rax,%rax,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmp    -0x64(%rbp),%eax
je     1580 <convert_result+0x410>
mov    %r13,%rdi
call   1050 <rewind@plt>
test   %r12d,%r12d
jle    15d0 <convert_result+0x460>
mov    -0x40(%rbp),%eax
mov    %eax,%ecx
sub    -0xf0(%rbp),%ecx
shl    $0x2,%ecx
mov    %ecx,-0xa4(%rbp)
not    %eax
add    -0x64(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0xe8(%rbp),%rdx
xor    %eax,%eax
mov    %rax,-0x50(%rbp)
jmp    165a <convert_result+0x4ea>
mov    -0x50(%rbp),%rsi
add    $0x1,%rsi
mov    -0xf8(%rbp),%rax
mov    -0x90(%rbp),%rdx
add    %rax,%rdx
mov    -0x98(%rbp),%rcx
add    %rax,%rcx
mov    %rsi,%rax
mov    %rsi,-0x50(%rbp)
mov    -0x88(%rbp),%r12
cmp    %r12,%rsi
je     15d0 <convert_result+0x460>
mov    %rdx,-0x90(%rbp)
mov    %rcx,-0x98(%rbp)
mov    -0x108(%rbp),%r12
test   %r12d,%r12d
je     1880 <convert_result+0x710>
mov    -0x50(%rbp),%rax
imul   %rbx,%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x58(%rbp)
xor    %r14d,%r14d
jmp    16be <convert_result+0x54e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x2941(%rip),%rax
mov    (%rax),%edx
mov    %r13,%rdi
call   1070 <fseek@plt>
add    $0x1,%r14d
cmp    %r12d,%r14d
je     1880 <convert_result+0x710>
mov    $0x0,%esi
test   %ebx,%ebx
movdqa 0x933(%rip),%xmm7
mov    -0x98(%rbp),%rdx
jle    16a0 <convert_result+0x530>
cmp    $0x8,%ebx
jae    16f0 <convert_result+0x580>
xor    %eax,%eax
xor    %esi,%esi
jmp    1850 <convert_result+0x6e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpq   $0x0,-0xc0(%rbp)
je     1867 <convert_result+0x6f7>
pxor   %xmm0,%xmm0
mov    %r15,%rcx
xor    %eax,%eax
pxor   %xmm1,%xmm1
mov    -0x90(%rbp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x30(%rsi,%rax,4),%xmm3
movdqu -0x20(%rsi,%rax,4),%xmm4
movdqu -0x10(%rsi,%rax,4),%xmm5
movdqu (%rsi,%rax,4),%xmm2
pshufd $0xf5,%xmm3,%xmm6
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm7,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm3
paddd  %xmm0,%xmm3
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm7,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm4
paddd  %xmm1,%xmm4
pshufd $0xf5,%xmm5,%xmm1
pmuludq %xmm7,%xmm5
pshufd $0xe8,%xmm5,%xmm0
pmuludq %xmm7,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
paddd  %xmm3,%xmm0
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm7,%xmm2
pshufd $0xe8,%xmm2,%xmm1
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm2
punpckldq %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1720 <convert_result+0x5b0>
testb  $0x1,-0xb8(%rbp)
je     1817 <convert_result+0x6a7>
mov    -0x58(%rbp),%rcx
movdqu (%rcx,%rax,4),%xmm2
movdqu 0x10(%rcx,%rax,4),%xmm3
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm7,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm7,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm2
paddd  %xmm2,%xmm0
pshufd $0xf5,%xmm3,%xmm2
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm7,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
mov    -0xc8(%rbp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     16a0 <convert_result+0x530>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
imul   $0x190,(%rdx,%rax,4),%ecx
add    %ecx,%esi
add    $0x1,%rax
cmp    %rax,%rbx
jne    1850 <convert_result+0x6e0>
jmp    16a0 <convert_result+0x530>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
testb  $0x1,-0xb8(%rbp)
jne    17ca <convert_result+0x65a>
jmp    1817 <convert_result+0x6a7>
test   %ebx,%ebx
mov    0x275f(%rip),%r14
jle    1980 <convert_result+0x810>
mov    -0x50(%rbp),%rax
imul   -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x120(%rbp)
xor    %ebx,%ebx
jmp    18e5 <convert_result+0x775>
nopl   0x0(%rax,%rax,1)
mov    -0x80(%rbp),%esi
imul   -0xa0(%rbp),%esi
mov    0x2727(%rip),%r14
mov    (%r14),%edx
mov    -0xd0(%rbp),%r13
mov    %r13,%rdi
call   1070 <fseek@plt>
mov    -0x58(%rbp),%rbx
add    $0x1,%rbx
cmp    -0x30(%rbp),%rbx
je     1980 <convert_result+0x810>
mov    -0x120(%rbp),%rax
mov    (%rax,%rbx,4),%r15d
mov    -0xa4(%rbp),%esi
imul   %r15d,%esi
mov    (%r14),%edx
mov    %r13,%rdi
call   1070 <fseek@plt>
mov    -0x60(%rbp),%rdi
mov    $0x4,%esi
mov    %r15d,%edx
mov    %r13,%rcx
call   1030 <fread@plt>
xor    %eax,%eax
mov    %rbx,-0x58(%rbp)
cmp    -0x110(%rbp),%rbx
jne    1936 <convert_result+0x7c6>
mov    -0xb0(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %r15d,-0x80(%rbp)
mov    %r15d,%ecx
sub    %eax,%ecx
test   %ecx,%ecx
mov    -0x118(%rbp),%r15
mov    -0x60(%rbp),%r14
lea    0x6d6(%rip),%r12
jle    18b0 <convert_result+0x740>
mov    %ecx,%ebx
xor    %r13d,%r13d
xchg   %ax,%ax
mov    (%r14,%r13,4),%edx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fprintf@plt>
add    $0x1,%r13
cmp    %r13,%rbx
jne    1960 <convert_result+0x7f0>
jmp    18b0 <convert_result+0x740>
nopl   (%rax)
mov    -0x44(%rbp),%eax
cmp    -0x78(%rbp),%eax
mov    -0x100(%rbp),%r15
mov    -0x30(%rbp),%rbx
jge    1620 <convert_result+0x4b0>
mov    -0x50(%rbp),%rax
imul   %rbx,%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%r12
mov    -0x44(%rbp),%r14d
jmp    19d1 <convert_result+0x861>
nopl   (%rax)
xor    %esi,%esi
mov    0x262f(%rip),%rax
mov    (%rax),%edx
mov    %r13,%rdi
call   1070 <fseek@plt>
add    $0x1,%r14d
cmp    -0x78(%rbp),%r14d
jge    1620 <convert_result+0x4b0>
test   %ebx,%ebx
mov    -0x98(%rbp),%rdi
jle    19b0 <convert_result+0x840>
cmp    $0x8,%ebx
jae    19f0 <convert_result+0x880>
xor    %eax,%eax
xor    %esi,%esi
jmp    1bb5 <convert_result+0xa45>
nopw   0x0(%rax,%rax,1)
cmpq   $0x0,-0xc0(%rbp)
je     1aff <convert_result+0x98f>
movdqa -0x130(%rbp),%xmm9
ff ff
movdqa %xmm9,%xmm8
cmp    -0x3c(%rbp),%r14d
je     1a20 <convert_result+0x8b0>
movdqa 0x5e5(%rip),%xmm9
movdqa %xmm9,%xmm8
pxor   %xmm0,%xmm0
mov    %r15,%rcx
xor    %eax,%eax
pxor   %xmm1,%xmm1
mov    -0x90(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x30(%rdx,%rax,4),%xmm5
movdqu -0x20(%rdx,%rax,4),%xmm6
movdqu -0x10(%rdx,%rax,4),%xmm7
movdqu (%rdx,%rax,4),%xmm4
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm8,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm8,%xmm3
pmuludq %xmm3,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm5
paddd  %xmm0,%xmm5
pshufd $0xf5,%xmm6,%xmm0
pmuludq %xmm9,%xmm6
pshufd $0xe8,%xmm6,%xmm2
pshufd $0xf5,%xmm9,%xmm6
pmuludq %xmm6,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
paddd  %xmm1,%xmm2
pshufd $0xf5,%xmm7,%xmm1
pmuludq %xmm8,%xmm7
pshufd $0xe8,%xmm7,%xmm0
pmuludq %xmm3,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
paddd  %xmm5,%xmm0
pshufd $0xf5,%xmm4,%xmm3
pmuludq %xmm9,%xmm4
pshufd $0xe8,%xmm4,%xmm1
pmuludq %xmm6,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
paddd  %xmm2,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1a40 <convert_result+0x8d0>
testb  $0x1,-0xb8(%rbp)
jne    1b12 <convert_result+0x9a2>
jmp    1b88 <convert_result+0xa18>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
testb  $0x1,-0xb8(%rbp)
je     1b88 <convert_result+0xa18>
movdqa -0x130(%rbp),%xmm2
ff
movdqa %xmm2,%xmm3
cmp    -0x3c(%rbp),%r14d
je     1b30 <convert_result+0x9c0>
movdqa 0x4d4(%rip),%xmm2
movdqa %xmm2,%xmm3
mov    %r12,%rcx
movdqu (%r12,%rax,4),%xmm4
movdqu 0x10(%r12,%rax,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm4
paddd  %xmm4,%xmm0
pshufd $0xf5,%xmm5,%xmm3
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm4
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm3,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm4
paddd  %xmm4,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
mov    -0xc8(%rbp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     19b2 <convert_result+0x842>
cmp    -0x3c(%rbp),%r14d
mov    $0x190,%ecx
cmove  -0x9c(%rbp),%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdi,%rax,4),%edx
imul   %ecx,%edx
add    %edx,%esi
add    $0x1,%rax
cmp    %rax,%rbx
jne    1bd0 <convert_result+0xa60>
jmp    19b2 <convert_result+0x842>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%eax
mov    %eax,%ecx
jmp    158a <convert_result+0x41a>
mov    -0x60(%rbp),%rdi
call   1090 <_mm_free@plt>
mov    -0xd8(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
shl    $0x2,%edi
mov    $0x40,%esi
call   1080 <_mm_malloc@plt>
test   %r12d,%r12d
mov    %rax,-0x60(%rbp)
jle    14ac <convert_result+0x33c>
xor    %r14d,%r14d
lea    0x3d3(%rip),%rax
mov    -0x38(%rbp),%rcx
jmp    1c68 <convert_result+0xaf8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
add    -0x80(%rbp),%rcx
mov    -0x88(%rbp),%r12
cmp    %r12,%r14
je     14a8 <convert_result+0x338>
mov    -0x30(%rbp),%rdx
test   %edx,%edx
jle    1c50 <convert_result+0xae0>
xor    %ebx,%ebx
mov    %rcx,-0x58(%rbp)
cs nopw 0x0(%rax,%rax,1)
mov    -0x58(%rbp),%rcx
mov    (%rcx,%rbx,4),%ecx
mov    %rax,%r12
mov    %rax,%rdi
mov    %r14d,%esi
mov    %ebx,%edx
call   1040 <printf@plt>
mov    -0x30(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    %r12,%rax
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1c80 <convert_result+0xb10>
jmp    1c50 <convert_result+0xae0>

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

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