void of_add_to_multiple_symbols(void **to, const void *from,
                                unsigned int to_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;
  unsigned long long *pt1, *pt2, *pt3, *pt4, *pt5, *pt6, *pt7, *pt8, *from_s,
      from_value;
  while (to_size >= 8) {
    from_s = (unsigned long long *)from;
    pt1 = (unsigned long long *)to[0];
    pt2 = (unsigned long long *)to[1];
    pt3 = (unsigned long long *)to[2];
    pt4 = (unsigned long long *)to[3];
    pt5 = (unsigned long long *)to[4];
    pt6 = (unsigned long long *)to[5];
    pt7 = (unsigned long long *)to[6];
    pt8 = (unsigned long long *)to[7];
    to += 8;
    to_size -= 8;
    for (i = symbolSize64; i > 0; i--) {
      from_value = *from_s;
      *pt1 ^= from_value;
      *pt2 ^= from_value;
      *pt3 ^= from_value;
      *pt4 ^= from_value;
      *pt5 ^= from_value;
      *pt6 ^= from_value;
      *pt7 ^= from_value;
      *pt8 ^= from_value;
      from_s++;
      pt1++;
      pt2++;
      pt3++;
      pt4++;
      pt5++;
      pt6++;
      pt7++;
      pt8++;
    }
    unsigned int *from_s32 = (unsigned int *)from_s;
    from_s32 = (unsigned int *)from_s;
    if ((symbolSize64 << 1) < symbolSize32) {
      (*(unsigned int *)pt1++) ^= *from_s32;
      (*(unsigned int *)pt2++) ^= *from_s32;
      (*(unsigned int *)pt3++) ^= *from_s32;
      (*(unsigned int *)pt4++) ^= *from_s32;
      (*(unsigned int *)pt5++) ^= *from_s32;
      (*(unsigned int *)pt6++) ^= *from_s32;
      (*(unsigned int *)pt7++) ^= *from_s32;
      (*(unsigned int *)pt8++) ^= *from_s32;
      from_s32++;
    }
    if (symbolSize32rem > 0) {
      unsigned char *s8;
      for (i = 0; i < symbolSize32rem; i++) {
        s8 = ((unsigned char *)from_s32 + i);
        (*(unsigned char *)((unsigned char *)pt1 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt2 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt3 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt4 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt5 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt6 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt7 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt8 + i)) ^= *(unsigned char *)s8;
      }
    }
  }
  while (to_size >= 4) {
    unsigned int *from_s32;
    from_s = (unsigned long long *)from;
    pt1 = (unsigned long long *)to[0];
    pt2 = (unsigned long long *)to[1];
    pt3 = (unsigned long long *)to[2];
    pt4 = (unsigned long long *)to[3];
    to += 4;
    to_size -= 4;
    for (i = symbolSize64; i > 0; i--) {
      from_value = *from_s;
      *pt1 ^= from_value;
      *pt2 ^= from_value;
      *pt3 ^= from_value;
      *pt4 ^= from_value;
      from_s++;
      pt1++;
      pt2++;
      pt3++;
      pt4++;
    }
    from_s32 = (unsigned int *)from_s;
    if ((symbolSize64 << 1) < symbolSize32) {
      (*(unsigned int *)pt1++) ^= *from_s32;
      (*(unsigned int *)pt2++) ^= *from_s32;
      (*(unsigned int *)pt3++) ^= *from_s32;
      (*(unsigned int *)pt4++) ^= *from_s32;
      from_s32++;
    }
    if (symbolSize32rem > 0) {
      unsigned char *s8;
      for (i = 0; i < symbolSize32rem; i++) {
        s8 = ((unsigned char *)from_s32 + i);
        (*(unsigned char *)((unsigned char *)pt1 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt2 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt3 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt4 + i)) ^= *(unsigned char *)s8;
      }
    }
  }
  while (to_size >= 2) {
    unsigned int *from_s32;
    from_s = (unsigned long long *)from;
    pt1 = (unsigned long long *)to[0];
    pt2 = (unsigned long long *)to[1];
    to += 2;
    to_size -= 2;
    for (i = symbolSize64; i > 0; i--) {
      *pt1 ^= *from_s;
      *pt2 ^= *from_s;
      from_s++;
      pt1++;
      pt2++;
    }
    from_s32 = (unsigned int *)from_s;
    if ((symbolSize64 << 1) < symbolSize32) {
      (*(unsigned int *)pt1++) ^= *from_s32;
      (*(unsigned int *)pt2++) ^= *from_s32;
      from_s32++;
    }
    if (symbolSize32rem > 0) {
      unsigned char *s8;
      for (i = 0; i < symbolSize32rem; i++) {
        s8 = ((unsigned char *)from_s32 + i);
        (*(unsigned char *)((unsigned char *)pt1 + i)) ^= *(unsigned char *)s8;
        (*(unsigned char *)((unsigned char *)pt2 + i)) ^= *(unsigned char *)s8;
      }
    }
  }
  if (to_size == 0)
    return;
  unsigned long long *t = (unsigned long long *)to[0];
  unsigned long long *f = (unsigned long long *)from;
  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_to_multiple_symbols>:
push   %rbp
mov    %rsp,%rbp
sub    $0x48,%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     14c5 <of_add_to_multiple_symbols+0x3c5>
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jbe    12bc <of_add_to_multiple_symbols+0x1bc>
mov    -0x70(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x30(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x38(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x40(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x48(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x50(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x58(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x60(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x68(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
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    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    11bd <of_add_to_multiple_symbols+0xbd>
mov    -0x70(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    13af <of_add_to_multiple_symbols+0x2af>
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x40(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x48(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x50(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x58(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x60(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x60(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x68(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x68(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    14c0 <of_add_to_multiple_symbols+0x3c0>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    14bb <of_add_to_multiple_symbols+0x3bb>
mov    -0x80(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x40(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x58(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x60(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movzbl (%rax),%esi
mov    -0x68(%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    13c0 <of_add_to_multiple_symbols+0x2c0>
jmp    14c0 <of_add_to_multiple_symbols+0x3c0>
jmp    1131 <of_add_to_multiple_symbols+0x31>
jmp    14ca <of_add_to_multiple_symbols+0x3ca>
cmpl   $0x4,-0x14(%rbp)
jb     170a <of_add_to_multiple_symbols+0x60a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jbe    15bd <of_add_to_multiple_symbols+0x4bd>
mov    -0x70(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x30(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x38(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x40(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rcx
mov    -0x48(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
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    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1526 <of_add_to_multiple_symbols+0x426>
mov    -0x70(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    1659 <of_add_to_multiple_symbols+0x559>
mov    -0x90(%rbp),%rax
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x90(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x90(%rbp),%rax
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x40(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x90(%rbp),%rax
mov    (%rax),%ecx
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x48(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x90(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    1705 <of_add_to_multiple_symbols+0x605>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1700 <of_add_to_multiple_symbols+0x600>
mov    -0x90(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
movzbl (%rax),%esi
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x98(%rbp),%rax
movzbl (%rax),%esi
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x98(%rbp),%rax
movzbl (%rax),%esi
mov    -0x40(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x98(%rbp),%rax
movzbl (%rax),%esi
mov    -0x48(%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    166a <of_add_to_multiple_symbols+0x56a>
jmp    1705 <of_add_to_multiple_symbols+0x605>
jmp    14ca <of_add_to_multiple_symbols+0x3ca>
jmp    170f <of_add_to_multiple_symbols+0x60f>
cmpl   $0x2,-0x14(%rbp)
jb     1892 <of_add_to_multiple_symbols+0x792>
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%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    17b1 <of_add_to_multiple_symbols+0x6b1>
mov    -0x70(%rbp),%rax
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x70(%rbp),%rax
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x70(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1753 <of_add_to_multiple_symbols+0x653>
mov    -0x70(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    1815 <of_add_to_multiple_symbols+0x715>
mov    -0xa0(%rbp),%rax
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xa0(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xa0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xa0(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    188d <of_add_to_multiple_symbols+0x78d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1888 <of_add_to_multiple_symbols+0x788>
mov    -0xa0(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
movzbl (%rax),%esi
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0xa8(%rbp),%rax
movzbl (%rax),%esi
mov    -0x38(%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    1826 <of_add_to_multiple_symbols+0x726>
jmp    188d <of_add_to_multiple_symbols+0x78d>
jmp    170f <of_add_to_multiple_symbols+0x60f>
cmpl   $0x0,-0x14(%rbp)
jne    18a1 <of_add_to_multiple_symbols+0x7a1>
jmp    19c7 <of_add_to_multiple_symbols+0x8c7>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jbe    1913 <of_add_to_multiple_symbols+0x813>
mov    -0xb8(%rbp),%rax
mov    (%rax),%rcx
mov    -0xb0(%rbp),%rax
xor    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0xb0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xb8(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    18c0 <of_add_to_multiple_symbols+0x7c0>
mov    -0xb0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x20(%rbp),%eax
jae    1976 <of_add_to_multiple_symbols+0x876>
mov    -0xc8(%rbp),%rax
mov    (%rax),%ecx
mov    -0xc0(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0xc0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xc8(%rbp)
cmpl   $0x0,-0x24(%rbp)
jbe    19c7 <of_add_to_multiple_symbols+0x8c7>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    19c2 <of_add_to_multiple_symbols+0x8c2>
mov    -0xc8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movzbl (%rax,%rcx,1),%esi
mov    -0xc0(%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    1987 <of_add_to_multiple_symbols+0x887>
jmp    19c7 <of_add_to_multiple_symbols+0x8c7>
add    $0x48,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<of_add_to_multiple_symbols>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r13
mov    %ecx,%eax
shr    $0x2,%eax
mov    %eax,-0x28(%rsp)
mov    %ecx,%r12d
and    $0x3,%r12d
mov    %ecx,%eax
shr    $0x3,%eax
cmp    $0x8,%edx
mov    %r12d,-0x3c(%rsp)
mov    %rax,-0x38(%rsp)
mov    %ecx,-0x2c(%rsp)
jb     1341 <of_add_to_multiple_symbols+0x241>
lea    (%rax,%rax,1),%r10d
jmp    1154 <of_add_to_multiple_symbols+0x54>
nop
add    $0x40,%rdi
cmp    $0x7,%edx
mov    -0x2c(%rsp),%ecx
mov    %esi,%r12d
jbe    1341 <of_add_to_multiple_symbols+0x241>
mov    (%rdi),%r9
mov    0x8(%rdi),%rax
mov    0x10(%rdi),%rbp
mov    0x18(%rdi),%rbx
mov    0x20(%rdi),%r8
mov    0x28(%rdi),%r15
mov    0x30(%rdi),%r14
mov    0x38(%rdi),%r11
cmp    $0x8,%ecx
jae    1190 <of_add_to_multiple_symbols+0x90>
mov    %r13,%r12
cmp    -0x28(%rsp),%r10d
jb     11f5 <of_add_to_multiple_symbols+0xf5>
jmp    124f <of_add_to_multiple_symbols+0x14f>
nopw   0x0(%rax,%rax,1)
mov    %r10d,%ecx
xor    %r10d,%r10d
mov    -0x38(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%r10,1),%r12
xor    %r12,(%r9,%r10,1)
xor    %r12,(%rax,%r10,1)
xor    %r12,0x0(%rbp,%r10,1)
xor    %r12,(%rbx,%r10,1)
xor    %r12,(%r8,%r10,1)
xor    %r12,(%r15,%r10,1)
xor    %r12,(%r14,%r10,1)
xor    %r12,(%r11,%r10,1)
add    $0x8,%r10
add    $0xffffffff,%esi
jne    11a0 <of_add_to_multiple_symbols+0xa0>
lea    (%r10,%r13,1),%r12
add    %r10,%r11
add    %r10,%r14
add    %r10,%r15
add    %r10,%r8
add    %r10,%rbx
add    %r10,%rbp
add    %r10,%rax
add    %r10,%r9
mov    %ecx,%r10d
cmp    -0x28(%rsp),%r10d
jae    124f <of_add_to_multiple_symbols+0x14f>
mov    (%r12),%esi
xor    %esi,(%r9)
add    $0x8,%r9
mov    (%r12),%esi
xor    %esi,(%rax)
mov    (%r12),%esi
xor    %esi,0x0(%rbp)
mov    (%r12),%esi
xor    %esi,(%rbx)
add    $0x8,%rax
add    $0x8,%rbp
add    $0x8,%rbx
mov    (%r12),%esi
xor    %esi,(%r8)
add    $0x8,%r8
mov    (%r12),%esi
xor    %esi,(%r15)
mov    (%r12),%esi
xor    %esi,(%r14)
mov    (%r12),%esi
xor    %esi,(%r11)
add    $0x8,%r15
add    $0x8,%r14
add    $0x8,%r11
add    $0x4,%r12
add    $0xfffffff8,%edx
mov    -0x3c(%rsp),%esi
test   %esi,%esi
je     1140 <of_add_to_multiple_symbols+0x40>
mov    (%r12),%cl
xor    %cl,(%r9)
mov    (%r12),%cl
xor    %cl,(%rax)
mov    (%r12),%cl
xor    %cl,0x0(%rbp)
mov    (%r12),%cl
xor    %cl,(%rbx)
mov    (%r12),%cl
xor    %cl,(%r8)
mov    (%r12),%cl
xor    %cl,(%r15)
mov    (%r12),%cl
xor    %cl,(%r14)
mov    (%r12),%cl
xor    %cl,(%r11)
mov    -0x3c(%rsp),%esi
cmp    $0x1,%esi
je     1140 <of_add_to_multiple_symbols+0x40>
mov    0x1(%r12),%cl
xor    %cl,0x1(%r9)
mov    0x1(%r12),%cl
xor    %cl,0x1(%rax)
mov    0x1(%r12),%cl
xor    %cl,0x1(%rbp)
mov    0x1(%r12),%cl
xor    %cl,0x1(%rbx)
mov    0x1(%r12),%cl
xor    %cl,0x1(%r8)
mov    0x1(%r12),%cl
xor    %cl,0x1(%r15)
mov    0x1(%r12),%cl
xor    %cl,0x1(%r14)
mov    0x1(%r12),%cl
xor    %cl,0x1(%r11)
mov    -0x3c(%rsp),%esi
cmp    $0x2,%esi
je     1140 <of_add_to_multiple_symbols+0x40>
mov    0x2(%r12),%cl
xor    %cl,0x2(%r9)
mov    0x2(%r12),%cl
xor    %cl,0x2(%rax)
mov    -0x3c(%rsp),%esi
mov    0x2(%r12),%al
xor    %al,0x2(%rbp)
mov    0x2(%r12),%al
xor    %al,0x2(%rbx)
mov    0x2(%r12),%al
xor    %al,0x2(%r8)
mov    0x2(%r12),%al
xor    %al,0x2(%r15)
mov    0x2(%r12),%al
xor    %al,0x2(%r14)
mov    0x2(%r12),%al
xor    %al,0x2(%r11)
jmp    1140 <of_add_to_multiple_symbols+0x40>
cmp    $0x4,%edx
jb     147f <of_add_to_multiple_symbols+0x37f>
mov    -0x38(%rsp),%r14
lea    (%r14,%r14,1),%r9d
jmp    136d <of_add_to_multiple_symbols+0x26d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x20,%rdi
cmp    $0x3,%edx
jbe    1484 <of_add_to_multiple_symbols+0x384>
mov    (%rdi),%rbx
mov    0x8(%rdi),%r15
mov    0x10(%rdi),%r8
mov    0x18(%rdi),%r11
cmp    $0x8,%ecx
jae    1390 <of_add_to_multiple_symbols+0x290>
mov    %r13,%r10
cmp    -0x28(%rsp),%r9d
jb     13da <of_add_to_multiple_symbols+0x2da>
jmp    1405 <of_add_to_multiple_symbols+0x305>
nopl   (%rax)
xor    %eax,%eax
mov    %r14d,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rax,1),%rsi
xor    %rsi,(%rbx,%rax,1)
xor    %rsi,(%r15,%rax,1)
xor    %rsi,(%r8,%rax,1)
xor    %rsi,(%r11,%rax,1)
add    $0x8,%rax
add    $0xffffffff,%ebp
jne    13a0 <of_add_to_multiple_symbols+0x2a0>
lea    (%rax,%r13,1),%r10
add    %rax,%r11
add    %rax,%r8
add    %rax,%r15
add    %rax,%rbx
mov    -0x3c(%rsp),%r12d
cmp    -0x28(%rsp),%r9d
jae    1405 <of_add_to_multiple_symbols+0x305>
mov    (%r10),%eax
xor    %eax,(%rbx)
add    $0x8,%rbx
mov    (%r10),%eax
xor    %eax,(%r15)
mov    (%r10),%eax
xor    %eax,(%r8)
mov    (%r10),%eax
xor    %eax,(%r11)
add    $0x8,%r15
add    $0x8,%r8
add    $0x8,%r11
add    $0x4,%r10
add    $0xfffffffc,%edx
test   %r12d,%r12d
je     1360 <of_add_to_multiple_symbols+0x260>
mov    (%r10),%al
xor    %al,(%rbx)
mov    (%r10),%al
xor    %al,(%r15)
mov    (%r10),%al
xor    %al,(%r8)
mov    (%r10),%al
xor    %al,(%r11)
cmp    $0x1,%r12d
je     1360 <of_add_to_multiple_symbols+0x260>
mov    0x1(%r10),%al
xor    %al,0x1(%rbx)
mov    0x1(%r10),%al
xor    %al,0x1(%r15)
mov    0x1(%r10),%al
xor    %al,0x1(%r8)
mov    0x1(%r10),%al
xor    %al,0x1(%r11)
cmp    $0x2,%r12d
je     1360 <of_add_to_multiple_symbols+0x260>
mov    0x2(%r10),%al
xor    %al,0x2(%rbx)
mov    0x2(%r10),%al
xor    %al,0x2(%r15)
mov    0x2(%r10),%al
xor    %al,0x2(%r8)
mov    0x2(%r10),%al
xor    %al,0x2(%r11)
jmp    1360 <of_add_to_multiple_symbols+0x260>
mov    -0x38(%rsp),%r14
cmp    $0x2,%edx
jb     173d <of_add_to_multiple_symbols+0x63d>
lea    (%r14,%r14,1),%r10d
lea    -0x1(%r14),%eax
lea    0x8(,%rax,8),%rsi
add    %r13,%rsi
mov    %rsi,-0x10(%rsp)
mov    %rax,-0x8(%rsp)
lea    0x1(%rax),%r15
mov    %r15,-0x20(%rsp)
and    $0xfffffffffffffffc,%r15
mov    %r14d,%eax
sub    %r15d,%eax
mov    %eax,-0x24(%rsp)
lea    0x0(,%r15,8),%rax
add    %r13,%rax
mov    %rax,-0x18(%rsp)
jmp    14ed <of_add_to_multiple_symbols+0x3ed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x10,%rdi
cmp    $0x1,%edx
jbe    173d <of_add_to_multiple_symbols+0x63d>
mov    (%rdi),%rax
mov    0x8(%rdi),%rbp
cmp    $0x8,%ecx
jae    1510 <of_add_to_multiple_symbols+0x410>
mov    %rax,%r9
mov    %rbp,%r8
mov    %r13,%rsi
jmp    16af <of_add_to_multiple_symbols+0x5af>
nopw   0x0(%rax,%rax,1)
cmpl   $0x3,-0x8(%rsp)
jb     1630 <of_add_to_multiple_symbols+0x530>
mov    -0x20(%rsp),%rcx
lea    (%rax,%rcx,8),%rsi
lea    0x0(,%rcx,8),%rbx
add    %rbp,%rbx
cmp    %rbx,%rax
setb   %r14b
cmp    %rsi,%rbp
setb   %r12b
mov    -0x10(%rsp),%rcx
cmp    %rax,%rcx
seta   %r11b
cmp    %r13,%rsi
seta   %sil
cmp    %rbp,%rcx
seta   %r8b
cmp    %r13,%rbx
seta   %r9b
test   %r12b,%r14b
jne    1717 <of_add_to_multiple_symbols+0x617>
and    %sil,%r11b
jne    1717 <of_add_to_multiple_symbols+0x617>
and    %r9b,%r8b
mov    -0x3c(%rsp),%r12d
mov    -0x2c(%rsp),%ecx
jne    1630 <of_add_to_multiple_symbols+0x530>
lea    0x0(,%r15,8),%r8
add    %rbp,%r8
lea    (%rax,%r15,8),%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%r13,%rsi,8),%xmm0
movups 0x10(%r13,%rsi,8),%xmm1
movups (%rax,%rsi,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rax,%rsi,8),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rax,%rsi,8)
movups %xmm0,0x10(%rax,%rsi,8)
movups 0x0(%r13,%rsi,8),%xmm0
movups 0x10(%r13,%rsi,8),%xmm1
movups 0x0(%rbp,%rsi,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbp,%rsi,8),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x0(%rbp,%rsi,8)
movups %xmm0,0x10(%rbp,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r15
jne    15a0 <of_add_to_multiple_symbols+0x4a0>
mov    -0x24(%rsp),%eax
mov    %eax,%r14d
mov    -0x18(%rsp),%rsi
cmp    %r15,-0x20(%rsp)
je     16af <of_add_to_multiple_symbols+0x5af>
nopw   0x0(%rax,%rax,1)
test   $0x1,%r14b
jne    1644 <of_add_to_multiple_symbols+0x544>
mov    %r14d,%eax
cmp    $0x1,%r14d
jne    1666 <of_add_to_multiple_symbols+0x566>
jmp    16af <of_add_to_multiple_symbols+0x5af>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x38(%rsp),%r14
mov    %r13,%rsi
mov    %rbp,%r8
mov    %rax,%r9
test   $0x1,%r14b
je     1616 <of_add_to_multiple_symbols+0x516>
mov    (%rsi),%rax
xor    %rax,(%r9)
mov    (%rsi),%rax
xor    %rax,(%r8)
add    $0x8,%rsi
add    $0x8,%r9
add    $0x8,%r8
lea    -0x1(%r14),%eax
cmp    $0x1,%r14d
je     16af <of_add_to_multiple_symbols+0x5af>
mov    %eax,%r14d
xor    %eax,%eax
xor    %ebx,%ebx
nopl   (%rax)
mov    (%rsi,%rbx,8),%rbp
xor    %rbp,(%r9,%rbx,8)
mov    (%rsi,%rbx,8),%rbp
xor    %rbp,(%r8,%rbx,8)
mov    0x8(%rsi,%rbx,8),%rbp
xor    %rbp,0x8(%r9,%rbx,8)
mov    0x8(%rsi,%rbx,8),%rbp
xor    %rbp,0x8(%r8,%rbx,8)
add    $0x2,%rbx
add    $0xfffffffffffffff0,%rax
cmp    %ebx,%r14d
jne    1670 <of_add_to_multiple_symbols+0x570>
sub    %rax,%rsi
sub    %rax,%r8
sub    %rax,%r9
mov    -0x3c(%rsp),%r12d
cmp    -0x28(%rsp),%r10d
jae    16cc <of_add_to_multiple_symbols+0x5cc>
mov    (%rsi),%eax
xor    %eax,(%r9)
mov    (%rsi),%eax
xor    %eax,(%r8)
add    $0x8,%r9
add    $0x8,%r8
add    $0x4,%rsi
add    $0xfffffffe,%edx
test   %r12d,%r12d
je     14e0 <of_add_to_multiple_symbols+0x3e0>
mov    (%rsi),%al
xor    %al,(%r9)
mov    (%rsi),%al
xor    %al,(%r8)
cmp    $0x1,%r12d
je     14e0 <of_add_to_multiple_symbols+0x3e0>
mov    0x1(%rsi),%al
xor    %al,0x1(%r9)
mov    0x1(%rsi),%al
xor    %al,0x1(%r8)
cmp    $0x2,%r12d
je     14e0 <of_add_to_multiple_symbols+0x3e0>
mov    0x2(%rsi),%al
xor    %al,0x2(%r9)
mov    0x2(%rsi),%al
xor    %al,0x2(%r8)
jmp    14e0 <of_add_to_multiple_symbols+0x3e0>
mov    -0x38(%rsp),%r14
mov    %r13,%rsi
mov    %rbp,%r8
mov    %rax,%r9
mov    -0x3c(%rsp),%r12d
mov    -0x2c(%rsp),%ecx
test   $0x1,%r14b
je     1616 <of_add_to_multiple_symbols+0x516>
jmp    1644 <of_add_to_multiple_symbols+0x544>
test   %edx,%edx
je     190c <of_add_to_multiple_symbols+0x80c>
mov    (%rdi),%rdx
cmp    $0x8,%ecx
jae    1757 <of_add_to_multiple_symbols+0x657>
mov    -0x38(%rsp),%rbx
jmp    18d1 <of_add_to_multiple_symbols+0x7d1>
mov    -0x38(%rsp),%rbx
lea    -0x1(%rbx),%eax
cmp    $0x3,%eax
jb     1789 <of_add_to_multiple_symbols+0x689>
lea    0x8(,%rax,8),%rcx
add    %r13,%rcx
cmp    %rdx,%rcx
jbe    180e <of_add_to_multiple_symbols+0x70e>
lea    (%rdx,%rax,8),%rcx
add    $0x8,%rcx
cmp    %r13,%rcx
jbe    180e <of_add_to_multiple_symbols+0x70e>
mov    %ebx,%eax
lea    -0x1(%rax),%ecx
test   $0x3,%al
je     17b9 <of_add_to_multiple_symbols+0x6b9>
mov    %eax,%edi
and    $0x3,%edi
xor    %esi,%esi
nopl   0x0(%rax)
mov    0x0(%r13),%rbp
xor    %rbp,(%rdx)
add    $0x8,%rdx
add    $0x8,%r13
add    $0x1,%rsi
cmp    %esi,%edi
jne    17a0 <of_add_to_multiple_symbols+0x6a0>
sub    %esi,%eax
cmp    $0x3,%ecx
mov    -0x3c(%rsp),%r12d
jb     18d1 <of_add_to_multiple_symbols+0x7d1>
mov    %eax,%eax
xor    %esi,%esi
xor    %ecx,%ecx
nopl   (%rax)
mov    0x0(%r13,%rsi,8),%rdi
xor    %rdi,(%rdx,%rsi,8)
mov    0x8(%r13,%rsi,8),%rdi
xor    %rdi,0x8(%rdx,%rsi,8)
mov    0x10(%r13,%rsi,8),%rdi
xor    %rdi,0x10(%rdx,%rsi,8)
mov    0x18(%r13,%rsi,8),%rdi
xor    %rdi,0x18(%rdx,%rsi,8)
add    $0xffffffffffffffe0,%rcx
add    $0x4,%rsi
cmp    %esi,%eax
jne    17d0 <of_add_to_multiple_symbols+0x6d0>
sub    %rcx,%r13
sub    %rcx,%rdx
jmp    18cc <of_add_to_multiple_symbols+0x7cc>
add    $0x1,%rax
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1920 <of_add_to_multiple_symbols+0x820>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups 0x0(%r13,%rsi,8),%xmm0
movups 0x10(%r13,%rsi,8),%xmm1
movups (%rdx,%rsi,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdx,%rsi,8),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%rdx,%rsi,8),%xmm1
movups 0x30(%rdx,%rsi,8),%xmm3
movups %xmm2,(%rdx,%rsi,8)
movups %xmm0,0x10(%rdx,%rsi,8)
movups 0x20(%r13,%rsi,8),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%r13,%rsi,8),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rdx,%rsi,8)
movups %xmm1,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1840 <of_add_to_multiple_symbols+0x740>
test   $0x1,%bpl
je     18be <of_add_to_multiple_symbols+0x7be>
movups 0x0(%r13,%rsi,8),%xmm0
movups 0x10(%r13,%rsi,8),%xmm1
movups (%rdx,%rsi,8),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rdx,%rsi,8),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rdx,%rsi,8)
movups %xmm0,0x10(%rdx,%rsi,8)
lea    0x0(%r13,%rcx,8),%r13
lea    (%rdx,%rcx,8),%rdx
cmp    %rcx,%rax
jne    1917 <of_add_to_multiple_symbols+0x817>
mov    -0x3c(%rsp),%r12d
add    %ebx,%ebx
cmp    -0x28(%rsp),%ebx
jae    18e7 <of_add_to_multiple_symbols+0x7e7>
mov    0x0(%r13),%eax
xor    %eax,(%rdx)
add    $0x4,%rdx
add    $0x4,%r13
test   %r12d,%r12d
je     190c <of_add_to_multiple_symbols+0x80c>
mov    0x0(%r13),%al
xor    %al,(%rdx)
cmp    $0x1,%r12d
je     190c <of_add_to_multiple_symbols+0x80c>
mov    0x1(%r13),%al
xor    %al,0x1(%rdx)
cmp    $0x2,%r12d
je     190c <of_add_to_multiple_symbols+0x80c>
mov    0x2(%r13),%al
xor    %al,0x2(%rdx)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebx,%eax
sub    %ecx,%eax
jmp    178b <of_add_to_multiple_symbols+0x68b>
xor    %esi,%esi
test   $0x1,%bpl
jne    189a <of_add_to_multiple_symbols+0x79a>
jmp    18be <of_add_to_multiple_symbols+0x7be>

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

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