user: 提供的汇编代码用C语言表示会是什么样子:

```asm
<fnmatch>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  movzbl (%rdi),%ebx
  mov    %rsi,0x20(%rsp)
  mov    %edx,0x28(%rsp)
  test   %bl,%bl
  je     L1664
  mov    %edx,%eax
  mov    %edx,%r14d
  and    $0x2,%edx
  mov    %rsi,0x8(%rsp)
  mov    %edx,0x1c(%rsp)
  mov    %eax,%edx
  shr    $0x2,%eax
  lea    0x1(%rdi),%r12
  and    $0x1,%edx
  and    $0x1,%eax
  and    $0x10,%r14d
  mov    %rdi,%r15
  mov    %edx,0x18(%rsp)
  mov    %al,0x2e(%rsp)
  mov    %dl,0x2d(%rsp)
L620:
  test   %r14d,%r14d
  je     L290
  movzbl %bl,%ebp
  mov    %ebp,%edi
  call   <isupper@plt>
  test   %eax,%eax
  je     L1121
  mov    %ebp,%edi
  call   <tolower@plt>
  mov    %eax,%ebx
L1121:
  cmp    $0x5b,%bl
  je     L642
  jg     L1726
  cmp    $0x2a,%bl
  je     L1316
  cmp    $0x3f,%bl
  jne    L946
L1132:
  mov    0x8(%rsp),%rax
  movzbl (%rax),%eax
  test   %al,%al
  je     L999
  cmp    $0x2f,%al
  jne    L1541
  cmpb   $0x0,0x2d(%rsp)
  jne    L999
L1541:
  cmpb   $0x0,0x2e(%rsp)
  je     L93
  cmp    $0x2e,%al
  je     L798
L93:
  mov    %r12,%r15
L499:
  movzbl (%r15),%ebx
  addq   $0x1,0x8(%rsp)
  lea    0x1(%r15),%r12
  test   %bl,%bl
  jne    L620
  mov    0x8(%rsp),%r15
L961:
  movzbl (%r15),%eax
  movl   $0x0,0x18(%rsp)
  test   %al,%al
  je     L477
  mov    0x28(%rsp),%edx
  shr    $0x3,%edx
  cmp    $0x2f,%al
  sete   %al
  and    %edx,%eax
  xor    $0x1,%eax
  movzbl %al,%eax
  mov    %eax,0x18(%rsp)
  jmp    L477
  nopw   0x0(%rax,%rax,1)
L1726:
  cmp    $0x5c,%bl
  jne    L946
  cmpl   $0x0,0x1c(%rsp)
  jne    L1156
  movzbl 0x1(%r15),%ebp
  lea    0x2(%r15),%rbx
  test   %bpl,%bpl
  je     L999
  movzbl %bpl,%r12d
  mov    %r12d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  jne    L1559
  movsbl %bpl,%ebp
  mov    %rbx,%r15
L1623:
  mov    0x8(%rsp),%rax
  movzbl (%rax),%r12d
  mov    %r12d,%edi
  mov    %r12d,%ebx
  call   <isupper@plt>
  test   %eax,%eax
  je     L1142
  mov    %r12d,%edi
  call   <tolower@plt>
  mov    %eax,%ebx
  jmp    L1031
  nopl   0x0(%rax)
L290:
  cmp    $0x5b,%bl
  je     L642
  jg     L865
  cmp    $0x2a,%bl
  je     L1316
  cmp    $0x3f,%bl
  je     L1132
  nopl   (%rax)
L998:
  mov    0x8(%rsp),%rax
  movsbl %bl,%ebx
  movzbl (%rax),%ebp
L617:
  movsbl %bpl,%ebp
L373:
  cmp    %ebx,%ebp
  je     L93
  nopw   0x0(%rax,%rax,1)
L999:
  movl   $0x1,0x18(%rsp)
L477:
  mov    0x18(%rsp),%eax
  add    $0x38,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
L865:
  cmp    $0x5c,%bl
  jne    L998
  mov    0x1c(%rsp),%eax
  test   %eax,%eax
  jne    L1764
  movsbl 0x1(%r15),%ebp
  lea    0x2(%r15),%rax
  test   %bpl,%bpl
  je     L999
  mov    0x8(%rsp),%rcx
  mov    %rax,%r15
  movzbl (%rcx),%ebx
  jmp    L1142
  nop
L642:
  mov    0x8(%rsp),%rcx
  movzbl (%rcx),%eax
  mov    %al,0x7(%rsp)
  test   %al,%al
  je     L999
  cmpb   $0x0,0x2e(%rsp)
  je     L51
  cmp    $0x2e,%al
  jne    L51
  cmp    %rcx,0x20(%rsp)
  je     L999
  mov    0x18(%rsp),%esi
  test   %esi,%esi
  jne    L192
L51:
  movzbl 0x1(%r15),%eax
  lea    0x2(%r15),%rcx
  movsbl 0x7(%rsp),%esi
  cmp    $0x21,%al
  mov    %esi,0x14(%rsp)
  sete   %dl
  cmp    $0x5e,%al
  sete   %al
  or     %al,%dl
  movzbl %sil,%eax
  cmovne %rcx,%r12
  mov    %dl,0x2f(%rsp)
  mov    0x1c(%rsp),%edx
  mov    %eax,0x10(%rsp)
  lea    0x1(%r12),%r15
  movzbl (%r12),%r12d
  test   %edx,%edx
  sete   0x2c(%rsp)
  mov    %r12d,%ebp
  jmp    L276
  cs nopw 0x0(%rax,%rax,1)
L1157:
  mov    0x10(%rsp),%r12d
  mov    %r12d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  je     L1106
  mov    %r12d,%edi
  call   <tolower@plt>
  cmp    %ebx,%eax
  jl     L935
L457:
  movsbl %r13b,%ecx
  cmp    %eax,%ecx
  jge    L554
L935:
  cmp    $0x5d,%bpl
  je     L14
L276:
  cmp    $0x5c,%bpl
  jne    L1268
  cmpb   $0x0,0x2c(%rsp)
  jne    L1090
L1268:
  test   %r14d,%r14d
  je     L940
  movzbl %bpl,%r12d
  mov    %r12d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  jne    L955
  mov    %r15,%r12
  movsbl %bpl,%ebx
L1021:
  test   %bpl,%bpl
  je     L999
L876:
  movzbl (%r12),%r13d
  add    $0x1,%r15
  mov    %r13d,%edi
  mov    %r13d,%ebp
  call   <isupper@plt>
  test   %eax,%eax
  je     L948
  mov    %r13d,%edi
  call   <tolower@plt>
  mov    %eax,%ebp
L948:
  cmp    $0x2f,%bpl
  jne    L1769
  cmpb   $0x0,0x2d(%rsp)
  jne    L999
L1769:
  mov    %ebx,%r13d
  cmp    $0x2d,%bpl
  je     L452
L232:
  test   %r14d,%r14d
  jne    L1157
  cmp    %bl,0x7(%rsp)
  jl     L935
  mov    0x14(%rsp),%eax
  jmp    L457
  nopl   (%rax)
L940:
  test   %bpl,%bpl
  je     L999
L527:
  movzbl (%r15),%eax
  mov    %r15,%r12
  movsbl %bpl,%ebx
  add    $0x1,%r15
  mov    %eax,%ebp
  jmp    L948
  nopl   0x0(%rax)
L452:
  movzbl 0x1(%r12),%r13d
  cmp    $0x5d,%r13b
  je     L1075
  lea    0x2(%r12),%rbp
  cmp    $0x5c,%r13b
  jne    L957
  cmpb   $0x0,0x2c(%rsp)
  jne    L1619
L957:
  test   %r13b,%r13b
  je     L999
  test   %r14d,%r14d
  je     L852
  movzbl %r13b,%r15d
  mov    %r15d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  je     L852
  mov    %r15d,%edi
  call   <tolower@plt>
  mov    %eax,%r13d
L852:
  lea    0x1(%rbp),%r15
  movzbl 0x0(%rbp),%ebp
  jmp    L232
  nopl   0x0(%rax)
L1224:
  movzbl %bl,%r12d
  mov    %r12d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  je     L614
  nopl   0x0(%rax)
L955:
  mov    %r12d,%edi
  mov    %r15,%r12
  call   <tolower@plt>
  movsbl %al,%ebx
  jmp    L1021
  nopl   0x0(%rax,%rax,1)
L1106:
  mov    0x14(%rsp),%eax
  cmp    %bl,0x7(%rsp)
  jge    L457
  cmp    $0x5d,%bpl
  jne    L276
  nopl   0x0(%rax,%rax,1)
L14:
  cmpb   $0x0,0x2f(%rsp)
  jne    L499
  jmp    L999
L1090:
  movsbl (%r15),%ebx
  test   %bl,%bl
  je     L999
  add    $0x1,%r15
  test   %r14d,%r14d
  jne    L1224
  mov    %ebx,%ebp
  jmp    L527
  nopl   0x0(%rax)
L1075:
  mov    %ebx,%r13d
  jmp    L232
  nopl   0x0(%rax,%rax,1)
L1316:
  mov    %r15,%r13
  mov    0x8(%rsp),%r15
  testb  $0x4,0x28(%rsp)
  jne    L98
L95:
  movzbl 0x1(%r13),%ebx
  lea    0x2(%r13),%rbp
  cmp    $0x2a,%bl
  je     L1240
  cmp    $0x3f,%bl
  jne    L377
L1240:
  mov    0x18(%rsp),%r10d
  test   %r10d,%r10d
  jne    L1634
  nopl   0x0(%rax)
L246:
  cmp    $0x3f,%bl
  je     L1423
  movzbl 0x0(%rbp),%ebx
  add    $0x1,%rbp
  cmp    $0x2a,%bl
  je     L246
  cmp    $0x3f,%bl
  jne    L377
L1423:
  cmpb   $0x0,(%r15)
  je     L999
  movzbl 0x0(%rbp),%ebx
  add    $0x1,%rbp
  add    $0x1,%r15
  cmp    $0x2a,%bl
  je     L246
  cmp    $0x3f,%bl
  je     L1423
L377:
  test   %bl,%bl
  je     L343
  mov    0x1c(%rsp),%r9d
  test   %r9d,%r9d
  jne    L1409
  cmp    $0x5c,%bl
  je     L1145
L1409:
  mov    %ebx,%r13d
L949:
  test   %r14d,%r14d
  je     L1422
  movzbl %r13b,%r12d
  mov    %r12d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  jne    L1087
L1422:
  movzbl (%r15),%r12d
  sub    $0x1,%rbp
  test   %r12b,%r12b
  je     L999
  cmp    $0x5b,%bl
  je     L421
  mov    0x18(%rsp),%r8d
  test   %r8d,%r8d
  jne    L1310
  test   %r14d,%r14d
  je     L350
  movsbl %r13b,%ebx
  mov    0x28(%rsp),%r13d
  and    $0xfffffffb,%r13d
  jmp    L1254
  cs nopw 0x0(%rax,%rax,1)
L132:
  movzbl 0x1(%r15),%r12d
  add    $0x1,%r15
  test   %r12b,%r12b
  je     L999
L1254:
  movzbl %r12b,%r14d
  movsbl %r12b,%r12d
  mov    %r14d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  je     L832
  mov    %r14d,%edi
  call   <tolower@plt>
  mov    %eax,%r12d
L832:
  cmp    %r12d,%ebx
  jne    L132
  mov    %r13d,%edx
  mov    %r15,%rsi
  mov    %rbp,%rdi
  call   <fnmatch>
  test   %eax,%eax
  jne    L132
L1373:
  mov    %eax,0x18(%rsp)
  jmp    L477
  nopl   0x0(%rax)
L614:
  mov    %r15,%r12
  jmp    L876
L98:
  cmpb   $0x2e,(%r15)
  jne    L95
  cmp    %r15,0x20(%rsp)
  je     L999
  mov    0x18(%rsp),%r11d
  test   %r11d,%r11d
  je     L1439
  cmpb   $0x2f,-0x1(%r15)
  je     L477
  movzbl 0x1(%r13),%ebx
  lea    0x2(%r13),%rbp
  cmp    $0x2a,%bl
  je     L1634
  cmp    $0x3f,%bl
  jne    L377
  jmp    L728
  xchg   %ax,%ax
L1619:
  movzbl 0x2(%r12),%r13d
  lea    0x3(%r12),%rbp
  jmp    L957
L946:
  mov    0x8(%rsp),%rax
  movsbl %bl,%ebx
  movzbl (%rax),%r13d
  mov    %r13d,%edi
  mov    %r13d,%ebp
  call   <isupper@plt>
  test   %eax,%eax
  je     L617
  mov    %r13d,%edi
  call   <tolower@plt>
  mov    %eax,%ebp
  jmp    L373
  xchg   %ax,%ax
L343:
  mov    0x28(%rsp),%eax
  and    $0x9,%eax
  mov    %eax,0x18(%rsp)
  cmp    $0x1,%eax
  jne    L1089
  movzbl (%r15),%eax
  test   %al,%al
  je     L1089
  nopl   0x0(%rax,%rax,1)
L1576:
  cmp    $0x2f,%al
  je     L477
  movzbl 0x1(%r15),%eax
  add    $0x1,%r15
  test   %al,%al
  jne    L1576
L1089:
  movl   $0x0,0x18(%rsp)
  jmp    L477
  nopw   0x0(%rax,%rax,1)
L1216:
  cmp    $0x2a,%bl
  jne    L377
L1634:
  cmp    $0x3f,%bl
  je     L728
  movzbl 0x0(%rbp),%ebx
  add    $0x1,%rbp
  cmp    $0x3f,%bl
  jne    L1216
L728:
  movzbl (%r15),%eax
  test   %al,%al
  je     L999
  cmp    $0x2f,%al
  je     L999
  movzbl 0x0(%rbp),%ebx
  add    $0x1,%rbp
  add    $0x1,%r15
  cmp    $0x3f,%bl
  jne    L1216
  jmp    L728
  nopw   0x0(%rax,%rax,1)
L1764:
  mov    0x8(%rsp),%rax
  mov    %r12,%r15
  mov    $0x5c,%ebp
  movzbl (%rax),%ebx
L1142:
  movsbl %bl,%ebx
L1031:
  cmp    %ebp,%ebx
  je     L499
  jmp    L999
L192:
  cmpb   $0x2f,-0x1(%rcx)
  jne    L51
  jmp    L477
  nop
L798:
  mov    0x8(%rsp),%rax
  cmp    %rax,0x20(%rsp)
  je     L999
  mov    0x18(%rsp),%ebx
  test   %ebx,%ebx
  je     L93
  cmpb   $0x2f,-0x1(%rax)
  jne    L93
  jmp    L477
  nopl   0x0(%rax,%rax,1)
L554:
  cmp    $0x5d,%bpl
  je     L1128
  test   %bpl,%bpl
  je     L999
  movzbl 0x2c(%rsp),%ecx
  jmp    L1111
  nopw   0x0(%rax,%rax,1)
L423:
  mov    %rdx,%r15
L1242:
  cmp    $0x5d,%al
  je     L1128
  test   %al,%al
  je     L999
L1111:
  movzbl (%r15),%eax
  lea    0x1(%r15),%rdx
  cmp    $0x5c,%al
  jne    L423
  test   %cl,%cl
  je     L423
L1317:
  cmpb   $0x0,0x1(%r15)
  je     L999
  movzbl 0x2(%r15),%eax
  lea    0x2(%r15),%rdx
  cmp    $0x5c,%al
  je     L355
  add    $0x3,%r15
  jmp    L1242
L350:
  mov    0x28(%rsp),%ebx
  and    $0xfffffffb,%ebx
  jmp    L1196
  xchg   %ax,%ax
L1593:
  movzbl 0x1(%r15),%r12d
  add    $0x1,%r15
  test   %r12b,%r12b
  je     L999
L1196:
  cmp    %r12b,%r13b
  jne    L1593
  mov    %ebx,%edx
  mov    %r15,%rsi
  mov    %rbp,%rdi
  call   <fnmatch>
  test   %eax,%eax
  jne    L1593
  jmp    L1373
L1087:
  mov    %r12d,%edi
  call   <tolower@plt>
  mov    %eax,%r13d
  jmp    L1422
L1439:
  movzbl 0x1(%r13),%ebx
  lea    0x2(%r13),%rbp
  cmp    $0x3f,%bl
  je     L1423
  cmp    $0x2a,%bl
  je     L246
  jmp    L377
  nopl   (%rax)
L1128:
  cmpb   $0x0,0x2f(%rsp)
  je     L499
  jmp    L999
L421:
  mov    0x28(%rsp),%ebx
  mov    0x18(%rsp),%edi
  and    $0xfffffffb,%ebx
  test   %edi,%edi
  je     L1481
  jmp    L1189
  nopl   0x0(%rax)
L1748:
  add    $0x1,%r15
  cmpb   $0x0,(%r15)
  je     L999
L1481:
  mov    %ebx,%edx
  mov    %r15,%rsi
  mov    %rbp,%rdi
  call   <fnmatch>
  test   %eax,%eax
  jne    L1748
  jmp    L1373
L641:
  cmp    $0x2f,%r12b
  je     L477
  movzbl 0x1(%r15),%r12d
  add    $0x1,%r15
  test   %r12b,%r12b
  je     L477
L1189:
  mov    %ebx,%edx
  mov    %r15,%rsi
  mov    %rbp,%rdi
  call   <fnmatch>
  test   %eax,%eax
  jne    L641
  jmp    L1089
  xchg   %ax,%ax
L1145:
  movzbl 0x0(%rbp),%r13d
  jmp    L949
L355:
  mov    %rdx,%r15
  jmp    L1317
L1664:
  mov    %rsi,%r15
  jmp    L961
L1310:
  test   %r14d,%r14d
  je     L778
  movsbl %r13b,%ebx
  mov    0x28(%rsp),%r13d
  and    $0xfffffffb,%r13d
  jmp    L1761
L366:
  mov    %r14d,%edi
  call   <tolower@plt>
L1352:
  cmp    %eax,%ebx
  je     L1307
L288:
  cmp    $0x2f,%r12b
  je     L477
  movzbl 0x1(%r15),%r12d
  add    $0x1,%r15
  test   %r12b,%r12b
  je     L477
L1761:
  movzbl %r12b,%r14d
  mov    %r14d,%edi
  call   <isupper@plt>
  test   %eax,%eax
  jne    L366
  movsbl %r12b,%eax
  jmp    L1352
L1307:
  mov    %r13d,%edx
  mov    %r15,%rsi
  mov    %rbp,%rdi
  call   <fnmatch>
  test   %eax,%eax
  jne    L288
  jmp    L1089
L778:
  mov    0x28(%rsp),%ebx
  and    $0xfffffffb,%ebx
  jmp    L1442
L1134:
  cmp    $0x2f,%r12b
  je     L477
  movzbl 0x1(%r15),%r12d
  add    $0x1,%r15
  test   %r12b,%r12b
  je     L477
L1442:
  cmp    %r12b,%r13b
  jne    L1134
  mov    %ebx,%edx
  mov    %r15,%rsi
  mov    %rbp,%rdi
  call   <fnmatch>
  test   %eax,%eax
  jne    L1134
  jmp    L1089
  nopl   0x0(%rax,%rax,1)
L1559:
  mov    %r12d,%edi
  mov    %rbx,%r15
  call   <tolower@plt>
  movsbl %al,%ebp
  jmp    L1623
L1156:
  mov    %r12,%r15
  mov    $0x5c,%ebp
  jmp    L1623
```

