user: Converte this assembly snippet into its equivalent C code:

```asm
<get_evec>:
  endbr64
  push   %r15
  movapd %xmm1,%xmm4
  mov    %r8d,%r15d
  push   %r14
  push   %r13
  mov    %rsi,%r13
  mov    %r8d,%esi
  push   %r12
  imul   %r8d,%esi
  push   %rbp
  mov    %rcx,%rbp
  push   %rbx
  mov    %rdx,%rbx
  movslq %esi,%rcx
  sub    $0x48,%rsp
  movq   D0(%rip),%xmm3
  mov    0x80(%rsp),%rax
  movsd  %xmm0,0x10(%rsp)
  andpd  %xmm3,%xmm4
  mov    %r9d,0x1c(%rsp)
  maxsd  %xmm4,%xmm0
  mov    %rax,0x8(%rsp)
  mov    0x88(%rsp),%rax
  mov    %rax,0x28(%rsp)
  movl   $0x0,(%rax)
  movapd %xmm0,%xmm4
  xor    %eax,%eax
  test   %esi,%esi
  je     L189
  nopl   0x0(%rax)
L159:
  movsd  (%rdi,%rax,8),%xmm0
  movsd  %xmm0,0x0(%r13,%rax,8)
  add    $0x1,%rax
  cmp    %rcx,%rax
  jne    L159
L189:
  test   %r15d,%r15d
  jle    L215
  movsd  0x10(%rsp),%xmm6
  lea    0x1(%r15),%esi
  mov    %r13,%rax
  xor    %ecx,%ecx
  movslq %esi,%rsi
  movapd %xmm6,%xmm2
  shl    $0x3,%rsi
  mulsd  %xmm6,%xmm2
  mulsd  %xmm4,%xmm2
  nopl   0x0(%rax,%rax,1)
L179:
  movsd  (%rax),%xmm0
  add    $0x1,%ecx
  subsd  %xmm1,%xmm0
  subsd  %xmm2,%xmm0
  movsd  %xmm0,(%rax)
  add    %rsi,%rax
  cmp    %ecx,%r15d
  jne    L179
  mov    0x28(%rsp),%r14
  mov    0x8(%rsp),%rcx
  xor    %eax,%eax
  mov    %r15d,%edx
  mov    %r15d,%esi
  mov    %r13,%rdi
  movslq %r15d,%r12
  mov    %r14,%r8
  call   <sgefa@plt>
  mov    %r14,%rax
  xor    %r14d,%r14d
  cmpl   $0xffffffff,(%rax)
  jne    L132
  nopw   0x0(%rax,%rax,1)
L204:
  xor    %eax,%eax
  call   <ndrand48@plt>
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  mulsd  D17(%rip),%xmm0
  addsd  D52(%rip),%xmm0
  movsd  %xmm0,(%rbx,%r14,8)
  movsd  %xmm0,0x0(%rbp,%r14,8)
  add    $0x1,%r14
  cmp    %r14,%r12
  jne    L204
L216:
  mov    0x28(%rsp),%rax
  xor    %r11d,%r11d
  mov    %rbx,0x38(%rsp)
  mov    %r13,0x20(%rsp)
  mov    %r15d,%r13d
  movl   $0x0,(%rax)
  lea    -0x1(%r15),%eax
  mov    %rax,0x30(%rsp)
  lea    0x1(%rax),%r14
  lea    0x8(%rbx,%rax,8),%r12
  mov    %r14,%r15
  mov    %rbx,%r14
  mov    %r11d,%ebx
  nopl   0x0(%rax,%rax,1)
L21:
  mov    0x8(%rsp),%rcx
  mov    0x20(%rsp),%rdi
  xor    %r9d,%r9d
  mov    %r14,%r8
  mov    %r13d,%edx
  mov    %r13d,%esi
  xor    %eax,%eax
  call   <sgesl@plt>
  movsd  (%r14),%xmm1
  movq   D0(%rip),%xmm3
  movapd %xmm1,%xmm2
  andpd  %xmm3,%xmm2
  test   %r13d,%r13d
  jle    L120
  mov    $0x1,%ecx
  xor    %eax,%eax
  jmp    L115
  nopl   0x0(%rax)
L122:
  movsd  (%r14,%rcx,8),%xmm0
  andpd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  maxsd  %xmm2,%xmm0
  cmova  %ecx,%eax
  movapd %xmm0,%xmm2
  add    $0x1,%rcx
L115:
  cmp    %rcx,%r15
  jne    L122
  cltq
  movsd  (%r14,%rax,8),%xmm0
  mov    %r14,%rax
  jmp    L176
  nopw   0x0(%rax,%rax,1)
L3:
  movsd  (%rax),%xmm1
L176:
  divsd  %xmm0,%xmm1
  add    $0x8,%rax
  movsd  %xmm1,-0x8(%rax)
  cmp    %rax,%r12
  jne    L3
  xor    %eax,%eax
  pxor   %xmm2,%xmm2
  nopl   0x0(%rax)
L93:
  movsd  (%r14,%rax,8),%xmm1
  movapd %xmm1,%xmm0
  subsd  0x0(%rbp,%rax,8),%xmm0
  movsd  %xmm1,0x0(%rbp,%rax,8)
  add    $0x1,%rax
  andpd  %xmm3,%xmm0
  addsd  %xmm0,%xmm2
  cmp    %rax,%rcx
  jne    L93
  movsd  0x10(%rsp),%xmm5
  comisd %xmm2,%xmm5
  ja     L102
L52:
  add    $0x1,%ebx
  cmp    0x1c(%rsp),%ebx
  jle    L21
  lea    D4(%rip),%rdi
  xor    %eax,%eax
  call   <plintf@plt>
  mov    0x28(%rsp),%rax
  movl   $0x1,(%rax)
L107:
  add    $0x48,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
L120:
  movsd  0x10(%rsp),%xmm5
  pxor   %xmm2,%xmm2
  comisd %xmm2,%xmm5
  jbe    L52
L102:
  mov    0x28(%rsp),%rax
  mov    %r14,%rbx
  mov    (%rax),%ecx
  test   %ecx,%ecx
  jne    L107
  movsd  (%r14),%xmm1
  movapd %xmm1,%xmm2
  andpd  %xmm3,%xmm2
  test   %r13d,%r13d
  jle    L107
  mov    0x30(%rsp),%rdx
  mov    $0x1,%eax
  add    $0x1,%rdx
  jmp    L12
L194:
  movsd  (%rbx,%rax,8),%xmm0
  andpd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  maxsd  %xmm2,%xmm0
  cmova  %eax,%ecx
  movapd %xmm0,%xmm2
  add    $0x1,%rax
L12:
  cmp    %rax,%rdx
  jne    L194
  movslq %ecx,%rcx
  mov    0x38(%rsp),%rax
  movsd  (%rbx,%rcx,8),%xmm0
  jmp    L208
L88:
  movsd  (%rax),%xmm1
L208:
  divsd  %xmm0,%xmm1
  add    $0x8,%rax
  movsd  %xmm1,-0x8(%rax)
  cmp    %rax,%r12
  jne    L88
  add    $0x48,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L215:
  mov    0x28(%rsp),%r14
  mov    0x8(%rsp),%rcx
  xor    %eax,%eax
  mov    %r15d,%edx
  mov    %r15d,%esi
  mov    %r13,%rdi
  mov    %r14,%r8
  call   <sgefa@plt>
  cmpl   $0xffffffff,(%r14)
  je     L216
L132:
  add    $0x48,%rsp
  lea    D58(%rip),%rdi
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    10b0 <plintf@plt>
```

