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

```asm
<R_Pauli_Fixed_E>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x88,%rsp
  mov    %rdx,0x48(%rsp)
  mov    %ecx,0x50(%rsp)
  movsd  %xmm1,0x20(%rsp)
  mov    %r8,%r13
  mov    %r9,%r15
  lea    0x1(%rsi),%edx
  imul   %esi,%edx
  pxor   %xmm6,%xmm6
  cvtsi2sd %edx,%xmm6
  movsd  %xmm6,0x38(%rsp)
  test   %esi,%esi
  jne    L218
  movapd %xmm0,%xmm1
  mulsd  D40(%rip),%xmm1
  mulsd  %xmm0,%xmm1
  movsd  D13(%rip),%xmm0
  subsd  %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  ucomisd %xmm0,%xmm1
  ja     L138
  sqrtsd %xmm0,%xmm0
  movsd  %xmm0,0x30(%rsp)
  jmp    L209
L138:
  call   <sqrt@plt>
  movsd  %xmm0,0x30(%rsp)
  jmp    L209
L218:
  pxor   %xmm5,%xmm5
  cvtsi2sd %esi,%xmm5
  movsd  %xmm5,0x8(%rsp)
  movapd %xmm0,%xmm1
  mulsd  D40(%rip),%xmm1
  movapd %xmm1,%xmm6
  mulsd  %xmm0,%xmm6
  movsd  %xmm6,0x10(%rsp)
  movapd %xmm5,%xmm0
  mulsd  %xmm5,%xmm0
  subsd  %xmm6,%xmm0
  pxor   %xmm1,%xmm1
  ucomisd %xmm0,%xmm1
  ja     L69
  sqrtsd %xmm0,%xmm0
L55:
  movsd  0x8(%rsp),%xmm3
  mulsd  %xmm3,%xmm0
  movsd  %xmm0,0x18(%rsp)
  addsd  D13(%rip),%xmm3
  movsd  %xmm3,0x28(%rsp)
  movapd %xmm3,%xmm0
  mulsd  %xmm3,%xmm0
  subsd  0x10(%rsp),%xmm0
  pxor   %xmm1,%xmm1
  ucomisd %xmm0,%xmm1
  ja     L33
  sqrtsd %xmm0,%xmm0
L176:
  mulsd  0x28(%rsp),%xmm0
  movsd  0x18(%rsp),%xmm1
  addsd  %xmm0,%xmm1
  movsd  0x8(%rsp),%xmm0
  addsd  %xmm0,%xmm0
  addsd  D13(%rip),%xmm0
  divsd  %xmm0,%xmm1
  movsd  %xmm1,0x30(%rsp)
L209:
  mov    $0x0,%eax
  call   <N_LogGrid@plt>
  mov    %eax,0x54(%rsp)
  mov    $0x0,%eax
  call   <log_amesh_LogGrid@plt>
  pxor   %xmm3,%xmm3
  cvtsi2sd %eax,%xmm3
  movsd  %xmm3,0x28(%rsp)
  mulsd  %xmm3,%xmm3
  movsd  %xmm3,0x18(%rsp)
  mov    $0x0,%eax
  call   <r_LogGrid@plt>
  mov    %eax,0x78(%rsp)
  mov    $0x0,%eax
  call   <alloc_LogGrid@plt>
  mov    %eax,%r14d
  cltq
  mov    %rax,0x60(%rsp)
  mov    $0x0,%eax
  call   <alloc_LogGrid@plt>
  movslq %eax,%rbx
  mov    %rbx,0x8(%rsp)
  mov    $0x0,%eax
  call   <alloc_LogGrid@plt>
  mov    %eax,0x44(%rsp)
  cltq
  mov    %rax,0x68(%rsp)
  mov    $0x0,%eax
  call   <alloc_LogGrid@plt>
  mov    %eax,%r12d
  cltq
  mov    %rax,0x70(%rsp)
  mov    $0x0,%eax
  call   <alloc_LogGrid@plt>
  mov    %eax,0x7c(%rsp)
  cltq
  mov    %rax,0x58(%rsp)
  lea    0x20(%rbx),%rsi
  mov    %rsi,0x10(%rsp)
  mov    %rbx,%rax
  mov    %r13,%rcx
  sub    %rbx,%rcx
  mov    %r15,%rdx
  sub    %rbx,%rdx
L173:
  movq   $0x0,(%rcx,%rax,1)
  movq   $0x0,(%rdx,%rax,1)
  movq   $0x0,(%rax)
  add    $0x8,%rax
  cmp    %rsi,%rax
  jne    L173
  mov    0x54(%rsp),%eax
  test   %eax,%eax
  jle    L233
  movslq 0x78(%rsp),%rbx
  lea    -0x1(%rax),%ebp
  shl    $0x3,%rbp
  lea    0x8(%rbx,%rbp,1),%rsi
  mov    %rbx,%rax
  movslq %r14d,%rdx
  sub    %rbx,%rdx
  mov    0x48(%rsp),%rcx
  sub    %rbx,%rcx
L245:
  movsd  (%rax),%xmm1
  movsd  (%rcx,%rax,1),%xmm0
  subsd  0x20(%rsp),%xmm0
  addsd  %xmm0,%xmm0
  mulsd  %xmm1,%xmm1
  mulsd  %xmm1,%xmm0
  addsd  0x38(%rsp),%xmm0
  mulsd  0x18(%rsp),%xmm0
  movsd  %xmm0,(%rdx,%rax,1)
  add    $0x8,%rax
  cmp    %rsi,%rax
  jne    L245
  mov    0x58(%rsp),%rsi
  mov    0x48(%rsp),%rdi
  mov    $0x0,%eax
  call   <Derivative_LogGrid@plt>
  mov    0x48(%rsp),%r10
  lea    0x8(%r10,%rbp,1),%rdi
  mov    %r10,%rax
  sub    %r10,%rbx
  movslq 0x7c(%rsp),%rdx
  sub    %r10,%rdx
  movslq 0x44(%rsp),%rsi
  sub    %r10,%rsi
  movsd  D2(%rip),%xmm2
  movsd  D13(%rip),%xmm3
  movsd  D81(%rip),%xmm6
  movslq %r12d,%rcx
  sub    %r10,%rcx
  movsd  0x28(%rsp),%xmm7
  xorpd  D53(%rip),%xmm7
  movsd  D20(%rip),%xmm5
  movsd  D40(%rip),%xmm4
L36:
  lea    (%rbx,%rax,1),%r9
  movsd  (%r9),%xmm1
  movsd  (%rax),%xmm10
  movapd %xmm10,%xmm9
  movsd  0x20(%rsp),%xmm11
  subsd  %xmm11,%xmm9
  lea    (%rdx,%rax,1),%r8
  movapd %xmm2,%xmm0
  mulsd  (%r8),%xmm0
  movapd %xmm11,%xmm8
  subsd  %xmm10,%xmm8
  mulsd  %xmm2,%xmm8
  addsd  %xmm3,%xmm8
  mulsd  %xmm1,%xmm8
  divsd  %xmm8,%xmm0
  movapd %xmm9,%xmm8
  mulsd  %xmm6,%xmm8
  mulsd  %xmm9,%xmm8
  addsd  %xmm8,%xmm0
  mulsd  %xmm1,%xmm1
  mulsd  0x18(%rsp),%xmm1
  mulsd  %xmm1,%xmm0
  movsd  %xmm0,(%rsi,%rax,1)
  movapd %xmm7,%xmm0
  mulsd  (%r9),%xmm0
  mulsd  %xmm5,%xmm0
  mulsd  %xmm4,%xmm0
  mulsd  (%r8),%xmm0
  movapd %xmm11,%xmm1
  subsd  (%rax),%xmm1
  mulsd  %xmm2,%xmm1
  addsd  %xmm3,%xmm1
  divsd  %xmm1,%xmm0
  movsd  %xmm0,(%rcx,%rax,1)
  add    $0x8,%rax
  cmp    %rdi,%rax
  jne    L36
L188:
  mov    $0x0,%ebx
  movslq 0x78(%rsp),%rbp
L199:
  movsd  0x0(%rbp,%rbx,1),%xmm0
  movsd  0x30(%rsp),%xmm1
  call   <pow@plt>
  movsd  %xmm0,0x0(%r13,%rbx,1)
  movsd  0x30(%rsp),%xmm1
  movsd  0x28(%rsp),%xmm7
  mulsd  %xmm7,%xmm1
  mulsd  %xmm0,%xmm1
  movsd  %xmm1,(%r15,%rbx,1)
  movslq %r12d,%rcx
  movslq %r14d,%rdx
  movslq 0x44(%rsp),%rax
  movsd  (%rbx,%rdx,1),%xmm0
  addsd  (%rbx,%rax,1),%xmm0
  mulsd  0x0(%r13,%rbx,1),%xmm0
  addsd  (%rbx,%rcx,1),%xmm7
  mulsd  %xmm7,%xmm1
  addsd  %xmm1,%xmm0
  mov    0x8(%rsp),%rdi
  movsd  %xmm0,(%rdi,%rbx,1)
  add    $0x8,%rbx
  cmp    $0x20,%rbx
  jne    L199
  mov    0x50(%rsp),%edi
  cmp    $0x3,%edi
  jle    L71
  add    $0x20,%rcx
  mov    %rcx,0x20(%rsp)
  lea    0x20(%rdx),%r14
  add    $0x20,%rax
  mov    %rax,0x18(%rsp)
  mov    %edi,%eax
  mov    %rax,0x38(%rsp)
  mov    $0x3,%ebx
  jmp    L239
L69:
  call   <sqrt@plt>
  jmp    L55
L33:
  call   <sqrt@plt>
  jmp    L176
L208:
  add    $0x1,%rbx
  addq   $0x8,0x20(%rsp)
  add    $0x8,%r14
  addq   $0x8,0x18(%rsp)
  addq   $0x8,0x10(%rsp)
  cmp    0x38(%rsp),%rbx
  je     L71
L239:
  mov    %ebx,%r12d
  mov    %r15,%rdx
  mov    %r13,%rsi
  mov    %ebx,%edi
  mov    $0x0,%eax
  call   <Predictor_Out@plt>
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x8(%r13,%rbx,8)
  mov    0x8(%rsp),%rdx
  mov    %r15,%rsi
  mov    %ebx,%edi
  mov    $0x0,%eax
  call   <Predictor_Out@plt>
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x8(%r15,%rbx,8)
  mov    $0x6,%ebp
L169:
  movsd  (%r14),%xmm0
  mov    0x18(%rsp),%rax
  addsd  (%rax),%xmm0
  mulsd  0x8(%r13,%rbx,8),%xmm0
  mov    0x20(%rsp),%rax
  movsd  0x28(%rsp),%xmm1
  addsd  (%rax),%xmm1
  mulsd  0x8(%r15,%rbx,8),%xmm1
  addsd  %xmm1,%xmm0
  mov    0x10(%rsp),%rax
  movsd  %xmm0,(%rax)
  mov    0x8(%rsp),%rdx
  mov    %r15,%rsi
  mov    %r12d,%edi
  mov    $0x0,%eax
  call   <Corrector_Out@plt>
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x8(%r15,%rbx,8)
  mov    %r15,%rdx
  mov    %r13,%rsi
  mov    %r12d,%edi
  mov    $0x0,%eax
  call   <Corrector_Out@plt>
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x8(%r13,%rbx,8)
  sub    $0x1,%ebp
  jne    L169
  jmp    L208
L71:
  mov    %r13,%rsi
  movsd  0x30(%rsp),%xmm0
  mov    0x50(%rsp),%edi
  mov    $0x1,%eax
  call   <Norm_LogGrid@plt>
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  pxor   %xmm1,%xmm1
  ucomisd %xmm0,%xmm1
  ja     L224
  sqrtsd %xmm0,%xmm0
L191:
  movsd  D13(%rip),%xmm1
  divsd  %xmm0,%xmm1
  mov    0x50(%rsp),%eax
  test   %eax,%eax
  js     L70
  lea    0x1(%rax),%edx
  shl    $0x3,%rdx
  mov    $0x0,%eax
L16:
  movapd %xmm1,%xmm0
  mulsd  0x0(%r13,%rax,1),%xmm0
  movsd  %xmm0,0x0(%r13,%rax,1)
  movapd %xmm1,%xmm0
  mulsd  (%r15,%rax,1),%xmm0
  movsd  %xmm0,(%r15,%rax,1)
  add    $0x8,%rax
  cmp    %rax,%rdx
  jne    L16
L70:
  mov    0x50(%rsp),%eax
  add    $0x1,%eax
  mov    0x54(%rsp),%edx
  cmp    %eax,%edx
  jle    L46
  cltq
L139:
  movq   $0x0,0x0(%r13,%rax,8)
  movq   $0x0,(%r15,%rax,8)
  add    $0x1,%rax
  cmp    %eax,%edx
  jg     L139
L46:
  mov    0x60(%rsp),%rdi
  mov    $0x0,%eax
  call   <dealloc_LogGrid@plt>
  mov    0x8(%rsp),%rdi
  mov    $0x0,%eax
  call   <dealloc_LogGrid@plt>
  mov    0x68(%rsp),%rdi
  mov    $0x0,%eax
  call   <dealloc_LogGrid@plt>
  mov    0x70(%rsp),%rdi
  mov    $0x0,%eax
  call   <dealloc_LogGrid@plt>
  mov    0x58(%rsp),%rdi
  mov    $0x0,%eax
  call   <dealloc_LogGrid@plt>
  add    $0x88,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L224:
  call   <sqrt@plt>
  jmp    L191
L233:
  mov    0x58(%rsp),%rsi
  mov    0x48(%rsp),%rdi
  mov    $0x0,%eax
  call   <Derivative_LogGrid@plt>
  jmp    L188
```