assistant: ```c
int fnmatch(const char *pattern, const char *string, int flags) {
  register const char *p = pattern, *n = string;
  register char c;
  while ((c = *p++) != '\0') {
    c = ((flags & (1 << 4)) && (1 && isupper((unsigned char)(c))) ? tolower((unsigned char)(c)) : (c));
    switch (c) {
    case '?':
      if (*n == '\0')
        return 1;
      else if ((flags & (1 << 0)) && *n == '/')
        return 1;
      else if ((flags & (1 << 2)) && *n == '.' && (n == string || ((flags & (1 << 0)) && n[-1] == '/')))
        return 1;
      break;
    case '\\':
      if (!(flags & (1 << 1))) {
        c = *p++;
        if (c == '\0')
          return 1;
        c = ((flags & (1 << 4)) && (1 && isupper((unsigned char)(c))) ? tolower((unsigned char)(c)) : (c));
      }
      if (((flags & (1 << 4)) && (1 && isupper((unsigned char)(*n))) ? tolower((unsigned char)(*n)) : (*n)) != c)
        return 1;
      break;
    case '*':
      if ((flags & (1 << 2)) && *n == '.' && (n == string || ((flags & (1 << 0)) && n[-1] == '/')))
        return 1;
      for (c = *p++; c == '?' || c == '*'; c = *p++) {
        if (c == '?') {
          if (*n == '\0' || (*n == '/' && (flags & (1 << 0))))
            return 1;
          else
            ++n;
        }
      }
      if (c == '\0') {
        if ((flags & ((1 << 0) | (1 << 3))) == (1 << 0))
          for (; *n != '\0'; n++)
            if (*n == '/')
              return 1;
        return 0;
      }
      {
        char c1 = (!(flags & (1 << 1)) && c == '\\') ? *p : c;
        c1 = ((flags & (1 << 4)) && (1 && isupper((unsigned char)(c1))) ? tolower((unsigned char)(c1)) : (c1));
        for (--p; *n != '\0'; ++n)
          if ((c == '[' || ((flags & (1 << 4)) && (1 && isupper((unsigned char)(*n))) ? tolower((unsigned char)(*n)) : (*n)) == c1) && fnmatch(p, n, flags & ~(1 << 2)) == 0)
            return 0;
          else if (*n == '/' && (flags & (1 << 0)))
            break;
        return 1;
      }
    case '[': {
      register int not ;
      if (*n == '\0')
        return 1;
      if ((flags & (1 << 2)) && *n == '.' && (n == string || ((flags & (1 << 0)) && n[-1] == '/')))
        return 1;
      not = (*p == '!' || *p == '^');
      if (not )
        ++p;
      c = *p++;
      for (;;) {
        register char cstart = c, cend = c;
        if (!(flags & (1 << 1)) && c == '\\') {
          if (*p == '\0')
            return 1;
          cstart = cend = *p++;
        }
        cstart = cend = ((flags & (1 << 4)) && (1 && isupper((unsigned char)(cstart))) ? tolower((unsigned char)(cstart)) : (cstart));
        if (c == '\0')
          return 1;
        c = *p++;
        c = ((flags & (1 << 4)) && (1 && isupper((unsigned char)(c))) ? tolower((unsigned char)(c)) : (c));
        if ((flags & (1 << 0)) && c == '/')
          return 1;
        if (c == '-' && *p != ']') {
          cend = *p++;
          if (!(flags & (1 << 1)) && cend == '\\')
            cend = *p++;
          if (cend == '\0')
            return 1;
          cend = ((flags & (1 << 4)) && (1 && isupper((unsigned char)(cend))) ? tolower((unsigned char)(cend)) : (cend));
          c = *p++;
        }
        if (((flags & (1 << 4)) && (1 && isupper((unsigned char)(*n))) ? tolower((unsigned char)(*n)) : (*n)) >= cstart && ((flags & (1 << 4)) && (1 && isupper((unsigned char)(*n))) ? tolower((unsigned char)(*n)) : (*n)) <= cend)
          goto matched;
        if (c == ']')
          break;
      }
      if (!not )
        return 1;
      break;
    matched:;
      while (c != ']') {
        if (c == '\0')
          return 1;
        c = *p++;
        if (!(flags & (1 << 1)) && c == '\\') {
          if (*p == '\0')
            return 1;
          ++p;
        }
      }
      if (not )
        return 1;
    } break;
    default:
      if (c != ((flags & (1 << 4)) && (1 && isupper((unsigned char)(*n))) ? tolower((unsigned char)(*n)) : (*n)))
        return 1;
    }
    ++n;
  }
  if (*n == '\0')
    return 0;
  if ((flags & (1 << 3)) && *n == '/')
    return 0;
  return 1;
}
```