#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 */

/* Variables and functions */
int /*<<< orphan*/ add_node(int, int, int, unsigned int volatile *,
                            unsigned int volatile);
int ram_basic_test(unsigned int test_start_addr, unsigned int test_len) {
  volatile unsigned char *MEM8_BASE = (volatile unsigned char *)test_start_addr;
  volatile unsigned short *MEM16_BASE =
      (volatile unsigned short *)test_start_addr;
  volatile unsigned int *MEM32_BASE = (volatile unsigned int *)test_start_addr;
  unsigned char pattern8;
  unsigned short pattern16;
  unsigned int pattern32;
  unsigned int test_4B_size;
  unsigned int readback_value;
  int i, j;
  test_4B_size = test_len >> 2;
  for (i = 0; i < test_4B_size; i++) {
    MEM32_BASE[i] = 0;
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] != 0) {
      add_node(1, 32, 0, &MEM32_BASE[i], MEM32_BASE[i]);
    } else {
      MEM32_BASE[i] = 0xffffffff;
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0xffffffff) {
      MEM32_BASE[i] = 0x00;
    } else {
      add_node(2, 32, 0xffffffff, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  pattern8 = 0x00;
  for (i = 0; i < test_len; i++) {
    MEM8_BASE[i] = pattern8++;
  }
  pattern8 = 0x00;
  for (i = 0; i < test_len; i++) {
    if (MEM8_BASE[i] != pattern8++) {
      add_node(3, 8, (pattern8 - 1), (volatile unsigned int *)&MEM8_BASE[i],
               MEM8_BASE[i]);
    }
  }
  pattern8 = 0x00;
  for (i = j = 0; i < test_len; i += 2, j++) {
    if (MEM8_BASE[i] == pattern8) {
      MEM16_BASE[j] = pattern8;
    }
    if (MEM16_BASE[j] != pattern8) {
      add_node(4, 16, pattern8, (volatile unsigned int *)&MEM16_BASE[i],
               MEM16_BASE[i]);
    }
    pattern8 += 2;
  }
  pattern16 = 0x00;
  for (i = 0; i < (test_len >> 1); i++) {
    MEM16_BASE[i] = pattern16++;
  }
  pattern16 = 0x00;
  for (i = 0; i < (test_len >> 1); i++) {
    if (MEM16_BASE[i] != pattern16++) {
      add_node(5, 16, (pattern16 - 1), (volatile unsigned int *)&MEM16_BASE[i],
               MEM16_BASE[i]);
    }
  }
  pattern32 = 0x00;
  for (i = 0; i < (test_len >> 2); i++) {
    MEM32_BASE[i] = pattern32++;
  }
  pattern32 = 0x00;
  for (i = 0; i < (test_len >> 2); i++) {
    if (MEM32_BASE[i] != pattern32++) {
      add_node(6, 32, (pattern32 - 1), &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    MEM32_BASE[i] = 0x44332211;
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0x44332211) {
      MEM32_BASE[i] = 0xa5a5a5a5;
    } else {
      add_node(7, 32, 0x44332211, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0xa5a5a5a5) {
      MEM8_BASE[i * 4] = 0x00;
    } else {
      add_node(8, 32, 0xa5a5a5a5, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0xa5a5a500) {
      MEM8_BASE[i * 4 + 2] = 0x00;
    } else {
      add_node(9, 32, 0xa5a5a500, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0xa500a500) {
      MEM8_BASE[i * 4 + 1] = 0x00;
    } else {
      add_node(10, 32, 0xa500a500, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0xa5000000) {
      MEM8_BASE[i * 4 + 3] = 0x00;
    } else {
      add_node(11, 8, 0xa5000000, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0x00000000) {
      MEM16_BASE[i * 2 + 1] = 0xffff;
    } else {
      add_node(12, 8, 0x00000000, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] == 0xffff0000) {
      MEM16_BASE[i * 2] = 0xffff;
    } else {
      add_node(13, 16, 0xffff0000, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    if (MEM32_BASE[i] != 0xffffffff) {
      add_node(14, 16, 0xffffffff, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    MEM32_BASE[i] = 0x0;
  }
  for (i = 0; i < test_4B_size; i++) {
    readback_value = MEM32_BASE[i];
    if (readback_value != 0x0) {
      add_node(15, 32, 0x0, &MEM32_BASE[i], MEM32_BASE[i]);
    }
    MEM32_BASE[i] = 0xffffffff;
  }
  for (i = 0; i < test_4B_size; i++) {
    readback_value = MEM32_BASE[i];
    if (readback_value != 0xffffffff) {
      add_node(16, 32, 0xffffffff, &MEM32_BASE[i], MEM32_BASE[i]);
    }
    MEM32_BASE[i] = 0x0;
  }
  for (i = 0; i < test_4B_size; i++) {
    readback_value = MEM32_BASE[i];
    if (readback_value != 0x0) {
      add_node(17, 32, 0x0, &MEM32_BASE[i], MEM32_BASE[i]);
    }
    MEM32_BASE[i] = 0xffffffff;
  }
  for (i = 0; i < test_4B_size; i++) {
    readback_value = MEM32_BASE[i];
    if (readback_value != 0xffffffff) {
      add_node(18, 32, 0xffffffff, &MEM32_BASE[i], MEM32_BASE[i]);
    }
    MEM32_BASE[i] = 0x0;
  }
  for (i = 0; i < test_4B_size; i++) {
    readback_value = MEM32_BASE[i];
    if (readback_value != 0x0) {
      add_node(19, 32, 0x0, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  for (i = 0; i < test_4B_size; i++) {
    MEM32_BASE[i] = 0x0;
    MEM32_BASE[i] = 0x61E11E49;
    readback_value = MEM32_BASE[i];
    if (readback_value != 0x61E11E49) {
      add_node(20, 32, 0x61E11E49, &MEM32_BASE[i], MEM32_BASE[i]);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<ram_basic_test>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0x10(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0x18(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
shr    $0x2,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    116c <ram_basic_test+0x5c>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1143 <ram_basic_test+0x33>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    11e6 <ram_basic_test+0xd6>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0x0,%eax
je     11c4 <ram_basic_test+0xb4>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x1,%edi
mov    $0x20,%esi
xor    %edx,%edx
call   1030 <add_node@plt>
jmp    11d3 <ram_basic_test+0xc3>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    11d8 <ram_basic_test+0xc8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1173 <ram_basic_test+0x63>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1263 <ram_basic_test+0x153>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0xffffffff,%eax
jne    1221 <ram_basic_test+0x111>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1250 <ram_basic_test+0x140>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x2,%edi
mov    $0x20,%esi
mov    $0xffffffff,%edx
call   1030 <add_node@plt>
jmp    1255 <ram_basic_test+0x145>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ed <ram_basic_test+0xdd>
movb   $0x0,-0x21(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    129d <ram_basic_test+0x18d>
mov    -0x21(%rbp),%dl
mov    %dl,%al
add    $0x1,%al
mov    %al,-0x21(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126e <ram_basic_test+0x15e>
movb   $0x0,-0x21(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    131b <ram_basic_test+0x20b>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%al
movzbl %al,%eax
mov    -0x21(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0x21(%rbp)
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1308 <ram_basic_test+0x1f8>
movzbl -0x21(%rbp),%edx
sub    $0x1,%edx
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rax
add    %rax,%rcx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rsi
mov    (%rax,%rsi,1),%al
movzbl %al,%r8d
mov    $0x3,%edi
mov    $0x8,%esi
call   1030 <add_node@plt>
jmp    130d <ram_basic_test+0x1fd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a8 <ram_basic_test+0x198>
movb   $0x0,-0x21(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    13d4 <ram_basic_test+0x2c4>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%al
movzbl %al,%eax
movzbl -0x21(%rbp),%ecx
cmp    %ecx,%eax
jne    1366 <ram_basic_test+0x256>
movzbl -0x21(%rbp),%eax
mov    %ax,%dx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
movzwl %ax,%eax
movzbl -0x21(%rbp),%ecx
cmp    %ecx,%eax
je     13b3 <ram_basic_test+0x2a3>
movzbl -0x21(%rbp),%edx
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rcx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rsi
mov    (%rax,%rsi,2),%ax
movzwl %ax,%r8d
mov    $0x4,%edi
mov    $0x10,%esi
call   1030 <add_node@plt>
movzbl -0x21(%rbp),%eax
add    $0x2,%eax
mov    %al,-0x21(%rbp)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    132d <ram_basic_test+0x21d>
movw   $0x0,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jae    141b <ram_basic_test+0x30b>
mov    -0x24(%rbp),%dx
mov    %dx,%ax
add    $0x1,%ax
mov    %ax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13e1 <ram_basic_test+0x2d1>
movw   $0x0,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jae    14aa <ram_basic_test+0x39a>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
movzwl %ax,%eax
mov    -0x24(%rbp),%cx
mov    %cx,%dx
add    $0x1,%dx
mov    %dx,-0x24(%rbp)
movzwl %cx,%ecx
cmp    %ecx,%eax
je     1497 <ram_basic_test+0x387>
movzwl -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rcx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rsi
mov    (%rax,%rsi,2),%ax
movzwl %ax,%r8d
mov    $0x5,%edi
mov    $0x10,%esi
call   1030 <add_node@plt>
jmp    149c <ram_basic_test+0x38c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1428 <ram_basic_test+0x318>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
shr    $0x2,%ecx
cmp    %ecx,%eax
jae    14ed <ram_basic_test+0x3dd>
mov    -0x28(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14b8 <ram_basic_test+0x3a8>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
shr    $0x2,%ecx
cmp    %ecx,%eax
jae    156d <ram_basic_test+0x45d>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
cmp    %ecx,%eax
je     155a <ram_basic_test+0x44a>
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rsi
mov    (%rax,%rsi,4),%r8d
mov    $0x6,%edi
mov    $0x20,%esi
call   1030 <add_node@plt>
jmp    155f <ram_basic_test+0x44f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14fb <ram_basic_test+0x3eb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    159d <ram_basic_test+0x48d>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x44332211,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1574 <ram_basic_test+0x464>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    161c <ram_basic_test+0x50c>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0x44332211,%eax
jne    15da <ram_basic_test+0x4ca>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0xa5a5a5a5,(%rax,%rcx,4)
jmp    1609 <ram_basic_test+0x4f9>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x7,%edi
mov    $0x20,%esi
mov    $0x44332211,%edx
call   1030 <add_node@plt>
jmp    160e <ram_basic_test+0x4fe>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15a4 <ram_basic_test+0x494>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    169d <ram_basic_test+0x58d>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0xa5a5a5a5,%eax
jne    165b <ram_basic_test+0x54b>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    168a <ram_basic_test+0x57a>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x8,%edi
mov    $0x20,%esi
mov    $0xa5a5a5a5,%edx
call   1030 <add_node@plt>
jmp    168f <ram_basic_test+0x57f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1623 <ram_basic_test+0x513>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1721 <ram_basic_test+0x611>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0xa5a5a500,%eax
jne    16df <ram_basic_test+0x5cf>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    170e <ram_basic_test+0x5fe>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x9,%edi
mov    $0x20,%esi
mov    $0xa5a5a500,%edx
call   1030 <add_node@plt>
jmp    1713 <ram_basic_test+0x603>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16a4 <ram_basic_test+0x594>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    17a5 <ram_basic_test+0x695>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0xa500a500,%eax
jne    1763 <ram_basic_test+0x653>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1792 <ram_basic_test+0x682>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0xa,%edi
mov    $0x20,%esi
mov    $0xa500a500,%edx
call   1030 <add_node@plt>
jmp    1797 <ram_basic_test+0x687>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1728 <ram_basic_test+0x618>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1829 <ram_basic_test+0x719>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0xa5000000,%eax
jne    17e7 <ram_basic_test+0x6d7>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1816 <ram_basic_test+0x706>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0xb,%edi
mov    $0x8,%esi
mov    $0xa5000000,%edx
call   1030 <add_node@plt>
jmp    181b <ram_basic_test+0x70b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17ac <ram_basic_test+0x69c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    18aa <ram_basic_test+0x79a>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0x0,%eax
jne    186b <ram_basic_test+0x75b>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movw   $0xffff,(%rax,%rcx,2)
jmp    1897 <ram_basic_test+0x787>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0xc,%edi
mov    $0x8,%esi
xor    %edx,%edx
call   1030 <add_node@plt>
jmp    189c <ram_basic_test+0x78c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1830 <ram_basic_test+0x720>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    192d <ram_basic_test+0x81d>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0xffff0000,%eax
jne    18eb <ram_basic_test+0x7db>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movw   $0xffff,(%rax,%rcx,2)
jmp    191a <ram_basic_test+0x80a>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0xd,%edi
mov    $0x10,%esi
mov    $0xffff0000,%edx
call   1030 <add_node@plt>
jmp    191f <ram_basic_test+0x80f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18b1 <ram_basic_test+0x7a1>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1996 <ram_basic_test+0x886>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    $0xffffffff,%eax
je     1983 <ram_basic_test+0x873>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0xe,%edi
mov    $0x10,%esi
mov    $0xffffffff,%edx
call   1030 <add_node@plt>
jmp    1988 <ram_basic_test+0x878>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1934 <ram_basic_test+0x824>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    19c6 <ram_basic_test+0x8b6>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    199d <ram_basic_test+0x88d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1a3a <ram_basic_test+0x92a>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     1a1d <ram_basic_test+0x90d>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0xf,%edi
mov    $0x20,%esi
xor    %edx,%edx
call   1030 <add_node@plt>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19cd <ram_basic_test+0x8bd>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1ab1 <ram_basic_test+0x9a1>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0xffffffff,-0x30(%rbp)
je     1a94 <ram_basic_test+0x984>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x10,%edi
mov    $0x20,%esi
mov    $0xffffffff,%edx
call   1030 <add_node@plt>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a41 <ram_basic_test+0x931>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1b25 <ram_basic_test+0xa15>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     1b08 <ram_basic_test+0x9f8>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x11,%edi
mov    $0x20,%esi
xor    %edx,%edx
call   1030 <add_node@plt>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ab8 <ram_basic_test+0x9a8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1b9c <ram_basic_test+0xa8c>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0xffffffff,-0x30(%rbp)
je     1b7f <ram_basic_test+0xa6f>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x12,%edi
mov    $0x20,%esi
mov    $0xffffffff,%edx
call   1030 <add_node@plt>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b2c <ram_basic_test+0xa1c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1c06 <ram_basic_test+0xaf6>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     1bf3 <ram_basic_test+0xae3>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x13,%edi
mov    $0x20,%esi
xor    %edx,%edx
call   1030 <add_node@plt>
jmp    1bf8 <ram_basic_test+0xae8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ba3 <ram_basic_test+0xa93>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1c94 <ram_basic_test+0xb84>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x61e11e49,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x61e11e49,-0x30(%rbp)
je     1c81 <ram_basic_test+0xb71>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    $0x14,%edi
mov    $0x20,%esi
mov    $0x61e11e49,%edx
call   1030 <add_node@plt>
jmp    1c86 <ram_basic_test+0xb76>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c0d <ram_basic_test+0xafd>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ram_basic_test>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r14d
mov    %edi,%r15d
mov    %esi,%eax
shr    $0x2,%eax
mov    %eax,0xc(%rsp)
cmp    $0x4,%esi
jb     1228 <ram_basic_test+0x118>
mov    0xc(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%r12d
cmovae %eax,%r12d
lea    -0x1(%r12),%rcx
mov    %r12d,%eax
and    $0x7,%eax
cmp    $0x7,%rcx
jae    115c <ram_basic_test+0x4c>
xor    %ecx,%ecx
jmp    11c0 <ram_basic_test+0xb0>
mov    %r12d,%edx
and    $0xfffffff8,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,(%r15,%rcx,4)
movl   $0x0,0x4(%r15,%rcx,4)
movl   $0x0,0x8(%r15,%rcx,4)
movl   $0x0,0xc(%r15,%rcx,4)
movl   $0x0,0x10(%r15,%rcx,4)
movl   $0x0,0x14(%r15,%rcx,4)
movl   $0x0,0x18(%r15,%rcx,4)
movl   $0x0,0x1c(%r15,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1170 <ram_basic_test+0x60>
test   %rax,%rax
je     11e0 <ram_basic_test+0xd0>
lea    (%r15,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11d0 <ram_basic_test+0xc0>
cmp    $0x4,%r14d
jb     1228 <ram_basic_test+0x118>
mov    %r12,%rbp
mov    %r15,%rbx
jmp    1200 <ram_basic_test+0xf0>
xchg   %ax,%ax
movl   $0xffffffff,(%rbx)
add    $0x4,%rbx
add    $0xffffffffffffffff,%rbp
je     121e <ram_basic_test+0x10e>
cmpl   $0x0,(%rbx)
je     11f0 <ram_basic_test+0xe0>
mov    (%rbx),%r8d
mov    $0x1,%edi
mov    $0x20,%esi
xor    %edx,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    11f6 <ram_basic_test+0xe6>
cmp    $0x4,%r14d
jae    1394 <ram_basic_test+0x284>
test   %r14d,%r14d
je     143a <ram_basic_test+0x32a>
mov    %r14d,%r13d
lea    -0x1(%r13),%rcx
mov    %r13d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    124f <ram_basic_test+0x13f>
xor    %ecx,%ecx
xor    %edx,%edx
test   %rax,%rax
jne    128c <ram_basic_test+0x17c>
jmp    12b0 <ram_basic_test+0x1a0>
mov    %r13d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %cl,(%r15,%rcx,1)
lea    0x1(%rcx),%esi
mov    %sil,0x1(%r15,%rcx,1)
lea    0x2(%rcx),%esi
mov    %sil,0x2(%r15,%rcx,1)
lea    0x3(%rcx),%esi
mov    %sil,0x3(%r15,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1260 <ram_basic_test+0x150>
mov    %ecx,%edx
test   %rax,%rax
je     12b0 <ram_basic_test+0x1a0>
add    %r15,%rcx
mov    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdx,%rsi,1),%edi
mov    %dil,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    12a0 <ram_basic_test+0x190>
test   %r14d,%r14d
je     143a <ram_basic_test+0x32a>
xor    %eax,%eax
jmp    12c8 <ram_basic_test+0x1b8>
nopl   (%rax)
mov    %rbx,%rax
cmp    %rbx,%r13
je     12f2 <ram_basic_test+0x1e2>
lea    0x1(%rax),%rbx
cmp    (%r15,%rax,1),%al
je     12c0 <ram_basic_test+0x1b0>
movzbl %bl,%edx
add    $0xffffffff,%edx
lea    (%r15,%rax,1),%rcx
movzbl (%r15,%rax,1),%r8d
mov    $0x3,%edi
mov    $0x8,%esi
call   1030 <add_node@plt>
jmp    12c0 <ram_basic_test+0x1b0>
test   %r14d,%r14d
je     143a <ram_basic_test+0x32a>
lea    -0x1(%r14),%ebp
and    $0xfffffffe,%ebp
add    $0x2,%rbp
xor    %ebx,%ebx
xor    %r12d,%r12d
jmp    131d <ram_basic_test+0x20d>
nopl   (%rax)
add    $0x2,%r12
add    $0x4,%rbx
cmp    %r12,%rbp
je     1355 <ram_basic_test+0x245>
mov    %r12d,%edx
and    $0xfe,%edx
cmp    (%r15,%r12,1),%r12b
jne    1331 <ram_basic_test+0x221>
mov    %dx,(%r15,%r12,1)
movzwl (%r15,%r12,1),%eax
cmp    %dx,%ax
je     1310 <ram_basic_test+0x200>
lea    (%r15,%rbx,1),%rcx
movzwl (%r15,%r12,2),%r8d
mov    $0x4,%edi
mov    $0x10,%esi
call   1030 <add_node@plt>
jmp    1310 <ram_basic_test+0x200>
cmp    $0x2,%r13d
jb     143a <ram_basic_test+0x32a>
mov    %r14d,%eax
shr    %eax
cmp    $0x2,%eax
mov    $0x1,%r12d
cmovae %eax,%r12d
lea    -0x1(%r12),%rcx
mov    %r12d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    13d7 <ram_basic_test+0x2c7>
xor    %ecx,%ecx
xor    %edx,%edx
test   %rax,%rax
jne    1410 <ram_basic_test+0x300>
jmp    1430 <ram_basic_test+0x320>
mov    %r15,%rbx
jmp    13c8 <ram_basic_test+0x2b8>
nopl   0x0(%rax)
mov    (%rbx),%r8d
mov    $0x2,%edi
mov    $0x20,%esi
mov    $0xffffffff,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
add    $0x4,%rbx
add    $0xffffffffffffffff,%r12
je     1228 <ram_basic_test+0x118>
mov    (%rbx),%eax
cmp    $0xffffffff,%eax
jne    13a0 <ram_basic_test+0x290>
movl   $0x0,(%rbx)
jmp    13ba <ram_basic_test+0x2aa>
mov    %r12d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
nop
mov    %cx,(%r15,%rcx,2)
lea    0x1(%rcx),%esi
mov    %si,0x2(%r15,%rcx,2)
lea    0x2(%rcx),%esi
mov    %si,0x4(%r15,%rcx,2)
lea    0x3(%rcx),%esi
mov    %si,0x6(%r15,%rcx,2)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    13e0 <ram_basic_test+0x2d0>
mov    %ecx,%edx
test   %rax,%rax
je     1430 <ram_basic_test+0x320>
lea    (%r15,%rcx,2),%rcx
mov    %edx,%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%rsi,1),%edi
mov    %di,(%rcx,%rsi,2)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1420 <ram_basic_test+0x310>
cmp    $0x2,%r13d
jae    1666 <ram_basic_test+0x556>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    0xc(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovae %eax,%ebp
lea    -0x1(%rbp),%rdi
mov    %ebp,%eax
and    $0x7,%eax
cmp    $0x7,%rdi
jae    1466 <ram_basic_test+0x356>
xor    %ecx,%ecx
jmp    14b5 <ram_basic_test+0x3a5>
mov    %ebp,%edx
and    $0xfffffff8,%edx
xor    %ecx,%ecx
nopl   (%rax)
mov    %ecx,(%r15,%rcx,4)
lea    0x1(%rcx),%esi
mov    %esi,0x4(%r15,%rcx,4)
lea    0x2(%rcx),%esi
mov    %esi,0x8(%r15,%rcx,4)
lea    0x3(%rcx),%esi
mov    %esi,0xc(%r15,%rcx,4)
lea    0x4(%rcx),%esi
mov    %esi,0x10(%r15,%rcx,4)
lea    0x5(%rcx),%esi
mov    %esi,0x14(%r15,%rcx,4)
lea    0x6(%rcx),%esi
mov    %esi,0x18(%r15,%rcx,4)
lea    0x7(%rcx),%esi
mov    %esi,0x1c(%r15,%rcx,4)
add    $0x8,%rcx
cmp    %rdx,%rcx
jne    1470 <ram_basic_test+0x360>
test   %rax,%rax
je     14ce <ram_basic_test+0x3be>
nopw   0x0(%rax,%rax,1)
mov    %ecx,(%r15,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    14c0 <ram_basic_test+0x3b0>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    %r14,0x10(%rsp)
mov    %rbp,%r12
mov    %rdi,%r14
xor    %ebp,%ebp
mov    %r12,%r13
mov    %r15,%rbx
jmp    14fd <ram_basic_test+0x3ed>
nopl   (%rax)
add    $0x1,%ebp
add    $0x4,%rbx
add    $0xffffffffffffffff,%r12
je     151a <ram_basic_test+0x40a>
cmp    (%rbx),%ebp
je     14f0 <ram_basic_test+0x3e0>
mov    (%rbx),%r8d
mov    $0x6,%edi
mov    $0x20,%esi
mov    %ebp,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    14f0 <ram_basic_test+0x3e0>
mov    0x10(%rsp),%rax
cmp    $0x4,%eax
jb     1a24 <ram_basic_test+0x914>
mov    %r14,%r12
mov    %rax,%r14
mov    %r13d,%eax
and    $0x7,%eax
cmp    $0x7,%r12
jae    153e <ram_basic_test+0x42e>
xor    %ecx,%ecx
jmp    15a0 <ram_basic_test+0x490>
mov    %r13d,%edx
and    $0xfffffff8,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movl   $0x44332211,(%r15,%rcx,4)
44
movl   $0x44332211,0x4(%r15,%rcx,4)
33 44
movl   $0x44332211,0x8(%r15,%rcx,4)
33 44
movl   $0x44332211,0xc(%r15,%rcx,4)
33 44
movl   $0x44332211,0x10(%r15,%rcx,4)
33 44
movl   $0x44332211,0x14(%r15,%rcx,4)
33 44
movl   $0x44332211,0x18(%r15,%rcx,4)
33 44
movl   $0x44332211,0x1c(%r15,%rcx,4)
33 44
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1550 <ram_basic_test+0x440>
test   %rax,%rax
je     15c0 <ram_basic_test+0x4b0>
lea    (%r15,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movl   $0x44332211,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    15b0 <ram_basic_test+0x4a0>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    %r13,%rbp
mov    %r15,%rbx
jmp    1604 <ram_basic_test+0x4f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx),%r8d
mov    $0x7,%edi
mov    $0x20,%esi
mov    $0x44332211,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
add    $0x4,%rbx
add    $0xffffffffffffffff,%rbp
je     1615 <ram_basic_test+0x505>
mov    (%rbx),%eax
cmp    $0x44332211,%eax
jne    15e0 <ram_basic_test+0x4d0>
movl   $0xa5a5a5a5,(%rbx)
jmp    15fa <ram_basic_test+0x4ea>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
lea    0x0(,%r13,4),%rbx
xor    %ebp,%ebp
jmp    1654 <ram_basic_test+0x544>
nopl   0x0(%rax,%rax,1)
lea    (%r15,%rbp,1),%rcx
mov    (%rcx),%r8d
mov    $0x8,%edi
mov    $0x20,%esi
mov    $0xa5a5a5a5,%edx
call   1030 <add_node@plt>
add    $0x4,%rbp
cmp    %rbp,%rbx
je     16a7 <ram_basic_test+0x597>
mov    (%r15,%rbp,1),%eax
cmp    $0xa5a5a5a5,%eax
jne    1630 <ram_basic_test+0x520>
movb   $0x0,(%r15,%rbp,1)
jmp    164b <ram_basic_test+0x53b>
xor    %ebp,%ebp
mov    %r15,%rbx
jmp    167d <ram_basic_test+0x56d>
nopl   (%rax)
add    $0x2,%rbx
cmp    %rbp,%r12
je     143a <ram_basic_test+0x32a>
mov    %rbp,%rax
add    $0x1,%rbp
cmp    (%rbx),%ax
je     1670 <ram_basic_test+0x560>
movzwl %bp,%edx
add    $0xffffffff,%edx
movzwl (%rbx),%r8d
mov    $0x5,%edi
mov    $0x10,%esi
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    1670 <ram_basic_test+0x560>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
xor    %ebp,%ebp
jmp    16e4 <ram_basic_test+0x5d4>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%rbp,1),%rcx
mov    (%rcx),%r8d
mov    $0x9,%edi
mov    $0x20,%esi
mov    $0xa5a5a500,%edx
call   1030 <add_node@plt>
add    $0x4,%rbp
cmp    %rbp,%rbx
je     16f7 <ram_basic_test+0x5e7>
mov    (%r15,%rbp,1),%eax
cmp    $0xa5a5a500,%eax
jne    16c0 <ram_basic_test+0x5b0>
movb   $0x0,0x2(%r15,%rbp,1)
jmp    16db <ram_basic_test+0x5cb>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
xor    %ebp,%ebp
jmp    1729 <ram_basic_test+0x619>
lea    (%r15,%rbp,1),%rcx
mov    (%rcx),%r8d
mov    $0xa,%edi
mov    $0x20,%esi
mov    $0xa500a500,%edx
call   1030 <add_node@plt>
add    $0x4,%rbp
cmp    %rbp,%rbx
je     173c <ram_basic_test+0x62c>
mov    (%r15,%rbp,1),%eax
cmp    $0xa500a500,%eax
jne    1705 <ram_basic_test+0x5f5>
movb   $0x0,0x1(%r15,%rbp,1)
jmp    1720 <ram_basic_test+0x610>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
xor    %ebp,%ebp
jmp    176e <ram_basic_test+0x65e>
lea    (%r15,%rbp,1),%rcx
mov    (%rcx),%r8d
mov    $0xb,%edi
mov    $0x8,%esi
mov    $0xa5000000,%edx
call   1030 <add_node@plt>
add    $0x4,%rbp
cmp    %rbp,%rbx
je     1781 <ram_basic_test+0x671>
mov    (%r15,%rbp,1),%eax
cmp    $0xa5000000,%eax
jne    174a <ram_basic_test+0x63a>
movb   $0x0,0x3(%r15,%rbp,1)
jmp    1765 <ram_basic_test+0x655>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
xor    %ebp,%ebp
jmp    17b0 <ram_basic_test+0x6a0>
lea    (%r15,%rbp,1),%rcx
mov    (%rcx),%r8d
mov    $0xc,%edi
mov    $0x8,%esi
xor    %edx,%edx
call   1030 <add_node@plt>
add    $0x4,%rbp
cmp    %rbp,%rbx
je     17c1 <ram_basic_test+0x6b1>
cmpl   $0x0,(%r15,%rbp,1)
jne    178f <ram_basic_test+0x67f>
movw   $0xffff,0x2(%r15,%rbp,1)
ff
jmp    17a7 <ram_basic_test+0x697>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
xor    %ebp,%ebp
jmp    17f3 <ram_basic_test+0x6e3>
lea    (%r15,%rbp,1),%rcx
mov    (%rcx),%r8d
mov    $0xd,%edi
mov    $0x10,%esi
mov    $0xffff0000,%edx
call   1030 <add_node@plt>
add    $0x4,%rbp
cmp    %rbp,%rbx
je     1807 <ram_basic_test+0x6f7>
mov    (%r15,%rbp,1),%eax
cmp    $0xffff0000,%eax
jne    17cf <ram_basic_test+0x6bf>
movw   $0xffff,(%r15,%rbp,1)
jmp    17ea <ram_basic_test+0x6da>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    %r13,%rbp
mov    %r15,%rbx
jmp    1823 <ram_basic_test+0x713>
add    $0x4,%rbx
add    $0xffffffffffffffff,%rbp
je     1846 <ram_basic_test+0x736>
mov    (%rbx),%eax
cmp    $0xffffffff,%eax
je     1819 <ram_basic_test+0x709>
mov    (%rbx),%r8d
mov    $0xe,%edi
mov    $0x10,%esi
mov    $0xffffffff,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    1819 <ram_basic_test+0x709>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    %r13d,%eax
and    $0x7,%eax
cmp    $0x7,%r12
jae    1860 <ram_basic_test+0x750>
xor    %ecx,%ecx
jmp    18b6 <ram_basic_test+0x7a6>
and    $0xfffffff8,%r13d
xor    %ecx,%ecx
movl   $0x0,(%r15,%rcx,4)
movl   $0x0,0x4(%r15,%rcx,4)
movl   $0x0,0x8(%r15,%rcx,4)
movl   $0x0,0xc(%r15,%rcx,4)
movl   $0x0,0x10(%r15,%rcx,4)
movl   $0x0,0x14(%r15,%rcx,4)
movl   $0x0,0x18(%r15,%rcx,4)
movl   $0x0,0x1c(%r15,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%r13
jne    1866 <ram_basic_test+0x756>
test   %rax,%rax
je     18d1 <ram_basic_test+0x7c1>
lea    (%r15,%rcx,4),%rcx
xor    %edx,%edx
movl   $0x0,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    18c1 <ram_basic_test+0x7b1>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    0xc(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%r12d
cmovae %eax,%r12d
mov    %r12,%rbp
mov    %r15,%rbx
jmp    1904 <ram_basic_test+0x7f4>
movl   $0xffffffff,(%rbx)
add    $0x4,%rbx
add    $0xffffffffffffffff,%rbp
je     1922 <ram_basic_test+0x812>
cmpl   $0x0,(%rbx)
je     18f4 <ram_basic_test+0x7e4>
mov    (%rbx),%r8d
mov    $0xf,%edi
mov    $0x20,%esi
xor    %edx,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    18f4 <ram_basic_test+0x7e4>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    %r12,%rbp
mov    %r15,%rbx
jmp    1944 <ram_basic_test+0x834>
movl   $0x0,(%rbx)
add    $0x4,%rbx
add    $0xffffffffffffffff,%rbp
je     1967 <ram_basic_test+0x857>
mov    (%rbx),%eax
cmp    $0xffffffff,%eax
je     1934 <ram_basic_test+0x824>
mov    (%rbx),%r8d
mov    $0x10,%edi
mov    $0x20,%esi
mov    $0xffffffff,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    1934 <ram_basic_test+0x824>
cmp    $0x4,%r14d
jb     1a24 <ram_basic_test+0x914>
mov    %r12,%rbp
mov    %r15,%rbx
jmp    1989 <ram_basic_test+0x879>
movl   $0xffffffff,(%rbx)
add    $0x4,%rbx
add    $0xffffffffffffffff,%rbp
je     19a7 <ram_basic_test+0x897>
cmpl   $0x0,(%rbx)
je     1979 <ram_basic_test+0x869>
mov    (%rbx),%r8d
mov    $0x11,%edi
mov    $0x20,%esi
xor    %edx,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    1979 <ram_basic_test+0x869>
cmpl   $0x4,0x10(%rsp)
jb     1a24 <ram_basic_test+0x914>
mov    %r12,%rbp
mov    %r15,%rbx
jmp    19c6 <ram_basic_test+0x8b6>
movl   $0x0,(%rbx)
add    $0x4,%rbx
add    $0xffffffffffffffff,%rbp
je     19e9 <ram_basic_test+0x8d9>
mov    (%rbx),%eax
cmp    $0xffffffff,%eax
je     19b6 <ram_basic_test+0x8a6>
mov    (%rbx),%r8d
mov    $0x12,%edi
mov    $0x20,%esi
mov    $0xffffffff,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    19b6 <ram_basic_test+0x8a6>
cmpl   $0x4,0x10(%rsp)
jb     1a24 <ram_basic_test+0x914>
mov    %r15,%rbx
jmp    19ff <ram_basic_test+0x8ef>
add    $0x4,%rbx
add    $0xffffffffffffffff,%r12
je     1a1d <ram_basic_test+0x90d>
cmpl   $0x0,(%rbx)
je     19f5 <ram_basic_test+0x8e5>
mov    (%rbx),%r8d
mov    $0x13,%edi
mov    $0x20,%esi
xor    %edx,%edx
mov    %rbx,%rcx
call   1030 <add_node@plt>
jmp    19f5 <ram_basic_test+0x8e5>
cmpl   $0x4,0x10(%rsp)
jae    1a35 <ram_basic_test+0x925>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0xc(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%ebx
cmovae %eax,%ebx
jmp    1a50 <ram_basic_test+0x940>
add    $0x4,%r15
add    $0xffffffffffffffff,%rbx
je     1a24 <ram_basic_test+0x914>
movl   $0x0,(%r15)
movl   $0x61e11e49,(%r15)
mov    (%r15),%eax
cmp    $0x61e11e49,%eax
je     1a46 <ram_basic_test+0x936>
mov    (%r15),%r8d
mov    $0x14,%edi
mov    $0x20,%esi
mov    $0x61e11e49,%edx
mov    %r15,%rcx
call   1030 <add_node@plt>
jmp    1a46 <ram_basic_test+0x936>

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

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