void of_add_from_multiple_symbols(void *to, const void **from,
                                  unsigned int from_size,
                                  unsigned int symbol_size) {
  unsigned int i;
  unsigned int symbolSize32;
  unsigned int symbolSize32rem;
  symbolSize32 = symbol_size >> 2;
  symbolSize32rem = symbol_size % 4;
  unsigned int symbolSize64;
  symbolSize64 = symbol_size >> 3;
  while (from_size >= 8) {
    unsigned long long *t = (unsigned long long *)to;
    unsigned long long *ps1 = (unsigned long long *)from[0];
    unsigned long long *ps2 = (unsigned long long *)from[1];
    unsigned long long *ps3 = (unsigned long long *)from[2];
    unsigned long long *ps4 = (unsigned long long *)from[3];
    unsigned long long *ps5 = (unsigned long long *)from[4];
    unsigned long long *ps6 = (unsigned long long *)from[5];
    unsigned long long *ps7 = (unsigned long long *)from[6];
    unsigned long long *ps8 = (unsigned long long *)from[7];
    from_size -= 8;
    from += 8;
    for (i = symbolSize64; i > 0; i--) {
      *t ^= (*ps1 ^ *ps2 ^ *ps3 ^ *ps4 ^ *ps5 ^ *ps6 ^ *ps7 ^ *ps8);
      t++;
      ps1++;
      ps2++;
      ps3++;
      ps4++;
      ps5++;
      ps6++;
      ps7++;
      ps8++;
    }
    unsigned int *t32 = (unsigned int *)t;
    unsigned int *ps1_32 = (unsigned int *)ps1;
    unsigned int *ps2_32 = (unsigned int *)ps2;
    unsigned int *ps3_32 = (unsigned int *)ps3;
    unsigned int *ps4_32 = (unsigned int *)ps4;
    unsigned int *ps5_32 = (unsigned int *)ps5;
    unsigned int *ps6_32 = (unsigned int *)ps6;
    unsigned int *ps7_32 = (unsigned int *)ps7;
    unsigned int *ps8_32 = (unsigned int *)ps8;
    if ((symbolSize64 << 1) < symbolSize32) {
      *(unsigned int *)t32 ^=
          (*(unsigned int *)ps1_32 ^ *(unsigned int *)ps2_32 ^
           *(unsigned int *)ps3_32 ^ *(unsigned int *)ps4_32 ^
           *(unsigned int *)ps5_32 ^ *(unsigned int *)ps6_32 ^
           *(unsigned int *)ps7_32 ^ *(unsigned int *)ps8_32);
      ps1_32++;
      ps2_32++;
      ps3_32++;
      ps4_32++;
      ps5_32++;
      ps6_32++;
      ps7_32++;
      ps8_32++;
      t32++;
    }
    if (symbolSize32rem > 0) {
      for (i = 0; i < symbolSize32rem; i++) {
        *(unsigned char *)((unsigned char *)t32 + i) ^=
            ((*(unsigned char *)((unsigned char *)ps1_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps2_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps3_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps4_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps5_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps6_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps7_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps8_32 + i)));
      }
    }
  }
  while (from_size >= 4) {
    unsigned long long *t = (unsigned long long *)to;
    unsigned long long *ps1 = (unsigned long long *)from[0];
    unsigned long long *ps2 = (unsigned long long *)from[1];
    unsigned long long *ps3 = (unsigned long long *)from[2];
    unsigned long long *ps4 = (unsigned long long *)from[3];
    from_size -= 4;
    from += 4;
    for (i = symbolSize64; i > 0; i--) {
      *t ^= (*ps1 ^ *ps2 ^ *ps3 ^ *ps4);
      t++;
      ps1++;
      ps2++;
      ps3++;
      ps4++;
    }
    unsigned int *t32 = (unsigned int *)t;
    unsigned int *ps1_32 = (unsigned int *)ps1;
    unsigned int *ps2_32 = (unsigned int *)ps2;
    unsigned int *ps3_32 = (unsigned int *)ps3;
    unsigned int *ps4_32 = (unsigned int *)ps4;
    if ((symbolSize64 << 1) < symbolSize32) {
      *(unsigned int *)t32 ^=
          (*(unsigned int *)ps1_32 ^ *(unsigned int *)ps2_32 ^
           *(unsigned int *)ps3_32 ^ *(unsigned int *)ps4_32);
      ps1_32++;
      ps2_32++;
      ps3_32++;
      ps4_32++;
      t32++;
    }
    if (symbolSize32rem > 0) {
      for (i = 0; i < symbolSize32rem; i++) {
        *(unsigned char *)((unsigned char *)t32 + i) ^=
            ((*(unsigned char *)((unsigned char *)ps1_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps2_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps3_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps4_32 + i)));
      }
    }
  }
  while (from_size >= 2) {
    unsigned long long *t = (unsigned long long *)to;
    unsigned long long *ps1 = (unsigned long long *)from[0];
    unsigned long long *ps2 = (unsigned long long *)from[1];
    from += 2;
    from_size -= 2;
    for (i = symbolSize64; i > 0; i--) {
      *t ^= (*ps1 ^ *ps2);
      t++;
      ps1++;
      ps2++;
    }
    unsigned int *t32 = (unsigned int *)t;
    unsigned int *ps1_32 = (unsigned int *)ps1;
    unsigned int *ps2_32 = (unsigned int *)ps2;
    if ((symbolSize64 << 1) < symbolSize32) {
      *(unsigned int *)t32 ^=
          (*(unsigned int *)ps1_32 ^ *(unsigned int *)ps2_32);
      ps1_32++;
      ps2_32++;
      t32++;
    }
    if (symbolSize32rem > 0) {
      for (i = 0; i < symbolSize32rem; i++) {
        *(unsigned char *)((unsigned char *)t32 + i) ^=
            ((*(unsigned char *)((unsigned char *)ps1_32 + i)) ^
             (*(unsigned char *)((unsigned char *)ps2_32 + i)));
      }
    }
  }
  if (from_size == 0)
    return;
  unsigned long long *t = (unsigned long long *)to;
  unsigned long long *f = (unsigned long long *)from[0];
  for (i = symbolSize64; i > 0; i--) {
    *t ^= *f;
    t++;
    f++;
  }
  unsigned int *t32 = (unsigned int *)t;
  unsigned int *f32 = (unsigned int *)f;
  if ((symbolSize64 << 1) < symbolSize32) {
    *(unsigned int *)t32 ^= *(unsigned int *)f32;
    t32++;
    f32++;
  }
  if (symbolSize32rem > 0) {
    for (i = 0; i < symbolSize32rem; i++) {
      *(unsigned char *)((unsigned char *)t32 + i) ^=
          *(unsigned char *)((unsigned char *)f32 + i);
    }
  }
}


