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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int nlz(unsigned short const);
void divmnu(unsigned short q[], unsigned short r[], const unsigned short u[],
            const unsigned short v[], const int m, const int n) {
  const unsigned int b = 65536;
  unsigned qhat;
  unsigned rhat;
  unsigned p;
  int s, i, j, t, k;
  unsigned short vn[8];
  unsigned short un[18];
  if (n == 1) {
    k = 0;
    for (j = m - 1; j >= 0; j--) {
      q[j] = (k * b + u[j]) / v[0];
      k = (k * b + u[j]) - q[j] * v[0];
    }
    r[0] = k;
    return;
  }
  s = nlz(v[n - 1]);
  for (i = n - 1; i > 0; i--)
    vn[i] = (v[i] << s) | (v[i - 1] >> (16 - s));
  vn[0] = v[0] << s;
  un[m] = u[m - 1] >> (16 - s);
  for (i = m - 1; i > 0; i--)
    un[i] = (u[i] << s) | (u[i - 1] >> (16 - s));
  un[0] = u[0] << s;
  for (j = m - n; j >= 0; j--) {
    qhat = (un[j + n] * b + un[j + n - 1]) / vn[n - 1];
    rhat = (un[j + n] * b + un[j + n - 1]) - qhat * vn[n - 1];
  again:
    if (qhat >= b || qhat * vn[n - 2] > b * rhat + un[j + n - 2]) {
      qhat = qhat - 1;
      rhat = rhat + vn[n - 1];
      if (rhat < b)
        goto again;
    }
    k = 0;
    for (i = 0; i < n; i++) {
      p = qhat * vn[i];
      t = un[i + j] - k - (p & 0xFFFF);
      un[i + j] = t;
      k = (p >> 16) - (t >> 16);
    }
    t = un[j + n] - k;
    un[j + n] = t;
    q[j] = qhat;
    if (t < 0) {
      q[j] = q[j] - 1;
      k = 0;
      for (i = 0; i < n; i++) {
        t = un[i + j] + vn[i] + k;
        un[i + j] = t;
        k = t >> 16;
      }
      un[j + n] = un[j + n] + k;
    }
  }
  for (i = 0; i < n; i++)
    r[i] = (un[i] >> s) | (un[i + 1] << (16 - s));
}


