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

```asm
<parse_constraints_line>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x188,%rsp
  mov    0x1c0(%rsp),%rbx
  mov    %rcx,0x30(%rsp)
  lea    -0x20(%rsi),%ecx
  mov    %rdi,(%rsp)
  mov    %rbx,0x18(%rsp)
  mov    0x1c8(%rsp),%rbx
  mov    %rdx,0x28(%rsp)
  mov    %rbx,0x10(%rsp)
  mov    0x1d0(%rsp),%rbx
  mov    %r8,0x40(%rsp)
  mov    %r9,0x38(%rsp)
  mov    %rbx,0x48(%rsp)
  mov    %sil,0x26(%rsp)
  mov    %fs:0x28,%rdx
  mov    %rdx,0x178(%rsp)
  xor    %edx,%edx
  cmp    $0x30,%cl
  ja     L313
  mov    $0x1,%eax
  shl    %cl,%rax
  test   $0x8008029,%eax
  jne    L251
  movabs $0x1004200000000,%rdx
  test   %rdx,%rax
  jne    L75
  movabs $0x2800000000,%rdx
  test   %rdx,%rax
  jne    L223
L313:
  mov    $0x1,%r15d
L85:
  mov    0x18(%rsp),%rax
  movb   $0x3f,(%rax)
  nopl   0x0(%rax,%rax,1)
L149:
  mov    0x178(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L481
  add    $0x188,%rsp
  mov    %r15d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L251:
  mov    $0x2,%r15d
  jmp    L85
L75:
  movl   $0x5,0x20(%rsp)
L556:
  mov    0x18(%rsp),%rax
  movb   $0x0,0x27(%rsp)
  lea    0x70(%rsp),%r13
  mov    $0x1,%ebp
  movl   $0x0,0xc(%rsp)
  xor    %ebx,%ebx
  lea    0x5c(%rsp),%r12
  mov    %r13,%r15
  movb   $0x3f,(%rax)
  nopl   (%rax)
L488:
  movslq %ebx,%rdi
  mov    %r12,%rcx
  add    (%rsp),%rdi
  mov    %r15,%rdx
  lea    D96(%rip),%rsi
  xor    %eax,%eax
  lea    -0x1(%rbp),%r13d
  call   <sscanf@plt>
  mov    %eax,%r14d
  cmp    $0x1,%eax
  jne    L358
  add    0x5c(%rsp),%ebx
  cmp    $0x3,%r13d
  je     L73
  jg     L578
  cmp    $0x1,%r13d
  je     L494
  cmp    $0x2,%r13d
  jne    L414
  mov    0xc(%rsp),%eax
  test   %eax,%eax
  je     L371
  subl   $0x1,0x20(%rsp)
L73:
  cmpb   $0x45,0x26(%rsp)
  je     L87
  lea    0x66(%rsp),%rdx
  mov    %r12,%rcx
  mov    %r15,%rdi
  xor    %eax,%eax
  lea    D63(%rip),%rsi
  call   <sscanf@plt>
  mov    %eax,%r13d
  cmp    $0x1,%eax
  je     L391
L616:
  mov    %r14d,%r15d
  jmp    L149
  nopl   0x0(%rax)
L578:
  cmp    $0x4,%r13d
  jne    L414
  mov    0x10(%rsp),%rdx
  mov    %r15,%rdi
  xor    %eax,%eax
  lea    D55(%rip),%rsi
  xor    %r15d,%r15d
  call   <sscanf@plt>
  cmp    $0x1,%eax
  setne  %r15b
  jmp    L149
  nopw   0x0(%rax,%rax,1)
L494:
  lea    0x54(%rsp),%r13
  xor    %eax,%eax
  lea    0x58(%rsp),%rcx
  mov    %r12,%r8
  mov    %r13,%rdx
  lea    D87(%rip),%rsi
  mov    %r15,%rdi
  call   <sscanf@plt>
  cmp    $0x2,%eax
  je     L65
  mov    0xc(%rsp),%r8d
  mov    %r12,%rcx
  mov    %r13,%rdx
  mov    %r15,%rdi
  lea    D5(%rip),%rsi
  xor    %eax,%eax
  test   %r8d,%r8d
  je     L259
  call   <sscanf@plt>
  mov    %eax,0xc(%rsp)
  cmp    $0x1,%eax
  jne    L616
  mov    %r15,%rdi
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  mov    0x54(%rsp),%eax
  mov    0x38(%rsp),%rcx
  cmpl   $0x2,0x20(%rsp)
  mov    %eax,(%rcx)
  setg   %al
  xor    %r13d,%r13d
  nopl   0x0(%rax)
L529:
  add    $0x1,%ebp
  test   %al,%al
  jne    L488
  mov    %r13d,%r15d
  jmp    L149
  nopl   0x0(%rax,%rax,1)
L414:
  lea    0x54(%rsp),%r13
  xor    %eax,%eax
  lea    0x58(%rsp),%rcx
  mov    %r12,%r8
  mov    %r13,%rdx
  lea    D87(%rip),%rsi
  mov    %r15,%rdi
  call   <sscanf@plt>
  cmp    $0x2,%eax
  je     L623
  xor    %eax,%eax
  mov    %r12,%rcx
  mov    %r13,%rdx
  mov    %r15,%rdi
  lea    D5(%rip),%rsi
  call   <sscanf@plt>
  cmp    $0x1,%eax
  jne    L616
  mov    %r15,%rdi
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  mov    0x54(%rsp),%eax
  mov    0x28(%rsp),%rcx
  cmp    0x20(%rsp),%ebp
  mov    %eax,(%rcx)
  setl   %al
  xor    %r13d,%r13d
  jmp    L529
  cs nopw 0x0(%rax,%rax,1)
L87:
  xor    %eax,%eax
  lea    0x60(%rsp),%rdx
  mov    %r12,%rcx
  mov    %r15,%rdi
  lea    D81(%rip),%rsi
  call   <sscanf@plt>
  cmp    $0x1,%eax
  jne    L616
  mov    %r15,%rdi
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  mov    0x48(%rsp),%rax
  movss  0x60(%rsp),%xmm0
  cmp    %ebp,0x20(%rsp)
  movss  %xmm0,(%rax)
  setg   %al
  xor    %r13d,%r13d
  jmp    L529
  nopw   0x0(%rax,%rax,1)
L259:
  call   <sscanf@plt>
  cmp    $0x1,%eax
  jne    L616
  mov    %r15,%rdi
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  mov    0x54(%rsp),%eax
  mov    0x30(%rsp),%rcx
  cmpl   $0x2,0x20(%rsp)
  mov    %eax,(%rcx)
  setg   %al
  xor    %r13d,%r13d
  jmp    L529
  nopl   0x0(%rax,%rax,1)
L358:
  xor    %r15d,%r15d
  jmp    L149
L623:
  mov    %r15,%rdi
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  mov    0x54(%rsp),%eax
  mov    0x28(%rsp),%rcx
  movl   $0x1,0xc(%rsp)
  subl   $0x1,0x20(%rsp)
  mov    %eax,(%rcx)
  mov    0x58(%rsp),%eax
  mov    0x30(%rsp),%rcx
  mov    %eax,(%rcx)
  mov    0x20(%rsp),%eax
  cmp    %ebp,%eax
  setg   %al
  xor    %r13d,%r13d
  jmp    L529
  cs nopw 0x0(%rax,%rax,1)
L371:
  xor    %eax,%eax
  lea    0x54(%rsp),%rdx
  mov    %r12,%rcx
  mov    %r15,%rdi
  lea    D5(%rip),%rsi
  call   <sscanf@plt>
  cmp    $0x1,%eax
  jne    L616
  mov    %r15,%rdi
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  mov    0x54(%rsp),%eax
  mov    0x40(%rsp),%rcx
  cmpl   $0x3,0x20(%rsp)
  mov    %eax,(%rcx)
  setg   %al
  xor    %r13d,%r13d
  jmp    L529
  nop
L391:
  mov    %r15,%rdi
  movb   $0x0,0x6e(%rsp)
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  movzbl 0x66(%rsp),%ecx
  cmp    %ebp,0x20(%rsp)
  setg   %al
  test   %cl,%cl
  je     L80
  movzbl 0x27(%rsp),%edi
  lea    0x67(%rsp),%rsi
  nopl   (%rax)
L334:
  lea    -0x41(%rcx),%edx
  cmp    $0x2c,%dl
  ja     L28
  lea    D95(%rip),%r10
  movzbl %dl,%edx
  movslq (%r10,%rdx,4),%rdx
  add    %r10,%rdx
  notrack jmp *%rdx
  nopl   0x0(%rax)
L28:
  mov    %dil,0x27(%rsp)
  xor    %eax,%eax
L472:
  cmpb   $0x0,0x27(%rsp)
  je     L529
L378:
  mov    0x18(%rsp),%rcx
  movzbl 0x27(%rsp),%edx
  mov    %dl,(%rcx)
  jmp    L529
  mov    0x10(%rsp),%rdx
  mov    %cl,(%rdx)
  movzbl (%rsi),%ecx
  test   %cl,%cl
  je     L1
  nopl   (%rax)
L641:
  add    $0x1,%rsi
  jmp    L334
  movzbl (%rsi),%ecx
  test   %cl,%cl
  je     L160
  mov    $0x3f,%edi
  jmp    L641
  movzbl (%rsi),%ecx
  or     $0x2,%edi
  test   %cl,%cl
  jne    L641
L660:
  mov    %dil,0x27(%rsp)
  xor    %r13d,%r13d
  jmp    L378
  movzbl (%rsi),%ecx
  or     $0x1,%edi
  test   %cl,%cl
  jne    L641
  jmp    L660
  nopl   0x0(%rax,%rax,1)
  movzbl (%rsi),%ecx
  or     $0x20,%edi
  test   %cl,%cl
  jne    L641
  jmp    L660
  nopl   0x0(%rax)
  movzbl (%rsi),%ecx
  or     $0x8,%edi
  test   %cl,%cl
  jne    L641
  jmp    L660
  nopl   0x0(%rax)
  movzbl (%rsi),%ecx
  or     $0x10,%edi
  test   %cl,%cl
  jne    L641
  jmp    L660
  nopl   0x0(%rax)
  movzbl (%rsi),%ecx
  or     $0x4,%edi
  test   %cl,%cl
  jne    L641
  jmp    L660
  nopl   0x0(%rax)
L65:
  mov    %r15,%rdi
  call   <strlen@plt>
  cmp    0x5c(%rsp),%eax
  jne    L616
  mov    0x54(%rsp),%eax
  mov    0x40(%rsp),%rcx
  mov    0xc(%rsp),%r9d
  mov    %eax,(%rcx)
  mov    0x58(%rsp),%eax
  mov    0x38(%rsp),%rcx
  mov    %eax,(%rcx)
  test   %r9d,%r9d
  jne    L426
  subl   $0x1,0x20(%rsp)
  mov    0x20(%rsp),%eax
  movl   $0x1,0xc(%rsp)
  cmp    $0x2,%eax
  setg   %al
  xor    %r13d,%r13d
  jmp    L529
L426:
  cmpl   $0x2,0x20(%rsp)
  setg   %al
  xor    %r13d,%r13d
  jmp    L529
L223:
  movl   $0x4,0x20(%rsp)
  jmp    L556
L80:
  xor    %r13d,%r13d
  jmp    L472
L1:
  mov    %dil,0x27(%rsp)
  xor    %r13d,%r13d
  jmp    L472
L160:
  movb   $0x3f,0x27(%rsp)
  xor    %r13d,%r13d
  jmp    L378
L481:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: data_tag: D96
type_guessed: string
name: unpack_data
arguments: data_tag: D63
type_guessed: string
name: unpack_data
arguments: data_tag: D55
type_guessed: string
name: unpack_data
arguments: data_tag: D87
type_guessed: string
name: unpack_data
arguments: data_tag: D5
type_guessed: string
name: unpack_data
arguments: data_tag: D81
type_guessed: string

tool: D96: %15s%n

tool: D63: %8s%n

tool: D55: %c

tool: D87: %d-%d%n

tool: D5: %d%n

tool: D81: %g%n

assistant: ```c
int parse_constraints_line(const char *line, char command, int *i, int *j, int *k, int *l, char *loop, char *orientation, float *e) {
  int v1, v2;
  int ret = 0;
  int range_mode = 0;
  int pos = 0;
  int max_entries = 5;
  int entries_seen = 0;
  int pp;
  float energy;
  char buf[256], buf2[10], *c, tmp_loop;
  switch (command) {
  case 'A':
  case 'F':
  case 'P':
    max_entries = 5;
    break;
  case 'C':
  case 'E':
    max_entries = 4;
    break;
  case '#':
  case ';':
  case '%':
  case '/':
  case ' ':
    ret = 2;
    break;
  default:
    ret = 1;
    break;
  }
  *loop = (char)((char)0x01 | (char)0x02 | (char)0x04 | (char)0x08 | (char)0x10 | (char)0x20);
  tmp_loop = (char)0;
  while (!ret && (entries_seen < max_entries) && (sscanf(line + pos, "%15s%n", &buf[0], &pp) == 1)) {
    pos += pp;
    switch (entries_seen) {
    case 0:
      if (sscanf(buf, "%d-%d%n", &v1, &v2, &pp) == 2) {
        if (pp == strlen(buf)) {
          *i = v1;
          *j = v2;
          range_mode = 1;
          --max_entries;
          break;
        }
      } else if (sscanf(buf, "%d%n", &v1, &pp) == 1) {
        if (pp == strlen(buf)) {
          *i = v1;
          break;
        }
      }
      ret = 1;
      break;
    case 1:
      if (sscanf(buf, "%d-%d%n", &v1, &v2, &pp) == 2) {
        if (pp == strlen(buf)) {
          *k = v1;
          *l = v2;
          if (!range_mode)
            --max_entries;
          range_mode = 1;
          break;
        }
      } else if (range_mode) {
        if (sscanf(buf, "%d%n", &v1, &pp) == 1) {
          if (pp == strlen(buf)) {
            *l = v1;
            break;
          }
        }
      } else if (sscanf(buf, "%d%n", &v1, &pp) == 1) {
        if (pp == strlen(buf)) {
          *j = v1;
          break;
        }
      }
      ret = 1;
      break;
    case 2:
      if (!range_mode) {
        if (sscanf(buf, "%d%n", &v1, &pp) == 1) {
          if (pp == strlen(buf)) {
            *k = v1;
            break;
          }
        }
        ret = 1;
        break;
      } else {
        --max_entries;
      }
    case 3:
      if (command == 'E') {
        if (sscanf(buf, "%g%n", &energy, &pp) == 1) {
          if (pp == strlen(buf)) {
            *e = energy;
            break;
          }
        }
      } else {
        if (sscanf(buf, "%8s%n", &buf2[0], &pp) == 1) {
          buf2[8] = '\0';
          if (pp == strlen(buf)) {
            for (c = &(buf2[0]); (*c != '\0') && (!ret); c++) {
              switch (*c) {
              case 'E':
                tmp_loop |= (char)0x01;
                break;
              case 'H':
                tmp_loop |= (char)0x02;
                break;
              case 'I':
                tmp_loop |= (char)0x04;
                break;
              case 'i':
                tmp_loop |= (char)0x08;
                break;
              case 'M':
                tmp_loop |= (char)0x10;
                break;
              case 'm':
                tmp_loop |= (char)0x20;
                break;
              case 'A':
                tmp_loop |= (char)((char)0x01 | (char)0x02 | (char)0x04 | (char)0x08 | (char)0x10 | (char)0x20);
                break;
              case 'U':
              case 'D':
                *orientation = *c;
                break;
              default:
                ret = 1;
              }
            }
            if (tmp_loop)
              *loop = tmp_loop;
            break;
          }
        }
      }
      ret = 1;
      break;
    case 4:
      if (!(sscanf(buf, "%c", orientation) == 1)) {
        ret = 1;
      }
      break;
    }
    ++entries_seen;
  }
  return ret;
}
```