tool_calls: name: unpack_data
arguments: data_tag: D40
type_infered: byte[8]
name: unpack_data
arguments: data_tag: D13
type_infered: f64
name: unpack_data
arguments: data_tag: D2
type_infered: byte[8]
name: unpack_data
arguments: data_tag: D81
type_infered: byte[8]
name: unpack_data
arguments: data_tag: D53
type_infered: f32[4]
name: unpack_data
arguments: data_tag: D20
type_infered: f64

tool: {"D40": [0xfc,0x1c,0xef,0x0c,0x46,0xeb,0x0b,0x3f]}

tool: D13: 1

tool: {"D2": [0xfc,0x1c,0xef,0x0c,0x46,0xeb,0xfb,0x3e]}

tool: {"D81": [0xfc,0x1c,0xef,0x0c,0x46,0xeb,0x0b,0xbf]}

tool: {"D53": [0.0,-0.0,0.0,0.0]}

tool: D20: 0.5

assistant: ```c
void R_Pauli_Fixed_E(n, l, Z, v, match, E, u, uprime) int n, l;
double Z;
double v[];
int match;
double E;
double u[], uprime[];
{
  int i, j, node, Ngrid;
  double log_amesh, log_amesh2, fss, gamma, L2, L0, r2, sum, *r, *f_upp, *dv, *frp, *fr, *upp;
  L2 = ((double)(l * (l + 1)));
  fss = 1.0 / 137.03602;
  fss = fss * fss;
  if (l == 0)
    gamma = sqrt(1.0 - fss * Z * Z);
  else {
    L0 = (double)l;
    gamma = (sqrt(L0 * L0 - fss * Z * Z) * L0 + sqrt((L0 + 1.0) * (L0 + 1) - fss * Z * Z) * (L0 + 1.0)) / (2.0 * L0 + 1.0);
  }
  Ngrid = N_LogGrid();
  log_amesh = log_amesh_LogGrid();
  log_amesh2 = log_amesh * log_amesh;
  r = r_LogGrid();
  f_upp = alloc_LogGrid();
  upp = alloc_LogGrid();
  fr = alloc_LogGrid();
  frp = alloc_LogGrid();
  dv = alloc_LogGrid();
  for (i = 0; i < 4; ++i) {
    u[i] = 0.0;
    uprime[i] = 0.0;
    upp[i] = 0.0;
  }
  for (i = 0; i < Ngrid; ++i) {
    r2 = r[i];
    r2 = r2 * r2;
    f_upp[i] = log_amesh2 * (L2 + 2.0 * (v[i] - E) * r2);
  }
  Derivative_LogGrid(v, dv);
  for (i = 0; i < Ngrid; ++i) {
    r2 = r[i] * r[i];
    fr[i] = log_amesh2 * r2 * (-fss * (v[i] - E) * (v[i] - E) + 0.5 * fss * dv[i] / (r[i] * (1.0 + 0.5 * fss * (E - v[i]))));
    frp[i] = -log_amesh * r[i] * 0.5 * fss * dv[i] / (1.0 + 0.5 * fss * (E - v[i]));
  }
  for (i = 0; i < 4; ++i) {
    u[i] = pow(r[i], gamma);
    uprime[i] = log_amesh * gamma * u[i];
    upp[i] = (log_amesh + frp[i]) * uprime[i] + (f_upp[i] + fr[i]) * u[i];
  }
  node = 0;
  for (i = 3; i < match; ++i) {
    u[i + 1] = Predictor_Out(i, u, uprime);
    uprime[i + 1] = Predictor_Out(i, uprime, upp);
    for (j = 0; j < 6; ++j) {
      upp[i + 1] = (log_amesh + frp[i + 1]) * uprime[i + 1] + (f_upp[i + 1] + fr[i + 1]) * u[i + 1];
      uprime[i + 1] = Corrector_Out(i, uprime, upp);
      u[i + 1] = Corrector_Out(i, u, uprime);
    }
  }
  sum = Norm_LogGrid(match, gamma, u);
  sum = 1.0 / sqrt(sum);
  for (i = 0; i <= match; ++i) {
    u[i] = sum * u[i];
    uprime[i] = sum * uprime[i];
  }
  for (i = match + 1; i < Ngrid; ++i) {
    u[i] = 0.0;
    uprime[i] = 0.0;
  }
  dealloc_LogGrid(f_upp);
  dealloc_LogGrid(upp);
  dealloc_LogGrid(fr);
  dealloc_LogGrid(frp);
  dealloc_LogGrid(dv);
  return;
}
```