x86 assembly (clang, -O0):
<divmnu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x10000,-0x2c(%rbp)
cmpl   $0x1,-0x28(%rbp)
jne    11db <divmnu+0xcb>
movl   $0x0,-0x4c(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     11c9 <divmnu+0xb9>
mov    -0x4c(%rbp),%eax
shl    $0x10,%eax
mov    -0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movzwl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
mov    -0x20(%rbp),%rcx
movzwl (%rcx),%ecx
xor    %edx,%edx
div    %ecx
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x4c(%rbp),%eax
shl    $0x10,%eax
mov    -0x18(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movzwl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movzwl (%rcx,%rdx,2),%ecx
mov    -0x20(%rbp),%rdx
movzwl (%rdx),%edx
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1154 <divmnu+0x44>
mov    -0x4c(%rbp),%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %cx,(%rax)
jmp    15f5 <divmnu+0x4e5>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edi
call   1030 <nlz@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    1251 <divmnu+0x141>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
mov    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    -0x20(%rbp),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzwl (%rcx,%rdx,2),%edx
mov    $0x10,%ecx
sub    -0x3c(%rbp),%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %ax,%cx
movslq -0x40(%rbp),%rax
mov    %cx,-0x60(%rbp,%rax,2)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    11fd <divmnu+0xed>
mov    -0x20(%rbp),%rax
movzwl (%rax),%eax
mov    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %ax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%eax
mov    $0x10,%ecx
sub    -0x3c(%rbp),%ecx
sar    %cl,%eax
mov    %ax,%cx
movslq -0x24(%rbp),%rax
mov    %cx,-0x90(%rbp,%rax,2)
ff
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    12eb <divmnu+0x1db>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
mov    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    -0x18(%rbp),%rcx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzwl (%rcx,%rdx,2),%edx
mov    $0x10,%ecx
sub    -0x3c(%rbp),%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %ax,%cx
movslq -0x40(%rbp),%rax
mov    %cx,-0x90(%rbp,%rax,2)
ff
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1294 <divmnu+0x184>
mov    -0x18(%rbp),%rax
movzwl (%rax),%eax
mov    -0x3c(%rbp),%ecx
shl    %cl,%eax
mov    %ax,-0x90(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1595 <divmnu+0x485>
mov    -0x44(%rbp),%eax
add    -0x28(%rbp),%eax
cltq
movzwl -0x90(%rbp,%rax,2),%eax
ff
shl    $0x10,%eax
mov    -0x44(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzwl -0x90(%rbp,%rcx,2),%ecx
ff
add    %ecx,%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzwl -0x60(%rbp,%rcx,2),%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    -0x28(%rbp),%eax
cltq
movzwl -0x90(%rbp,%rax,2),%eax
ff
shl    $0x10,%eax
mov    -0x44(%rbp),%ecx
add    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzwl -0x90(%rbp,%rcx,2),%ecx
ff
add    %ecx,%eax
mov    -0x30(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzwl -0x60(%rbp,%rdx,2),%edx
imul   %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x10000,-0x30(%rbp)
jae    13d6 <divmnu+0x2c6>
mov    -0x30(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movzwl -0x60(%rbp,%rcx,2),%ecx
imul   %ecx,%eax
mov    -0x34(%rbp),%ecx
shl    $0x10,%ecx
mov    -0x44(%rbp),%edx
add    -0x28(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
movzwl -0x90(%rbp,%rdx,2),%edx
ff
add    %edx,%ecx
cmp    %ecx,%eax
jbe    140c <divmnu+0x2fc>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzwl -0x60(%rbp,%rcx,2),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x10000,-0x34(%rbp)
jae    1407 <divmnu+0x2f7>
jmp    1391 <divmnu+0x281>
jmp    140c <divmnu+0x2fc>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    148e <divmnu+0x37e>
mov    -0x30(%rbp),%eax
movslq -0x40(%rbp),%rcx
movzwl -0x60(%rbp,%rcx,2),%ecx
imul   %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    -0x44(%rbp),%eax
cltq
movzwl -0x90(%rbp,%rax,2),%eax
ff
sub    -0x4c(%rbp),%eax
mov    -0x38(%rbp),%ecx
and    $0xffff,%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%eax
add    -0x44(%rbp),%eax
cltq
mov    %cx,-0x90(%rbp,%rax,2)
ff
mov    -0x38(%rbp),%eax
shr    $0x10,%eax
mov    -0x48(%rbp),%ecx
sar    $0x10,%ecx
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    141a <divmnu+0x30a>
mov    -0x44(%rbp),%eax
add    -0x28(%rbp),%eax
cltq
movzwl -0x90(%rbp,%rax,2),%eax
ff
sub    -0x4c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %ax,%cx
mov    -0x44(%rbp),%eax
add    -0x28(%rbp),%eax
cltq
mov    %cx,-0x90(%rbp,%rax,2)
ff
mov    -0x30(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
cmpl   $0x0,-0x48(%rbp)
jge    1582 <divmnu+0x472>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
sub    $0x1,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    155c <divmnu+0x44c>
mov    -0x40(%rbp),%eax
add    -0x44(%rbp),%eax
cltq
movzwl -0x90(%rbp,%rax,2),%eax
ff
movslq -0x40(%rbp),%rcx
movzwl -0x60(%rbp,%rcx,2),%ecx
add    %ecx,%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %ax,%cx
mov    -0x40(%rbp),%eax
add    -0x44(%rbp),%eax
cltq
mov    %cx,-0x90(%rbp,%rax,2)
ff
mov    -0x48(%rbp),%eax
sar    $0x10,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1502 <divmnu+0x3f2>
mov    -0x44(%rbp),%eax
add    -0x28(%rbp),%eax
cltq
movzwl -0x90(%rbp,%rax,2),%eax
ff
add    -0x4c(%rbp),%eax
mov    %ax,%cx
mov    -0x44(%rbp),%eax
add    -0x28(%rbp),%eax
cltq
mov    %cx,-0x90(%rbp,%rax,2)
ff
jmp    1587 <divmnu+0x477>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1307 <divmnu+0x1f7>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15f5 <divmnu+0x4e5>
movslq -0x40(%rbp),%rax
movzwl -0x90(%rbp,%rax,2),%eax
ff
mov    -0x3c(%rbp),%ecx
sar    %cl,%eax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzwl -0x90(%rbp,%rcx,2),%edx
ff
mov    $0x10,%ecx
sub    -0x3c(%rbp),%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    159c <divmnu+0x48c>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<divmnu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8d,%r14d
mov    %rcx,%r13
mov    %rdx,%r15
mov    %rdi,%r12
cmp    $0x1,%r9d
jne    118f <divmnu+0x7f>
xor    %ecx,%ecx
test   %r14d,%r14d
jle    1187 <divmnu+0x77>
mov    %r14d,%ebp
movzwl 0x0(%r13),%edx
add    $0x1,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x2(%rbp),%edi
shl    $0x10,%ecx
movzwl (%r15,%rdi,2),%eax
or     %ecx,%eax
movzwl %dx,%ebx
xor    %edx,%edx
div    %ebx
mov    %ax,(%r12,%rdi,2)
movzwl (%r15,%rdi,2),%edx
or     %edx,%ecx
movzwl %ax,%eax
movzwl 0x0(%r13),%edx
imul   %edx,%eax
sub    %eax,%ecx
add    $0xffffffffffffffff,%rbp
cmp    $0x1,%rbp
ja     1150 <divmnu+0x40>
mov    %cx,(%rsi)
jmp    15b6 <divmnu+0x4a6>
mov    %r9d,%ebx
mov    %rsi,0x58(%rsp)
movslq %r9d,%rax
lea    -0x1(%rax),%rbp
mov    %rax,0x60(%rsp)
movzwl -0x2(%r13,%rax,2),%edi
call   1030 <nlz@plt>
mov    %rbp,%rdi
mov    %eax,%r10d
mov    $0x10,%ebp
sub    %eax,%ebp
mov    %rbx,0x48(%rsp)
cmp    $0x2,%ebx
jl     1219 <divmnu+0x109>
mov    %edi,%ecx
cmp    $0x1,%edi
mov    %rcx,%r11
adc    $0xffffffffffffffff,%r11
add    $0x1,%r11
cmp    $0x8,%r11
jae    15c5 <divmnu+0x4b5>
mov    %rcx,%rax
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
movzwl -0x2(%r13,%rax,2),%edx
mov    %r10d,%ecx
shl    %cl,%edx
lea    -0x2(%rax),%ecx
movzwl 0x0(%r13,%rcx,2),%esi
mov    %ebp,%ecx
shr    %cl,%esi
or     %edx,%esi
mov    %si,0xe(%rsp,%rax,2)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     11f0 <divmnu+0xe0>
movzwl 0x0(%r13),%eax
mov    %r10d,%ecx
shl    %cl,%eax
mov    %ax,0x10(%rsp)
movslq %r14d,%rax
movzwl -0x2(%r15,%rax,2),%edx
mov    %ebp,%ecx
shr    %cl,%edx
mov    %dx,0x20(%rsp,%rax,2)
cmp    $0x2,%r14d
mov    %ebp,0xc(%rsp)
mov    0x48(%rsp),%r13
jl     1298 <divmnu+0x188>
lea    -0x1(%r14),%eax
mov    %eax,%ecx
cmp    $0x1,%eax
mov    %rcx,%r11
adc    $0xffffffffffffffff,%r11
add    $0x1,%r11
cmp    $0x8,%r11
jae    16df <divmnu+0x5cf>
mov    %rcx,%rax
add    $0x1,%rax
xchg   %ax,%ax
movzwl -0x2(%r15,%rax,2),%edx
mov    %r10d,%ecx
shl    %cl,%edx
lea    -0x2(%rax),%ecx
movzwl (%r15,%rcx,2),%esi
mov    %ebp,%ecx
shr    %cl,%esi
or     %edx,%esi
mov    %si,0x1e(%rsp,%rax,2)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1270 <divmnu+0x160>
movzwl (%r15),%eax
mov    %r10d,0x54(%rsp)
mov    %r10d,%ecx
shl    %cl,%eax
mov    %ax,0x20(%rsp)
sub    %r13d,%r14d
mov    %r13d,%r10d
js     14b0 <divmnu+0x3a0>
movzwl 0x10(%rsp,%rdi,2),%ecx
lea    -0x2(%r13),%eax
movslq %eax,%r8
mov    %r14d,%r9d
lea    -0x1(%r10),%rax
mov    %rax,(%rsp)
mov    %r10d,%r11d
and    $0xfffffffe,%r11d
lea    (%rsp,%r9,2),%rdi
add    $0x22,%rdi
jmp    12f9 <divmnu+0x1e9>
nop
mov    %ax,(%r12,%r9,2)
lea    -0x1(%r9),%rax
add    $0xfffffffffffffffe,%rdi
test   %r9,%r9
mov    %rax,%r9
jle    14b0 <divmnu+0x3a0>
mov    0x60(%rsp),%rax
lea    (%r9,%rax,1),%r14
mov    0x1e(%rsp,%r14,2),%eax
xor    %edx,%edx
div    %ecx
jmp    131d <divmnu+0x20d>
nopl   (%rax)
add    $0xffffffff,%eax
add    %ecx,%edx
cmp    $0x10000,%edx
jae    133e <divmnu+0x22e>
cmp    $0xffff,%eax
ja     1310 <divmnu+0x200>
movzwl 0x10(%rsp,%r8,2),%esi
imul   %eax,%esi
mov    %edx,%ebx
shl    $0x10,%ebx
movzwl 0x1c(%rsp,%r14,2),%ebp
or     %ebx,%ebp
cmp    %ebp,%esi
ja     1310 <divmnu+0x200>
test   %r13d,%r13d
jle    12e0 <divmnu+0x1d0>
cmpq   $0x0,(%rsp)
je     1480 <divmnu+0x370>
xor    %edx,%edx
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzwl 0x10(%rsp,%rdx,2),%esi
imul   %eax,%esi
movzwl -0x2(%rdi,%rdx,2),%ebx
movzwl %si,%ebp
add    %r13d,%ebp
sub    %ebp,%ebx
mov    %bx,-0x2(%rdi,%rdx,2)
shr    $0x10,%esi
sar    $0x10,%ebx
sub    %ebx,%esi
movzwl 0x12(%rsp,%rdx,2),%r13d
imul   %eax,%r13d
movzwl (%rdi,%rdx,2),%ebx
movzwl %r13w,%ebp
add    %esi,%ebp
sub    %ebp,%ebx
mov    %bx,(%rdi,%rdx,2)
shr    $0x10,%r13d
sar    $0x10,%ebx
sub    %ebx,%r13d
add    $0x2,%rdx
cmp    %rdx,%r11
jne    1360 <divmnu+0x250>
test   $0x1,%r10b
je     13de <divmnu+0x2ce>
movzwl 0x10(%rsp,%rdx,2),%esi
imul   %eax,%esi
add    %r9,%rdx
movzwl 0x20(%rsp,%rdx,2),%ebx
movzwl %si,%ebp
add    %ebp,%r13d
sub    %r13d,%ebx
mov    %bx,0x20(%rsp,%rdx,2)
shr    $0x10,%esi
sar    $0x10,%ebx
sub    %ebx,%esi
mov    %esi,%r13d
movzwl 0x20(%rsp,%r14,2),%r15d
sub    %r13d,%r15d
mov    %r15w,0x20(%rsp,%r14,2)
mov    %ax,(%r12,%r9,2)
mov    0x48(%rsp),%r13
jns    12e5 <divmnu+0x1d5>
add    $0xffffffff,%eax
mov    %ax,(%r12,%r9,2)
test   %r13d,%r13d
jle    1494 <divmnu+0x384>
cmpq   $0x0,(%rsp)
je     14a4 <divmnu+0x394>
xor    %eax,%eax
xor    %edx,%edx
nopl   (%rax)
movzwl -0x2(%rdi,%rax,2),%esi
add    %edx,%esi
movzwl 0x10(%rsp,%rax,2),%edx
add    %esi,%edx
mov    %dx,-0x2(%rdi,%rax,2)
sar    $0x10,%edx
movzwl (%rdi,%rax,2),%esi
add    %edx,%esi
movzwl 0x12(%rsp,%rax,2),%edx
add    %esi,%edx
mov    %dx,(%rdi,%rax,2)
sar    $0x10,%edx
add    $0x2,%rax
cmp    %rax,%r11
jne    1420 <divmnu+0x310>
test   $0x1,%r10b
je     1475 <divmnu+0x365>
lea    (%rax,%r9,1),%rsi
movzwl 0x20(%rsp,%rsi,2),%ebx
add    %ebx,%edx
movzwl 0x10(%rsp,%rax,2),%eax
add    %edx,%eax
mov    %ax,0x20(%rsp,%rsi,2)
sar    $0x10,%eax
mov    %eax,%edx
movzwl 0x20(%rsp,%r14,2),%r15d
jmp    1496 <divmnu+0x386>
nopl   (%rax)
xor    %edx,%edx
xor    %r13d,%r13d
test   $0x1,%r10b
jne    13b5 <divmnu+0x2a5>
jmp    13de <divmnu+0x2ce>
xor    %edx,%edx
add    %edx,%r15d
mov    %r15w,0x20(%rsp,%r14,2)
jmp    12e5 <divmnu+0x1d5>
xor    %eax,%eax
xor    %edx,%edx
test   $0x1,%r10b
jne    1459 <divmnu+0x349>
jmp    1475 <divmnu+0x365>
test   %r13d,%r13d
mov    0x58(%rsp),%rbp
mov    0x54(%rsp),%r8d
mov    0xc(%rsp),%ebx
jle    15b6 <divmnu+0x4a6>
movzwl 0x20(%rsp),%edx
cmp    $0x8,%r13d
jae    14d9 <divmnu+0x3c9>
xor    %eax,%eax
jmp    1590 <divmnu+0x480>
mov    %r10d,%eax
and    $0xfffffff8,%eax
movd   %edx,%xmm0
pslldq $0xe,%xmm0
movd   %r8d,%xmm3
movd   %ebx,%xmm4
lea    (%r10,%r10,1),%rcx
and    $0xfffffffffffffff0,%rcx
xor    %edx,%edx
pxor   %xmm1,%xmm1
xorps  %xmm2,%xmm2
movss  %xmm3,%xmm2
xorps  %xmm3,%xmm3
movss  %xmm4,%xmm3
nopl   (%rax)
movdqa %xmm0,%xmm4
movdqu 0x22(%rsp,%rdx,1),%xmm0
psrldq $0xe,%xmm4
movdqa %xmm0,%xmm5
pslldq $0x2,%xmm5
por    %xmm5,%xmm4
punpcklwd %xmm1,%xmm4
punpckhwd %xmm1,%xmm5
psrld  %xmm2,%xmm5
psrld  %xmm2,%xmm4
movdqa %xmm0,%xmm6
punpcklwd %xmm1,%xmm6
movdqa %xmm0,%xmm7
punpckhwd %xmm1,%xmm7
pslld  %xmm3,%xmm7
por    %xmm5,%xmm7
pslld  %xmm3,%xmm6
por    %xmm4,%xmm6
pslld  $0x10,%xmm7
psrad  $0x10,%xmm7
pslld  $0x10,%xmm6
psrad  $0x10,%xmm6
packssdw %xmm7,%xmm6
movdqu %xmm6,0x0(%rbp,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    1510 <divmnu+0x400>
cmp    %r10,%rax
je     15b6 <divmnu+0x4a6>
pextrw $0x7,%xmm0,%edx
nopl   (%rax)
movzwl %dx,%esi
mov    %r8d,%ecx
shr    %cl,%esi
movzwl 0x22(%rsp,%rax,2),%edx
mov    %edx,%edi
mov    %ebx,%ecx
shl    %cl,%edi
or     %esi,%edi
mov    %di,0x0(%rbp,%rax,2)
lea    0x1(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r10
jne    1590 <divmnu+0x480>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x1,%edi
mov    %rcx,%rax
adc    $0xffffffffffffffff,%rax
mov    0x48(%rsp),%rdx
add    $0xfffffffe,%edx
cmp    %eax,%edx
jb     11df <divmnu+0xcf>
shr    $0x20,%rax
jne    11df <divmnu+0xcf>
mov    %rdi,(%rsp)
mov    %r14,%r8
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
mov    %rcx,%rax
sub    %r9,%rax
movd   %r10d,%xmm2
movd   %ebp,%xmm3
mov    %r9,%rsi
neg    %rsi
lea    -0xe(,%rcx,2),%r14
ff
add    %r13,%r14
mov    $0xffffffff,%edx
add    %rcx,%rdx
lea    (%rsp,%rcx,2),%rcx
add    $0x2,%rcx
xor    %edi,%edi
pxor   %xmm0,%xmm0
xorps  %xmm1,%xmm1
movss  %xmm2,%xmm1
xorps  %xmm2,%xmm2
movss  %xmm3,%xmm2
nopl   0x0(%rax,%rax,1)
movdqu (%r14,%rdi,2),%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm4
pshufhw $0x1b,%xmm3,%xmm3
punpckhwd %xmm0,%xmm3
punpcklwd %xmm0,%xmm4
pslld  %xmm1,%xmm4
pslld  %xmm1,%xmm3
lea    (%rdx,%rdi,1),%ebx
movdqu -0xe(%r13,%rbx,2),%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm6
pshufhw $0x1b,%xmm5,%xmm5
punpckhwd %xmm0,%xmm5
punpcklwd %xmm0,%xmm6
psrld  %xmm2,%xmm6
psrld  %xmm2,%xmm5
por    %xmm4,%xmm6
por    %xmm3,%xmm5
pslld  $0x10,%xmm6
psrad  $0x10,%xmm6
pslld  $0x10,%xmm5
psrad  $0x10,%xmm5
packssdw %xmm6,%xmm5
pshuflw $0x1b,%xmm5,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
movdqu %xmm3,(%rcx,%rdi,2)
add    $0xfffffffffffffff8,%rdi
cmp    %rdi,%rsi
jne    1640 <divmnu+0x530>
cmp    %r9,%r11
mov    %r8,%r14
mov    (%rsp),%rdi
jne    11e2 <divmnu+0xd2>
jmp    1219 <divmnu+0x109>
cmp    $0x1,%eax
mov    %rcx,%rax
adc    $0xffffffffffffffff,%rax
lea    -0x2(%r14),%edx
cmp    %eax,%edx
jb     1267 <divmnu+0x157>
shr    $0x20,%rax
jne    1267 <divmnu+0x157>
mov    %rdi,(%rsp)
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
mov    %rcx,%rax
sub    %r9,%rax
movd   %r10d,%xmm2
movd   %ebp,%xmm3
mov    %r9,%rsi
neg    %rsi
lea    (%r15,%rcx,2),%r8
add    $0xfffffffffffffff2,%r8
mov    $0xffffffff,%edi
add    %rcx,%rdi
lea    (%rsp,%rcx,2),%rdx
add    $0x12,%rdx
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
xorps  %xmm1,%xmm1
movss  %xmm2,%xmm1
xorps  %xmm2,%xmm2
movss  %xmm3,%xmm2
nopl   0x0(%rax,%rax,1)
movdqu (%r8,%rcx,2),%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm4
pshufhw $0x1b,%xmm3,%xmm3
punpckhwd %xmm0,%xmm3
punpcklwd %xmm0,%xmm4
pslld  %xmm1,%xmm4
pslld  %xmm1,%xmm3
lea    (%rdi,%rcx,1),%ebx
movdqu -0xe(%r15,%rbx,2),%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm6
pshufhw $0x1b,%xmm5,%xmm5
punpckhwd %xmm0,%xmm5
punpcklwd %xmm0,%xmm6
psrld  %xmm2,%xmm6
psrld  %xmm2,%xmm5
por    %xmm4,%xmm6
por    %xmm3,%xmm5
pslld  $0x10,%xmm6
psrad  $0x10,%xmm6
pslld  $0x10,%xmm5
psrad  $0x10,%xmm5
packssdw %xmm6,%xmm5
pshuflw $0x1b,%xmm5,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
movdqu %xmm3,(%rdx,%rcx,2)
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%rsi
jne    1750 <divmnu+0x640>
cmp    %r9,%r11
mov    0xc(%rsp),%ebp
mov    (%rsp),%rdi
jne    126a <divmnu+0x15a>
jmp    1298 <divmnu+0x188>

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

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