user: 这段汇编代码用C语言表示是什么样的？

```asm
<bitmap_decompress2>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rdi,-0x28(%rsp)
  movslq %r8d,%r8
  lea    (%rcx,%r8,1),%rax
  mov    %rax,-0x8(%rsp)
  cmp    %rax,%rcx
  jae    L720
  mov    %esi,%edi
  mov    %edx,%r11d
  mov    %rcx,%r9
  mov    %esi,%edx
  mov    $0x0,%r12d
  mov    $0x0,%ebp
  movb   $0x0,-0x9(%rsp)
  movb   $0xff,-0xb(%rsp)
  mov    $0xffffffff,%r13d
  movl   $0x0,-0x14(%rsp)
  movl   $0x0,-0x18(%rsp)
  movl   $0xffffffff,-0x30(%rsp)
  movl   $0x0,-0x1c(%rsp)
  mov    $0x0,%esi
  mov    $0x0,%r8d
  movb   $0x0,-0xa(%rsp)
L541:
  lea    0x1(%r9),%rbx
  movzbl (%r9),%eax
  movzbl %al,%r10d
  mov    %r10d,%ecx
  sar    $0x4,%ecx
  cmp    $0xef,%r10d
  jle    L190
  mov    %eax,%ecx
  and    $0xf,%ecx
  mov    %eax,%r10d
  and    $0xf,%r10d
  cmp    $0x8,%r10d
  jg     L1039
  movzbl 0x1(%r9),%r14d
  lea    0x3(%r9),%rbx
  movzbl 0x2(%r9),%eax
  shl    $0x8,%eax
  or     %r14d,%eax
  cmp    $0xa,%cl
  ja     L1009
  movzbl %cl,%ecx
  lea    D28(%rip),%r9
  movslq (%r9,%rcx,4),%rcx
  add    %r9,%rcx
  notrack jmp *%rcx
L190:
  cmp    $0xb,%ecx
  jg     L681
  sar    $0x5,%r10d
  and    $0x1f,%eax
  mov    $0x20,%r15d
  jmp    L439
L681:
  lea    -0x6(%rcx),%r10d
  and    $0xf,%eax
  mov    $0x10,%r15d
L439:
  lea    0x6(%r10),%ecx
  mov    $0x2100,%r14d
  shr    %cl,%r14
  and    $0x1,%r14d
  test   %eax,%eax
  je     L1021
  lea    0x0(,%rax,8),%ecx
  test   %r14,%r14
  cmovne %ecx,%eax
L559:
  cmp    $0xa,%r10d
  ja     L101
  mov    %r10d,%ecx
  lea    D0(%rip),%r9
  movslq (%r9,%rcx,4),%rcx
  add    %r9,%rcx
  notrack jmp *%rcx
L1039:
  cmp    $0xb,%r10d
  mov    $0x8,%eax
  mov    $0x1,%r9d
  cmovge %r9d,%eax
  cmp    $0xa,%cl
  ja     L1034
  movzbl %cl,%ecx
  lea    D34(%rip),%r9
  movslq (%r9,%rcx,4),%rcx
  add    %r9,%rcx
  notrack jmp *%rcx
L1021:
  test   %r14,%r14
  je     L418
  lea    0x2(%r9),%rbx
  movzbl 0x1(%r9),%eax
  add    $0x1,%eax
  jmp    L559
L418:
  lea    0x2(%r9),%rbx
  movzbl 0x1(%r9),%eax
  add    %r15d,%eax
  jmp    L559
  mov    %rbx,%r9
  jmp    L753
  mov    %rbx,%r9
L753:
  cmpl   $0x0,-0x30(%rsp)
  je     L916
  movl   $0x0,-0x2c(%rsp)
  movl   $0x0,-0x30(%rsp)
  jmp    L896
  mov    %rbx,%r9
  jmp    L753
L916:
  cmp    %edx,%edi
  jne    L1033
  mov    -0x30(%rsp),%ebx
  mov    %ebx,-0x2c(%rsp)
  test   %r8,%r8
  je     L896
L1033:
  mov    -0x30(%rsp),%ebx
  mov    %ebx,-0x2c(%rsp)
  movl   $0x1,-0x18(%rsp)
  jmp    L896
  mov    %r10d,-0x30(%rsp)
  jmp    L364
  mov    %r10d,-0x30(%rsp)
L364:
  movzbl (%rbx),%ecx
  mov    %cl,-0x9(%rsp)
  lea    0x2(%rbx),%rcx
  movzbl 0x1(%rbx),%ebx
  mov    %bl,-0xa(%rsp)
L767:
  movzbl (%rcx),%ebp
  lea    0x2(%rcx),%r9
  movzbl 0x1(%rcx),%r12d
  movl   $0x0,-0x2c(%rsp)
L896:
  test   %eax,%eax
  jle    L703
L745:
  mov    $0x0,%r10d
  mov    -0x30(%rsp),%ecx
  mov    %ecx,%ebx
  mov    -0x2c(%rsp),%r14d
  mov    %r14d,-0x20(%rsp)
  mov    %ecx,-0x10(%rsp)
  mov    %rbx,-0x38(%rsp)
  movzbl -0xb(%rsp),%ebx
  jmp    L555
  mov    %r10d,-0x30(%rsp)
  jmp    L364
  mov    %r10d,-0x30(%rsp)
  mov    %rbx,%rcx
  jmp    L767
  mov    %r10d,-0x30(%rsp)
  mov    %rbx,%rcx
  jmp    L767
  mov    %r10d,-0x30(%rsp)
  mov    %rbx,%rcx
  jmp    L767
  movzbl (%rbx),%ecx
  mov    %cl,-0xb(%rsp)
  lea    0x2(%rbx),%r9
  movzbl 0x1(%rbx),%r13d
  lea    -0x5(%r10),%ebx
  mov    %ebx,-0x30(%rsp)
  movl   $0x0,-0x2c(%rsp)
  jmp    L896
  mov    %rbx,%r9
  jmp    L924
  mov    %rbx,%r9
L924:
  movl   $0x3,-0x2c(%rsp)
  movl   $0x2,-0x30(%rsp)
  movl   $0x3,-0x1c(%rsp)
  jmp    L896
  mov    %rbx,%r9
  jmp    L924
  mov    %rbx,%r9
  jmp    L566
  mov    %rbx,%r9
L566:
  movl   $0x5,-0x2c(%rsp)
  movl   $0x2,-0x30(%rsp)
  movl   $0x5,-0x1c(%rsp)
  jmp    L896
  mov    %rbx,%r9
  jmp    L566
L1009:
  mov    %r10d,-0x30(%rsp)
  mov    %rbx,%r9
  movl   $0x0,-0x2c(%rsp)
  jmp    L896
L101:
  mov    %r10d,-0x30(%rsp)
  mov    %rbx,%r9
  movl   $0x0,-0x2c(%rsp)
  jmp    L745
L1034:
  mov    %r10d,-0x30(%rsp)
  mov    %rbx,%r9
  movl   $0x0,-0x2c(%rsp)
  jmp    L745
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  setl   %r14b
  lea    0x1(%rdx),%ecx
  movslq %ecx,%rcx
  test   %r14b,%r14b
  je     L1155
L892:
  movb   $0x0,-0x2(%rsi,%rcx,2)
  movb   $0x0,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L892
  jmp    L1155
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  setl   %r14b
  lea    0x1(%rdx),%ecx
  movslq %ecx,%rcx
  test   %r14b,%r14b
  je     L1155
L466:
  movb   $0xff,-0x2(%rsi,%rcx,2)
  movb   $0xff,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L466
  jmp    L1155
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  jge    L1155
  movzbl -0xa(%rsp),%r14d
  movzbl -0x9(%rsp),%r15d
  mov    -0x14(%rsp),%ecx
  jmp    L414
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  setl   %r14b
  lea    0x1(%rdx),%ecx
  movslq %ecx,%rcx
  test   %r14b,%r14b
  je     L1155
L570:
  movzbl (%r9),%edx
  mov    %dl,-0x2(%rsi,%rcx,2)
  add    $0x2,%r9
  movzbl -0x1(%r9),%edx
  mov    %dl,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L570
  jmp    L1155
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  setl   %r14b
  lea    0x1(%rdx),%ecx
  movslq %ecx,%rcx
  test   %r14b,%r14b
  je     L1155
L620:
  mov    %bpl,-0x2(%rsi,%rcx,2)
  mov    %r12b,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L620
L1155:
  test   %eax,%eax
  jle    L703
L555:
  cmp    %edx,%edi
  jg     L895
  test   %r11d,%r11d
  jle    L373
  sub    $0x1,%r11d
  mov    %edi,%edx
  imul   %r11d,%edx
  add    %edx,%edx
  movslq %edx,%rdx
  mov    %rsi,%r8
  mov    -0x28(%rsp),%rsi
  lea    (%rsi,%rdx,1),%rsi
  mov    $0x0,%edx
L895:
  cmpl   $0xe,-0x30(%rsp)
  ja     L295
  lea    D6(%rip),%r15
  mov    -0x38(%rsp),%rcx
  movslq (%r15,%rcx,4),%rcx
  add    %r15,%rcx
  notrack jmp *%rcx
  cmpl   $0x0,-0x18(%rsp)
  je     L501
  test   %r8,%r8
  je     L1119
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  mov    %ebx,%r14d
  xor    (%r8,%rcx,1),%r14b
  mov    %r14b,(%rsi,%rcx,1)
  mov    %r13d,%r14d
  xor    0x1(%r8,%rcx,1),%r14b
  mov    %r14b,0x1(%rsi,%rcx,1)
L6:
  sub    $0x1,%eax
  add    $0x1,%edx
L501:
  test   %r8,%r8
  je     L946
  test   %eax,%eax
  jle    L565
  cmp    %edi,%edx
  setl   %r14b
  lea    0x1(%rdx),%ecx
  movslq %ecx,%rcx
  test   %r14b,%r14b
  je     L565
L850:
  movzbl -0x2(%r8,%rcx,2),%edx
  mov    %dl,-0x2(%rsi,%rcx,2)
  movzbl -0x1(%r8,%rcx,2),%edx
  mov    %dl,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L850
  mov    -0x10(%rsp),%ecx
  mov    %ecx,-0x18(%rsp)
  jmp    L1155
L1119:
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  mov    %bl,(%rsi,%rcx,1)
  mov    %r13b,0x1(%rsi,%rcx,1)
  jmp    L6
L565:
  mov    -0x10(%rsp),%ecx
  mov    %ecx,-0x18(%rsp)
  jmp    L1155
L946:
  test   %eax,%eax
  jle    L264
  cmp    %edi,%edx
  jge    L264
  add    $0x1,%edx
  movslq %edx,%rcx
L1154:
  movb   $0x0,-0x2(%rsi,%rcx,2)
  movb   $0x0,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L1154
  mov    -0x10(%rsp),%ecx
  mov    %ecx,-0x18(%rsp)
  jmp    L1155
  test   %r8,%r8
  je     L601
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  setl   %r14b
  lea    0x1(%rdx),%ecx
  movslq %ecx,%rcx
  test   %r14b,%r14b
  je     L1155
L611:
  mov    %ebx,%edx
  xor    -0x2(%r8,%rcx,2),%dl
  mov    %dl,-0x2(%rsi,%rcx,2)
  mov    %r13d,%edx
  xor    -0x1(%r8,%rcx,2),%dl
  mov    %dl,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L611
  jmp    L1155
L601:
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  jge    L1155
  add    $0x1,%edx
  movslq %edx,%rcx
L657:
  mov    %bl,-0x2(%rsi,%rcx,2)
  mov    %r13b,-0x1(%rsi,%rcx,2)
  sub    $0x1,%eax
  mov    %ecx,%edx
  test   %eax,%eax
  setg   %r15b
  cmp    %ecx,%edi
  setg   %r14b
  add    $0x1,%rcx
  test   %r14b,%r15b
  jne    L657
  jmp    L1155
  test   %r8,%r8
  je     L437
  test   %eax,%eax
  jle    L1155
  mov    -0x1c(%rsp),%r14d
  cmp    %edi,%edx
  jl     L674
  jmp    L1155
L437:
  test   %eax,%eax
  jle    L1155
  cmp    %edi,%edx
  jge    L1155
  mov    -0x1c(%rsp),%r14d
  mov    -0x2c(%rsp),%r15d
  jmp    L400
L278:
  mov    -0x20(%rsp),%r14d
  mov    $0x1,%r10d
L1069:
  test   %r14d,%r10d
  je     L13
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  mov    %bl,(%rsi,%rcx,1)
  mov    %r13b,0x1(%rsi,%rcx,1)
L1030:
  sub    $0x1,%eax
  add    $0x1,%edx
  test   %eax,%eax
  jle    L988
  cmp    %edx,%edi
  jle    L214
L400:
  add    %r10d,%r10d
  test   %r10b,%r10b
  jne    L1069
  test   %r15d,%r15d
  jne    L278
  movzbl (%r9),%r14d
  lea    0x1(%r9),%r9
  mov    $0x1,%r10d
  jmp    L1069
L13:
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  movb   $0x0,(%rsi,%rcx,1)
  movb   $0x0,0x1(%rsi,%rcx,1)
  jmp    L1030
L214:
  mov    %r14d,-0x1c(%rsp)
  jmp    L1155
L209:
  mov    -0x20(%rsp),%r14d
  mov    $0x1,%r10d
L85:
  test   %r14d,%r10d
  je     L1110
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  mov    %ebx,%r15d
  xor    (%r8,%rcx,1),%r15b
  mov    %r15b,(%rsi,%rcx,1)
  mov    %r13d,%r15d
  xor    0x1(%r8,%rcx,1),%r15b
  mov    %r15b,0x1(%rsi,%rcx,1)
L480:
  sub    $0x1,%eax
  add    $0x1,%edx
  test   %eax,%eax
  jle    L483
  cmp    %edx,%edi
  jle    L996
L674:
  add    %r10d,%r10d
  test   %r10b,%r10b
  jne    L85
  cmpl   $0x0,-0x2c(%rsp)
  jne    L209
  movzbl (%r9),%r14d
  lea    0x1(%r9),%r9
  mov    $0x1,%r10d
  jmp    L85
L1110:
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  movzbl (%r8,%rcx,1),%r15d
  mov    %r15b,(%rsi,%rcx,1)
  movzbl 0x1(%r8,%rcx,1),%r15d
  mov    %r15b,0x1(%rsi,%rcx,1)
  jmp    L480
L996:
  mov    %r14d,-0x1c(%rsp)
  jmp    L1155
L289:
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  mov    %r15b,(%rsi,%rcx,1)
  mov    %r14b,0x1(%rsi,%rcx,1)
  add    $0x1,%eax
  mov    $0x1,%ecx
L1133:
  sub    $0x1,%eax
  add    $0x1,%edx
  test   %eax,%eax
  jle    L808
  cmp    %edx,%edi
  jle    L622
L414:
  test   %ecx,%ecx
  je     L289
  lea    (%rdx,%rdx,1),%ecx
  movslq %ecx,%rcx
  mov    %bpl,(%rsi,%rcx,1)
  mov    %r12b,0x1(%rsi,%rcx,1)
  mov    $0x0,%ecx
  jmp    L1133
L622:
  mov    %ecx,-0x14(%rsp)
  jmp    L1155
L264:
  mov    -0x10(%rsp),%ecx
  mov    %ecx,-0x18(%rsp)
  jmp    L1155
L988:
  mov    %r14d,-0x1c(%rsp)
  jmp    L1155
L483:
  mov    %r14d,-0x1c(%rsp)
  jmp    L1155
L808:
  mov    %ecx,-0x14(%rsp)
  jmp    L1155
L703:
  cmp    %r9,-0x8(%rsp)
  ja     L541
  mov    $0x1,%eax
  jmp    L575
L720:
  mov    $0x1,%eax
  jmp    L575
L373:
  mov    $0x0,%eax
  jmp    L575
L295:
  mov    $0x0,%eax
L575:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
int bitmap_decompress2(char *output, int width, int height, char *input, int size) {
  char *prevline;
  char *line;
  char *end;
  char color1[2];
  char color2[2];
  char mix[2];
  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] = 0;
  color1[1] = 0;
  color2[0] = 0;
  color2[1] = 0;
  mix[0] = 0xff;
  mix[1] = 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[0] = ((unsigned char)(*(input++)));
      color1[1] = ((unsigned char)(*(input++)));
    case 3:
      color2[0] = ((unsigned char)(*(input++)));
      color2[1] = ((unsigned char)(*(input++)));
      break;
    case 6:
    case 7:
      mix[0] = ((unsigned char)(*(input++)));
      mix[1] = ((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 * 2);
      }
      switch (opcode) {
      case 0:
        if (insertmix) {
          if (prevline == 0) {
            line[x * 2 + 0] = mix[0];
            line[x * 2 + 1] = mix[1];
          } else {
            line[x * 2 + 0] = prevline[x * 2 + 0] ^ mix[0];
            line[x * 2 + 1] = prevline[x * 2 + 1] ^ mix[1];
          }
          insertmix = 0;
          count--;
          x++;
        }
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = 0;
              line[x * 2 + 1] = 0;
              ;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = prevline[x * 2 + 0];
              line[x * 2 + 1] = prevline[x * 2 + 1];
              ;
              count--;
              x++;
            }
          }
        }
        break;
      case 1:
        if (prevline == 0) {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = mix[0];
              line[x * 2 + 1] = mix[1];
              ;
              count--;
              x++;
            }
          }
        } else {
          {
            while ((count > 0) && (x < width)) {
              line[x * 2 + 0] = prevline[x * 2 + 0] ^ mix[0];
              line[x * 2 + 1] = prevline[x * 2 + 1] ^ mix[1];
              ;
              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 * 2 + 0] = mix[0];
                line[x * 2 + 1] = mix[1];
              } else {
                line[x * 2 + 0] = 0;
                line[x * 2 + 1] = 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 * 2 + 0] = prevline[x * 2 + 0] ^ mix[0];
                line[x * 2 + 1] = prevline[x * 2 + 1] ^ mix[1];
              } else {
                line[x * 2 + 0] = prevline[x * 2 + 0];
                line[x * 2 + 1] = prevline[x * 2 + 1];
              };
              count--;
              x++;
            }
          }
        }
        break;
      case 3: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = color2[0];
          line[x * 2 + 1] = color2[1];
          ;
          count--;
          x++;
        }
      } break;
      case 4: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = ((unsigned char)(*(input++)));
          line[x * 2 + 1] = ((unsigned char)(*(input++)));
          ;
          count--;
          x++;
        }
      } break;
      case 8: {
        while ((count > 0) && (x < width)) {
          if (bicolor) {
            line[x * 2 + 0] = color2[0];
            line[x * 2 + 1] = color2[1];
            bicolor = 0;
          } else {
            line[x * 2 + 0] = color1[0];
            line[x * 2 + 1] = color1[1];
            bicolor = 1;
            count++;
          };
          count--;
          x++;
        }
      } break;
      case 0xd: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = 0xff;
          line[x * 2 + 1] = 0xff;
          ;
          count--;
          x++;
        }
      } break;
      case 0xe: {
        while ((count > 0) && (x < width)) {
          line[x * 2 + 0] = 0;
          line[x * 2 + 1] = 0;
          ;
          count--;
          x++;
        }
      } break;
      default:
        return 0;
        break;
      }
    }
  }
  return 1;
}
```