tool_calls: name: parse_data
arguments: data_tag: D0
data_type: qword
name: parse_data
arguments: data_tag: D17
data_type: byte[8]
name: parse_data
arguments: data_tag: D52
data_type: f32[2]
name: parse_data
arguments: data_tag: D4
data_type: string
name: parse_data
arguments: data_tag: D58
data_type: string

tool: D0: 9223372036854775807

tool: {"D17": [0x9a,0x99,0x99,0x99,0x99,0x99,0xb9,0x3f]}

tool: {"D52": [0.0,1.875]}

tool: D4:  max iterates exceeded


tool: D58:  Pivot failed


assistant: ```c
void get_evec(a, anew, b, bp, n, maxit, err, ipivot, eval, ierr) double *a, *anew, *b, *bp, err, eval;
int n, maxit, *ipivot, *ierr;
{
  int j, iter, jmax;
  double temp;
  double zz = fabs(eval);
  if (zz < err)
    zz = err;
  *ierr = 0;
  for (j = 0; j < n * n; j++) {
    anew[j] = a[j];
  }
  for (j = 0; j < n; j++)
    anew[j * (1 + n)] = anew[j * (1 + n)] - eval - err * err * zz;
  sgefa(anew, n, n, ipivot, ierr);
  if (*ierr != -1) {
    plintf(" Pivot failed\n");
    return;
  }
  for (j = 0; j < n; j++) {
    b[j] = 1 + .1 * ndrand48();
    bp[j] = b[j];
  }
  iter = 0;
  *ierr = 0;
  while (1) {
    sgesl(anew, n, n, ipivot, b, 0);
    temp = fabs(b[0]);
    jmax = 0;
    for (j = 0; j < n; j++) {
      if (fabs(b[j]) > temp) {
        temp = fabs(b[j]);
        jmax = j;
      }
    }
    temp = b[jmax];
    for (j = 0; j < n; j++)
      b[j] = b[j] / temp;
    temp = 0.0;
    for (j = 0; j < n; j++) {
      temp = temp + fabs(b[j] - bp[j]);
      bp[j] = b[j];
    }
    if (temp < err)
      break;
    iter++;
    if (iter > maxit) {
      plintf(" max iterates exceeded\n");
      *ierr = 1;
      break;
    }
  }
  if (*ierr == 0) {
    temp = fabs(b[0]);
    jmax = 0;
    for (j = 0; j < n; j++) {
      if (fabs(b[j]) > temp) {
        temp = fabs(b[j]);
        jmax = j;
      }
    }
    temp = b[jmax];
    for (j = 0; j < n; j++)
      b[j] = b[j] / temp;
  }
  return;
}
```