#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 */
unsigned char bd(unsigned char, unsigned char);
unsigned char miLookup(unsigned char);
int /*<<< orphan*/ modprod(unsigned char *, unsigned char *, unsigned char *);
void longdivision(unsigned char a[5], unsigned char b[5], unsigned char dest[5],
                  unsigned char quo[4], unsigned char x[6][4], int round) {
  int i, j;
  int index_a;
  int index_b;
  unsigned char inv;
  unsigned char prod[4] = {0, 0, 0, 0};
  unsigned char temp[4] = {0, 0, 0, 0};
  unsigned char tempx[4] = {0, 0, 0, 0};
  if (a[0] == 1) {
    quo[0] = 0;
    quo[1] = 0;
    inv = miLookup(b[1]);
    for (i = 0; i < 3; i++) {
      prod[i] = bd(inv, b[i + 2]);
    }
    prod[3] = a[4];
    quo[2] = inv;
    inv = bd(inv, prod[0]);
    quo[3] = inv;
    for (i = 0; i < 4; i++) {
      temp[i] = bd(inv, b[i + 1]);
    }
    dest[0] = 0x0;
    for (i = 0; i < 4; i++) {
      dest[i + 1] = prod[i] ^ temp[i];
    }
    modprod(x[round], quo, tempx);
    for (i = 0; i < 4; i++) {
      x[round + 1][i] = x[round - 1][i] ^ tempx[i];
    }
  } else {
    quo[0] = 0;
    quo[1] = 0;
    for (index_a = 0; index_a < 5; index_a++) {
      if (a[index_a] != 0) {
        break;
      }
    }
    for (index_b = 0; index_b < 5; index_b++) {
      if (b[index_b] != 0x0) {
        break;
      }
    }
    inv = miLookup(b[index_b]);
    quo[2] = bd(inv, a[index_a]);
    j = 0;
    for (i = index_a - 1; i < 4 - index_b + index_a; i++, j++) {
      prod[i] = bd(quo[2], b[index_b + j]);
    }
    j = 0;
    for (i = index_a - 1; i < 4 - index_b + index_a; i++, j++) {
      temp[i] = a[index_a + j] ^ prod[i];
    }
    temp[3] = a[4];
    quo[3] = bd(inv, temp[index_a]);
    for (i = 0; i < 4; i++) {
      prod[i] = bd(quo[3], b[i + 1]);
    }
    dest[0] = 0x0;
    for (i = 0; i < 4; i++) {
      dest[i + 1] = prod[i] ^ temp[i];
    }
    modprod(x[round], quo, tempx);
    for (i = 0; i < 4; i++) {
      x[round + 1][i] = x[round - 1][i] ^ tempx[i];
    }
  }
}


