user: 请将以下的汇编代码转换成C语言代码:

```asm
<rangematch>:
  endbr64
  push   %r15
  mov    %esi,%r15d
  push   %r14
  mov    %rdi,%r14
  push   %r13
  mov    %edx,%r13d
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x28,%rsp
  movzbl (%rdi),%eax
  mov    %rcx,0x8(%rsp)
  cmp    $0x21,%al
  sete   %bpl
  cmp    $0x5e,%al
  sete   %al
  or     %eax,%ebp
  mov    %edx,%eax
  cmp    $0x1,%bpl
  mov    %bpl,0x1b(%rsp)
  sbb    $0xffffffffffffffff,%r14
  and    $0x10,%eax
  mov    %eax,0x4(%rsp)
  jne    L576
L69:
  movzbl (%r14),%edx
  mov    %r13d,%r8d
  lea    0x1(%r14),%rbx
  xor    %r12d,%r12d
  mov    %r15d,%r13d
  mov    %edx,%ebp
  jmp    L582
  nopl   0x0(%rax)
L2:
  movzbl (%rbx),%eax
  cmp    $0x2d,%al
  je     L0
  mov    %ebp,%r14d
  mov    %rbx,%r9
  mov    %eax,%ebp
L182:
  lea    0x1(%r9),%rbx
  cmp    $0x5b,%r14b
  jne    L568
  cmp    $0x3a,%bpl
  je     L513
L568:
  cmp    %r14b,%r13b
  mov    $0x1,%eax
  cmove  %eax,%r12d
L424:
  cmp    $0x5d,%bpl
  je     L244
L582:
  cmp    $0x5c,%bpl
  je     L150
  test   %bpl,%bpl
  je     L528
L278:
  cmp    $0x2f,%bpl
  jne    L2
  test   $0x2,%r8b
  jne    L283
  movzbl (%rbx),%eax
  cmp    $0x2d,%al
  je     L0
  add    $0x1,%rbx
  mov    $0x2f,%r14d
  mov    %eax,%ebp
  jmp    L568
  nopl   0x0(%rax)
L0:
  movzbl 0x1(%rbx),%r15d
  cmp    $0x5d,%r15b
  je     L449
  test   %r15b,%r15b
  je     L449
L411:
  lea    0x2(%rbx),%r9
  cmp    $0x5c,%r15b
  je     L531
L605:
  mov    0x4(%rsp),%edx
  test   %edx,%edx
  jne    L563
L94:
  mov    %ebp,%r14d
  cmp    %r15b,%bpl
  jle    L534
  mov    %r15d,%r14d
  mov    %ebp,%r15d
L534:
  movzbl (%r9),%ebp
  cmp    %r14b,%r13b
  jl     L182
  cmp    %r15b,%r13b
  mov    $0x1,%eax
  cmovle %eax,%r12d
  jmp    L182
  cs nopw 0x0(%rax,%rax,1)
L150:
  mov    %r8d,%edx
  movzbl (%rbx),%eax
  and    $0x1,%edx
  je     L432
  cmp    $0x2d,%al
  je     L609
  add    $0x1,%rbx
  mov    $0x5c,%r14d
  mov    %eax,%ebp
  jmp    L568
L449:
  mov    %ebp,%r14d
  mov    %rbx,%r9
  movzbl (%rbx),%ebp
  jmp    L182
  xchg   %ax,%ax
L432:
  mov    %eax,%ebp
  add    $0x1,%rbx
  test   %bpl,%bpl
  jne    L278
L528:
  add    $0x28,%rsp
  mov    $0xffffffff,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
L513:
  cmpb   $0x0,0x1(%r9)
  jne    L27
  cmp    $0x5b,%r13b
  mov    $0x1,%eax
  cmove  %eax,%r12d
  jmp    L2
  nopl   (%rax)
L609:
  movzbl 0x1(%rbx),%r15d
  cmp    $0x5d,%r15b
  je     L544
  test   %r15b,%r15b
  jne    L411
L544:
  add    $0x1,%rbx
  cmp    $0x5c,%r13b
  mov    $0x2d,%ebp
  cmove  %edx,%r12d
  jmp    L2
  nopw   0x0(%rax,%rax,1)
L531:
  test   $0x1,%r8b
  jne    L605
  movzbl 0x2(%rbx),%r15d
  lea    0x3(%rbx),%r9
  test   %r15b,%r15b
  je     L528
  mov    0x4(%rsp),%edx
  test   %edx,%edx
  je     L94
L563:
  movzbl %bpl,%edi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <tolower@plt>
  movzbl %r15b,%edi
  mov    %eax,%ebp
  call   <tolower@plt>
  mov    0x1c(%rsp),%r8d
  mov    0x10(%rsp),%r9
  mov    %eax,%r15d
  jmp    L94
L27:
  mov    $0x2,%edx
  lea    D119(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  jne    L168
  movzbl (%r9),%ebp
  cmp    $0x5d,%bpl
  jne    L582
L244:
  mov    0x8(%rsp),%rax
  mov    %rbx,(%rax)
  movzbl 0x1b(%rsp),%eax
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  xor    %r12d,%eax
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L168:
  mov    $0x7,%edx
  lea    D65(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L197
  mov    $0x7,%edx
  lea    D7(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L127
  mov    $0x7,%edx
  lea    D46(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L281
  mov    $0x7,%edx
  lea    D45(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L412
  mov    $0x7,%edx
  lea    D106(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L117
  mov    $0x7,%edx
  lea    D21(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L93
  mov    $0x7,%edx
  lea    D83(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L346
  mov    $0x7,%edx
  lea    D28(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L464
  mov    $0x7,%edx
  lea    D47(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L172
  mov    $0x7,%edx
  lea    D126(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L326
  mov    $0x8,%edx
  lea    D96(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L163
  mov    0x4(%rsp),%eax
  mov    %r13d,%ebp
  test   %eax,%eax
  jne    L203
L141:
  mov    $0x7,%edx
  lea    D123(%rip),%rsi
  mov    %rbx,%rdi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <strncmp@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %eax,%eax
  je     L487
  movzbl (%r9),%ebp
  jmp    L568
  nopl   0x0(%rax,%rax,1)
L576:
  movzbl %sil,%edi
  call   <tolower@plt>
  mov    %eax,%r15d
  jmp    L69
L197:
  movsbl %r13b,%edi
  call   <isalnum@plt>
L209:
  mov    0x10(%rsp),%r9
  test   %rax,%rax
  mov    $0x1,%eax
  mov    0x1c(%rsp),%r8d
  cmovne %eax,%r12d
  movzbl 0x8(%r9),%ebp
  lea    0x9(%r9),%rbx
  jmp    L424
L283:
  add    $0x28,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L127:
  movsbl %r13b,%edi
  call   <isalpha@plt>
  jmp    L209
L117:
  movsbl %r13b,%edi
  call   <isdigit@plt>
  jmp    L209
L281:
  movsbl %r13b,%edi
  call   <isblank@plt>
  jmp    L209
L412:
  movsbl %r13b,%edi
  call   <iscntrl@plt>
  jmp    L209
L93:
  movsbl %r13b,%edi
  call   <isgraph@plt>
  jmp    L209
L346:
  movsbl %r13b,%edi
  call   <islower@plt>
  jmp    L209
L464:
  movsbl %r13b,%edi
  call   <isprint@plt>
  jmp    L209
L172:
  movsbl %r13b,%edi
  call   <ispunct@plt>
  jmp    L209
L326:
  movsbl %r13b,%edi
  call   <isspace@plt>
  jmp    L209
L163:
  movsbl %r13b,%edi
  call   <isxdigit@plt>
  mov    0x10(%rsp),%r9
  mov    0x1c(%rsp),%r8d
  test   %rax,%rax
  mov    $0x1,%eax
  cmovne %eax,%r12d
  movzbl 0x9(%r9),%ebp
  lea    0xa(%r9),%rbx
  jmp    L424
L487:
  movsbl %bpl,%edi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <isupper@plt>
  jmp    L209
L203:
  movsbl %r13b,%edi
  mov    %r8d,0x1c(%rsp)
  mov    %r9,0x10(%rsp)
  call   <toupper@plt>
  mov    0x1c(%rsp),%r8d
  mov    0x10(%rsp),%r9
  mov    %eax,%ebp
  jmp    L141
```

