user: Demonstrate the C code that generates the assembly output below:

```asm
<flt_divide>:
  endbr64
  mov    (%rdx),%r9d
  mov    %r9d,%r8d
  shr    $0x14,%r8d
  and    $0x7ff,%r8d
  je     L17
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  mov    %rdi,%rbp
  push   %rbx
  mov    (%rsi),%ecx
  mov    0x4(%rsi),%eax
  mov    0x4(%rdx),%ebx
  mov    %ecx,%r13d
  mov    %ecx,%r12d
  xor    %r9d,%r13d
  shr    $0x14,%r12d
  and    $0x80000000,%r13d
  and    $0x7ff,%r12d
  je     L119
  mov    %ecx,%edx
  and    $0xfffff,%r9d
  mov    %ebx,%r11d
  sub    %r8d,%r12d
  and    $0xfffff,%edx
  shr    $0x8,%r11d
  xor    %esi,%esi
  xor    %edi,%edi
  or     $0x100000,%edx
  or     $0x100000,%r9d
  mov    $0x37,%r8d
  movzbl %bl,%r10d
  nopl   0x0(%rax,%rax,1)
L40:
  mov    %esi,%ecx
  add    %edi,%edi
  add    %esi,%esi
  shr    $0x1f,%ecx
  or     %ecx,%edi
  cmp    %edx,%r9d
  jb     L48
  jne    L63
  cmp    %eax,%ebx
  ja     L63
L48:
  movzbl %al,%ecx
  shr    $0x8,%eax
  sub    %r9d,%edx
  or     $0x1,%esi
  sub    %r10d,%ecx
  sub    %r11d,%eax
  mov    %ecx,%r14d
  movzbl %cl,%ecx
  sar    $0x8,%r14d
  add    %r14d,%eax
  mov    %eax,%r14d
  shl    $0x8,%eax
  sar    $0x18,%r14d
  or     %ecx,%eax
  add    %r14d,%edx
L63:
  mov    %eax,%ecx
  add    %edx,%edx
  add    %eax,%eax
  shr    $0x1f,%ecx
  or     %ecx,%edx
  sub    $0x1,%r8d
  jne    L40
  or     %eax,%edx
  movzbl %dl,%eax
  shr    $0x8,%edx
  or     %edx,%eax
  test   $0x400000,%edi
  jne    L107
  add    $0x3fe,%r12d
L118:
  mov    %esi,%ecx
  mov    %edi,%edx
  shr    %esi
  shl    $0x1f,%edx
  shl    $0x1f,%ecx
  or     %esi,%edx
  shr    %edi
  or     %eax,%ecx
  js     L134
L154:
  xor    %r8d,%r8d
  cmp    $0x7fe,%r12d
  jg     L143
  test   %r12d,%r12d
  jle    L119
  and    $0xffefffff,%edi
  shl    $0x14,%r12d
  mov    %edx,0x4(%rbp)
  mov    $0x1,%r8d
  or     %r13d,%edi
  or     %r12d,%edi
  mov    %edi,0x0(%rbp)
L143:
  pop    %rbx
  mov    %r8d,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  nopl   0x0(%rax,%rax,1)
L119:
  mov    $0x1,%r8d
  mov    %r13d,0x0(%rbp)
  movl   $0x0,0x4(%rbp)
  mov    %r8d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  nopl   (%rax)
L17:
  mov    %r8d,%eax
  ret
L107:
  mov    %esi,%ecx
  mov    %edi,%edx
  and    $0x1,%esi
  shr    %edi
  shr    %ecx
  shl    $0x1f,%edx
  or     %esi,%eax
  add    $0x3ff,%r12d
  mov    %ecx,%esi
  or     %edx,%esi
  jmp    L118
L134:
  test   $0x1,%dl
  jne    L167
  cmp    $0x80000000,%ecx
  je     L154
L74:
  add    $0x1,%edx
  jmp    L154
L167:
  cmp    $0xffffffff,%edx
  jne    L74
  add    $0x1,%edi
  mov    %edi,%edx
  and    $0x200000,%edx
  je     L154
  add    $0x1,%r12d
  xor    %edx,%edx
  mov    $0x100000,%edi
  jmp    L154
```

assistant: ```c
int flt_divide(a, b, c)
double *a;
double *b;
double *c;
{
  unsigned int bh = ((unsigned int *)b)[0];
  unsigned int bl = ((unsigned int *)b)[1];
  unsigned int ch = ((unsigned int *)c)[0];
  unsigned int cl = ((unsigned int *)c)[1];
  unsigned int ah, al, as = (bh ^ ch) & 0x80000000;
  int ax, bx, cx, i;
  bx = (bh >> 20) & 0x7ff;
  cx = (ch >> 20) & 0x7ff;
  if (cx == 0)
    return 0;
  if (bx == 0) {
    ((unsigned int *)a)[0] = as;
    ((unsigned int *)a)[1] = 0;
    return 1;
  }
  bh = (bh & 0xfffff) | 0x00100000;
  ch = (ch & 0xfffff) | 0x00100000;
  ax = bx - cx + 0x3fe;
  ah = al = 0;
  for (i = 0; i < 55; i++) {
    if (bh > ch || (bh == ch && bl >= cl)) {
      unsigned int w = (bl & 0xff) - (cl & 0xff);
      bl = (bl >> 8) - (cl >> 8) + ((int)w >> 8);
      bh = bh - ch + (((int)bl) >> 24);
      bl = (bl << 8) | (w & 0xff);
      ah = (ah << 1) | (al >> 31);
      al = (al << 1) | 1;
    } else {
      ah = (ah << 1) | (al >> 31);
      al = al << 1;
    }
    bh = (bh << 1) | (bl >> 31);
    bl = bl << 1;
  }
  bh |= bl;
  bh = (bh & 0xff) | (bh >> 8);
  if (ah & 0x00400000) {
    bh |= al & 1;
    al = (al >> 1) | (ah << 31);
    ah = ah >> 1;
    ax += 1;
  }
  bh = bh | (al << 31);
  al = (al >> 1) | (ah << 31);
  ah = ah >> 1;
  if ((bh & 0x80000000) && ((al & 1) != 0 || bh != 0x80000000)) {
    if (al == 0xffffffff) {
      al = 0;
      ah += 1;
      if (ah & 0x00200000) {
        ah = 0x00100000;
        ax += 1;
      }
    } else
      al += 1;
  }
  if (ax >= 0x7ff)
    return 0;
  else if (ax <= 0) {
    ((unsigned int *)a)[0] = as;
    ((unsigned int *)a)[1] = 0;
    return 1;
  }
  ((int *)a)[0] = (ah & ~0x00100000) | (ax << 20) | as;
  ((int *)a)[1] = al;
  return 1;
}
```