x86 assembly (clang, -O0):
<longdivision>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
lea    -0x41(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
lea    -0x45(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
lea    -0x49(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x1,%eax
jne    1349 <longdivision+0x209>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movb   $0x0,0x1(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%edi
call   1050 <miLookup@plt>
mov    %al,-0x3d(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1204 <longdivision+0xc4>
mov    -0x3d(%rbp),%dl
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1060 <bd@plt>
mov    %al,%cl
movslq -0x30(%rbp),%rax
mov    %cl,-0x41(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c6 <longdivision+0x86>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%al
mov    %al,-0x3e(%rbp)
mov    -0x3d(%rbp),%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x3d(%rbp),%al
movzbl %al,%edi
movzbl -0x41(%rbp),%esi
call   1060 <bd@plt>
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    1279 <longdivision+0x139>
mov    -0x3d(%rbp),%dl
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1060 <bd@plt>
mov    %al,%cl
movslq -0x30(%rbp),%rax
mov    %cl,-0x45(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    123b <longdivision+0xfb>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    12c5 <longdivision+0x185>
movslq -0x30(%rbp),%rax
movzbl -0x41(%rbp,%rax,1),%eax
movslq -0x30(%rbp),%rcx
movzbl -0x45(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1287 <longdivision+0x147>
mov    -0x28(%rbp),%rdi
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
lea    -0x49(%rbp),%rdx
call   1040 <modprod@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    1344 <longdivision+0x204>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movslq -0x30(%rbp),%rcx
movzbl -0x49(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12e8 <longdivision+0x1a8>
jmp    1612 <longdivision+0x4d2>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movb   $0x0,0x1(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x5,-0x38(%rbp)
jge    1396 <longdivision+0x256>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1383 <longdivision+0x243>
jmp    1396 <longdivision+0x256>
jmp    1388 <longdivision+0x248>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    135f <longdivision+0x21f>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x5,-0x3c(%rbp)
jge    13d4 <longdivision+0x294>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     13c1 <longdivision+0x281>
jmp    13d4 <longdivision+0x294>
jmp    13c6 <longdivision+0x286>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    139d <longdivision+0x25d>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1050 <miLookup@plt>
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%dl
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1060 <bd@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x4,%ecx
sub    -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    146f <longdivision+0x32f>
mov    -0x20(%rbp),%rax
mov    0x2(%rax),%dl
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1060 <bd@plt>
mov    %al,%cl
movslq -0x30(%rbp),%rax
mov    %cl,-0x41(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1418 <longdivision+0x2d8>
movl   $0x0,-0x34(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x4,%ecx
sub    -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    14d2 <longdivision+0x392>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
movslq -0x30(%rbp),%rcx
movzbl -0x41(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
movslq -0x30(%rbp),%rax
mov    %cl,-0x45(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    147f <longdivision+0x33f>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%al
mov    %al,-0x42(%rbp)
mov    -0x3d(%rbp),%cl
movslq -0x38(%rbp),%rax
movzbl %cl,%edi
movzbl -0x45(%rbp,%rax,1),%esi
call   1060 <bd@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x3(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    1542 <longdivision+0x402>
mov    -0x20(%rbp),%rax
mov    0x3(%rax),%dl
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl %dl,%edi
movzbl (%rax,%rcx,1),%esi
call   1060 <bd@plt>
mov    %al,%cl
movslq -0x30(%rbp),%rax
mov    %cl,-0x41(%rbp,%rax,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1500 <longdivision+0x3c0>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    158e <longdivision+0x44e>
movslq -0x30(%rbp),%rax
movzbl -0x41(%rbp,%rax,1),%eax
movslq -0x30(%rbp),%rcx
movzbl -0x45(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1550 <longdivision+0x410>
mov    -0x28(%rbp),%rdi
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
lea    -0x49(%rbp),%rdx
call   1040 <modprod@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    160d <longdivision+0x4cd>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movslq -0x30(%rbp),%rcx
movzbl -0x49(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15b1 <longdivision+0x471>
jmp    1612 <longdivision+0x4d2>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<longdivision>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8,%r14
mov    %rcx,%r12
mov    %rdi,%rbp
movl   $0x0,0x4(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
cmpb   $0x1,(%rdi)
movw   $0x0,(%rcx)
movslq %r9d,%r15
mov    %r8,0x50(%rsp)
mov    %r15,0x48(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rdx,0x40(%rsp)
jne    1286 <longdivision+0x156>
movzbl 0x1(%rsi),%edi
mov    %rsi,%rbx
call   1040 <miLookup@plt>
movzbl 0x2(%rbx),%esi
mov    %r12,%r13
movzbl %al,%r12d
mov    %r12d,%edi
call   1050 <bd@plt>
mov    %eax,%r14d
mov    %al,0x4(%rsp)
movzbl 0x3(%rbx),%esi
mov    %r12d,%edi
call   1050 <bd@plt>
mov    %al,0x18(%rsp)
mov    %al,0x5(%rsp)
movzbl 0x4(%rbx),%esi
mov    %r12d,%edi
call   1050 <bd@plt>
mov    %al,0xc(%rsp)
mov    %al,0x6(%rsp)
mov    0x4(%rbp),%al
mov    %al,0x28(%rsp)
mov    %al,0x7(%rsp)
mov    %r13,%rbp
mov    %r12b,0x2(%r13)
movzbl %r14b,%r13d
mov    %r12d,%edi
mov    %r13d,%esi
call   1050 <bd@plt>
mov    %al,0x3(%rbp)
movzbl 0x1(%rbx),%esi
movzbl %al,%ebp
mov    %ebp,%edi
call   1050 <bd@plt>
mov    %eax,%r14d
mov    %al,0x8(%rsp)
movzbl 0x2(%rbx),%esi
mov    %ebp,%edi
call   1050 <bd@plt>
mov    %eax,%r12d
mov    %al,0x9(%rsp)
movzbl 0x3(%rbx),%esi
mov    %ebp,%edi
call   1050 <bd@plt>
mov    %eax,%r15d
mov    %al,0xa(%rsp)
movzbl 0x4(%rbx),%esi
mov    %ebp,%edi
call   1050 <bd@plt>
mov    0x40(%rsp),%rcx
movb   $0x0,(%rcx)
xor    %r14b,%r13b
mov    0x48(%rsp),%rbx
mov    0x50(%rsp),%rbp
mov    %r13b,0x1(%rcx)
xor    0x18(%rsp),%r12b
mov    %r12b,0x2(%rcx)
xor    0xc(%rsp),%r15b
mov    %r15b,0x3(%rcx)
xor    0x28(%rsp),%al
mov    %al,0x4(%rcx)
lea    0x0(,%rbx,4),%rdi
add    %rbp,%rdi
lea    0x10(%rsp),%rdx
mov    0x38(%rsp),%rsi
jmp    16ba <longdivision+0x58a>
xor    %ebx,%ebx
cmpb   $0x0,0x0(%rbp)
mov    $0x0,%r13d
jne    12c7 <longdivision+0x197>
mov    $0x1,%r13d
cmpb   $0x0,0x1(%rbp)
jne    12c7 <longdivision+0x197>
mov    $0x2,%r13d
cmpb   $0x0,0x2(%rbp)
jne    12c7 <longdivision+0x197>
mov    $0x3,%r13d
cmpb   $0x0,0x3(%rbp)
jne    12c7 <longdivision+0x197>
xor    %r13d,%r13d
cmpb   $0x0,0x4(%rbp)
sete   %r13b
or     $0x4,%r13d
mov    %rbp,0x18(%rsp)
mov    (%rsi),%al
mov    $0x1,%bpl
test   %al,%al
jne    130f <longdivision+0x1df>
mov    0x1(%rsi),%al
mov    $0x1,%ebx
test   %al,%al
jne    130f <longdivision+0x1df>
mov    0x2(%rsi),%al
mov    $0x2,%ebx
test   %al,%al
jne    130f <longdivision+0x1df>
mov    0x3(%rsi),%al
mov    $0x3,%ebx
test   %al,%al
jne    130f <longdivision+0x1df>
mov    0x4(%rsi),%al
mov    $0x4,%ebx
test   %al,%al
jne    130f <longdivision+0x1df>
mov    0x5(%rsi),%al
mov    $0x5,%ebx
xor    %ebp,%ebp
mov    %rsi,0x28(%rsp)
movzbl %al,%edi
call   1040 <miLookup@plt>
mov    %r13d,%r14d
mov    0x18(%rsp),%rcx
movzbl (%rcx,%r14,1),%esi
movzbl %al,%r15d
mov    %r15d,%edi
call   1050 <bd@plt>
mov    %al,0x2(%r12)
test   %bpl,%bpl
je     1406 <longdivision+0x2d6>
mov    %ebp,0xc(%rsp)
mov    %r15d,0x14(%rsp)
mov    %r13d,%r12d
sub    %ebx,%r12d
add    $0x4,%r12d
cmp    %r12d,%r13d
cmovg  %r13d,%r12d
mov    %ebx,%ebx
sub    %r13d,%r12d
add    $0x1,%r12d
mov    0x28(%rsp),%rcx
movzbl (%rcx,%rbx,1),%esi
movzbl %al,%edi
call   1050 <bd@plt>
lea    0x4(%rsp),%rcx
mov    %r14,0x30(%rsp)
mov    %al,-0x1(%r14,%rcx,1)
cmp    $0x1,%r12d
mov    0x38(%rsp),%r14
je     13dc <longdivision+0x2ac>
lea    -0x1(%r12),%r15
mov    0x28(%rsp),%rax
lea    (%rbx,%rax,1),%r13
add    $0x1,%r13
mov    0x30(%rsp),%rax
lea    (%rsp,%rax,1),%rbx
add    $0x4,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x2(%r14),%edi
movzbl 0x0(%r13,%rbp,1),%esi
call   1050 <bd@plt>
mov    %al,(%rbx,%rbp,1)
add    $0x1,%rbp
cmp    %rbp,%r15
jne    13c0 <longdivision+0x290>
cmpb   $0x0,0xc(%rsp)
je     1428 <longdivision+0x2f8>
mov    0x30(%rsp),%r14
lea    -0x1(%r14),%r8
cmp    $0x8,%r12d
jae    1454 <longdivision+0x324>
xor    %eax,%eax
mov    %r8,%rcx
mov    0x18(%rsp),%r10
mov    0x14(%rsp),%r15d
jmp    15a8 <longdivision+0x478>
movl   $0x0,0xc(%rsp)
movl   $0x0,0x24(%rsp)
movl   $0x0,0x20(%rsp)
mov    0x18(%rsp),%r10
jmp    15fb <longdivision+0x4cb>
movl   $0x0,0xc(%rsp)
movl   $0x0,0x24(%rsp)
movl   $0x0,0x20(%rsp)
mov    0x18(%rsp),%r10
mov    0x30(%rsp),%r14
mov    0x14(%rsp),%r15d
jmp    15fb <longdivision+0x4cb>
cmp    $0x20,%r12d
jae    146b <longdivision+0x33b>
xor    %eax,%eax
mov    0x18(%rsp),%r10
mov    0x14(%rsp),%r15d
jmp    1554 <longdivision+0x424>
mov    %r12d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
mov    0x18(%rsp),%r10
mov    0x14(%rsp),%r15d
je     1511 <longdivision+0x3e1>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rsp,%r14,1),%rcx
add    $0x37,%rcx
lea    (%rsp,%r14,1),%rdx
add    $0x33,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
mov    %rsi,%rbp
or     %r14,%rbp
movups (%r10,%rbp,1),%xmm0
movups 0x10(%r10,%rbp,1),%xmm1
movups -0x30(%rdx,%rsi,1),%xmm2
xorps  %xmm0,%xmm2
movups -0x20(%rdx,%rsi,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,-0x30(%rcx,%rsi,1)
movups %xmm0,-0x20(%rcx,%rsi,1)
lea    0x20(%rsi),%rbp
or     %r14,%rbp
movups (%r10,%rbp,1),%xmm0
movups 0x10(%r10,%rbp,1),%xmm1
movups -0x10(%rdx,%rsi,1),%xmm2
xorps  %xmm0,%xmm2
movups (%rdx,%rsi,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,-0x10(%rcx,%rsi,1)
movups %xmm0,(%rcx,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rdi
jne    14b0 <longdivision+0x380>
jmp    1513 <longdivision+0x3e3>
xor    %esi,%esi
test   $0x1,%r9b
je     1545 <longdivision+0x415>
lea    (%r8,%rsi,1),%rcx
or     %r14,%rsi
movups (%r10,%rsi,1),%xmm0
movups 0x10(%r10,%rsi,1),%xmm1
movups 0x4(%rsp,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x14(%rsp,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x8(%rsp,%rcx,1)
movups %xmm0,0x18(%rsp,%rcx,1)
cmp    %r12,%rax
je     15e3 <longdivision+0x4b3>
test   $0x18,%r12b
je     15a2 <longdivision+0x472>
mov    %rax,%rdx
mov    %r12d,%eax
and    $0xfffffff8,%eax
lea    (%r8,%rax,1),%rcx
lea    (%rsp,%r8,1),%rsi
add    $0x4,%rsi
lea    (%rsp,%r8,1),%rdi
add    $0x8,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rbp
or     %r14,%rbp
mov    (%rsi,%rdx,1),%rbx
xor    (%r10,%rbp,1),%rbx
mov    %rbx,(%rdi,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    1580 <longdivision+0x450>
cmp    %r12,%rax
jne    15a8 <longdivision+0x478>
jmp    15e3 <longdivision+0x4b3>
add    %rax,%r8
mov    %r8,%rcx
lea    (%rsp,%rcx,1),%rdx
add    $0x4,%rdx
add    %rsp,%rcx
add    $0x8,%rcx
lea    (%rax,%r14,1),%rsi
add    %r10,%rsi
sub    %rax,%r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdx,%rax,1),%ebx
xor    (%rsi,%rax,1),%bl
mov    %bl,(%rcx,%rax,1)
add    $0x1,%rax
cmp    %rax,%r12
jne    15d0 <longdivision+0x4a0>
mov    0x8(%rsp),%al
mov    %eax,0x20(%rsp)
mov    0x9(%rsp),%al
mov    %eax,0x24(%rsp)
mov    0xa(%rsp),%al
mov    %eax,0xc(%rsp)
mov    0x4(%r10),%r12b
mov    %r12b,0xb(%rsp)
movzbl 0x8(%rsp,%r14,1),%esi
mov    %r15d,%edi
call   1050 <bd@plt>
mov    0x38(%rsp),%r13
mov    %al,0x3(%r13)
mov    0x28(%rsp),%r15
movzbl 0x1(%r15),%esi
movzbl %al,%edi
call   1050 <bd@plt>
mov    %eax,%ebp
mov    %al,0x4(%rsp)
movzbl 0x3(%r13),%edi
movzbl 0x2(%r15),%esi
call   1050 <bd@plt>
mov    %eax,%r14d
mov    %al,0x5(%rsp)
movzbl 0x3(%r13),%edi
movzbl 0x3(%r15),%esi
call   1050 <bd@plt>
mov    %eax,%ebx
mov    %al,0x6(%rsp)
movzbl 0x3(%r13),%edi
movzbl 0x4(%r15),%esi
call   1050 <bd@plt>
mov    %al,0x7(%rsp)
mov    0x40(%rsp),%rcx
movb   $0x0,(%rcx)
mov    0x20(%rsp),%edx
xor    %bpl,%dl
mov    %dl,0x1(%rcx)
mov    0x24(%rsp),%edx
xor    %r14b,%dl
mov    %dl,0x2(%rcx)
mov    0xc(%rsp),%edx
xor    %bl,%dl
mov    %dl,0x3(%rcx)
xor    %al,%r12b
mov    %r12b,0x4(%rcx)
mov    0x50(%rsp),%rbp
mov    0x48(%rsp),%rbx
lea    0x0(,%rbx,4),%rdi
add    %rbp,%rdi
lea    0x10(%rsp),%rdx
mov    %r13,%rsi
call   1030 <modprod@plt>
lea    -0x1(%rbx),%rax
mov    0x10(%rsp),%cl
xor    -0x4(%rbp,%rbx,4),%cl
mov    %cl,0x4(%rbp,%rbx,4)
mov    0x11(%rsp),%cl
xor    0x1(%rbp,%rax,4),%cl
mov    %cl,0x5(%rbp,%rbx,4)
mov    0x12(%rsp),%cl
xor    0x2(%rbp,%rax,4),%cl
mov    %cl,0x6(%rbp,%rbx,4)
mov    0x13(%rsp),%cl
xor    0x3(%rbp,%rax,4),%cl
mov    %cl,0x7(%rbp,%rbx,4)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @longdivision(i8* nocapture %0, i8* nocapture %1, i8* nocapture writeonly %2, i8* %3, [4 x i8]* %4, i32 %5) {
%7 = alloca i32
%8 = bitcast i32* %7 to [4 x i8]*
%9 = alloca i32
%10 = bitcast i32* %9 to [4 x i8]*
%11 = alloca i32
%12 = bitcast i32* %11 to [4 x i8]*
%13 = bitcast i32* %7 to i8*
store i32 0, i32* %7
%14 = bitcast i32* %9 to i8*
store i32 0, i32* %9
%15 = bitcast i32* %11 to i8*
store i32 0, i32* %11
%16 = load i8, i8* %0
%17 = icmp eq i8 %16, 1
store i8 0, i8* %3
%18 = getelementptr inbounds i8, i8* %3, i64 1
store i8 0, i8* %18
br i1 %17, label %19, label %70
19: ; preds = %6
%20 = getelementptr inbounds i8, i8* %1, i64 1
%21 = load i8, i8* %20
%22 = tail call zeroext i8 @miLookup(i8 zeroext %21)
%23 = getelementptr inbounds i8, i8* %1, i64 2
%24 = load i8, i8* %23
%25 = tail call zeroext i8 @bd(i8 zeroext %22, i8 zeroext %24)
%26 = bitcast i32* %7 to i8*
store i8 %25, i8* %26
%27 = getelementptr inbounds i8, i8* %1, i64 3
%28 = load i8, i8* %27
%29 = tail call zeroext i8 @bd(i8 zeroext %22, i8 zeroext %28)
%30 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 1
store i8 %29, i8* %30
%31 = getelementptr inbounds i8, i8* %1, i64 4
%32 = load i8, i8* %31
%33 = tail call zeroext i8 @bd(i8 zeroext %22, i8 zeroext %32)
%34 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 2
store i8 %33, i8* %34
%35 = getelementptr inbounds i8, i8* %0, i64 4
%36 = load i8, i8* %35
%37 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 3
store i8 %36, i8* %37
%38 = getelementptr inbounds i8, i8* %3, i64 2
store i8 %22, i8* %38
%39 = tail call zeroext i8 @bd(i8 zeroext %22, i8 zeroext %25)
%40 = getelementptr inbounds i8, i8* %3, i64 3
store i8 %39, i8* %40
%41 = load i8, i8* %20
%42 = tail call zeroext i8 @bd(i8 zeroext %39, i8 zeroext %41)
%43 = bitcast i32* %9 to i8*
store i8 %42, i8* %43
%44 = load i8, i8* %23
%45 = tail call zeroext i8 @bd(i8 zeroext %39, i8 zeroext %44)
%46 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 1
store i8 %45, i8* %46
%47 = load i8, i8* %27
%48 = tail call zeroext i8 @bd(i8 zeroext %39, i8 zeroext %47)
%49 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 2
store i8 %48, i8* %49
%50 = load i8, i8* %31
%51 = tail call zeroext i8 @bd(i8 zeroext %39, i8 zeroext %50)
store i8 0, i8* %2
%52 = xor i8 %42, %25
%53 = getelementptr inbounds i8, i8* %2, i64 1
store i8 %52, i8* %53
%54 = xor i8 %45, %29
%55 = getelementptr inbounds i8, i8* %2, i64 2
store i8 %54, i8* %55
%56 = xor i8 %48, %33
%57 = getelementptr inbounds i8, i8* %2, i64 3
store i8 %56, i8* %57
%58 = xor i8 %51, %36
%59 = getelementptr inbounds i8, i8* %2, i64 4
store i8 %58, i8* %59
%60 = sext i32 %5 to i64
%61 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %60, i64 0
%62 = call i32 @modprod(i8* %61, i8* %3, i8* %15)
%63 = add nsw i32 %5, -1
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %64, i64 0
%66 = load i8, i8* %65
%67 = bitcast i32* %11 to i8*
%68 = load i8, i8* %67
%69 = xor i8 %68, %66
br label %337
70: ; preds = %6
%71 = load i8, i8* %0
%72 = icmp eq i8 %71, 0
br i1 %72, label %73, label %90
73: ; preds = %70
%74 = getelementptr inbounds i8, i8* %0, i64 1
%75 = load i8, i8* %74
%76 = icmp eq i8 %75, 0
br i1 %76, label %77, label %90
77: ; preds = %73
%78 = getelementptr inbounds i8, i8* %0, i64 2
%79 = load i8, i8* %78
%80 = icmp eq i8 %79, 0
br i1 %80, label %81, label %90
81: ; preds = %77
%82 = getelementptr inbounds i8, i8* %0, i64 3
%83 = load i8, i8* %82
%84 = icmp eq i8 %83, 0
br i1 %84, label %85, label %90
85: ; preds = %81
%86 = getelementptr inbounds i8, i8* %0, i64 4
%87 = load i8, i8* %86
%88 = icmp eq i8 %87, 0
%89 = select i1 %88, i32 5, i32 4
br label %90
90: ; preds = %85, %81, %77, %73, %70
%91 = phi i32 [ 0, %70 ], [ 1, %73 ], [ 2, %77 ], [ 3, %81 ], [ %89, %85 ]
%92 = load i8, i8* %1
%93 = icmp eq i8 %92, 0
br i1 %93, label %94, label %113
94: ; preds = %90
%95 = getelementptr inbounds i8, i8* %1, i64 1
%96 = load i8, i8* %95
%97 = icmp eq i8 %96, 0
br i1 %97, label %98, label %113
98: ; preds = %94
%99 = getelementptr inbounds i8, i8* %1, i64 2
%100 = load i8, i8* %99
%101 = icmp eq i8 %100, 0
br i1 %101, label %102, label %113
102: ; preds = %98
%103 = getelementptr inbounds i8, i8* %1, i64 3
%104 = load i8, i8* %103
%105 = icmp eq i8 %104, 0
br i1 %105, label %106, label %113
106: ; preds = %102
%107 = getelementptr inbounds i8, i8* %1, i64 4
%108 = load i8, i8* %107
%109 = icmp eq i8 %108, 0
br i1 %109, label %110, label %113
110: ; preds = %106
%111 = getelementptr inbounds i8, i8* %1, i64 5
%112 = load i8, i8* %111
br label %113
113: ; preds = %110, %106, %102, %98, %94, %90
%114 = phi i8 [ %92, %90 ], [ %96, %94 ], [ %100, %98 ], [ %104, %102 ], [ %108, %106 ], [ %112, %110 ]
%115 = phi i1 [ true, %90 ], [ true, %94 ], [ true, %98 ], [ true, %102 ], [ true, %106 ], [ false, %110 ]
%116 = phi i32 [ 0, %90 ], [ 1, %94 ], [ 2, %98 ], [ 3, %102 ], [ 4, %106 ], [ 5, %110 ]
%117 = zext i32 %116 to i64
%118 = tail call zeroext i8 @miLookup(i8 zeroext %114)
%119 = zext i32 %91 to i64
%120 = getelementptr inbounds i8, i8* %0, i64 %119
%121 = load i8, i8* %120
%122 = tail call zeroext i8 @bd(i8 zeroext %118, i8 zeroext %121)
%123 = getelementptr inbounds i8, i8* %3, i64 2
store i8 %122, i8* %123
%124 = sub nsw i32 4, %116
%125 = add nsw i32 %124, %91
br i1 %115, label %126, label %289
126: ; preds = %113
%127 = add nsw i64 %119, -1
%128 = call i32 @llvm.smax.i32(i32 %91, i32 %125)
%129 = add nuw nsw i32 %128, 1
%130 = sub nsw i32 %129, %91
%131 = zext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %1, i64 %117
%133 = load i8, i8* %132
%134 = tail call zeroext i8 @bd(i8 zeroext %122, i8 zeroext %133)
%135 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %127
store i8 %134, i8* %135
%136 = icmp eq i32 %130, 1
br i1 %136, label %137, label %257
137: ; preds = %257, %126
br i1 %115, label %138, label %289
138: ; preds = %137
%139 = add nsw i64 %119, -1
%140 = call i32 @llvm.smax.i32(i32 %91, i32 %125)
%141 = add nuw i32 %140, 1
%142 = sub i32 %141, %91
%143 = zext i32 %142 to i64
%144 = icmp ult i32 %130, 8
br i1 %144, label %254, label %145
145: ; preds = %138
%146 = icmp ult i32 %130, 32
br i1 %146, label %233, label %147
147: ; preds = %145
%148 = and i64 %131, 4294967264
%149 = add nsw i64 %148, -32
%150 = lshr exact i64 %149, 5
%151 = add nuw nsw i64 %150, 1
%152 = and i64 %151, 1
%153 = icmp eq i64 %149, 0
br i1 %153, label %203, label %154
154: ; preds = %147
%155 = and i64 %151, 1152921504606846974
br label %156
156: ; preds = %156, %154
%157 = phi i64 [ 0, %154 ], [ %200, %156 ]
%158 = phi i64 [ 0, %154 ], [ %201, %156 ]
%159 = add i64 %139, %157
%160 = or i64 %157, %119
%161 = getelementptr inbounds i8, i8* %0, i64 %160
%162 = bitcast i8* %161 to <16 x i8>*
%163 = load <16 x i8>, <16 x i8>* %162
%164 = getelementptr inbounds i8, i8* %161, i64 16
%165 = bitcast i8* %164 to <16 x i8>*
%166 = load <16 x i8>, <16 x i8>* %165
%167 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %159
%168 = bitcast i8* %167 to <16 x i8>*
%169 = load <16 x i8>, <16 x i8>* %168
%170 = getelementptr inbounds i8, i8* %167, i64 16
%171 = bitcast i8* %170 to <16 x i8>*
%172 = load <16 x i8>, <16 x i8>* %171
%173 = xor <16 x i8> %169, %163
%174 = xor <16 x i8> %172, %166
%175 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 %159
%176 = bitcast i8* %175 to <16 x i8>*
store <16 x i8> %173, <16 x i8>* %176
%177 = getelementptr inbounds i8, i8* %175, i64 16
%178 = bitcast i8* %177 to <16 x i8>*
store <16 x i8> %174, <16 x i8>* %178
%179 = or i64 %157, 32
%180 = add i64 %139, %179
%181 = or i64 %179, %119
%182 = getelementptr inbounds i8, i8* %0, i64 %181
%183 = bitcast i8* %182 to <16 x i8>*
%184 = load <16 x i8>, <16 x i8>* %183
%185 = getelementptr inbounds i8, i8* %182, i64 16
%186 = bitcast i8* %185 to <16 x i8>*
%187 = load <16 x i8>, <16 x i8>* %186
%188 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %180
%189 = bitcast i8* %188 to <16 x i8>*
%190 = load <16 x i8>, <16 x i8>* %189
%191 = getelementptr inbounds i8, i8* %188, i64 16
%192 = bitcast i8* %191 to <16 x i8>*
%193 = load <16 x i8>, <16 x i8>* %192
%194 = xor <16 x i8> %190, %184
%195 = xor <16 x i8> %193, %187
%196 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 %180
%197 = bitcast i8* %196 to <16 x i8>*
store <16 x i8> %194, <16 x i8>* %197
%198 = getelementptr inbounds i8, i8* %196, i64 16
%199 = bitcast i8* %198 to <16 x i8>*
store <16 x i8> %195, <16 x i8>* %199
%200 = add nuw i64 %157, 64
%201 = add i64 %158, 2
%202 = icmp eq i64 %201, %155
br i1 %202, label %203, label %156
203: ; preds = %156, %147
%204 = phi i64 [ 0, %147 ], [ %200, %156 ]
%205 = icmp eq i64 %152, 0
br i1 %205, label %227, label %206
206: ; preds = %203
%207 = add i64 %139, %204
%208 = or i64 %204, %119
%209 = getelementptr inbounds i8, i8* %0, i64 %208
%210 = bitcast i8* %209 to <16 x i8>*
%211 = load <16 x i8>, <16 x i8>* %210
%212 = getelementptr inbounds i8, i8* %209, i64 16
%213 = bitcast i8* %212 to <16 x i8>*
%214 = load <16 x i8>, <16 x i8>* %213
%215 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %207
%216 = bitcast i8* %215 to <16 x i8>*
%217 = load <16 x i8>, <16 x i8>* %216
%218 = getelementptr inbounds i8, i8* %215, i64 16
%219 = bitcast i8* %218 to <16 x i8>*
%220 = load <16 x i8>, <16 x i8>* %219
%221 = xor <16 x i8> %217, %211
%222 = xor <16 x i8> %220, %214
%223 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 %207
%224 = bitcast i8* %223 to <16 x i8>*
store <16 x i8> %221, <16 x i8>* %224
%225 = getelementptr inbounds i8, i8* %223, i64 16
%226 = bitcast i8* %225 to <16 x i8>*
store <16 x i8> %222, <16 x i8>* %226
br label %227
227: ; preds = %203, %206
%228 = icmp eq i64 %148, %131
br i1 %228, label %282, label %229
229: ; preds = %227
%230 = add nsw i64 %139, %148
%231 = and i64 %131, 24
%232 = icmp eq i64 %231, 0
br i1 %232, label %254, label %233
233: ; preds = %145, %229
%234 = phi i64 [ %148, %229 ], [ 0, %145 ]
%235 = and i64 %131, 4294967288
%236 = add nsw i64 %139, %235
br label %237
237: ; preds = %237, %233
%238 = phi i64 [ %234, %233 ], [ %250, %237 ]
%239 = add i64 %139, %238
%240 = or i64 %238, %119
%241 = getelementptr inbounds i8, i8* %0, i64 %240
%242 = bitcast i8* %241 to <8 x i8>*
%243 = load <8 x i8>, <8 x i8>* %242
%244 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %239
%245 = bitcast i8* %244 to <8 x i8>*
%246 = load <8 x i8>, <8 x i8>* %245
%247 = xor <8 x i8> %246, %243
%248 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 %239
%249 = bitcast i8* %248 to <8 x i8>*
store <8 x i8> %247, <8 x i8>* %249
%250 = add nuw i64 %238, 8
%251 = icmp eq i64 %250, %235
br i1 %251, label %252, label %237
252: ; preds = %237
%253 = icmp eq i64 %235, %131
br i1 %253, label %282, label %254
254: ; preds = %138, %229, %252
%255 = phi i64 [ %139, %138 ], [ %230, %229 ], [ %236, %252 ]
%256 = phi i64 [ 0, %138 ], [ %148, %229 ], [ %235, %252 ]
br label %269
257: ; preds = %126, %257
%258 = phi i64 [ %267, %257 ], [ 1, %126 ]
%259 = phi i64 [ %260, %257 ], [ %127, %126 ]
%260 = add nsw i64 %259, 1
%261 = load i8, i8* %123
%262 = add nuw nsw i64 %258, %117
%263 = getelementptr inbounds i8, i8* %1, i64 %262
%264 = load i8, i8* %263
%265 = tail call zeroext i8 @bd(i8 zeroext %261, i8 zeroext %264)
%266 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %260
store i8 %265, i8* %266
%267 = add nuw nsw i64 %258, 1
%268 = icmp eq i64 %267, %131
br i1 %268, label %137, label %257
269: ; preds = %254, %269
%270 = phi i64 [ %279, %269 ], [ %255, %254 ]
%271 = phi i64 [ %280, %269 ], [ %256, %254 ]
%272 = add nuw nsw i64 %271, %119
%273 = getelementptr inbounds i8, i8* %0, i64 %272
%274 = load i8, i8* %273
%275 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %270
%276 = load i8, i8* %275
%277 = xor i8 %276, %274
%278 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 %270
store i8 %277, i8* %278
%279 = add nsw i64 %270, 1
%280 = add nuw nsw i64 %271, 1
%281 = icmp eq i64 %280, %143
br i1 %281, label %282, label %269
282: ; preds = %269, %252, %227
%283 = bitcast i32* %9 to i8*
%284 = load i8, i8* %283
%285 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 1
%286 = load i8, i8* %285
%287 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 2
%288 = load i8, i8* %287
br label %289
289: ; preds = %113, %282, %137
%290 = phi i8 [ %288, %282 ], [ 0, %137 ], [ 0, %113 ]
%291 = phi i8 [ %286, %282 ], [ 0, %137 ], [ 0, %113 ]
%292 = phi i8 [ %284, %282 ], [ 0, %137 ], [ 0, %113 ]
%293 = getelementptr inbounds i8, i8* %0, i64 4
%294 = load i8, i8* %293
%295 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 3
store i8 %294, i8* %295
%296 = getelementptr inbounds [4 x i8], [4 x i8]* %10, i64 0, i64 %119
%297 = load i8, i8* %296
%298 = tail call zeroext i8 @bd(i8 zeroext %118, i8 zeroext %297)
%299 = getelementptr inbounds i8, i8* %3, i64 3
store i8 %298, i8* %299
%300 = getelementptr inbounds i8, i8* %1, i64 1
%301 = load i8, i8* %300
%302 = tail call zeroext i8 @bd(i8 zeroext %298, i8 zeroext %301)
%303 = bitcast i32* %7 to i8*
store i8 %302, i8* %303
%304 = load i8, i8* %299
%305 = getelementptr inbounds i8, i8* %1, i64 2
%306 = load i8, i8* %305
%307 = tail call zeroext i8 @bd(i8 zeroext %304, i8 zeroext %306)
%308 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 1
store i8 %307, i8* %308
%309 = load i8, i8* %299
%310 = getelementptr inbounds i8, i8* %1, i64 3
%311 = load i8, i8* %310
%312 = tail call zeroext i8 @bd(i8 zeroext %309, i8 zeroext %311)
%313 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 2
store i8 %312, i8* %313
%314 = load i8, i8* %299
%315 = getelementptr inbounds i8, i8* %1, i64 4
%316 = load i8, i8* %315
%317 = tail call zeroext i8 @bd(i8 zeroext %314, i8 zeroext %316)
%318 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 3
store i8 %317, i8* %318
store i8 0, i8* %2
%319 = xor i8 %292, %302
%320 = getelementptr inbounds i8, i8* %2, i64 1
store i8 %319, i8* %320
%321 = xor i8 %291, %307
%322 = getelementptr inbounds i8, i8* %2, i64 2
store i8 %321, i8* %322
%323 = xor i8 %290, %312
%324 = getelementptr inbounds i8, i8* %2, i64 3
store i8 %323, i8* %324
%325 = xor i8 %294, %317
%326 = getelementptr inbounds i8, i8* %2, i64 4
store i8 %325, i8* %326
%327 = sext i32 %5 to i64
%328 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %327, i64 0
%329 = call i32 @modprod(i8* %328, i8* %3, i8* %15)
%330 = add nsw i32 %5, -1
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %331, i64 0
%333 = load i8, i8* %332
%334 = bitcast i32* %11 to i8*
%335 = load i8, i8* %334
%336 = xor i8 %335, %333
br label %337
337: ; preds = %289, %19
%338 = phi i8 [ %336, %289 ], [ %69, %19 ]
%339 = phi i64 [ %331, %289 ], [ %64, %19 ]
%340 = add nsw i32 %5, 1
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %341, i64 0
store i8 %338, i8* %342
%343 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %339, i64 1
%344 = load i8, i8* %343
%345 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 1
%346 = load i8, i8* %345
%347 = xor i8 %346, %344
%348 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %341, i64 1
store i8 %347, i8* %348
%349 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %339, i64 2
%350 = load i8, i8* %349
%351 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 2
%352 = load i8, i8* %351
%353 = xor i8 %352, %350
%354 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %341, i64 2
store i8 %353, i8* %354
%355 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %339, i64 3
%356 = load i8, i8* %355
%357 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 3
%358 = load i8, i8* %357
%359 = xor i8 %358, %356
%360 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 %341, i64 3
store i8 %359, i8* %360
ret void
}