tool_calls: name: read_data
arguments: tag: D119
type_guessed: string
name: read_data
arguments: tag: D65
type_guessed: string
name: read_data
arguments: tag: D7
type_guessed: string
name: read_data
arguments: tag: D46
type_guessed: string
name: read_data
arguments: tag: D45
type_guessed: string
name: read_data
arguments: tag: D106
type_guessed: string
name: read_data
arguments: tag: D21
type_guessed: string
name: read_data
arguments: tag: D83
type_guessed: string
name: read_data
arguments: tag: D28
type_guessed: string
name: read_data
arguments: tag: D47
type_guessed: string
name: read_data
arguments: tag: D126
type_guessed: string
name: read_data
arguments: tag: D96
type_guessed: string
name: read_data
arguments: tag: D123
type_guessed: string

tool: D119: :]

tool: D65: alnum:]

tool: D7: alpha:]

tool: D46: blank:]

tool: D45: cntrl:]

tool: D106: digit:]

tool: D21: graph:]

tool: D83: lower:]

tool: D28: print:]

tool: D47: punct:]

tool: D126: space:]

tool: D96: xdigit:]

tool: D123: upper:]

assistant: ```c
int rangematch(const char *pattern, char test, int flags, const char **newp) {
  int negate, ok;
  char c, c2;
  char tmp;
  if ((negate = (*pattern == '!' || *pattern == '^')))
    ++pattern;
  if (((flags) & (0x10)))
    test = tolower((unsigned char)test);
  ok = 0;
  c = *pattern++;
  do {
    if (c == '\\' && !((flags) & (0x01)))
      c = *pattern++;
    if (c == '\0')
      return -1;
    if (c == '/' && ((flags) & (0x02)))
      return 0;
    if (*pattern == '-' && (c2 = *(pattern + 1)) != '\0' && c2 != ']') {
      pattern += 2;
      if (c2 == '\\' && !((flags) & (0x01)))
        c2 = *pattern++;
      if (c2 == '\0')
        return -1;
      if (((flags) & (0x10))) {
        c = tolower((unsigned char)c);
        c2 = tolower((unsigned char)c2);
      }
      if (c > c2) {
        tmp = c2;
        c2 = c;
        c = tmp;
      }
      if (c <= test && test <= c2) {
        ok = 1;
      }
    }
    if (c == '[' && *pattern == ':' && *(pattern + 1) != '\0') {
      if (!strncmp(pattern + 1, ":]", sizeof(":]") - 1)) {
        continue;
      }
      {{if (!strncmp(pattern + 1,
                     "alnum"
                     ":]",
                     sizeof("alnum"
                            ":]") -
                         1)){if (isalnum(test)){ok = 1;
    }
    pattern += sizeof("alnum"
                      ":]");
    continue;
  }
}
}
;
{{if (!strncmp(pattern + 1,
               "alpha"
               ":]",
               sizeof("alpha"
                      ":]") -
                   1)){if (isalpha(test)){ok = 1;
}
pattern += sizeof("alpha"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "blank"
               ":]",
               sizeof("blank"
                      ":]") -
                   1)){if (isblank(test)){ok = 1;
}
pattern += sizeof("blank"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "cntrl"
               ":]",
               sizeof("cntrl"
                      ":]") -
                   1)){if (iscntrl(test)){ok = 1;
}
pattern += sizeof("cntrl"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "digit"
               ":]",
               sizeof("digit"
                      ":]") -
                   1)){if (isdigit(test)){ok = 1;
}
pattern += sizeof("digit"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "graph"
               ":]",
               sizeof("graph"
                      ":]") -
                   1)){if (isgraph(test)){ok = 1;
}
pattern += sizeof("graph"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "lower"
               ":]",
               sizeof("lower"
                      ":]") -
                   1)){if (islower(test)){ok = 1;
}
pattern += sizeof("lower"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "print"
               ":]",
               sizeof("print"
                      ":]") -
                   1)){if (isprint(test)){ok = 1;
}
pattern += sizeof("print"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "punct"
               ":]",
               sizeof("punct"
                      ":]") -
                   1)){if (ispunct(test)){ok = 1;
}
pattern += sizeof("punct"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "space"
               ":]",
               sizeof("space"
                      ":]") -
                   1)){if (isspace(test)){ok = 1;
}
pattern += sizeof("space"
                  ":]");
continue;
}
}
}
;
{{if (!strncmp(pattern + 1,
               "xdigit"
               ":]",
               sizeof("xdigit"
                      ":]") -
                   1)){if (isxdigit(test)){ok = 1;
}
pattern += sizeof("xdigit"
                  ":]");
continue;
}
}
}
;
c2 = ((flags) & (0x10)) ? toupper(test) : test;
{{if (!strncmp(pattern + 1,
               "upper"
               ":]",
               sizeof("upper"
                      ":]") -
                   1)){if (isupper(c2)){ok = 1;
}
pattern += sizeof("upper"
                  ":]");
continue;
}
}
}
;
}
if (c == test) {
  ok = 1;
}
}
while ((c = *pattern++) != ']')
  ;
*newp = (const char *)pattern;
return (ok == negate) ? 0 : 1;
}
```