x86 assembly (clang, -O0):
<of_add_from_multiple_symbols>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd8,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shr    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
and    $0x3,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shr    $0x3,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x8,-0x14(%rbp)
jb     1495 <of_add_from_multiple_symbols+0x395>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jbe    1286 <of_add_from_multiple_symbols+0x186>
mov    -0x38(%rbp),%rax
mov    (%rax),%rcx
mov    -0x40(%rbp),%rax
xor    (%rax),%rcx
mov    -0x48(%rbp),%rax
xor    (%rax),%rcx
mov    -0x50(%rbp),%rax
xor    (%rax),%rcx
mov    -0x58(%rbp),%rax
xor    (%rax),%rcx
mov    -0x60(%rbp),%rax
xor    (%rax),%rcx
mov    -0x68(%rbp),%rax
xor    (%rax),%rcx
mov    -0x70(%rbp),%rax
xor    (%rax),%rcx
mov    -0x30(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c0 <of_add_from_multiple_symbols+0xc0>
mov    -0x30(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    13d5 <of_add_from_multiple_symbols+0x2d5>
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x88(%rbp),%rax
xor    (%rax),%ecx
mov    -0x90(%rbp),%rax
xor    (%rax),%ecx
mov    -0x98(%rbp),%rax
xor    (%rax),%ecx
mov    -0xa0(%rbp),%rax
xor    (%rax),%ecx
mov    -0xa8(%rbp),%rax
xor    (%rax),%ecx
mov    -0xb0(%rbp),%rax
xor    (%rax),%ecx
mov    -0xb8(%rbp),%rax
xor    (%rax),%ecx
mov    -0x78(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x88(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x90(%rbp)
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x98(%rbp)
mov    -0xa0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xb0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xb8(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    1490 <of_add_from_multiple_symbols+0x390>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    148b <of_add_from_multiple_symbols+0x38b>
mov    -0x80(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
mov    -0x88(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0x90(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0x98(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0xa0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0xa8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0xb0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0xb8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0x78(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13e6 <of_add_from_multiple_symbols+0x2e6>
jmp    1490 <of_add_from_multiple_symbols+0x390>
jmp    1134 <of_add_from_multiple_symbols+0x34>
jmp    149a <of_add_from_multiple_symbols+0x39a>
cmpl   $0x4,-0x14(%rbp)
jb     1710 <of_add_from_multiple_symbols+0x610>
mov    -0x8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jbe    15ac <of_add_from_multiple_symbols+0x4ac>
mov    -0xc8(%rbp),%rax
mov    (%rax),%rcx
mov    -0xd0(%rbp),%rax
xor    (%rax),%rcx
mov    -0xd8(%rbp),%rax
xor    (%rax),%rcx
mov    -0xe0(%rbp),%rax
xor    (%rax),%rcx
mov    -0xc0(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1505 <of_add_from_multiple_symbols+0x405>
mov    -0xc0(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0xd8(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0xe0(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    168a <of_add_from_multiple_symbols+0x58a>
mov    -0xf0(%rbp),%rax
mov    (%rax),%ecx
mov    -0xf8(%rbp),%rax
xor    (%rax),%ecx
mov    -0x100(%rbp),%rax
xor    (%rax),%ecx
mov    -0x108(%rbp),%rax
xor    (%rax),%ecx
mov    -0xe8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xf0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x100(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x100(%rbp)
mov    -0x108(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x108(%rbp)
mov    -0xe8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xe8(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    170b <of_add_from_multiple_symbols+0x60b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1706 <of_add_from_multiple_symbols+0x606>
mov    -0xf0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
mov    -0xf8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0x100(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0x108(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0xe8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    169b <of_add_from_multiple_symbols+0x59b>
jmp    170b <of_add_from_multiple_symbols+0x60b>
jmp    149a <of_add_from_multiple_symbols+0x39a>
jmp    1715 <of_add_from_multiple_symbols+0x615>
cmpl   $0x2,-0x14(%rbp)
jb     18c3 <of_add_from_multiple_symbols+0x7c3>
mov    -0x8(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x118(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x120(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jbe    17d1 <of_add_from_multiple_symbols+0x6d1>
mov    -0x118(%rbp),%rax
mov    (%rax),%rcx
mov    -0x120(%rbp),%rax
xor    (%rax),%rcx
mov    -0x110(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x110(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x110(%rbp)
mov    -0x118(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x118(%rbp)
mov    -0x120(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x120(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1762 <of_add_from_multiple_symbols+0x662>
mov    -0x110(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x118(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x120(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    185d <of_add_from_multiple_symbols+0x75d>
mov    -0x130(%rbp),%rax
mov    (%rax),%ecx
mov    -0x138(%rbp),%rax
xor    (%rax),%ecx
mov    -0x128(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x130(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x130(%rbp)
mov    -0x138(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x138(%rbp)
mov    -0x128(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x128(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    18be <of_add_from_multiple_symbols+0x7be>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    18b9 <of_add_from_multiple_symbols+0x7b9>
mov    -0x130(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
mov    -0x138(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
xor    %eax,%esi
mov    -0x128(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    186e <of_add_from_multiple_symbols+0x76e>
jmp    18be <of_add_from_multiple_symbols+0x7be>
jmp    1715 <of_add_from_multiple_symbols+0x615>
cmpl   $0x0,-0x14(%rbp)
jne    18d2 <of_add_from_multiple_symbols+0x7d2>
jmp    19f8 <of_add_from_multiple_symbols+0x8f8>
mov    -0x8(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x148(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jbe    1944 <of_add_from_multiple_symbols+0x844>
mov    -0x148(%rbp),%rax
mov    (%rax),%rcx
mov    -0x140(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x140(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x140(%rbp)
mov    -0x148(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x148(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    18f1 <of_add_from_multiple_symbols+0x7f1>
mov    -0x140(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x148(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    19a7 <of_add_from_multiple_symbols+0x8a7>
mov    -0x158(%rbp),%rax
mov    (%rax),%ecx
mov    -0x150(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x150(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x150(%rbp)
mov    -0x158(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x158(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    19f8 <of_add_from_multiple_symbols+0x8f8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    19f3 <of_add_from_multiple_symbols+0x8f3>
mov    -0x158(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
mov    -0x150(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    19b8 <of_add_from_multiple_symbols+0x8b8>
jmp    19f8 <of_add_from_multiple_symbols+0x8f8>
add    $0xd8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<of_add_from_multiple_symbols>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x30,%rsp
movabs $0x1fffffffc,%rbp
mov    %ecx,%eax
shr    $0x2,%eax
mov    %eax,-0x2c(%rsp)
mov    %ecx,%ebx
and    $0x3,%ebx
mov    %ecx,-0x30(%rsp)
mov    %ecx,%r8d
shr    $0x3,%r8d
mov    %edx,%eax
cmp    $0x8,%edx
mov    %ebx,-0x7c(%rsp)
mov    %r8,-0x60(%rsp)
mov    %rdi,-0x78(%rsp)
jb     1595 <of_add_from_multiple_symbols+0x495>
lea    (%r8,%r8,1),%ecx
mov    %ecx,-0x20(%rsp)
lea    -0x1(%r8),%ecx
lea    (%rdi,%rcx,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x20(%rsp)
mov    %rcx,0x28(%rsp)
add    $0x1,%rcx
lea    0x2(%rbp),%r10
mov    %rcx,0x8(%rsp)
and    %rcx,%r10
lea    (%rdi,%r10,8),%rcx
mov    %rcx,0x10(%rsp)
mov    %r8d,%ecx
sub    %r10d,%ecx
mov    %ecx,0x4(%rsp)
mov    %eax,%edi
mov    %r10,0x18(%rsp)
jmp    11c5 <of_add_from_multiple_symbols+0xc5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x18(%rsp),%rsi
add    $0x40,%rsi
mov    %r12d,%edi
cmp    $0x7,%r12d
mov    -0x60(%rsp),%r8
movabs $0x1fffffffc,%rbp
jbe    1597 <of_add_from_multiple_symbols+0x497>
mov    %edi,-0x70(%rsp)
mov    (%rsi),%rax
mov    0x8(%rsi),%r10
mov    0x10(%rsi),%r12
mov    0x18(%rsi),%r9
mov    0x20(%rsi),%rbx
mov    0x28(%rsi),%rdx
mov    0x30(%rsi),%rdi
mov    0x38(%rsi),%r13
cmpl   $0x8,-0x30(%rsp)
mov    %rsi,-0x18(%rsp)
jae    1220 <of_add_from_multiple_symbols+0x120>
mov    -0x78(%rsp),%rcx
mov    %rax,%r15
mov    %r10,%r8
mov    %r12,%r11
mov    %rbx,%r14
mov    %rdx,%rbp
mov    -0x70(%rsp),%r12d
jmp    14ca <of_add_from_multiple_symbols+0x3ca>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x0,0x28(%rsp)
je     141c <of_add_from_multiple_symbols+0x31c>
mov    0x8(%rsp),%r14
lea    (%rax,%r14,8),%rcx
mov    -0x78(%rsp),%rsi
cmp    %rsi,%rcx
seta   -0x38(%rsp)
mov    0x20(%rsp),%r15
mov    %rax,-0x58(%rsp)
cmp    %rax,%r15
seta   -0x28(%rsp)
lea    (%r10,%r14,8),%rcx
cmp    %rsi,%rcx
seta   %cl
cmp    %r10,%r15
seta   -0x8(%rsp)
lea    (%r12,%r14,8),%rbp
cmp    %rsi,%rbp
seta   %r8b
cmp    %r12,%r15
seta   -0x10(%rsp)
lea    (%r9,%r14,8),%rbp
cmp    %rsi,%rbp
mov    %r9,%rax
seta   %r9b
mov    %rax,-0x40(%rsp)
cmp    %rax,%r15
seta   -0x61(%rsp)
lea    (%rbx,%r14,8),%rbp
cmp    %rsi,%rbp
seta   %r11b
mov    %rbx,-0x50(%rsp)
cmp    %rbx,%r15
seta   -0x62(%rsp)
lea    (%rdx,%r14,8),%rbp
cmp    %rsi,%rbp
mov    %r13,%rbx
seta   %r13b
mov    %rdx,-0x48(%rsp)
cmp    %rdx,%r15
seta   -0x63(%rsp)
lea    (%rdi,%r14,8),%rbp
cmp    %rsi,%rbp
seta   %al
cmp    %rdi,%r15
seta   -0x64(%rsp)
lea    (%rbx,%r14,8),%rbp
cmp    %rsi,%rbp
seta   %bpl
mov    %rbx,%r14
cmp    %rbx,%r15
seta   %r15b
mov    -0x28(%rsp),%bl
test   %bl,-0x38(%rsp)
jne    1449 <of_add_from_multiple_symbols+0x349>
and    -0x8(%rsp),%cl
jne    1449 <of_add_from_multiple_symbols+0x349>
and    -0x10(%rsp),%r8b
jne    1449 <of_add_from_multiple_symbols+0x349>
and    -0x61(%rsp),%r9b
jne    1449 <of_add_from_multiple_symbols+0x349>
and    -0x62(%rsp),%r11b
jne    1449 <of_add_from_multiple_symbols+0x349>
and    -0x63(%rsp),%r13b
jne    1449 <of_add_from_multiple_symbols+0x349>
and    -0x64(%rsp),%al
mov    -0x40(%rsp),%rax
jne    1437 <of_add_from_multiple_symbols+0x337>
and    %r15b,%bpl
jne    1437 <of_add_from_multiple_symbols+0x337>
mov    -0x58(%rsp),%rbx
mov    %r12,%rdx
mov    0x18(%rsp),%rbp
lea    (%r14,%rbp,8),%rcx
mov    %rcx,-0x38(%rsp)
lea    (%rdi,%rbp,8),%rcx
mov    %rcx,-0x8(%rsp)
mov    -0x48(%rsp),%r13
lea    0x0(%r13,%rbp,8),%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x50(%rsp),%r12
lea    (%r12,%rbp,8),%rcx
mov    %rcx,-0x10(%rsp)
lea    (%rax,%rbp,8),%r9
lea    (%rdx,%rbp,8),%r11
lea    (%r10,%rbp,8),%r8
lea    (%rbx,%rbp,8),%r15
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rcx,8),%xmm0
movups (%r10,%rcx,8),%xmm1
xorps  %xmm0,%xmm1
movups (%rdx,%rcx,8),%xmm0
movups (%rax,%rcx,8),%xmm2
xorps  %xmm0,%xmm2
xorps  %xmm1,%xmm2
movups (%r12,%rcx,8),%xmm0
movups 0x0(%r13,%rcx,8),%xmm1
xorps  %xmm0,%xmm1
movups (%rdi,%rcx,8),%xmm0
xorps  %xmm1,%xmm0
xorps  %xmm2,%xmm0
movups (%r14,%rcx,8),%xmm1
movups (%rsi,%rcx,8),%xmm2
xorps  %xmm1,%xmm2
xorps  %xmm0,%xmm2
movups %xmm2,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbp
jne    13a0 <of_add_from_multiple_symbols+0x2a0>
mov    0x10(%rsp),%rcx
mov    0x4(%rsp),%eax
cmp    %rbp,0x8(%rsp)
mov    -0x70(%rsp),%r12d
mov    -0x38(%rsp),%r13
mov    -0x8(%rsp),%rdi
mov    -0x28(%rsp),%rbp
mov    -0x10(%rsp),%r14
jne    1473 <of_add_from_multiple_symbols+0x373>
jmp    14ca <of_add_from_multiple_symbols+0x3ca>
mov    %rbx,%r14
mov    %rdx,%rbp
mov    %r12,%r11
mov    %r8,%rdx
mov    %r10,%r8
mov    %rax,%r15
mov    -0x78(%rsp),%rcx
mov    %edx,%eax
jmp    146e <of_add_from_multiple_symbols+0x36e>
mov    %r14,%r13
mov    -0x48(%rsp),%rbp
mov    -0x50(%rsp),%r14
mov    %rax,%r9
jmp    145b <of_add_from_multiple_symbols+0x35b>
mov    %r14,%r13
mov    -0x48(%rsp),%rbp
mov    -0x50(%rsp),%r14
mov    -0x40(%rsp),%r9
mov    %r12,%r11
mov    %r10,%r8
mov    -0x58(%rsp),%r15
mov    %rsi,%rcx
mov    -0x60(%rsp),%rax
mov    -0x70(%rsp),%r12d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r8,%rdx,1),%rsi
xor    (%r15,%rdx,1),%rsi
xor    (%r11,%rdx,1),%rsi
xor    (%r9,%rdx,1),%rsi
xor    (%r14,%rdx,1),%rsi
xor    0x0(%rbp,%rdx,1),%rsi
xor    (%rdi,%rdx,1),%rsi
xor    0x0(%r13,%rdx,1),%rsi
xor    %rsi,(%rcx,%rdx,1)
add    $0x8,%rdx
add    $0xffffffff,%eax
jne    1480 <of_add_from_multiple_symbols+0x380>
add    %rdx,%r13
add    %rdx,%rdi
add    %rdx,%rbp
add    %rdx,%r14
add    %rdx,%r9
add    %rdx,%r11
add    %rdx,%r8
add    %rdx,%r15
add    %rdx,%rcx
mov    -0x20(%rsp),%eax
cmp    -0x2c(%rsp),%eax
jae    1512 <of_add_from_multiple_symbols+0x412>
mov    (%r8),%eax
xor    (%r15),%eax
xor    (%r11),%eax
xor    (%r9),%eax
xor    (%r14),%eax
xor    0x0(%rbp),%eax
xor    (%rdi),%eax
xor    0x0(%r13),%eax
xor    %eax,(%rcx)
add    $0x4,%r15
add    $0x4,%r8
add    $0x4,%r11
add    $0x4,%r9
add    $0x4,%r14
add    $0x4,%rbp
add    $0x4,%rdi
add    $0x4,%r13
add    $0x4,%rcx
mov    -0x7c(%rsp),%ebx
add    $0xfffffff8,%r12d
test   %ebx,%ebx
je     11a0 <of_add_from_multiple_symbols+0xa0>
mov    (%r8),%al
xor    (%r15),%al
xor    (%r11),%al
xor    (%r9),%al
xor    (%r14),%al
xor    0x0(%rbp),%al
xor    (%rdi),%al
xor    0x0(%r13),%al
xor    %al,(%rcx)
cmp    $0x1,%ebx
je     11a0 <of_add_from_multiple_symbols+0xa0>
mov    0x1(%r8),%al
xor    0x1(%r15),%al
xor    0x1(%r11),%al
xor    0x1(%r9),%al
xor    0x1(%r14),%al
xor    0x1(%rbp),%al
xor    0x1(%rdi),%al
xor    0x1(%r13),%al
xor    %al,0x1(%rcx)
cmp    $0x2,%ebx
je     11a0 <of_add_from_multiple_symbols+0xa0>
mov    0x2(%r8),%al
xor    0x2(%r15),%al
xor    0x2(%r11),%al
xor    0x2(%r9),%al
xor    0x2(%r14),%al
xor    0x2(%rbp),%al
xor    0x2(%rdi),%al
xor    0x2(%r13),%al
xor    %al,0x2(%rcx)
jmp    11a0 <of_add_from_multiple_symbols+0xa0>
mov    %eax,%edi
cmp    $0x4,%edi
jb     18ec <of_add_from_multiple_symbols+0x7ec>
lea    (%r8,%r8,1),%r9d
lea    -0x1(%r8),%r14d
mov    -0x78(%rsp),%rax
lea    (%rax,%r14,8),%rcx
add    $0x8,%rcx
mov    %rcx,-0x20(%rsp)
lea    0x1(%r14),%rdx
mov    %rbp,%rcx
mov    %rdx,-0x70(%rsp)
mov    %rdx,%r15
and    %rbp,%r15
lea    (%rax,%r15,8),%rax
mov    %rax,-0x50(%rsp)
mov    %r8d,%eax
sub    %r15d,%eax
mov    %eax,-0x58(%rsp)
mov    %r9d,-0x38(%rsp)
mov    %r14,-0x28(%rsp)
mov    %r15,-0x40(%rsp)
jmp    1604 <of_add_from_multiple_symbols+0x504>
mov    %esi,%ebx
mov    -0x18(%rsp),%rsi
add    $0x20,%rsi
cmp    $0x3,%edi
jbe    18ec <of_add_from_multiple_symbols+0x7ec>
mov    %edi,%r11d
mov    (%rsi),%rdx
mov    0x8(%rsi),%rdi
mov    0x10(%rsi),%rax
mov    0x18(%rsi),%r13
cmpl   $0x8,-0x30(%rsp)
mov    %rsi,-0x18(%rsp)
jae    1640 <of_add_from_multiple_symbols+0x540>
mov    -0x78(%rsp),%rbx
mov    %rdx,%rbp
mov    %rdi,%rcx
mov    %rax,%r12
mov    %r13,%r10
mov    -0x7c(%rsp),%esi
mov    %r11d,%edi
jmp    183a <of_add_from_multiple_symbols+0x73a>
nop
cmp    $0x3,%r14d
jae    1660 <of_add_from_multiple_symbols+0x560>
mov    %r13,%r10
mov    %rax,%r12
mov    %rdi,%rcx
mov    %rdx,%rbp
mov    -0x78(%rsp),%rbx
jmp    17af <of_add_from_multiple_symbols+0x6af>
nopl   0x0(%rax)
mov    -0x70(%rsp),%rbp
lea    (%rdx,%rbp,8),%rcx
mov    -0x78(%rsp),%rsi
cmp    %rsi,%rcx
seta   %r14b
mov    -0x20(%rsp),%r15
cmp    %rdx,%r15
seta   %r8b
lea    (%rdi,%rbp,8),%rcx
cmp    %rsi,%rcx
seta   %cl
cmp    %rdi,%r15
seta   %r9b
lea    (%rax,%rbp,8),%rbx
cmp    %rsi,%rbx
seta   %bl
cmp    %rax,%r15
seta   %r12b
lea    0x0(,%rbp,8),%rbp
add    %r13,%rbp
cmp    %rsi,%rbp
seta   %r10b
cmp    %r13,%r15
seta   %bpl
test   %r8b,%r14b
jne    18b7 <of_add_from_multiple_symbols+0x7b7>
and    %r9b,%cl
jne    18b7 <of_add_from_multiple_symbols+0x7b7>
and    %r12b,%bl
mov    -0x60(%rsp),%r8
mov    -0x38(%rsp),%r9d
mov    -0x28(%rsp),%r14
mov    -0x40(%rsp),%r15
jne    17a0 <of_add_from_multiple_symbols+0x6a0>
and    %bpl,%r10b
jne    17a0 <of_add_from_multiple_symbols+0x6a0>
lea    0x0(,%r15,8),%r10
add    %r13,%r10
lea    (%rax,%r15,8),%r12
lea    (%rdi,%r15,8),%rcx
lea    (%rdx,%r15,8),%rbp
xor    %ebx,%ebx
nopl   (%rax)
movups (%rdx,%rbx,8),%xmm0
movups 0x10(%rdx,%rbx,8),%xmm1
movups (%rdi,%rbx,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdi,%rbx,8),%xmm0
xorps  %xmm1,%xmm0
movups (%rax,%rbx,8),%xmm1
movups 0x10(%rax,%rbx,8),%xmm3
movups 0x0(%r13,%rbx,8),%xmm4
xorps  %xmm1,%xmm4
xorps  %xmm2,%xmm4
movups 0x10(%r13,%rbx,8),%xmm1
xorps  %xmm3,%xmm1
xorps  %xmm0,%xmm1
movups (%rsi,%rbx,8),%xmm0
xorps  %xmm4,%xmm0
movups 0x10(%rsi,%rbx,8),%xmm2
xorps  %xmm1,%xmm2
movups %xmm0,(%rsi,%rbx,8)
movups %xmm2,0x10(%rsi,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r15
jne    1710 <of_add_from_multiple_symbols+0x610>
mov    -0x50(%rsp),%rbx
mov    -0x58(%rsp),%eax
cmp    %r15,-0x70(%rsp)
mov    -0x7c(%rsp),%esi
mov    %r11d,%edi
je     183a <of_add_from_multiple_symbols+0x73a>
cs nopw 0x0(%rax,%rax,1)
nop
test   $0x1,%al
jne    17bd <of_add_from_multiple_symbols+0x6bd>
mov    %eax,%edx
cmp    $0x1,%eax
jne    17ea <of_add_from_multiple_symbols+0x6ea>
jmp    183a <of_add_from_multiple_symbols+0x73a>
mov    %r13,%r10
mov    %rax,%r12
mov    %rdi,%rcx
mov    %rdx,%rbp
mov    %rsi,%rbx
mov    %r8d,%eax
mov    -0x7c(%rsp),%esi
mov    %r11d,%edi
test   $0x1,%al
je     1794 <of_add_from_multiple_symbols+0x694>
mov    (%rcx),%rdx
xor    0x0(%rbp),%rdx
xor    (%r12),%rdx
xor    (%r10),%rdx
xor    %rdx,(%rbx)
add    $0x8,%rbx
add    $0x8,%rbp
add    $0x8,%rcx
add    $0x8,%r12
add    $0x8,%r10
lea    -0x1(%rax),%edx
cmp    $0x1,%eax
je     183a <of_add_from_multiple_symbols+0x73a>
xor    %eax,%eax
nopl   0x0(%rax)
mov    (%rcx,%rax,1),%rsi
xor    0x0(%rbp,%rax,1),%rsi
xor    (%r12,%rax,1),%rsi
xor    (%r10,%rax,1),%rsi
xor    %rsi,(%rbx,%rax,1)
mov    0x8(%rcx,%rax,1),%rsi
xor    0x8(%rbp,%rax,1),%rsi
xor    0x8(%r12,%rax,1),%rsi
xor    0x8(%r10,%rax,1),%rsi
xor    %rsi,0x8(%rbx,%rax,1)
add    $0x10,%rax
add    $0xfffffffe,%edx
jne    17f0 <of_add_from_multiple_symbols+0x6f0>
add    %rax,%r10
add    %rax,%r12
add    %rax,%rcx
add    %rax,%rbp
add    %rax,%rbx
mov    -0x7c(%rsp),%esi
cmp    -0x2c(%rsp),%r9d
jae    1863 <of_add_from_multiple_symbols+0x763>
mov    (%rcx),%eax
xor    0x0(%rbp),%eax
xor    (%r12),%eax
xor    (%r10),%eax
xor    %eax,(%rbx)
add    $0x4,%rbp
add    $0x4,%rcx
add    $0x4,%r12
add    $0x4,%r10
add    $0x4,%rbx
add    $0xfffffffc,%edi
test   %esi,%esi
je     15f0 <of_add_from_multiple_symbols+0x4f0>
mov    (%rcx),%al
xor    0x0(%rbp),%al
xor    (%r12),%al
xor    (%r10),%al
xor    %al,(%rbx)
cmp    $0x1,%esi
je     15f0 <of_add_from_multiple_symbols+0x4f0>
mov    0x1(%rcx),%al
xor    0x1(%rbp),%al
xor    0x1(%r12),%al
xor    0x1(%r10),%al
xor    %al,0x1(%rbx)
cmp    $0x2,%esi
je     15f0 <of_add_from_multiple_symbols+0x4f0>
mov    0x2(%rcx),%al
xor    0x2(%rbp),%al
xor    0x2(%r12),%al
xor    0x2(%r10),%al
xor    %al,0x2(%rbx)
jmp    15f0 <of_add_from_multiple_symbols+0x4f0>
mov    %r13,%r10
mov    %rax,%r12
mov    %rdi,%rcx
mov    %rdx,%rbp
mov    %rsi,%rbx
mov    -0x60(%rsp),%r8
mov    %r8d,%eax
mov    -0x7c(%rsp),%esi
mov    %r11d,%edi
mov    -0x38(%rsp),%r9d
mov    -0x28(%rsp),%r14
test   $0x1,%al
je     1794 <of_add_from_multiple_symbols+0x694>
jmp    17bd <of_add_from_multiple_symbols+0x6bd>
cmp    $0x2,%edi
jb     1ba1 <of_add_from_multiple_symbols+0xaa1>
lea    (%r8,%r8,1),%r11d
lea    -0x1(%r8),%r15d
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r15,8),%r9
add    $0x8,%r9
lea    0x1(%r15),%r10
mov    %r10,%r13
movabs $0x1fffffffc,%rax
and    %rax,%r13
lea    -0x4(%r13),%r14
mov    %r14,-0x18(%rsp)
shr    $0x2,%r14
add    $0x1,%r14
lea    (%rcx,%r13,8),%rax
mov    %rax,-0x70(%rsp)
mov    %r8d,%eax
sub    %r13d,%eax
mov    %eax,-0x20(%rsp)
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x38(%rsp)
jmp    1960 <of_add_from_multiple_symbols+0x860>
mov    %r12,%rsi
add    $0x10,%rsi
cmp    $0x1,%edi
jbe    1ba1 <of_add_from_multiple_symbols+0xaa1>
mov    (%rsi),%rcx
mov    %rsi,%r12
mov    0x8(%rsi),%rbp
cmpl   $0x8,-0x30(%rsp)
jae    1980 <of_add_from_multiple_symbols+0x880>
mov    -0x78(%rsp),%rdx
jmp    1b37 <of_add_from_multiple_symbols+0xa37>
nopl   0x0(%rax,%rax,1)
cmp    $0x3,%r15d
jb     1ac0 <of_add_from_multiple_symbols+0x9c0>
lea    (%rcx,%r10,8),%rdx
mov    -0x78(%rsp),%rsi
cmp    %rsi,%rdx
seta   %al
cmp    %rcx,%r9
seta   %bl
lea    0x0(,%r10,8),%rdx
add    %rbp,%rdx
cmp    %rsi,%rdx
seta   %dl
cmp    %rbp,%r9
seta   %sil
test   %bl,%al
jne    1ac0 <of_add_from_multiple_symbols+0x9c0>
and    %sil,%dl
jne    1ac0 <of_add_from_multiple_symbols+0x9c0>
cmpq   $0x0,-0x18(%rsp)
je     1b90 <of_add_from_multiple_symbols+0xa90>
mov    -0x38(%rsp),%rsi
xor    %edx,%edx
mov    -0x78(%rsp),%rax
movups (%rcx,%rdx,8),%xmm0
movups 0x10(%rcx,%rdx,8),%xmm1
movups 0x0(%rbp,%rdx,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbp,%rdx,8),%xmm0
xorps  %xmm1,%xmm0
movups (%rax,%rdx,8),%xmm1
xorps  %xmm2,%xmm1
movups 0x10(%rax,%rdx,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x20(%rax,%rdx,8),%xmm0
movups 0x30(%rax,%rdx,8),%xmm3
movups %xmm1,(%rax,%rdx,8)
movups %xmm2,0x10(%rax,%rdx,8)
movups 0x20(%rcx,%rdx,8),%xmm1
movups 0x30(%rcx,%rdx,8),%xmm2
movups 0x20(%rbp,%rdx,8),%xmm4
xorps  %xmm1,%xmm4
xorps  %xmm0,%xmm4
movups 0x30(%rbp,%rdx,8),%xmm0
xorps  %xmm2,%xmm0
xorps  %xmm3,%xmm0
movups %xmm4,0x20(%rax,%rdx,8)
movups %xmm0,0x30(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    19e0 <of_add_from_multiple_symbols+0x8e0>
test   $0x1,%r14b
je     1a8b <of_add_from_multiple_symbols+0x98b>
movups (%rcx,%rdx,8),%xmm0
movups 0x10(%rcx,%rdx,8),%xmm1
movups 0x0(%rbp,%rdx,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbp,%rdx,8),%xmm0
xorps  %xmm1,%xmm0
mov    -0x78(%rsp),%rax
movups (%rax,%rdx,8),%xmm1
xorps  %xmm2,%xmm1
movups 0x10(%rax,%rdx,8),%xmm2
xorps  %xmm0,%xmm2
movups %xmm1,(%rax,%rdx,8)
movups %xmm2,0x10(%rax,%rdx,8)
lea    0x0(%rbp,%r13,8),%rbp
lea    (%rcx,%r13,8),%rcx
mov    -0x70(%rsp),%rdx
mov    -0x20(%rsp),%eax
mov    %eax,%esi
cmp    %r13,%r10
je     1b37 <of_add_from_multiple_symbols+0xa37>
nopl   0x0(%rax,%rax,1)
test   $0x1,%sil
jne    1ace <of_add_from_multiple_symbols+0x9ce>
mov    %esi,%ebx
cmp    $0x1,%esi
jne    1aec <of_add_from_multiple_symbols+0x9ec>
jmp    1b37 <of_add_from_multiple_symbols+0xa37>
nop
mov    -0x78(%rsp),%rdx
mov    %r8d,%esi
test   $0x1,%sil
je     1ab6 <of_add_from_multiple_symbols+0x9b6>
mov    0x0(%rbp),%rax
xor    (%rcx),%rax
xor    %rax,(%rdx)
add    $0x8,%rdx
add    $0x8,%rcx
add    $0x8,%rbp
lea    -0x1(%rsi),%ebx
cmp    $0x1,%esi
je     1b37 <of_add_from_multiple_symbols+0xa37>
mov    %ebx,%r8d
xor    %ebx,%ebx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%rbp,%rbx,8),%rax
xor    (%rcx,%rbx,8),%rax
xor    %rax,(%rdx,%rbx,8)
mov    0x8(%rbp,%rbx,8),%rax
xor    0x8(%rcx,%rbx,8),%rax
xor    %rax,0x8(%rdx,%rbx,8)
add    $0xfffffffffffffff0,%rsi
add    $0x2,%rbx
cmp    %ebx,%r8d
jne    1b00 <of_add_from_multiple_symbols+0xa00>
sub    %rsi,%rbp
sub    %rsi,%rcx
sub    %rsi,%rdx
mov    -0x60(%rsp),%r8
cmp    -0x2c(%rsp),%r11d
jae    1b51 <of_add_from_multiple_symbols+0xa51>
mov    0x0(%rbp),%eax
xor    (%rcx),%eax
xor    %eax,(%rdx)
add    $0x4,%rcx
add    $0x4,%rbp
add    $0x4,%rdx
mov    -0x7c(%rsp),%ebx
add    $0xfffffffe,%edi
test   %ebx,%ebx
je     1950 <of_add_from_multiple_symbols+0x850>
mov    0x0(%rbp),%al
xor    (%rcx),%al
xor    %al,(%rdx)
cmp    $0x1,%ebx
je     1950 <of_add_from_multiple_symbols+0x850>
mov    0x1(%rbp),%al
xor    0x1(%rcx),%al
xor    %al,0x1(%rdx)
cmp    $0x2,%ebx
je     1950 <of_add_from_multiple_symbols+0x850>
mov    0x2(%rbp),%al
xor    0x2(%rcx),%al
xor    %al,0x2(%rdx)
jmp    1950 <of_add_from_multiple_symbols+0x850>
xor    %edx,%edx
test   $0x1,%r14b
jne    1a55 <of_add_from_multiple_symbols+0x955>
jmp    1a8b <of_add_from_multiple_symbols+0x98b>
test   %edi,%edi
je     1d97 <of_add_from_multiple_symbols+0xc97>
mov    (%rsi),%rax
cmpl   $0x8,-0x30(%rsp)
jae    1bbd <of_add_from_multiple_symbols+0xabd>
mov    -0x78(%rsp),%rsi
jmp    1d63 <of_add_from_multiple_symbols+0xc63>
lea    -0x1(%r8),%ecx
cmp    $0x3,%ecx
jb     1bed <of_add_from_multiple_symbols+0xaed>
lea    (%rax,%rcx,8),%rdx
add    $0x8,%rdx
mov    -0x78(%rsp),%rsi
cmp    %rsi,%rdx
jbe    1c94 <of_add_from_multiple_symbols+0xb94>
lea    (%rsi,%rcx,8),%rdx
add    $0x8,%rdx
cmp    %rax,%rdx
jbe    1c94 <of_add_from_multiple_symbols+0xb94>
mov    %r8d,%ebp
lea    -0x1(%rbp),%edx
test   $0x3,%bpl
je     1c39 <of_add_from_multiple_symbols+0xb39>
mov    %ebp,%ecx
and    $0x3,%ecx
xor    %esi,%esi
mov    -0x78(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rax),%rbx
xor    %rbx,(%rdi)
add    $0x8,%rdi
add    $0x8,%rax
add    $0x1,%rsi
cmp    %esi,%ecx
jne    1c10 <of_add_from_multiple_symbols+0xb10>
sub    %esi,%ebp
mov    -0x7c(%rsp),%ebx
mov    %rdi,%rsi
cmp    $0x3,%edx
jae    1c47 <of_add_from_multiple_symbols+0xb47>
jmp    1d63 <of_add_from_multiple_symbols+0xc63>
mov    -0x78(%rsp),%rsi
cmp    $0x3,%edx
jb     1d63 <of_add_from_multiple_symbols+0xc63>
mov    %ebp,%ecx
mov    %rsi,%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    (%rax,%rsi,8),%rbp
xor    %rbp,(%rdi,%rsi,8)
mov    0x8(%rax,%rsi,8),%rbp
xor    %rbp,0x8(%rdi,%rsi,8)
mov    0x10(%rax,%rsi,8),%rbp
xor    %rbp,0x10(%rdi,%rsi,8)
mov    0x18(%rax,%rsi,8),%rbp
xor    %rbp,0x18(%rdi,%rsi,8)
add    $0xffffffffffffffe0,%rdx
add    $0x4,%rsi
cmp    %esi,%ecx
jne    1c50 <of_add_from_multiple_symbols+0xb50>
sub    %rdx,%rax
sub    %rdx,%rdi
mov    -0x7c(%rsp),%ebx
mov    %rdi,%rsi
jmp    1d63 <of_add_from_multiple_symbols+0xc63>
add    $0x1,%rcx
movabs $0x1fffffffc,%r9
and    %rcx,%r9
lea    -0x4(%r9),%rdx
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     1d21 <of_add_from_multiple_symbols+0xc21>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
mov    -0x78(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movups (%rax,%rdx,8),%xmm0
movups 0x10(%rax,%rdx,8),%xmm1
movups (%rdi,%rdx,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdi,%rdx,8),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%rdi,%rdx,8),%xmm1
movups 0x30(%rdi,%rdx,8),%xmm3
movups %xmm2,(%rdi,%rdx,8)
movups %xmm0,0x10(%rdi,%rdx,8)
movups 0x20(%rax,%rdx,8),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%rax,%rdx,8),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rdi,%rdx,8)
movups %xmm1,0x30(%rdi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1cd0 <of_add_from_multiple_symbols+0xbd0>
jmp    1d28 <of_add_from_multiple_symbols+0xc28>
xor    %edx,%edx
mov    -0x78(%rsp),%rdi
test   $0x1,%bpl
mov    -0x7c(%rsp),%ebx
mov    %rdi,%rsi
je     1d56 <of_add_from_multiple_symbols+0xc56>
movups (%rax,%rdx,8),%xmm0
movups 0x10(%rax,%rdx,8),%xmm1
movups (%rsi,%rdx,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rsi,%rdx,8),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rsi,%rdx,8)
movups %xmm0,0x10(%rsi,%rdx,8)
lea    (%rax,%r9,8),%rax
lea    (%rsi,%r9,8),%rsi
cmp    %r9,%rcx
jne    1da6 <of_add_from_multiple_symbols+0xca6>
add    %r8d,%r8d
cmp    -0x2c(%rsp),%r8d
jae    1d79 <of_add_from_multiple_symbols+0xc79>
mov    (%rax),%ecx
xor    %ecx,(%rsi)
add    $0x4,%rsi
add    $0x4,%rax
test   %ebx,%ebx
je     1d97 <of_add_from_multiple_symbols+0xc97>
mov    (%rax),%cl
xor    %cl,(%rsi)
cmp    $0x1,%ebx
je     1d97 <of_add_from_multiple_symbols+0xc97>
mov    0x1(%rax),%cl
xor    %cl,0x1(%rsi)
cmp    $0x2,%ebx
je     1d97 <of_add_from_multiple_symbols+0xc97>
mov    0x2(%rax),%al
xor    %al,0x2(%rsi)
add    $0x30,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rsi,-0x78(%rsp)
mov    %r8d,%ebp
sub    %r9d,%ebp
jmp    1bf0 <of_add_from_multiple_symbols+0xaf0>

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

LLVM IR (-O2):
define void @of_add_from_multiple_symbols(i8* nocapture %0, i8** nocapture %1, i32 %2, i32 %3) {
%5 = lshr i32 %3, 2
%6 = and i32 %3, 3
%7 = lshr i32 %3, 3
%8 = icmp ugt i32 %2, 7
br i1 %8, label %9, label %32
9: ; preds = %4
%10 = bitcast i8* %0 to i64*
%11 = icmp ult i32 %3, 8
%12 = shl nuw nsw i32 %7, 1
%13 = icmp ult i32 %12, %5
%14 = icmp eq i32 %6, 0
%15 = add nsw i32 %7, -1
%16 = zext i32 %15 to i64
%17 = shl nuw nsw i64 %16, 3
%18 = add nuw nsw i64 %17, 8
%19 = getelementptr i8, i8* %0, i64 %18
%20 = add nuw nsw i64 %16, 1
%21 = add nsw i32 %7, -1
%22 = zext i32 %21 to i64
%23 = add nuw nsw i64 %22, 1
%24 = icmp eq i32 %21, 0
%25 = and i64 %23, 8589934590
%26 = getelementptr i64, i64* %10, i64 %25
%27 = trunc i64 %25 to i32
%28 = sub i32 %7, %27
%29 = icmp eq i64 %23, %25
%30 = icmp eq i32 %6, 1
%31 = icmp eq i32 %6, 2
br label %59
32: ; preds = %381, %4
%33 = phi i32 [ %2, %4 ], [ %93, %381 ]
%34 = phi i8** [ %1, %4 ], [ %94, %381 ]
%35 = icmp ugt i32 %33, 3
br i1 %35, label %36, label %383
36: ; preds = %32
%37 = bitcast i8* %0 to i64*
%38 = icmp ult i32 %3, 8
%39 = shl nuw nsw i32 %7, 1
%40 = icmp ult i32 %39, %5
%41 = icmp eq i32 %6, 0
%42 = add nsw i32 %7, -1
%43 = zext i32 %42 to i64
%44 = shl nuw nsw i64 %43, 3
%45 = add nuw nsw i64 %44, 8
%46 = getelementptr i8, i8* %0, i64 %45
%47 = add nuw nsw i64 %43, 1
%48 = add nsw i32 %7, -1
%49 = zext i32 %48 to i64
%50 = add nuw nsw i64 %49, 1
%51 = icmp ult i32 %48, 3
%52 = and i64 %50, 8589934588
%53 = getelementptr i64, i64* %37, i64 %52
%54 = trunc i64 %52 to i32
%55 = sub i32 %7, %54
%56 = icmp eq i64 %50, %52
%57 = icmp eq i32 %6, 1
%58 = icmp eq i32 %6, 2
br label %418
59: ; preds = %9, %381
%60 = phi i8** [ %1, %9 ], [ %94, %381 ]
%61 = phi i32 [ %2, %9 ], [ %93, %381 ]
%62 = bitcast i8** %60 to i64**
%63 = load i64*, i64** %62
%64 = bitcast i64* %63 to i8*
%65 = getelementptr inbounds i8*, i8** %60, i64 1
%66 = bitcast i8** %65 to i64**
%67 = load i64*, i64** %66
%68 = bitcast i64* %67 to i8*
%69 = getelementptr inbounds i8*, i8** %60, i64 2
%70 = bitcast i8** %69 to i64**
%71 = load i64*, i64** %70
%72 = bitcast i64* %71 to i8*
%73 = getelementptr inbounds i8*, i8** %60, i64 3
%74 = bitcast i8** %73 to i64**
%75 = load i64*, i64** %74
%76 = bitcast i64* %75 to i8*
%77 = getelementptr inbounds i8*, i8** %60, i64 4
%78 = bitcast i8** %77 to i64**
%79 = load i64*, i64** %78
%80 = bitcast i64* %79 to i8*
%81 = getelementptr inbounds i8*, i8** %60, i64 5
%82 = bitcast i8** %81 to i64**
%83 = load i64*, i64** %82
%84 = bitcast i64* %83 to i8*
%85 = getelementptr inbounds i8*, i8** %60, i64 6
%86 = bitcast i8** %85 to i64**
%87 = load i64*, i64** %86
%88 = bitcast i64* %87 to i8*
%89 = getelementptr inbounds i8*, i8** %60, i64 7
%90 = bitcast i8** %89 to i64**
%91 = load i64*, i64** %90
%92 = bitcast i64* %91 to i8*
%93 = add i32 %61, -8
%94 = getelementptr inbounds i8*, i8** %60, i64 8
br i1 %11, label %244, label %95
95: ; preds = %59
br i1 %24, label %194, label %96
96: ; preds = %95
%97 = getelementptr i64, i64* %63, i64 %20
%98 = bitcast i64* %97 to i8*
%99 = getelementptr i64, i64* %67, i64 %20
%100 = bitcast i64* %99 to i8*
%101 = getelementptr i64, i64* %71, i64 %20
%102 = bitcast i64* %101 to i8*
%103 = getelementptr i64, i64* %75, i64 %20
%104 = bitcast i64* %103 to i8*
%105 = getelementptr i64, i64* %79, i64 %20
%106 = bitcast i64* %105 to i8*
%107 = getelementptr i64, i64* %83, i64 %20
%108 = bitcast i64* %107 to i8*
%109 = getelementptr i64, i64* %87, i64 %20
%110 = bitcast i64* %109 to i8*
%111 = getelementptr i64, i64* %91, i64 %20
%112 = bitcast i64* %111 to i8*
%113 = icmp ugt i8* %98, %0
%114 = icmp ugt i8* %19, %64
%115 = and i1 %113, %114
%116 = icmp ugt i8* %100, %0
%117 = icmp ugt i8* %19, %68
%118 = and i1 %116, %117
%119 = or i1 %115, %118
%120 = icmp ugt i8* %102, %0
%121 = icmp ugt i8* %19, %72
%122 = and i1 %120, %121
%123 = or i1 %119, %122
%124 = icmp ugt i8* %104, %0
%125 = icmp ugt i8* %19, %76
%126 = and i1 %124, %125
%127 = or i1 %123, %126
%128 = icmp ugt i8* %106, %0
%129 = icmp ugt i8* %19, %80
%130 = and i1 %128, %129
%131 = or i1 %127, %130
%132 = icmp ugt i8* %108, %0
%133 = icmp ugt i8* %19, %84
%134 = and i1 %132, %133
%135 = or i1 %131, %134
%136 = icmp ugt i8* %110, %0
%137 = icmp ugt i8* %19, %88
%138 = and i1 %136, %137
%139 = or i1 %135, %138
%140 = icmp ugt i8* %112, %0
%141 = icmp ugt i8* %19, %92
%142 = and i1 %140, %141
%143 = or i1 %139, %142
br i1 %143, label %194, label %144
144: ; preds = %96
%145 = getelementptr i64, i64* %91, i64 %25
%146 = getelementptr i64, i64* %87, i64 %25
%147 = getelementptr i64, i64* %83, i64 %25
%148 = getelementptr i64, i64* %79, i64 %25
%149 = getelementptr i64, i64* %75, i64 %25
%150 = getelementptr i64, i64* %71, i64 %25
%151 = getelementptr i64, i64* %67, i64 %25
%152 = getelementptr i64, i64* %63, i64 %25
br label %153
153: ; preds = %153, %144
%154 = phi i64 [ 0, %144 ], [ %191, %153 ]
%155 = getelementptr i64, i64* %91, i64 %154
%156 = getelementptr i64, i64* %87, i64 %154
%157 = getelementptr i64, i64* %83, i64 %154
%158 = getelementptr i64, i64* %79, i64 %154
%159 = getelementptr i64, i64* %75, i64 %154
%160 = getelementptr i64, i64* %71, i64 %154
%161 = getelementptr i64, i64* %67, i64 %154
%162 = getelementptr i64, i64* %63, i64 %154
%163 = getelementptr i64, i64* %10, i64 %154
%164 = bitcast i64* %162 to <2 x i64>*
%165 = load <2 x i64>, <2 x i64>* %164
%166 = bitcast i64* %161 to <2 x i64>*
%167 = load <2 x i64>, <2 x i64>* %166
%168 = xor <2 x i64> %167, %165
%169 = bitcast i64* %160 to <2 x i64>*
%170 = load <2 x i64>, <2 x i64>* %169
%171 = xor <2 x i64> %168, %170
%172 = bitcast i64* %159 to <2 x i64>*
%173 = load <2 x i64>, <2 x i64>* %172
%174 = xor <2 x i64> %171, %173
%175 = bitcast i64* %158 to <2 x i64>*
%176 = load <2 x i64>, <2 x i64>* %175
%177 = xor <2 x i64> %174, %176
%178 = bitcast i64* %157 to <2 x i64>*
%179 = load <2 x i64>, <2 x i64>* %178
%180 = xor <2 x i64> %177, %179
%181 = bitcast i64* %156 to <2 x i64>*
%182 = load <2 x i64>, <2 x i64>* %181
%183 = xor <2 x i64> %180, %182
%184 = bitcast i64* %155 to <2 x i64>*
%185 = load <2 x i64>, <2 x i64>* %184
%186 = xor <2 x i64> %183, %185
%187 = bitcast i64* %163 to <2 x i64>*
%188 = load <2 x i64>, <2 x i64>* %187
%189 = xor <2 x i64> %186, %188
%190 = bitcast i64* %163 to <2 x i64>*
store <2 x i64> %189, <2 x i64>* %190
%191 = add nuw i64 %154, 2
%192 = icmp eq i64 %191, %25
br i1 %192, label %193, label %153
193: ; preds = %153
br i1 %29, label %244, label %194
194: ; preds = %96, %95, %193
%195 = phi i64* [ %91, %96 ], [ %91, %95 ], [ %145, %193 ]
%196 = phi i64* [ %87, %96 ], [ %87, %95 ], [ %146, %193 ]
%197 = phi i64* [ %83, %96 ], [ %83, %95 ], [ %147, %193 ]
%198 = phi i64* [ %79, %96 ], [ %79, %95 ], [ %148, %193 ]
%199 = phi i64* [ %75, %96 ], [ %75, %95 ], [ %149, %193 ]
%200 = phi i64* [ %71, %96 ], [ %71, %95 ], [ %150, %193 ]
%201 = phi i64* [ %67, %96 ], [ %67, %95 ], [ %151, %193 ]
%202 = phi i64* [ %63, %96 ], [ %63, %95 ], [ %152, %193 ]
%203 = phi i64* [ %10, %96 ], [ %10, %95 ], [ %26, %193 ]
%204 = phi i32 [ %7, %96 ], [ %7, %95 ], [ %28, %193 ]
br label %205
205: ; preds = %194, %205
%206 = phi i64* [ %241, %205 ], [ %195, %194 ]
%207 = phi i64* [ %240, %205 ], [ %196, %194 ]
%208 = phi i64* [ %239, %205 ], [ %197, %194 ]
%209 = phi i64* [ %238, %205 ], [ %198, %194 ]
%210 = phi i64* [ %237, %205 ], [ %199, %194 ]
%211 = phi i64* [ %236, %205 ], [ %200, %194 ]
%212 = phi i64* [ %235, %205 ], [ %201, %194 ]
%213 = phi i64* [ %234, %205 ], [ %202, %194 ]
%214 = phi i64* [ %233, %205 ], [ %203, %194 ]
%215 = phi i32 [ %242, %205 ], [ %204, %194 ]
%216 = load i64, i64* %213
%217 = load i64, i64* %212
%218 = xor i64 %217, %216
%219 = load i64, i64* %211
%220 = xor i64 %218, %219
%221 = load i64, i64* %210
%222 = xor i64 %220, %221
%223 = load i64, i64* %209
%224 = xor i64 %222, %223
%225 = load i64, i64* %208
%226 = xor i64 %224, %225
%227 = load i64, i64* %207
%228 = xor i64 %226, %227
%229 = load i64, i64* %206
%230 = xor i64 %228, %229
%231 = load i64, i64* %214
%232 = xor i64 %230, %231
store i64 %232, i64* %214
%233 = getelementptr inbounds i64, i64* %214, i64 1
%234 = getelementptr inbounds i64, i64* %213, i64 1
%235 = getelementptr inbounds i64, i64* %212, i64 1
%236 = getelementptr inbounds i64, i64* %211, i64 1
%237 = getelementptr inbounds i64, i64* %210, i64 1
%238 = getelementptr inbounds i64, i64* %209, i64 1
%239 = getelementptr inbounds i64, i64* %208, i64 1
%240 = getelementptr inbounds i64, i64* %207, i64 1
%241 = getelementptr inbounds i64, i64* %206, i64 1
%242 = add nsw i32 %215, -1
%243 = icmp eq i32 %242, 0
br i1 %243, label %244, label %205
244: ; preds = %205, %193, %59
%245 = phi i64* [ %10, %59 ], [ %26, %193 ], [ %233, %205 ]
%246 = phi i64* [ %63, %59 ], [ %152, %193 ], [ %234, %205 ]
%247 = phi i64* [ %67, %59 ], [ %151, %193 ], [ %235, %205 ]
%248 = phi i64* [ %71, %59 ], [ %150, %193 ], [ %236, %205 ]
%249 = phi i64* [ %75, %59 ], [ %149, %193 ], [ %237, %205 ]
%250 = phi i64* [ %79, %59 ], [ %148, %193 ], [ %238, %205 ]
%251 = phi i64* [ %83, %59 ], [ %147, %193 ], [ %239, %205 ]
%252 = phi i64* [ %87, %59 ], [ %146, %193 ], [ %240, %205 ]
%253 = phi i64* [ %91, %59 ], [ %145, %193 ], [ %241, %205 ]
%254 = bitcast i64* %245 to i32*
%255 = bitcast i64* %246 to i32*
%256 = bitcast i64* %247 to i32*
%257 = bitcast i64* %248 to i32*
%258 = bitcast i64* %249 to i32*
%259 = bitcast i64* %250 to i32*
%260 = bitcast i64* %251 to i32*
%261 = bitcast i64* %252 to i32*
%262 = bitcast i64* %253 to i32*
br i1 %13, label %263, label %290
263: ; preds = %244
%264 = load i32, i32* %255
%265 = load i32, i32* %256
%266 = xor i32 %265, %264
%267 = load i32, i32* %257
%268 = xor i32 %266, %267
%269 = load i32, i32* %258
%270 = xor i32 %268, %269
%271 = load i32, i32* %259
%272 = xor i32 %270, %271
%273 = load i32, i32* %260
%274 = xor i32 %272, %273
%275 = load i32, i32* %261
%276 = xor i32 %274, %275
%277 = load i32, i32* %262
%278 = xor i32 %276, %277
%279 = load i32, i32* %254
%280 = xor i32 %278, %279
store i32 %280, i32* %254
%281 = getelementptr inbounds i32, i32* %255, i64 1
%282 = getelementptr inbounds i32, i32* %256, i64 1
%283 = getelementptr inbounds i32, i32* %257, i64 1
%284 = getelementptr inbounds i32, i32* %258, i64 1
%285 = getelementptr inbounds i32, i32* %259, i64 1
%286 = getelementptr inbounds i32, i32* %260, i64 1
%287 = getelementptr inbounds i32, i32* %261, i64 1
%288 = getelementptr inbounds i32, i32* %262, i64 1
%289 = getelementptr inbounds i32, i32* %254, i64 1
br label %290
290: ; preds = %263, %244
%291 = phi i32* [ %289, %263 ], [ %254, %244 ]
%292 = phi i32* [ %281, %263 ], [ %255, %244 ]
%293 = phi i32* [ %282, %263 ], [ %256, %244 ]
%294 = phi i32* [ %283, %263 ], [ %257, %244 ]
%295 = phi i32* [ %284, %263 ], [ %258, %244 ]
%296 = phi i32* [ %285, %263 ], [ %259, %244 ]
%297 = phi i32* [ %286, %263 ], [ %260, %244 ]
%298 = phi i32* [ %287, %263 ], [ %261, %244 ]
%299 = phi i32* [ %288, %263 ], [ %262, %244 ]
br i1 %14, label %381, label %300
300: ; preds = %290
%301 = bitcast i32* %292 to i8*
%302 = bitcast i32* %293 to i8*
%303 = bitcast i32* %294 to i8*
%304 = bitcast i32* %295 to i8*
%305 = bitcast i32* %296 to i8*
%306 = bitcast i32* %297 to i8*
%307 = bitcast i32* %298 to i8*
%308 = bitcast i32* %299 to i8*
%309 = bitcast i32* %291 to i8*
%310 = load i8, i8* %301
%311 = load i8, i8* %302
%312 = xor i8 %311, %310
%313 = load i8, i8* %303
%314 = xor i8 %312, %313
%315 = load i8, i8* %304
%316 = xor i8 %314, %315
%317 = load i8, i8* %305
%318 = xor i8 %316, %317
%319 = load i8, i8* %306
%320 = xor i8 %318, %319
%321 = load i8, i8* %307
%322 = xor i8 %320, %321
%323 = load i8, i8* %308
%324 = xor i8 %322, %323
%325 = load i8, i8* %309
%326 = xor i8 %324, %325
store i8 %326, i8* %309
br i1 %30, label %381, label %327
327: ; preds = %300
%328 = getelementptr inbounds i8, i8* %301, i64 1
%329 = load i8, i8* %328
%330 = getelementptr inbounds i8, i8* %302, i64 1
%331 = load i8, i8* %330
%332 = xor i8 %331, %329
%333 = getelementptr inbounds i8, i8* %303, i64 1
%334 = load i8, i8* %333
%335 = xor i8 %332, %334
%336 = getelementptr inbounds i8, i8* %304, i64 1
%337 = load i8, i8* %336
%338 = xor i8 %335, %337
%339 = getelementptr inbounds i8, i8* %305, i64 1
%340 = load i8, i8* %339
%341 = xor i8 %338, %340
%342 = getelementptr inbounds i8, i8* %306, i64 1
%343 = load i8, i8* %342
%344 = xor i8 %341, %343
%345 = getelementptr inbounds i8, i8* %307, i64 1
%346 = load i8, i8* %345
%347 = xor i8 %344, %346
%348 = getelementptr inbounds i8, i8* %308, i64 1
%349 = load i8, i8* %348
%350 = xor i8 %347, %349
%351 = getelementptr inbounds i8, i8* %309, i64 1
%352 = load i8, i8* %351
%353 = xor i8 %350, %352
store i8 %353, i8* %351
br i1 %31, label %381, label %354
354: ; preds = %327
%355 = getelementptr inbounds i8, i8* %301, i64 2
%356 = load i8, i8* %355
%357 = getelementptr inbounds i8, i8* %302, i64 2
%358 = load i8, i8* %357
%359 = xor i8 %358, %356
%360 = getelementptr inbounds i8, i8* %303, i64 2
%361 = load i8, i8* %360
%362 = xor i8 %359, %361
%363 = getelementptr inbounds i8, i8* %304, i64 2
%364 = load i8, i8* %363
%365 = xor i8 %362, %364
%366 = getelementptr inbounds i8, i8* %305, i64 2
%367 = load i8, i8* %366
%368 = xor i8 %365, %367
%369 = getelementptr inbounds i8, i8* %306, i64 2
%370 = load i8, i8* %369
%371 = xor i8 %368, %370
%372 = getelementptr inbounds i8, i8* %307, i64 2
%373 = load i8, i8* %372
%374 = xor i8 %371, %373
%375 = getelementptr inbounds i8, i8* %308, i64 2
%376 = load i8, i8* %375
%377 = xor i8 %374, %376
%378 = getelementptr inbounds i8, i8* %309, i64 2
%379 = load i8, i8* %378
%380 = xor i8 %377, %379
store i8 %380, i8* %378
br label %381
381: ; preds = %300, %327, %354, %290
%382 = icmp ugt i32 %93, 7
br i1 %382, label %59, label %32
383: ; preds = %665, %32
%384 = phi i32 [ %33, %32 ], [ %436, %665 ]
%385 = phi i8** [ %34, %32 ], [ %437, %665 ]
%386 = icmp ugt i32 %384, 1
br i1 %386, label %387, label %876
387: ; preds = %383
%388 = bitcast i8* %0 to i64*
%389 = icmp ult i32 %3, 8
%390 = shl nuw nsw i32 %7, 1
%391 = icmp ult i32 %390, %5
%392 = icmp eq i32 %6, 0
%393 = add nsw i32 %7, -1
%394 = zext i32 %393 to i64
%395 = shl nuw nsw i64 %394, 3
%396 = add nuw nsw i64 %395, 8
%397 = getelementptr i8, i8* %0, i64 %396
%398 = add nuw nsw i64 %394, 1
%399 = add nsw i32 %7, -1
%400 = zext i32 %399 to i64
%401 = add nuw nsw i64 %400, 1
%402 = and i64 %401, 8589934588
%403 = add nsw i64 %402, -4
%404 = lshr exact i64 %403, 2
%405 = add nuw nsw i64 %404, 1
%406 = icmp ult i32 %399, 3
%407 = and i64 %401, 8589934588
%408 = getelementptr i64, i64* %388, i64 %407
%409 = trunc i64 %407 to i32
%410 = sub i32 %7, %409
%411 = and i64 %405, 1
%412 = icmp eq i64 %403, 0
%413 = and i64 %405, 9223372036854775806
%414 = icmp eq i64 %411, 0
%415 = icmp eq i64 %401, %407
%416 = icmp eq i32 %6, 1
%417 = icmp eq i32 %6, 2
br label %667
418: ; preds = %36, %665
%419 = phi i8** [ %34, %36 ], [ %437, %665 ]
%420 = phi i32 [ %33, %36 ], [ %436, %665 ]
%421 = bitcast i8** %419 to i64**
%422 = load i64*, i64** %421
%423 = bitcast i64* %422 to i8*
%424 = getelementptr inbounds i8*, i8** %419, i64 1
%425 = bitcast i8** %424 to i64**
%426 = load i64*, i64** %425
%427 = bitcast i64* %426 to i8*
%428 = getelementptr inbounds i8*, i8** %419, i64 2
%429 = bitcast i8** %428 to i64**
%430 = load i64*, i64** %429
%431 = bitcast i64* %430 to i8*
%432 = getelementptr inbounds i8*, i8** %419, i64 3
%433 = bitcast i8** %432 to i64**
%434 = load i64*, i64** %433
%435 = bitcast i64* %434 to i8*
%436 = add i32 %420, -4
%437 = getelementptr inbounds i8*, i8** %419, i64 4
br i1 %38, label %588, label %438
438: ; preds = %418
br i1 %51, label %513, label %439
439: ; preds = %438
%440 = getelementptr i64, i64* %422, i64 %47
%441 = bitcast i64* %440 to i8*
%442 = getelementptr i64, i64* %426, i64 %47
%443 = bitcast i64* %442 to i8*
%444 = getelementptr i64, i64* %430, i64 %47
%445 = bitcast i64* %444 to i8*
%446 = getelementptr i64, i64* %434, i64 %47
%447 = bitcast i64* %446 to i8*
%448 = icmp ugt i8* %441, %0
%449 = icmp ugt i8* %46, %423
%450 = and i1 %448, %449
%451 = icmp ugt i8* %443, %0
%452 = icmp ugt i8* %46, %427
%453 = and i1 %451, %452
%454 = or i1 %450, %453
%455 = icmp ugt i8* %445, %0
%456 = icmp ugt i8* %46, %431
%457 = and i1 %455, %456
%458 = or i1 %454, %457
%459 = icmp ugt i8* %447, %0
%460 = icmp ugt i8* %46, %435
%461 = and i1 %459, %460
%462 = or i1 %458, %461
br i1 %462, label %513, label %463
463: ; preds = %439
%464 = getelementptr i64, i64* %434, i64 %52
%465 = getelementptr i64, i64* %430, i64 %52
%466 = getelementptr i64, i64* %426, i64 %52
%467 = getelementptr i64, i64* %422, i64 %52
br label %468
468: ; preds = %468, %463
%469 = phi i64 [ 0, %463 ], [ %510, %468 ]
%470 = getelementptr i64, i64* %434, i64 %469
%471 = getelementptr i64, i64* %430, i64 %469
%472 = getelementptr i64, i64* %426, i64 %469
%473 = getelementptr i64, i64* %422, i64 %469
%474 = getelementptr i64, i64* %37, i64 %469
%475 = bitcast i64* %473 to <2 x i64>*
%476 = load <2 x i64>, <2 x i64>* %475
%477 = getelementptr i64, i64* %473, i64 2
%478 = bitcast i64* %477 to <2 x i64>*
%479 = load <2 x i64>, <2 x i64>* %478
%480 = bitcast i64* %472 to <2 x i64>*
%481 = load <2 x i64>, <2 x i64>* %480
%482 = getelementptr i64, i64* %472, i64 2
%483 = bitcast i64* %482 to <2 x i64>*
%484 = load <2 x i64>, <2 x i64>* %483
%485 = xor <2 x i64> %481, %476
%486 = xor <2 x i64> %484, %479
%487 = bitcast i64* %471 to <2 x i64>*
%488 = load <2 x i64>, <2 x i64>* %487
%489 = getelementptr i64, i64* %471, i64 2
%490 = bitcast i64* %489 to <2 x i64>*
%491 = load <2 x i64>, <2 x i64>* %490
%492 = xor <2 x i64> %485, %488
%493 = xor <2 x i64> %486, %491
%494 = bitcast i64* %470 to <2 x i64>*
%495 = load <2 x i64>, <2 x i64>* %494
%496 = getelementptr i64, i64* %470, i64 2
%497 = bitcast i64* %496 to <2 x i64>*
%498 = load <2 x i64>, <2 x i64>* %497
%499 = xor <2 x i64> %492, %495
%500 = xor <2 x i64> %493, %498
%501 = bitcast i64* %474 to <2 x i64>*
%502 = load <2 x i64>, <2 x i64>* %501
%503 = getelementptr i64, i64* %474, i64 2
%504 = bitcast i64* %503 to <2 x i64>*
%505 = load <2 x i64>, <2 x i64>* %504
%506 = xor <2 x i64> %499, %502
%507 = xor <2 x i64> %500, %505
%508 = bitcast i64* %474 to <2 x i64>*
store <2 x i64> %506, <2 x i64>* %508
%509 = bitcast i64* %503 to <2 x i64>*
store <2 x i64> %507, <2 x i64>* %509
%510 = add nuw i64 %469, 4
%511 = icmp eq i64 %510, %52
br i1 %511, label %512, label %468
512: ; preds = %468
br i1 %56, label %588, label %513
513: ; preds = %439, %438, %512
%514 = phi i64* [ %434, %439 ], [ %434, %438 ], [ %464, %512 ]
%515 = phi i64* [ %430, %439 ], [ %430, %438 ], [ %465, %512 ]
%516 = phi i64* [ %426, %439 ], [ %426, %438 ], [ %466, %512 ]
%517 = phi i64* [ %422, %439 ], [ %422, %438 ], [ %467, %512 ]
%518 = phi i64* [ %37, %439 ], [ %37, %438 ], [ %53, %512 ]
%519 = phi i32 [ %7, %439 ], [ %7, %438 ], [ %55, %512 ]
%520 = and i32 %519, 1
%521 = icmp eq i32 %520, 0
br i1 %521, label %538, label %522
522: ; preds = %513
%523 = load i64, i64* %517
%524 = load i64, i64* %516
%525 = xor i64 %524, %523
%526 = load i64, i64* %515
%527 = xor i64 %525, %526
%528 = load i64, i64* %514
%529 = xor i64 %527, %528
%530 = load i64, i64* %518
%531 = xor i64 %529, %530
store i64 %531, i64* %518
%532 = getelementptr inbounds i64, i64* %518, i64 1
%533 = getelementptr inbounds i64, i64* %517, i64 1
%534 = getelementptr inbounds i64, i64* %516, i64 1
%535 = getelementptr inbounds i64, i64* %515, i64 1
%536 = getelementptr inbounds i64, i64* %514, i64 1
%537 = add nsw i32 %519, -1
br label %538
538: ; preds = %522, %513
%539 = phi i64* [ undef, %513 ], [ %532, %522 ]
%540 = phi i64* [ undef, %513 ], [ %533, %522 ]
%541 = phi i64* [ undef, %513 ], [ %534, %522 ]
%542 = phi i64* [ undef, %513 ], [ %535, %522 ]
%543 = phi i64* [ undef, %513 ], [ %536, %522 ]
%544 = phi i64* [ %514, %513 ], [ %536, %522 ]
%545 = phi i64* [ %515, %513 ], [ %535, %522 ]
%546 = phi i64* [ %516, %513 ], [ %534, %522 ]
%547 = phi i64* [ %517, %513 ], [ %533, %522 ]
%548 = phi i64* [ %518, %513 ], [ %532, %522 ]
%549 = phi i32 [ %519, %513 ], [ %537, %522 ]
%550 = icmp eq i32 %519, 1
br i1 %550, label %588, label %551
551: ; preds = %538, %551
%552 = phi i64* [ %585, %551 ], [ %544, %538 ]
%553 = phi i64* [ %584, %551 ], [ %545, %538 ]
%554 = phi i64* [ %583, %551 ], [ %546, %538 ]
%555 = phi i64* [ %582, %551 ], [ %547, %538 ]
%556 = phi i64* [ %581, %551 ], [ %548, %538 ]
%557 = phi i32 [ %586, %551 ], [ %549, %538 ]
%558 = load i64, i64* %555
%559 = load i64, i64* %554
%560 = xor i64 %559, %558
%561 = load i64, i64* %553
%562 = xor i64 %560, %561
%563 = load i64, i64* %552
%564 = xor i64 %562, %563
%565 = load i64, i64* %556
%566 = xor i64 %564, %565
store i64 %566, i64* %556
%567 = getelementptr inbounds i64, i64* %556, i64 1
%568 = getelementptr inbounds i64, i64* %555, i64 1
%569 = getelementptr inbounds i64, i64* %554, i64 1
%570 = getelementptr inbounds i64, i64* %553, i64 1
%571 = getelementptr inbounds i64, i64* %552, i64 1
%572 = load i64, i64* %568
%573 = load i64, i64* %569
%574 = xor i64 %573, %572
%575 = load i64, i64* %570
%576 = xor i64 %574, %575
%577 = load i64, i64* %571
%578 = xor i64 %576, %577
%579 = load i64, i64* %567
%580 = xor i64 %578, %579
store i64 %580, i64* %567
%581 = getelementptr inbounds i64, i64* %556, i64 2
%582 = getelementptr inbounds i64, i64* %555, i64 2
%583 = getelementptr inbounds i64, i64* %554, i64 2
%584 = getelementptr inbounds i64, i64* %553, i64 2
%585 = getelementptr inbounds i64, i64* %552, i64 2
%586 = add nsw i32 %557, -2
%587 = icmp eq i32 %586, 0
br i1 %587, label %588, label %551
588: ; preds = %538, %551, %512, %418
%589 = phi i64* [ %37, %418 ], [ %53, %512 ], [ %539, %538 ], [ %581, %551 ]
%590 = phi i64* [ %422, %418 ], [ %467, %512 ], [ %540, %538 ], [ %582, %551 ]
%591 = phi i64* [ %426, %418 ], [ %466, %512 ], [ %541, %538 ], [ %583, %551 ]
%592 = phi i64* [ %430, %418 ], [ %465, %512 ], [ %542, %538 ], [ %584, %551 ]
%593 = phi i64* [ %434, %418 ], [ %464, %512 ], [ %543, %538 ], [ %585, %551 ]
%594 = bitcast i64* %589 to i32*
%595 = bitcast i64* %590 to i32*
%596 = bitcast i64* %591 to i32*
%597 = bitcast i64* %592 to i32*
%598 = bitcast i64* %593 to i32*
br i1 %40, label %599, label %614
599: ; preds = %588
%600 = load i32, i32* %595
%601 = load i32, i32* %596
%602 = xor i32 %601, %600
%603 = load i32, i32* %597
%604 = xor i32 %602, %603
%605 = load i32, i32* %598
%606 = xor i32 %604, %605
%607 = load i32, i32* %594
%608 = xor i32 %606, %607
store i32 %608, i32* %594
%609 = getelementptr inbounds i32, i32* %595, i64 1
%610 = getelementptr inbounds i32, i32* %596, i64 1
%611 = getelementptr inbounds i32, i32* %597, i64 1
%612 = getelementptr inbounds i32, i32* %598, i64 1
%613 = getelementptr inbounds i32, i32* %594, i64 1
br label %614
614: ; preds = %599, %588
%615 = phi i32* [ %613, %599 ], [ %594, %588 ]
%616 = phi i32* [ %609, %599 ], [ %595, %588 ]
%617 = phi i32* [ %610, %599 ], [ %596, %588 ]
%618 = phi i32* [ %611, %599 ], [ %597, %588 ]
%619 = phi i32* [ %612, %599 ], [ %598, %588 ]
br i1 %41, label %665, label %620
620: ; preds = %614
%621 = bitcast i32* %616 to i8*
%622 = bitcast i32* %617 to i8*
%623 = bitcast i32* %618 to i8*
%624 = bitcast i32* %619 to i8*
%625 = bitcast i32* %615 to i8*
%626 = load i8, i8* %621
%627 = load i8, i8* %622
%628 = xor i8 %627, %626
%629 = load i8, i8* %623
%630 = xor i8 %628, %629
%631 = load i8, i8* %624
%632 = xor i8 %630, %631
%633 = load i8, i8* %625
%634 = xor i8 %632, %633
store i8 %634, i8* %625
br i1 %57, label %665, label %635
635: ; preds = %620
%636 = getelementptr inbounds i8, i8* %621, i64 1
%637 = load i8, i8* %636
%638 = getelementptr inbounds i8, i8* %622, i64 1
%639 = load i8, i8* %638
%640 = xor i8 %639, %637
%641 = getelementptr inbounds i8, i8* %623, i64 1
%642 = load i8, i8* %641
%643 = xor i8 %640, %642
%644 = getelementptr inbounds i8, i8* %624, i64 1
%645 = load i8, i8* %644
%646 = xor i8 %643, %645
%647 = getelementptr inbounds i8, i8* %625, i64 1
%648 = load i8, i8* %647
%649 = xor i8 %646, %648
store i8 %649, i8* %647
br i1 %58, label %665, label %650
650: ; preds = %635
%651 = getelementptr inbounds i8, i8* %621, i64 2
%652 = load i8, i8* %651
%653 = getelementptr inbounds i8, i8* %622, i64 2
%654 = load i8, i8* %653
%655 = xor i8 %654, %652
%656 = getelementptr inbounds i8, i8* %623, i64 2
%657 = load i8, i8* %656
%658 = xor i8 %655, %657
%659 = getelementptr inbounds i8, i8* %624, i64 2
%660 = load i8, i8* %659
%661 = xor i8 %658, %660
%662 = getelementptr inbounds i8, i8* %625, i64 2
%663 = load i8, i8* %662
%664 = xor i8 %661, %663
store i8 %664, i8* %662
br label %665
665: ; preds = %620, %635, %650, %614
%666 = icmp ugt i32 %436, 3
br i1 %666, label %418, label %383
667: ; preds = %387, %874
%668 = phi i8** [ %385, %387 ], [ %677, %874 ]
%669 = phi i32 [ %384, %387 ], [ %678, %874 ]
%670 = bitcast i8** %668 to i64**
%671 = load i64*, i64** %670
%672 = bitcast i64* %671 to i8*
%673 = getelementptr inbounds i8*, i8** %668, i64 1
%674 = bitcast i8** %673 to i64**
%675 = load i64*, i64** %674
%676 = bitcast i64* %675 to i8*
%677 = getelementptr inbounds i8*, i8** %668, i64 2
%678 = add i32 %669, -2
br i1 %389, label %827, label %679
679: ; preds = %667
br i1 %406, label %778, label %680
680: ; preds = %679
%681 = getelementptr i64, i64* %671, i64 %398
%682 = bitcast i64* %681 to i8*
%683 = getelementptr i64, i64* %675, i64 %398
%684 = bitcast i64* %683 to i8*
%685 = icmp ugt i8* %682, %0
%686 = icmp ugt i8* %397, %672
%687 = and i1 %685, %686
%688 = icmp ugt i8* %684, %0
%689 = icmp ugt i8* %397, %676
%690 = and i1 %688, %689
%691 = or i1 %687, %690
br i1 %691, label %778, label %692
692: ; preds = %680
%693 = getelementptr i64, i64* %675, i64 %407
%694 = getelementptr i64, i64* %671, i64 %407
br i1 %412, label %750, label %695
695: ; preds = %692, %695
%696 = phi i64 [ %747, %695 ], [ 0, %692 ]
%697 = phi i64 [ %748, %695 ], [ 0, %692 ]
%698 = getelementptr i64, i64* %675, i64 %696
%699 = getelementptr i64, i64* %671, i64 %696
%700 = getelementptr i64, i64* %388, i64 %696
%701 = bitcast i64* %699 to <2 x i64>*
%702 = load <2 x i64>, <2 x i64>* %701
%703 = getelementptr i64, i64* %699, i64 2
%704 = bitcast i64* %703 to <2 x i64>*
%705 = load <2 x i64>, <2 x i64>* %704
%706 = bitcast i64* %698 to <2 x i64>*
%707 = load <2 x i64>, <2 x i64>* %706
%708 = getelementptr i64, i64* %698, i64 2
%709 = bitcast i64* %708 to <2 x i64>*
%710 = load <2 x i64>, <2 x i64>* %709
%711 = xor <2 x i64> %707, %702
%712 = xor <2 x i64> %710, %705
%713 = bitcast i64* %700 to <2 x i64>*
%714 = load <2 x i64>, <2 x i64>* %713
%715 = getelementptr i64, i64* %700, i64 2
%716 = bitcast i64* %715 to <2 x i64>*
%717 = load <2 x i64>, <2 x i64>* %716
%718 = xor <2 x i64> %711, %714
%719 = xor <2 x i64> %712, %717
%720 = bitcast i64* %700 to <2 x i64>*
store <2 x i64> %718, <2 x i64>* %720
%721 = bitcast i64* %715 to <2 x i64>*
store <2 x i64> %719, <2 x i64>* %721
%722 = or i64 %696, 4
%723 = getelementptr i64, i64* %675, i64 %722
%724 = getelementptr i64, i64* %671, i64 %722
%725 = getelementptr i64, i64* %388, i64 %722
%726 = bitcast i64* %724 to <2 x i64>*
%727 = load <2 x i64>, <2 x i64>* %726
%728 = getelementptr i64, i64* %724, i64 2
%729 = bitcast i64* %728 to <2 x i64>*
%730 = load <2 x i64>, <2 x i64>* %729
%731 = bitcast i64* %723 to <2 x i64>*
%732 = load <2 x i64>, <2 x i64>* %731
%733 = getelementptr i64, i64* %723, i64 2
%734 = bitcast i64* %733 to <2 x i64>*
%735 = load <2 x i64>, <2 x i64>* %734
%736 = xor <2 x i64> %732, %727
%737 = xor <2 x i64> %735, %730
%738 = bitcast i64* %725 to <2 x i64>*
%739 = load <2 x i64>, <2 x i64>* %738
%740 = getelementptr i64, i64* %725, i64 2
%741 = bitcast i64* %740 to <2 x i64>*
%742 = load <2 x i64>, <2 x i64>* %741
%743 = xor <2 x i64> %736, %739
%744 = xor <2 x i64> %737, %742
%745 = bitcast i64* %725 to <2 x i64>*
store <2 x i64> %743, <2 x i64>* %745
%746 = bitcast i64* %740 to <2 x i64>*
store <2 x i64> %744, <2 x i64>* %746
%747 = add nuw i64 %696, 8
%748 = add i64 %697, 2
%749 = icmp eq i64 %748, %413
br i1 %749, label %750, label %695
750: ; preds = %695, %692
%751 = phi i64 [ 0, %692 ], [ %747, %695 ]
br i1 %414, label %777, label %752
752: ; preds = %750
%753 = getelementptr i64, i64* %675, i64 %751
%754 = getelementptr i64, i64* %671, i64 %751
%755 = getelementptr i64, i64* %388, i64 %751
%756 = bitcast i64* %754 to <2 x i64>*
%757 = load <2 x i64>, <2 x i64>* %756
%758 = getelementptr i64, i64* %754, i64 2
%759 = bitcast i64* %758 to <2 x i64>*
%760 = load <2 x i64>, <2 x i64>* %759
%761 = bitcast i64* %753 to <2 x i64>*
%762 = load <2 x i64>, <2 x i64>* %761
%763 = getelementptr i64, i64* %753, i64 2
%764 = bitcast i64* %763 to <2 x i64>*
%765 = load <2 x i64>, <2 x i64>* %764
%766 = xor <2 x i64> %762, %757
%767 = xor <2 x i64> %765, %760
%768 = bitcast i64* %755 to <2 x i64>*
%769 = load <2 x i64>, <2 x i64>* %768
%770 = getelementptr i64, i64* %755, i64 2
%771 = bitcast i64* %770 to <2 x i64>*
%772 = load <2 x i64>, <2 x i64>* %771
%773 = xor <2 x i64> %766, %769
%774 = xor <2 x i64> %767, %772
%775 = bitcast i64* %755 to <2 x i64>*
store <2 x i64> %773, <2 x i64>* %775
%776 = bitcast i64* %770 to <2 x i64>*
store <2 x i64> %774, <2 x i64>* %776
br label %777
777: ; preds = %750, %752
br i1 %415, label %827, label %778
778: ; preds = %680, %679, %777
%779 = phi i64* [ %675, %680 ], [ %675, %679 ], [ %693, %777 ]
%780 = phi i64* [ %671, %680 ], [ %671, %679 ], [ %694, %777 ]
%781 = phi i64* [ %388, %680 ], [ %388, %679 ], [ %408, %777 ]
%782 = phi i32 [ %7, %680 ], [ %7, %679 ], [ %410, %777 ]
%783 = and i32 %782, 1
%784 = icmp eq i32 %783, 0
br i1 %784, label %795, label %785
785: ; preds = %778
%786 = load i64, i64* %780
%787 = load i64, i64* %779
%788 = xor i64 %787, %786
%789 = load i64, i64* %781
%790 = xor i64 %788, %789
store i64 %790, i64* %781
%791 = getelementptr inbounds i64, i64* %781, i64 1
%792 = getelementptr inbounds i64, i64* %780, i64 1
%793 = getelementptr inbounds i64, i64* %779, i64 1
%794 = add nsw i32 %782, -1
br label %795
795: ; preds = %785, %778
%796 = phi i64* [ undef, %778 ], [ %791, %785 ]
%797 = phi i64* [ undef, %778 ], [ %792, %785 ]
%798 = phi i64* [ undef, %778 ], [ %793, %785 ]
%799 = phi i64* [ %779, %778 ], [ %793, %785 ]
%800 = phi i64* [ %780, %778 ], [ %792, %785 ]
%801 = phi i64* [ %781, %778 ], [ %791, %785 ]
%802 = phi i32 [ %782, %778 ], [ %794, %785 ]
%803 = icmp eq i32 %782, 1
br i1 %803, label %827, label %804
804: ; preds = %795, %804
%805 = phi i64* [ %824, %804 ], [ %799, %795 ]
%806 = phi i64* [ %823, %804 ], [ %800, %795 ]
%807 = phi i64* [ %822, %804 ], [ %801, %795 ]
%808 = phi i32 [ %825, %804 ], [ %802, %795 ]
%809 = load i64, i64* %806
%810 = load i64, i64* %805
%811 = xor i64 %810, %809
%812 = load i64, i64* %807
%813 = xor i64 %811, %812
store i64 %813, i64* %807
%814 = getelementptr inbounds i64, i64* %807, i64 1
%815 = getelementptr inbounds i64, i64* %806, i64 1
%816 = getelementptr inbounds i64, i64* %805, i64 1
%817 = load i64, i64* %815
%818 = load i64, i64* %816
%819 = xor i64 %818, %817
%820 = load i64, i64* %814
%821 = xor i64 %819, %820
store i64 %821, i64* %814
%822 = getelementptr inbounds i64, i64* %807, i64 2
%823 = getelementptr inbounds i64, i64* %806, i64 2
%824 = getelementptr inbounds i64, i64* %805, i64 2
%825 = add nsw i32 %808, -2
%826 = icmp eq i32 %825, 0
br i1 %826, label %827, label %804
827: ; preds = %795, %804, %777, %667
%828 = phi i64* [ %388, %667 ], [ %408, %777 ], [ %796, %795 ], [ %822, %804 ]
%829 = phi i64* [ %671, %667 ], [ %694, %777 ], [ %797, %795 ], [ %823, %804 ]
%830 = phi i64* [ %675, %667 ], [ %693, %777 ], [ %798, %795 ], [ %824, %804 ]
%831 = bitcast i64* %828 to i32*
%832 = bitcast i64* %829 to i32*
%833 = bitcast i64* %830 to i32*
br i1 %391, label %834, label %843
834: ; preds = %827
%835 = load i32, i32* %832
%836 = load i32, i32* %833
%837 = xor i32 %836, %835
%838 = load i32, i32* %831
%839 = xor i32 %837, %838
store i32 %839, i32* %831
%840 = getelementptr inbounds i32, i32* %832, i64 1
%841 = getelementptr inbounds i32, i32* %833, i64 1
%842 = getelementptr inbounds i32, i32* %831, i64 1
br label %843
843: ; preds = %834, %827
%844 = phi i32* [ %842, %834 ], [ %831, %827 ]
%845 = phi i32* [ %840, %834 ], [ %832, %827 ]
%846 = phi i32* [ %841, %834 ], [ %833, %827 ]
br i1 %392, label %874, label %847
847: ; preds = %843
%848 = bitcast i32* %845 to i8*
%849 = bitcast i32* %846 to i8*
%850 = bitcast i32* %844 to i8*
%851 = load i8, i8* %848
%852 = load i8, i8* %849
%853 = xor i8 %852, %851
%854 = load i8, i8* %850
%855 = xor i8 %853, %854
store i8 %855, i8* %850
br i1 %416, label %874, label %856
856: ; preds = %847
%857 = getelementptr inbounds i8, i8* %848, i64 1
%858 = load i8, i8* %857
%859 = getelementptr inbounds i8, i8* %849, i64 1
%860 = load i8, i8* %859
%861 = xor i8 %860, %858
%862 = getelementptr inbounds i8, i8* %850, i64 1
%863 = load i8, i8* %862
%864 = xor i8 %861, %863
store i8 %864, i8* %862
br i1 %417, label %874, label %865
865: ; preds = %856
%866 = getelementptr inbounds i8, i8* %848, i64 2
%867 = load i8, i8* %866
%868 = getelementptr inbounds i8, i8* %849, i64 2
%869 = load i8, i8* %868
%870 = xor i8 %869, %867
%871 = getelementptr inbounds i8, i8* %850, i64 2
%872 = load i8, i8* %871
%873 = xor i8 %870, %872
store i8 %873, i8* %871
br label %874
874: ; preds = %847, %856, %865, %843
%875 = icmp ugt i32 %678, 1
br i1 %875, label %667, label %876
876: ; preds = %874, %383
%877 = phi i32 [ %384, %383 ], [ %678, %874 ]
%878 = phi i8** [ %385, %383 ], [ %677, %874 ]
%879 = icmp eq i32 %877, 0
br i1 %879, label %1067, label %880
880: ; preds = %876
%881 = bitcast i8* %0 to i64*
%882 = bitcast i8** %878 to i64**
%883 = load i64*, i64** %882
%884 = bitcast i64* %883 to i8*
%885 = icmp ult i32 %3, 8
br i1 %885, label %1030, label %886
886: ; preds = %880
%887 = add nsw i32 %7, -1
%888 = zext i32 %887 to i64
%889 = add nuw nsw i64 %888, 1
%890 = icmp ult i32 %887, 3
br i1 %890, label %977, label %891
891: ; preds = %886
%892 = add nsw i32 %7, -1
%893 = zext i32 %892 to i64
%894 = shl nuw nsw i64 %893, 3
%895 = add nuw nsw i64 %894, 8
%896 = getelementptr i8, i8* %0, i64 %895
%897 = add nuw nsw i64 %893, 1
%898 = getelementptr i64, i64* %883, i64 %897
%899 = bitcast i64* %898 to i8*
%900 = icmp ugt i8* %899, %0
%901 = icmp ugt i8* %896, %884
%902 = and i1 %900, %901
br i1 %902, label %977, label %903
903: ; preds = %891
%904 = and i64 %889, 8589934588
%905 = getelementptr i64, i64* %883, i64 %904
%906 = getelementptr i64, i64* %881, i64 %904
%907 = trunc i64 %904 to i32
%908 = sub i32 %7, %907
%909 = add nsw i64 %904, -4
%910 = lshr exact i64 %909, 2
%911 = add nuw nsw i64 %910, 1
%912 = and i64 %911, 1
%913 = icmp eq i64 %909, 0
br i1 %913, label %955, label %914
914: ; preds = %903
%915 = and i64 %911, 9223372036854775806
br label %916
916: ; preds = %916, %914
%917 = phi i64 [ 0, %914 ], [ %952, %916 ]
%918 = phi i64 [ 0, %914 ], [ %953, %916 ]
%919 = getelementptr i64, i64* %883, i64 %917
%920 = getelementptr i64, i64* %881, i64 %917
%921 = bitcast i64* %919 to <2 x i64>*
%922 = load <2 x i64>, <2 x i64>* %921
%923 = getelementptr i64, i64* %919, i64 2
%924 = bitcast i64* %923 to <2 x i64>*
%925 = load <2 x i64>, <2 x i64>* %924
%926 = bitcast i64* %920 to <2 x i64>*
%927 = load <2 x i64>, <2 x i64>* %926
%928 = getelementptr i64, i64* %920, i64 2
%929 = bitcast i64* %928 to <2 x i64>*
%930 = load <2 x i64>, <2 x i64>* %929
%931 = xor <2 x i64> %927, %922
%932 = xor <2 x i64> %930, %925
%933 = bitcast i64* %920 to <2 x i64>*
store <2 x i64> %931, <2 x i64>* %933
%934 = bitcast i64* %928 to <2 x i64>*
store <2 x i64> %932, <2 x i64>* %934
%935 = or i64 %917, 4
%936 = getelementptr i64, i64* %883, i64 %935
%937 = getelementptr i64, i64* %881, i64 %935
%938 = bitcast i64* %936 to <2 x i64>*
%939 = load <2 x i64>, <2 x i64>* %938
%940 = getelementptr i64, i64* %936, i64 2
%941 = bitcast i64* %940 to <2 x i64>*
%942 = load <2 x i64>, <2 x i64>* %941
%943 = bitcast i64* %937 to <2 x i64>*
%944 = load <2 x i64>, <2 x i64>* %943
%945 = getelementptr i64, i64* %937, i64 2
%946 = bitcast i64* %945 to <2 x i64>*
%947 = load <2 x i64>, <2 x i64>* %946
%948 = xor <2 x i64> %944, %939
%949 = xor <2 x i64> %947, %942
%950 = bitcast i64* %937 to <2 x i64>*
store <2 x i64> %948, <2 x i64>* %950
%951 = bitcast i64* %945 to <2 x i64>*
store <2 x i64> %949, <2 x i64>* %951
%952 = add nuw i64 %917, 8
%953 = add i64 %918, 2
%954 = icmp eq i64 %953, %915
br i1 %954, label %955, label %916
955: ; preds = %916, %903
%956 = phi i64 [ 0, %903 ], [ %952, %916 ]
%957 = icmp eq i64 %912, 0
br i1 %957, label %975, label %958
958: ; preds = %955
%959 = getelementptr i64, i64* %883, i64 %956
%960 = getelementptr i64, i64* %881, i64 %956
%961 = bitcast i64* %959 to <2 x i64>*
%962 = load <2 x i64>, <2 x i64>* %961
%963 = getelementptr i64, i64* %959, i64 2
%964 = bitcast i64* %963 to <2 x i64>*
%965 = load <2 x i64>, <2 x i64>* %964
%966 = bitcast i64* %960 to <2 x i64>*
%967 = load <2 x i64>, <2 x i64>* %966
%968 = getelementptr i64, i64* %960, i64 2
%969 = bitcast i64* %968 to <2 x i64>*
%970 = load <2 x i64>, <2 x i64>* %969
%971 = xor <2 x i64> %967, %962
%972 = xor <2 x i64> %970, %965
%973 = bitcast i64* %960 to <2 x i64>*
store <2 x i64> %971, <2 x i64>* %973
%974 = bitcast i64* %968 to <2 x i64>*
store <2 x i64> %972, <2 x i64>* %974
br label %975
975: ; preds = %955, %958
%976 = icmp eq i64 %889, %904
br i1 %976, label %1030, label %977
977: ; preds = %891, %886, %975
%978 = phi i64* [ %883, %891 ], [ %883, %886 ], [ %905, %975 ]
%979 = phi i64* [ %881, %891 ], [ %881, %886 ], [ %906, %975 ]
%980 = phi i32 [ %7, %891 ], [ %7, %886 ], [ %908, %975 ]
%981 = add i32 %980, -1
%982 = and i32 %980, 3
%983 = icmp eq i32 %982, 0
br i1 %983, label %997, label %984
984: ; preds = %977, %984
%985 = phi i64* [ %993, %984 ], [ %978, %977 ]
%986 = phi i64* [ %992, %984 ], [ %979, %977 ]
%987 = phi i32 [ %994, %984 ], [ %980, %977 ]
%988 = phi i32 [ %995, %984 ], [ 0, %977 ]
%989 = load i64, i64* %985
%990 = load i64, i64* %986
%991 = xor i64 %990, %989
store i64 %991, i64* %986
%992 = getelementptr inbounds i64, i64* %986, i64 1
%993 = getelementptr inbounds i64, i64* %985, i64 1
%994 = add nsw i32 %987, -1
%995 = add i32 %988, 1
%996 = icmp eq i32 %995, %982
br i1 %996, label %997, label %984
997: ; preds = %984, %977
%998 = phi i64* [ undef, %977 ], [ %992, %984 ]
%999 = phi i64* [ undef, %977 ], [ %993, %984 ]
%1000 = phi i64* [ %978, %977 ], [ %993, %984 ]
%1001 = phi i64* [ %979, %977 ], [ %992, %984 ]
%1002 = phi i32 [ %980, %977 ], [ %994, %984 ]
%1003 = icmp ult i32 %981, 3
br i1 %1003, label %1030, label %1004
1004: ; preds = %997, %1004
%1005 = phi i64* [ %1027, %1004 ], [ %1000, %997 ]
%1006 = phi i64* [ %1026, %1004 ], [ %1001, %997 ]
%1007 = phi i32 [ %1028, %1004 ], [ %1002, %997 ]
%1008 = load i64, i64* %1005
%1009 = load i64, i64* %1006
%1010 = xor i64 %1009, %1008
store i64 %1010, i64* %1006
%1011 = getelementptr inbounds i64, i64* %1006, i64 1
%1012 = getelementptr inbounds i64, i64* %1005, i64 1
%1013 = load i64, i64* %1012
%1014 = load i64, i64* %1011
%1015 = xor i64 %1014, %1013
store i64 %1015, i64* %1011
%1016 = getelementptr inbounds i64, i64* %1006, i64 2
%1017 = getelementptr inbounds i64, i64* %1005, i64 2
%1018 = load i64, i64* %1017
%1019 = load i64, i64* %1016
%1020 = xor i64 %1019, %1018
store i64 %1020, i64* %1016
%1021 = getelementptr inbounds i64, i64* %1006, i64 3
%1022 = getelementptr inbounds i64, i64* %1005, i64 3
%1023 = load i64, i64* %1022
%1024 = load i64, i64* %1021
%1025 = xor i64 %1024, %1023
store i64 %1025, i64* %1021
%1026 = getelementptr inbounds i64, i64* %1006, i64 4
%1027 = getelementptr inbounds i64, i64* %1005, i64 4
%1028 = add nsw i32 %1007, -4
%1029 = icmp eq i32 %1028, 0
br i1 %1029, label %1030, label %1004
1030: ; preds = %997, %1004, %975, %880
%1031 = phi i64* [ %881, %880 ], [ %906, %975 ], [ %998, %997 ], [ %1026, %1004 ]
%1032 = phi i64* [ %883, %880 ], [ %905, %975 ], [ %999, %997 ], [ %1027, %1004 ]
%1033 = bitcast i64* %1031 to i32*
%1034 = bitcast i64* %1032 to i32*
%1035 = shl nuw nsw i32 %7, 1
%1036 = icmp ult i32 %1035, %5
br i1 %1036, label %1037, label %1043
1037: ; preds = %1030
%1038 = load i32, i32* %1034
%1039 = load i32, i32* %1033
%1040 = xor i32 %1039, %1038
store i32 %1040, i32* %1033
%1041 = getelementptr inbounds i32, i32* %1033, i64 1
%1042 = getelementptr inbounds i32, i32* %1034, i64 1
br label %1043
1043: ; preds = %1037, %1030
%1044 = phi i32* [ %1041, %1037 ], [ %1033, %1030 ]
%1045 = phi i32* [ %1042, %1037 ], [ %1034, %1030 ]
%1046 = icmp eq i32 %6, 0
br i1 %1046, label %1067, label %1047
1047: ; preds = %1043
%1048 = bitcast i32* %1045 to i8*
%1049 = bitcast i32* %1044 to i8*
%1050 = load i8, i8* %1048
%1051 = load i8, i8* %1049
%1052 = xor i8 %1051, %1050
store i8 %1052, i8* %1049
%1053 = icmp eq i32 %6, 1
br i1 %1053, label %1067, label %1054
1054: ; preds = %1047
%1055 = getelementptr inbounds i8, i8* %1048, i64 1
%1056 = load i8, i8* %1055
%1057 = getelementptr inbounds i8, i8* %1049, i64 1
%1058 = load i8, i8* %1057
%1059 = xor i8 %1058, %1056
store i8 %1059, i8* %1057
%1060 = icmp eq i32 %6, 2
br i1 %1060, label %1067, label %1061
1061: ; preds = %1054
%1062 = getelementptr inbounds i8, i8* %1048, i64 2
%1063 = load i8, i8* %1062
%1064 = getelementptr inbounds i8, i8* %1049, i64 2
%1065 = load i8, i8* %1064
%1066 = xor i8 %1065, %1063
store i8 %1066, i8* %1064
br label %1067
1067: ; preds = %1047, %1054, %1061, %1043, %876
ret void
}