user: 下面的汇编指令对应的C源代码是什么：

```asm
<bitmap_decompress1>:
  endbr64
  push   %r15
  movslq %r8d,%r8
  push   %r14
  lea    (%rcx,%r8,1),%rax
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rdi,-0x20(%rsp)
  mov    %rax,-0x8(%rsp)
  cmp    %rax,%rcx
  jae    L756
  movl   $0x0,-0x10(%rsp)
  mov    %edx,%ebx
  mov    %rcx,%r9
  mov    %esi,%edx
  movl   $0xffffffff,-0x14(%rsp)
  xor    %r12d,%r12d
  xor    %ebp,%ebp
  xor    %edi,%edi
  movb   $0x0,-0x16(%rsp)
  mov    $0xffffffff,%r13d
  xor    %r11d,%r11d
  movb   $0x0,-0x15(%rsp)
L540:
  movzbl (%r9),%ecx
  lea    0x1(%r9),%r10
  mov    %ecx,%r8d
  mov    %ecx,%eax
  sar    $0x4,%r8d
  cmp    $0xf,%r8d
  jne    L605
  mov    %ecx,%r8d
  and    $0xf,%ecx
  and    $0xf,%r8d
  cmp    $0x8,%r8b
  ja     L455
  movzwl 0x1(%r9),%eax
  lea    0x3(%r9),%r10
  cmp    $0xa,%r8b
  ja     L16
  lea    D2(%rip),%r9
  movzbl %r8b,%r8d
  movslq (%r9,%r8,4),%r8
  add    %r9,%r8
  notrack jmp *%r8
  nopl   (%rax)
L605:
  cmp    $0xb,%r8d
  jg     L569
  sar    $0x5,%ecx
  and    $0x1f,%eax
  mov    $0x20,%r14d
L94:
  mov    $0x84,%r8d
  shr    %cl,%r8
  and    $0x1,%r8d
  test   %eax,%eax
  je     L738
  lea    0x0(,%rax,8),%r9d
  test   %r8,%r8
  cmovne %r9d,%eax
L489:
  cmp    $0xa,%ecx
  ja     L39
L731:
  lea    D17(%rip),%r9
  mov    %ecx,%r8d
  movslq (%r9,%r8,4),%r8
  add    %r9,%r8
  notrack jmp *%r8
L738:
  movzbl 0x1(%r9),%r15d
  lea    0x2(%r9),%r10
  add    %r15d,%r14d
  lea    0x1(%r15),%eax
  test   %r8,%r8
  cmove  %r14d,%eax
  cmp    $0xa,%ecx
  jbe    L731
L39:
  movl   $0x0,-0x14(%rsp)
  jmp    L426
  cs nopw 0x0(%rax,%rax,1)
L455:
  cmp    $0xa,%r8b
  ja     L875
  mov    $0x8,%eax
  jmp    L489
  nopl   0x0(%rax)
L569:
  lea    -0x6(%r8),%ecx
  and    $0xf,%eax
  mov    $0x10,%r14d
  jmp    L94
  nopw   0x0(%rax,%rax,1)
  movl   $0x0,-0x14(%rsp)
  movzbl (%r10),%r13d
  sub    $0x5,%ecx
  add    $0x1,%r10
  nopl   0x0(%rax,%rax,1)
L60:
  test   %eax,%eax
  je     L96
L426:
  xor    %r9d,%r9d
  nopl   0x0(%rax,%rax,1)
L843:
  cmp    %edx,%esi
  jg     L499
  test   %ebx,%ebx
  jle    L566
  sub    $0x1,%ebx
  mov    %esi,%edx
  mov    %rdi,%r11
  mov    -0x20(%rsp),%rdi
  imul   %ebx,%edx
  movslq %edx,%rdx
  add    %rdx,%rdi
  xor    %edx,%edx
L499:
  cmp    $0xe,%ecx
  ja     L566
  lea    D27(%rip),%r15
  mov    %ecx,%r8d
  movslq (%r15,%r8,4),%r8
  add    %r15,%r8
  notrack jmp *%r8
  nopw   0x0(%rax,%rax,1)
L566:
  xor    %eax,%eax
L527:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   (%rax)
  lea    0x1(%rdx),%r8d
  movslq %r8d,%r8
  cmp    %esi,%edx
  jge    L843
  nopl   0x0(%rax,%rax,1)
L279:
  sub    $0x1,%eax
  movb   $0x0,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L279
L753:
  test   %eax,%eax
  jne    L843
L96:
  mov    %ecx,-0x14(%rsp)
  mov    %r10,%r9
  cmp    %r10,-0x8(%rsp)
  ja     L540
L756:
  mov    $0x1,%eax
  jmp    L527
  nopl   0x0(%rax,%rax,1)
  lea    0x1(%rdx),%r8d
  movslq %r8d,%r8
  cmp    %esi,%edx
  jge    L843
  nop
L49:
  sub    $0x1,%eax
  movb   $0xff,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L49
  test   %eax,%eax
  jne    L843
  jmp    L96
  nopl   0x0(%rax)
  lea    0x1(%rdx),%r8d
  movslq %r8d,%r8
  cmp    %esi,%edx
  jl     L691
  jmp    L843
L675:
  movzbl -0x16(%rsp),%edx
  sub    $0x1,%eax
  xor    %r12d,%r12d
L642:
  cmp    %r8d,%esi
  mov    %dl,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  setg   %r15b
  test   %eax,%eax
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  je     L753
L691:
  test   %r12d,%r12d
  jne    L675
  movzbl -0x15(%rsp),%edx
  mov    $0x1,%r12d
  jmp    L642
  nop
  lea    0x1(%rdx),%r8d
  movslq %r8d,%r8
  cmp    %esi,%edx
  jge    L843
  nop
L419:
  sub    $0x1,%eax
  add    $0x1,%r10
  movzbl -0x1(%r10),%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  mov    %dl,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L419
  test   %eax,%eax
  jne    L843
  jmp    L96
  nopw   0x0(%rax,%rax,1)
  lea    0x1(%rdx),%r8d
  movslq %r8d,%r8
  cmp    %esi,%edx
  jge    L843
  mov    %ecx,-0xc(%rsp)
  movzbl -0x16(%rsp),%r15d
  nopl   0x0(%rax)
L370:
  sub    $0x1,%eax
  mov    %r15b,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  test   %eax,%eax
  setg   %r14b
  cmp    %r8d,%esi
  setg   %cl
  add    $0x1,%r8
  test   %cl,%r14b
  jne    L370
  mov    -0xc(%rsp),%ecx
L308:
  test   %eax,%eax
  jne    L843
  jmp    L96
  nopl   0x0(%rax)
  test   %r11,%r11
  je     L653
  cmp    %esi,%edx
  jge    L843
  mov    -0x14(%rsp),%r14d
  add    $0x1,%edx
  movslq %edx,%r8
  test   %r14d,%r14d
  je     L578
  mov    %ecx,-0xc(%rsp)
  mov    %r14d,%ecx
L140:
  add    %r9d,%r9d
  mov    $0x1,%edx
  test   $0xfe,%r9b
  cmove  %edx,%r9d
  movzbl -0x1(%r11,%r8,1),%edx
  cmove  %ecx,%ebp
  mov    %edx,%r14d
  xor    %r13d,%r14d
  test   %r9d,%ebp
  cmovne %r14d,%edx
  sub    $0x1,%eax
  cmp    %r8d,%esi
  setg   %r15b
  test   %eax,%eax
  setg   %r14b
  mov    %dl,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L140
  mov    -0xc(%rsp),%ecx
  jmp    L308
L578:
  add    %r9d,%r9d
  test   $0xfe,%r9b
  jne    L85
  movzbl (%r10),%ebp
  mov    $0x1,%r9d
  add    $0x1,%r10
L85:
  movzbl -0x1(%r11,%r8,1),%edx
  mov    %edx,%r14d
  xor    %r13d,%r14d
  test   %ebp,%r9d
  cmovne %r14d,%edx
  sub    $0x1,%eax
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  mov    %dl,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L578
  test   %eax,%eax
  jne    L843
  jmp    L96
  nopl   0x0(%rax,%rax,1)
  test   %r11,%r11
  je     L879
  lea    0x1(%rdx),%r8d
  movslq %r8d,%r8
  cmp    %esi,%edx
  jge    L843
  nopl   0x0(%rax,%rax,1)
L346:
  movzbl -0x1(%r11,%r8,1),%edx
  sub    $0x1,%eax
  xor    %r13d,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  mov    %dl,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L346
  test   %eax,%eax
  jne    L843
  jmp    L96
  nopw   0x0(%rax,%rax,1)
  mov    -0x10(%rsp),%r8d
  test   %r8d,%r8d
  je     L617
  movslq %edx,%r14
  mov    %r13d,%r8d
  lea    (%rdi,%r14,1),%r15
  test   %r11,%r11
  je     L648
  xor    (%r11,%r14,1),%r8b
L648:
  mov    %r8b,(%r15)
  sub    $0x1,%eax
  add    $0x1,%edx
L617:
  test   %eax,%eax
  setg   %r14b
  cmp    %esi,%edx
  setl   %r8b
  and    %r8d,%r14d
  test   %r11,%r11
  je     L661
  lea    0x1(%rdx),%r8d
  movslq %r8d,%r8
  test   %r14b,%r14b
  je     L786
  nopw   0x0(%rax,%rax,1)
L688:
  sub    $0x1,%eax
  movzbl -0x1(%r11,%r8,1),%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  mov    %dl,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L688
L786:
  mov    %ecx,-0x10(%rsp)
L300:
  test   %eax,%eax
  jne    L843
  jmp    L96
  nopl   0x0(%rax,%rax,1)
L875:
  movl   $0x0,-0x14(%rsp)
  mov    $0x1,%eax
  jmp    L426
  nopw   0x0(%rax,%rax,1)
L16:
  movl   $0x0,-0x14(%rsp)
  jmp    L60
  nopl   (%rax)
  movl   $0x5,-0x14(%rsp)
  mov    $0x2,%ecx
  mov    $0x5,%ebp
  jmp    L60
  nop
  movl   $0x3,-0x14(%rsp)
  mov    $0x2,%ecx
  mov    $0x3,%ebp
  jmp    L60
  nopw   0x0(%rax,%rax,1)
  movzbl (%r10),%ecx
  lea    0x1(%r10),%r8
  mov    %cl,-0x15(%rsp)
  mov    $0x8,%ecx
L651:
  movzbl (%r8),%r9d
  movl   $0x0,-0x14(%rsp)
  lea    0x1(%r8),%r10
  mov    %r9b,-0x16(%rsp)
  jmp    L60
  nopl   0x0(%rax,%rax,1)
  mov    -0x14(%rsp),%r9d
  test   %r9d,%r9d
  jne    L115
  cmp    %edx,%esi
  jne    L25
  xor    %ecx,%ecx
  test   %r11,%r11
  je     L60
L25:
  movl   $0x1,-0x10(%rsp)
  xor    %ecx,%ecx
  jmp    L60
  mov    %r10,%r8
  jmp    L651
  nopl   0x0(%rax)
L879:
  cmp    %esi,%edx
  jge    L843
  add    $0x1,%edx
  movslq %edx,%r8
  cs nopw 0x0(%rax,%rax,1)
L139:
  sub    $0x1,%eax
  mov    %r13b,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L139
  test   %eax,%eax
  jne    L843
  jmp    L96
  xchg   %ax,%ax
L661:
  test   %r14b,%r14b
  je     L786
  add    $0x1,%edx
  movslq %edx,%r8
  nop
L815:
  sub    $0x1,%eax
  movb   $0x0,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L815
  mov    %ecx,-0x10(%rsp)
  jmp    L300
  nopl   0x0(%rax,%rax,1)
L653:
  cmp    %esi,%edx
  jge    L843
  add    $0x1,%edx
  movslq %edx,%r8
  mov    -0x14(%rsp),%edx
  test   %edx,%edx
  je     L354
  cs nopw 0x0(%rax,%rax,1)
L303:
  add    %r9d,%r9d
  mov    $0x1,%edx
  test   $0xfe,%r9b
  cmove  -0x14(%rsp),%ebp
  cmove  %edx,%r9d
  test   %ebp,%r9d
  jne    L524
  sub    $0x1,%eax
  movb   $0x0,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L303
  jmp    L753
  nopl   0x0(%rax)
L214:
  movb   $0x0,-0x1(%rdi,%r8,1)
L252:
  sub    $0x1,%eax
  mov    %r8d,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %r8d,%esi
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  je     L753
L354:
  add    %r9d,%r9d
  test   $0xfe,%r9b
  jne    L801
  movzbl (%r10),%ebp
  mov    $0x1,%r9d
  add    $0x1,%r10
L801:
  test   %ebp,%r9d
  je     L214
  mov    %r13b,-0x1(%rdi,%r8,1)
  jmp    L252
  nopl   0x0(%rax)
L524:
  sub    $0x1,%eax
  cmp    %r8d,%esi
  mov    %r13b,-0x1(%rdi,%r8,1)
  mov    %r8d,%edx
  setg   %r15b
  test   %eax,%eax
  setg   %r14b
  add    $0x1,%r8
  test   %r14b,%r15b
  jne    L303
  jmp    L753
  nopw   0x0(%rax,%rax,1)
L115:
  movl   $0x0,-0x14(%rsp)
  xor    %ecx,%ecx
  jmp    L60
  mov    %r10,%r8
  mov    $0x3,%ecx
  jmp    L651
```

