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

```asm
<First_Pass>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x68,%rsp
  mov    %rsi,0x18(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x58(%rsp)
  movabs $0x400000000,%rax
  movl   $0x3,0x54(%rsp)
  mov    %rax,0x4c(%rsp)
  movslq %edi,%rax
  movb   $0x43,(%rdx,%rax,1)
  lea    0x8(%rsi),%rax
  movb   $0x43,0x1(%rdx)
  mov    %rax,0x20(%rsp)
  test   %edi,%edi
  jle    L82
  mov    %edi,%r12d
  mov    %rdx,%rbp
  mov    $0x1,%r14d
  xor    %r15d,%r15d
  jmp    L113
  nopl   0x0(%rax)
L163:
  test   %r15d,%r15d
  jne    L77
  mov    %r14d,0x38(%rsp)
  mov    $0x1,%r15d
L77:
  add    $0x1,%r14
  cmp    %r14d,%r12d
  jl     L82
L113:
  cmpb   $0x43,0x0(%rbp,%r14,1)
  mov    %r14d,0xc(%rsp)
  jne    L163
  test   %r15d,%r15d
  je     L77
  movslq 0x38(%rsp),%rax
  lea    0x0(%rbp,%rax,1),%rcx
  mov    %rax,%r13
  mov    %rax,0x28(%rsp)
  movsbl (%rcx),%edi
  mov    %rcx,0x30(%rsp)
  call   <obs_indx@plt>
  lea    -0x1(%r14),%edx
  lea    0x1(%r13),%esi
  mov    %r13d,%ecx
  movq   $0x1,0x44(%rsp)
  movslq %eax,%rbx
  mov    %edx,0x3c(%rsp)
  cmp    %edx,%esi
  jg     L21
  mov    0x28(%rsp),%rax
  movslq %esi,%rsi
  lea    0x0(%rbp,%rsi,1),%r13
  lea    0x2(%rbp,%rax,1),%rdx
  mov    %r14d,%eax
  sub    %ecx,%eax
  sub    $0x2,%eax
  add    %rdx,%rax
  mov    %rax,0x10(%rsp)
  nop
L166:
  movsbl 0x0(%r13),%edi
  call   <obs_indx@plt>
  cmp    %rbx,%rax
  setne  %al
  movzbl %al,%eax
  add    %eax,%r15d
  cmp    $0x2,%r15d
  jg     L125
  movslq %r15d,%rax
  addl   $0x1,0x40(%rsp,%rax,4)
L125:
  movsbl 0x0(%r13),%edi
  add    $0x1,%r13
  call   <obs_indx@plt>
  movslq %eax,%rbx
  cmp    0x10(%rsp),%r13
  jne    L166
  cmp    $0x2,%r15d
  jg     L71
  mov    0x44(%rsp),%r15d
L21:
  mov    0x30(%rsp),%rax
  movsbl (%rax),%edi
  call   <obs_indx@plt>
  cmp    %r15d,0x4c(%rsp,%rax,4)
  jg     L71
  movsbl -0x1(%rbp,%r14,1),%edi
  mov    0x48(%rsp),%ebx
  call   <obs_indx@plt>
  cmp    0x4c(%rsp,%rax,4),%ebx
  jl     L71
L136:
  xor    %r15d,%r15d
L138:
  add    $0x1,%r14
  cmp    %r14d,%r12d
  jge    L113
L82:
  mov    0x58(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L0
  add    $0x68,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
L71:
  mov    0x3c(%rsp),%ecx
  cmp    %ecx,0x38(%rsp)
  jg     L136
  mov    0x28(%rsp),%rcx
  mov    0x18(%rsp),%rax
  mov    0xc(%rsp),%edx
  sub    0x38(%rsp),%edx
  lea    -0x1(%rdx),%edi
  movsd  D3(%rip),%xmm0
  lea    (%rax,%rcx,8),%rax
  lea    (%rcx,%rdi,1),%rdx
  mov    0x20(%rsp),%rcx
  movapd %xmm0,%xmm1
  lea    (%rcx,%rdx,8),%rsi
  nopl   0x0(%rax)
L101:
  mov    (%rax),%rdx
  pxor   %xmm2,%xmm2
  add    $0x8,%rax
  cvtss2sd 0x4(%rdx),%xmm2
  mulsd  %xmm2,%xmm1
  pxor   %xmm2,%xmm2
  cvtss2sd 0x8(%rdx),%xmm2
  mulsd  %xmm2,%xmm0
  cmp    %rax,%rsi
  jne    L101
  comisd %xmm0,%xmm1
  jbe    L116
  lea    0x1(%rdi),%rdx
  mov    0x30(%rsp),%rdi
  mov    $0x48,%esi
  xor    %r15d,%r15d
  call   <memset@plt>
  jmp    L138
  nop
L116:
  mov    0xc(%rsp),%r13d
  sub    0x38(%rsp),%r13d
  mov    $0x45,%esi
  xor    %r15d,%r15d
  mov    0x30(%rsp),%rdi
  lea    -0x1(%r13),%edx
  add    $0x1,%rdx
  call   <memset@plt>
  jmp    L138
L0:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: data_label: D3
datatype: f64

tool: D3: 1

assistant: ```c
void First_Pass(int nres, float **proba, char *pred) {
  int ires;
  int lim1, lim2;
  int open;
  int kk;
  int type;
  int block[3];
  int nseg;
  int size[3] = {0, 4, 3};
  double ptot[3];
  pred[1] = pred[nres] = 'C';
  open = 0;
  for (ires = 1; ires <= nres; ires++) {
    if (pred[ires] != 'C') {
      if (!open) {
        open = 1;
        lim1 = ires;
      }
    } else {
      if (open) {
        open = 0;
        lim2 = ires - 1;
        type = obs_indx(pred[lim1]);
        block[1] = block[2] = 0;
        nseg = 1;
        block[nseg]++;
        for (kk = lim1 + 1; kk <= lim2; kk++) {
          if (obs_indx(pred[kk]) != type)
            nseg++;
          if (nseg <= 2)
            block[nseg]++;
          type = obs_indx(pred[kk]);
        }
        if (nseg > 2 || block[1] < size[obs_indx(pred[lim1])] || block[2] < size[obs_indx(pred[lim2])]) {
          ptot[1] = ptot[2] = 1.0;
          for (kk = lim1; kk <= lim2; kk++) {
            ptot[1] = ptot[1] * proba[kk][1];
            ptot[2] = ptot[2] * proba[kk][2];
          }
          if (ptot[1] > ptot[2]) {
            for (kk = lim1; kk <= lim2; kk++)
              pred[kk] = 'H';
          } else {
            for (kk = lim1; kk <= lim2; kk++)
              pred[kk] = 'E';
          }
        }
      }
    }
  }
}
```