void merge(char *str, int start, int mid, int high) {
  int n1 = mid - start + 1;
  int n2 = high - mid;
  int L[n1], R[n2];
  int i, j, k;
  for (i = 0; i < n1; i++) {
    L[i] = str[start + i];
  }
  for (i = 0; i < n2; i++) {
    R[i] = str[mid + i + 1];
  }
  i = 0, j = 0, k = start;
  while (i < n1 && j < n2) {
    if (L[i] < R[j]) {
      str[k] = L[i];
      k++;
      i++;
    } else {
      str[k] = R[j];
      k++;
      j++;
    }
  }
  while (i < n1) {
    str[k] = L[i];
    k++;
    i++;
  }
  while (j < n2) {
    str[k] = R[j];
    k++;
    j++;
  }
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x28(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11b2 <merge+0xb2>
mov    -0x58(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    -0x3c(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%edx
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    117c <merge+0x7c>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11f2 <merge+0xf2>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%edx
add    -0x3c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%edx
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11b9 <merge+0xb9>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x59(%rbp)
jge    1223 <merge+0x123>
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    1233 <merge+0x133>
jmp    12ad <merge+0x1ad>
mov    -0x50(%rbp),%rcx
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
movslq -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    127e <merge+0x17e>
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12a8 <merge+0x1a8>
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1206 <merge+0x106>
jmp    12b2 <merge+0x1b2>
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12ed <merge+0x1ed>
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12b2 <merge+0x1b2>
jmp    12f2 <merge+0x1f2>
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    132d <merge+0x22d>
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12f2 <merge+0x1f2>
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r13d
mov    %edx,%r8d
sub    %esi,%r8d
lea    0x1(%r8),%r11d
sub    %edx,%ecx
lea    0xf(,%r11,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rsi
sub    %rax,%rsi
mov    %rsi,%rsp
lea    0xf(,%rcx,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r10
sub    %rax,%r10
mov    %r10,%rsp
test   %r8d,%r8d
mov    %r13d,-0x2c(%rbp)
js     1271 <merge+0x171>
movslq %r13d,%r14
cmp    $0x8,%r11d
jae    1167 <merge+0x67>
xor    %eax,%eax
jmp    125a <merge+0x15a>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbx
mov    %rbx,%r15
shr    $0x3,%r15
add    $0x1,%r15
test   %rbx,%rbx
je     1213 <merge+0x113>
mov    %r15,%r12
and    $0xfffffffffffffffe,%r12
lea    (%r14,%rdi,1),%r13
add    $0xc,%r13
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movd   -0xc(%r13,%rbx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   -0x8(%r13,%rbx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqa %xmm0,(%rsi,%rbx,4)
movdqa %xmm1,0x10(%rsi,%rbx,4)
movd   -0x4(%r13,%rbx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x0(%r13,%rbx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqa %xmm0,0x20(%rsi,%rbx,4)
movdqa %xmm1,0x30(%rsi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%r12
jne    11a0 <merge+0xa0>
jmp    1215 <merge+0x115>
xor    %ebx,%ebx
test   $0x1,%r15b
mov    -0x2c(%rbp),%r13d
je     1255 <merge+0x155>
lea    (%rbx,%r14,1),%r15
movd   (%rdi,%r15,1),%xmm0
movd   0x4(%rdi,%r15,1),%xmm1
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
movdqa %xmm0,(%rsi,%rbx,4)
movdqa %xmm1,0x10(%rsi,%rbx,4)
cmp    %r11,%rax
je     1271 <merge+0x171>
add    %rdi,%r14
nopl   (%rax)
movsbl (%r14,%rax,1),%ebx
mov    %ebx,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%r11
jne    1260 <merge+0x160>
test   %ecx,%ecx
jle    12cc <merge+0x1cc>
cmp    $0x8,%ecx
jae    12d6 <merge+0x1d6>
xor    %r12d,%r12d
mov    %r12,%r11
not    %r11
add    %rcx,%r11
mov    %rcx,%r15
and    $0x3,%r15
je     13e7 <merge+0x2e7>
lea    0x1(%rdx),%r14d
nopw   0x0(%rax,%rax,1)
lea    0x1(%r12),%rax
lea    (%r14,%r12,1),%ebx
movslq %ebx,%rbx
movsbl (%rdi,%rbx,1),%ebx
mov    %ebx,(%r10,%r12,4)
mov    %rax,%r12
add    $0xffffffffffffffff,%r15
jne    12a0 <merge+0x1a0>
cmp    $0x3,%r11
jae    13f0 <merge+0x2f0>
jmp    144e <merge+0x34e>
mov    %r8,%r9
xor    %ebx,%ebx
jmp    14c3 <merge+0x3c3>
lea    -0x1(%rcx),%rax
lea    0x1(%rdx),%r11d
lea    (%rdx,%rax,1),%ebx
add    $0x1,%ebx
xor    %r12d,%r12d
cmp    %r11d,%ebx
jl     127d <merge+0x17d>
shr    $0x20,%rax
jne    127d <merge+0x17d>
mov    %ecx,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     178d <merge+0x68d>
mov    %r11,%r14
and    $0xfffffffffffffffe,%r14
lea    0x9(%rdx),%eax
xor    %r15d,%r15d
nop
lea    -0x8(%rax),%ebx
movslq %ebx,%rbx
movd   (%rdi,%rbx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x4(%rdi,%rbx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqa %xmm0,(%r10,%r15,4)
movdqa %xmm1,0x10(%r10,%r15,4)
cltq
movd   (%rdi,%rax,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x4(%rdi,%rax,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqa %xmm0,0x20(%r10,%r15,4)
movdqa %xmm1,0x30(%r10,%r15,4)
add    $0x10,%r15
add    $0x10,%eax
add    $0xfffffffffffffffe,%r14
jne    1320 <merge+0x220>
test   $0x1,%r11b
je     13dc <merge+0x2dc>
mov    %r15d,%eax
or     $0x1,%eax
add    %edx,%eax
cltq
movd   (%rdi,%rax,1),%xmm0
movd   0x4(%rdi,%rax,1),%xmm1
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
movdqa %xmm0,(%r10,%r15,4)
movdqa %xmm1,0x10(%r10,%r15,4)
cmp    %rcx,%r12
jne    127d <merge+0x17d>
jmp    144e <merge+0x34e>
mov    %r12,%rax
cmp    $0x3,%r11
jb     144e <merge+0x34e>
mov    %edx,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r11,%rax,1),%ebx
add    $0x1,%ebx
movslq %ebx,%rbx
movsbl (%rdi,%rbx,1),%ebx
mov    %ebx,(%r10,%rax,4)
lea    0x2(%r11,%rax,1),%ebx
movslq %ebx,%rbx
movsbl (%rdi,%rbx,1),%ebx
mov    %ebx,0x4(%r10,%rax,4)
lea    0x3(%r11,%rax,1),%ebx
movslq %ebx,%rbx
movsbl (%rdi,%rbx,1),%ebx
mov    %ebx,0x8(%r10,%rax,4)
lea    0x4(%r11,%rax,1),%ebx
movslq %ebx,%rbx
movsbl (%rdi,%rbx,1),%ebx
mov    %ebx,0xc(%r10,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1400 <merge+0x300>
xor    %ebx,%ebx
mov    %r8,%r9
test   %r8d,%r8d
js     14c3 <merge+0x3c3>
mov    $0x0,%r12d
mov    %r13d,%r11d
test   %ecx,%ecx
jle    14c9 <merge+0x3c9>
mov    -0x2c(%rbp),%ebx
movslq %ebx,%rax
add    %rdi,%rax
xor    %r12d,%r12d
mov    %ebx,%r11d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%r14d
mov    %r12d,%r15d
mov    %ebx,%ebx
mov    (%rsi,%rbx,4),%r13d
mov    %r12d,%ebx
mov    (%r10,%rbx,4),%r8d
xor    %r12d,%r12d
xor    %ebx,%ebx
cmp    %r8d,%r13d
setge  %r12b
setl   %bl
cmovl  %r13d,%r8d
add    %r14d,%ebx
add    %r15d,%r12d
mov    %r8b,(%rax)
add    $0x1,%r11d
cmp    %r9d,%ebx
jg     14c9 <merge+0x3c9>
add    $0x1,%rax
cmp    %ecx,%r12d
jl     1480 <merge+0x380>
jmp    14c9 <merge+0x3c9>
xor    %r12d,%r12d
mov    %r13d,%r11d
mov    %r9,%r8
cmp    %r8d,%ebx
jg     1633 <merge+0x533>
movslq %r11d,%r11
movslq %ebx,%r14
mov    -0x2c(%rbp),%eax
add    %ebx,%eax
sub    %eax,%edx
cmp    $0x7,%edx
jae    14ef <merge+0x3ef>
mov    %rsi,%r9
jmp    1604 <merge+0x504>
add    $0x1,%rdx
mov    %rdx,%r15
and    $0xfffffffffffffff8,%r15
lea    -0x8(%r15),%rax
mov    %rax,%r13
shr    $0x3,%r13
add    $0x1,%r13
test   %rax,%rax
mov    %rsi,%r9
mov    %r14,-0x38(%rbp)
je     15ae <merge+0x4ae>
mov    %r13,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r9,%r14,4),%rsi
add    $0x30,%rsi
lea    (%r11,%rdi,1),%r14
add    $0xc,%r14
xor    %ebx,%ebx
movdqa 0xac6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rbx,4),%xmm1
movdqu -0x20(%rsi,%rbx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,-0xc(%r14,%rbx,1)
movd   %xmm2,-0x8(%r14,%rbx,1)
movdqu -0x10(%rsi,%rbx,4),%xmm1
movdqu (%rsi,%rbx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,-0x4(%r14,%rbx,1)
movd   %xmm2,(%r14,%rbx,1)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    1540 <merge+0x440>
jmp    15b0 <merge+0x4b0>
xor    %ebx,%ebx
test   $0x1,%r13b
mov    -0x38(%rbp),%r14
je     15f9 <merge+0x4f9>
lea    (%rbx,%r14,1),%rax
add    %r11,%rbx
movdqu (%r9,%rax,4),%xmm0
movdqu 0x10(%r9,%rax,4),%xmm1
movdqa 0xa2a(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rdi,%rbx,1)
movd   %xmm1,0x4(%rdi,%rbx,1)
add    %r15,%r11
cmp    %r15,%rdx
je     1633 <merge+0x533>
add    %r15,%r14
lea    (%r9,%r14,4),%rax
sub    %r14d,%r8d
add    $0x1,%r8d
lea    (%rdi,%r11,1),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rax,%rdx,4),%ebx
mov    %bl,(%rsi,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%r8d
jne    1620 <merge+0x520>
add    %rdx,%r11
cmp    %ecx,%r12d
jge    1774 <merge+0x674>
movslq %r11d,%r8
movslq %r12d,%rax
movslq %ecx,%r15
mov    %r15,%r14
sub    %rax,%r14
cmp    $0x8,%r14
jb     1758 <merge+0x658>
mov    %r14,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1783 <merge+0x683>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r10,%rax,4),%rsi
add    $0x30,%rsi
lea    (%r8,%rdi,1),%rcx
add    $0xc,%rcx
xor    %edx,%edx
movdqa 0x96b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x30(%rsi,%rdx,4),%xmm1
movdqu -0x20(%rsi,%rdx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,-0xc(%rcx,%rdx,1)
movd   %xmm2,-0x8(%rcx,%rdx,1)
movdqu -0x10(%rsi,%rdx,4),%xmm1
movdqu (%rsi,%rdx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,-0x4(%rcx,%rdx,1)
movd   %xmm2,(%rcx,%rdx,1)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbx
jne    16a0 <merge+0x5a0>
test   $0x1,%r11b
je     174d <merge+0x64d>
lea    (%rdx,%rax,1),%rcx
add    %r8,%rdx
movdqu (%r10,%rcx,4),%xmm0
movdqu 0x10(%r10,%rcx,4),%xmm1
movdqa 0x8d6(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rdi,%rdx,1)
movd   %xmm1,0x4(%rdi,%rdx,1)
cmp    %r9,%r14
je     1774 <merge+0x674>
add    %r9,%rax
add    %r9,%r8
add    %r8,%rdi
nopl   0x0(%rax,%rax,1)
movzbl (%r10,%rax,4),%ecx
mov    %cl,(%rdi)
add    $0x1,%rax
add    $0x1,%rdi
cmp    %r15,%rax
jl     1760 <merge+0x660>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r11b
jne    170e <merge+0x60e>
jmp    174d <merge+0x64d>
xor    %r15d,%r15d
test   $0x1,%r11b
jne    13a0 <merge+0x2a0>
jmp    13dc <merge+0x2dc>

LLVM IR (-O0):
define void @merge(i8* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i64
%13 = alloca i64
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%17 = load i32, i32* %7
%18 = load i32, i32* %6
%19 = sub nsw i32 %17, %18
%20 = add nsw i32 %19, 1
store i32 %20, i32* %9
%21 = load i32, i32* %8
%22 = load i32, i32* %7
%23 = sub nsw i32 %21, %22
store i32 %23, i32* %10
%24 = load i32, i32* %9
%25 = zext i32 %24 to i64
%26 = call i8* @llvm.stacksave()
store i8* %26, i8** %11
%27 = alloca i32, i64 %25
store i64 %25, i64* %12
%28 = load i32, i32* %10
%29 = zext i32 %28 to i64
%30 = alloca i32, i64 %29
store i64 %29, i64* %13
store i32 0, i32* %14
br label %31
31: ; preds = %47, %4
%32 = load i32, i32* %14
%33 = load i32, i32* %9
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %50
35: ; preds = %31
%36 = load i8*, i8** %5
%37 = load i32, i32* %6
%38 = load i32, i32* %14
%39 = add nsw i32 %37, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %36, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = load i32, i32* %14
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %27, i64 %45
store i32 %43, i32* %46
br label %47
47: ; preds = %35
%48 = load i32, i32* %14
%49 = add nsw i32 %48, 1
store i32 %49, i32* %14
br label %31
50: ; preds = %31
store i32 0, i32* %14
br label %51
51: ; preds = %68, %50
%52 = load i32, i32* %14
%53 = load i32, i32* %10
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %71
55: ; preds = %51
%56 = load i8*, i8** %5
%57 = load i32, i32* %7
%58 = load i32, i32* %14
%59 = add nsw i32 %57, %58
%60 = add nsw i32 %59, 1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %56, i64 %61
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = load i32, i32* %14
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %30, i64 %66
store i32 %64, i32* %67
br label %68
68: ; preds = %55
%69 = load i32, i32* %14
%70 = add nsw i32 %69, 1
store i32 %70, i32* %14
br label %51
71: ; preds = %51
store i32 0, i32* %14
store i32 0, i32* %15
%72 = load i32, i32* %6
store i32 %72, i32* %16
br label %73
73: ; preds = %121, %71
%74 = load i32, i32* %14
%75 = load i32, i32* %9
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %81
77: ; preds = %73
%78 = load i32, i32* %15
%79 = load i32, i32* %10
%80 = icmp slt i32 %78, %79
br label %81
81: ; preds = %77, %73
%82 = phi i1 [ false, %73 ], [ %80, %77 ]
br i1 %82, label %83, label %122
83: ; preds = %81
%84 = load i32, i32* %14
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %27, i64 %85
%87 = load i32, i32* %86
%88 = load i32, i32* %15
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %30, i64 %89
%91 = load i32, i32* %90
%92 = icmp slt i32 %87, %91
br i1 %92, label %93, label %107
93: ; preds = %83
%94 = load i32, i32* %14
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %27, i64 %95
%97 = load i32, i32* %96
%98 = trunc i32 %97 to i8
%99 = load i8*, i8** %5
%100 = load i32, i32* %16
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %99, i64 %101
store i8 %98, i8* %102
%103 = load i32, i32* %16
%104 = add nsw i32 %103, 1
store i32 %104, i32* %16
%105 = load i32, i32* %14
%106 = add nsw i32 %105, 1
store i32 %106, i32* %14
br label %121
107: ; preds = %83
%108 = load i32, i32* %15
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %30, i64 %109
%111 = load i32, i32* %110
%112 = trunc i32 %111 to i8
%113 = load i8*, i8** %5
%114 = load i32, i32* %16
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %113, i64 %115
store i8 %112, i8* %116
%117 = load i32, i32* %16
%118 = add nsw i32 %117, 1
store i32 %118, i32* %16
%119 = load i32, i32* %15
%120 = add nsw i32 %119, 1
store i32 %120, i32* %15
br label %121
121: ; preds = %107, %93
br label %73
122: ; preds = %81
br label %123
123: ; preds = %127, %122
%124 = load i32, i32* %14
%125 = load i32, i32* %9
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %141
127: ; preds = %123
%128 = load i32, i32* %14
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i32, i32* %27, i64 %129
%131 = load i32, i32* %130
%132 = trunc i32 %131 to i8
%133 = load i8*, i8** %5
%134 = load i32, i32* %16
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8, i8* %133, i64 %135
store i8 %132, i8* %136
%137 = load i32, i32* %16
%138 = add nsw i32 %137, 1
store i32 %138, i32* %16
%139 = load i32, i32* %14
%140 = add nsw i32 %139, 1
store i32 %140, i32* %14
br label %123
141: ; preds = %123
br label %142
142: ; preds = %146, %141
%143 = load i32, i32* %15
%144 = load i32, i32* %10
%145 = icmp slt i32 %143, %144
br i1 %145, label %146, label %160
146: ; preds = %142
%147 = load i32, i32* %15
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %30, i64 %148
%150 = load i32, i32* %149
%151 = trunc i32 %150 to i8
%152 = load i8*, i8** %5
%153 = load i32, i32* %16
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i8, i8* %152, i64 %154
store i8 %151, i8* %155
%156 = load i32, i32* %16
%157 = add nsw i32 %156, 1
store i32 %157, i32* %16
%158 = load i32, i32* %15
%159 = add nsw i32 %158, 1
store i32 %159, i32* %15
br label %142
160: ; preds = %142
%161 = load i8*, i8** %11
ret void
}

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