assistant: ```c
int bitmap_decompress1(char *output, int width, int height, char *input, int size) {
  char *prevline;
  char *line;
  char *end;
  char color1;
  char color2;
  char mix;
  int code;
  int mixmask;
  int mask;
  int opcode;
  int count;
  int offset;
  int isfillormix;
  int x;
  int lastopcode;
  int insertmix;
  int bicolor;
  int fom_mask;
  end = input + size;
  prevline = 0;
  line = 0;
  x = width;
  lastopcode = -1;
  insertmix = 0;
  bicolor = 0;
  color1 = 0;
  color2 = 0;
  mix = 0xff;
  mask = 0;
  fom_mask = 0;
  while (input < end) {
    fom_mask = 0;
    code = ((unsigned char)(*(input++)));
    opcode = code >> 4;
    switch (opcode) {
    case 0xc:
    case 0xd:
    case 0xe:
      opcode -= 6;
      count = code & 0xf;
      offset = 16;
      break;
    case 0xf:
      opcode = code & 0xf;
      if (opcode < 9) {
        count = ((unsigned char)(*(input++)));
        count |= ((unsigned char)(*(input++))) << 8;
      } else {
        count = (opcode < 0xb) ? 8 : 1;
      }
      offset = 0;
      break;
    default:
      opcode >>= 1;
      count = code & 0x1f;
      offset = 32;
      break;
    }
    if (offset != 0) {
      isfillormix = ((opcode == 2) || (opcode == 7));
      if (count == 0) {
        if (isfillormix) {
          count = ((unsigned char)(*(input++))) + 1;
        } else {
          count = ((unsigned char)(*(input++))) + offset;
        }
      } else if (isfillormix) {
        count <<= 3;
      }
    }
    switch (opcode) {
    case 0:
      if ((lastopcode == opcode) && !((x == width) && (prevline == 0))) {
        insertmix = 1;
      }
      break;
    case 8:
      color1 = ((unsigned char)(*(input++)));
    case 3:
      color2 = ((unsigned char)(*(input++)));
      break;
    case 6:
    case 7:
      mix = ((unsigned char)(*(input++)));
      opcode -= 5;
      break;
    case 9:
      mask = 0x03;
      opcode = 0x02;
      fom_mask = 3;
      break;
    case 0x0a:
      mask = 0x05;
      opcode = 0x02;
      fom_mask = 5;
      break;
    }
    lastopcode = opcode;
    mixmask = 0;
    while (count > 0) {
      if (x >= width) {
        if (height <= 0) {
          return 0;
        }
        x = 0;
        height--;
        prevline = line;
        line = output + height * width;
      }
      switch (opcode) {
      case 0:
        if (insertmix) {
          if (prevline == 0) {
            line[x] = mix;
          } else {
            line[x] = prevline[x] ^ mix;
          }
          insertmix = 0;
          count--;
          x++;
        }
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x] = 0;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x] = prevline[x];
              count--;
              x++;
            }
          }
        }
        break;
      case 1:
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x] = mix;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x] = prevline[x] ^ mix;
              count--;
              x++;
            }
          }
        }
        break;
      case 2:
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              {
                mixmask <<= 1;
                if ((mixmask & 0xff) == 0) {
                  mask = fom_mask ? fom_mask : ((unsigned char)(*(input++)));
                  mixmask = 1;
                }
              };
              if (mask & mixmask) {
                line[x] = mix;
              } else {
                line[x] = 0;
              };
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              {
                mixmask <<= 1;
                if ((mixmask & 0xff) == 0) {
                  mask = fom_mask ? fom_mask : ((unsigned char)(*(input++)));
                  mixmask = 1;
                }
              };
              if (mask & mixmask) {
                line[x] = prevline[x] ^ mix;
              } else {
                line[x] = prevline[x];
              };
              count--;
              x++;
            }
          }
        }
        break;
      case 3: {
        while ((count > 0) && (x < width)) {
          line[x] = color2;
          count--;
          x++;
        }
      } break;
      case 4: {
        while ((count > 0) && (x < width)) {
          line[x] = ((unsigned char)(*(input++)));
          count--;
          x++;
        }
      } break;
      case 8: {
        while ((count > 0) && (x < width)) {
          if (bicolor) {
            line[x] = color2;
            bicolor = 0;
          } else {
            line[x] = color1;
            bicolor = 1;
            count++;
          };
          count--;
          x++;
        }
      } break;
      case 0xd: {
        while ((count > 0) && (x < width)) {
          line[x] = 0xff;
          count--;
          x++;
        }
      } break;
      case 0xe: {
        while ((count > 0) && (x < width)) {
          line[x] = 0;
          count--;
          x++;
        }
      } break;
      default:
        return 0;
        break;
      }
    }
  }
  return 1;
}
```