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

```asm
<localCvtDoubleToExpNotationString>:
  endbr64
  push   %r14
  push   %rbp
  push   %rbx
  sub    $0x90,%rsp
  movq   %xmm0,%r14
  mov    %rdi,%rbx
  mov    %fs:0x28,%rax
  mov    %rax,0x88(%rsp)
  xor    %eax,%eax
  andpd  D17(%rip),%xmm0
  movsd  D18(%rip),%xmm1
  comisd %xmm0,%xmm1
  ja     L161
  mov    $0x0,%ebp
  movsd  D11(%rip),%xmm2
  movsd  D57(%rip),%xmm1
  comisd %xmm1,%xmm0
  jb     L106
L103:
  mulsd  %xmm2,%xmm0
  add    $0x3,%ebp
  comisd %xmm1,%xmm0
  jae    L103
L106:
  movzwl %si,%esi
  mov    %rsp,%rdi
  call   <localCvtDoubleToString@plt>
  pxor   %xmm0,%xmm0
  movq   %r14,%xmm4
  mov    $0x0,%ecx
  comisd %xmm4,%xmm0
  ja     L25
L92:
  movzbl (%rsp),%edx
  test   %dl,%dl
  je     L96
  lea    0x1(%rcx),%eax
  cltq
  mov    %rsp,%rsi
  movslq %ecx,%rcx
  sub    %rcx,%rsi
L156:
  mov    %eax,%ecx
  mov    %dl,-0x1(%rbx,%rax,1)
  add    $0x1,%rax
  movzbl -0x1(%rsi,%rax,1),%edx
  test   %dl,%dl
  jne    L156
L96:
  movslq %ecx,%rax
  movb   $0x65,(%rbx,%rax,1)
  lea    0x1(%rcx),%eax
  cltq
  movb   $0x2b,(%rbx,%rax,1)
  lea    0x2(%rcx),%edx
  movslq %edx,%rdx
  movslq %ebp,%rax
  imul   $0x66666667,%rax,%rax
  sar    $0x22,%rax
  mov    %ebp,%esi
  sar    $0x1f,%esi
  sub    %esi,%eax
  lea    0x30(%rax),%esi
  mov    %sil,(%rbx,%rdx,1)
  lea    0x3(%rcx),%edx
  movslq %edx,%rdx
  lea    (%rax,%rax,4),%eax
  add    %eax,%eax
  sub    %eax,%ebp
  add    $0x30,%ebp
  mov    %bpl,(%rbx,%rdx,1)
  add    $0x4,%ecx
  movslq %ecx,%rcx
  movb   $0x0,(%rbx,%rcx,1)
L10:
  mov    0x88(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L0
  add    $0x90,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r14
  ret
L161:
  movq   %r14,%xmm3
  ucomisd D30(%rip),%xmm3
  jp     L168
  mov    $0x0,%ebp
  jne    L168
L70:
  movzwl %si,%esi
  mov    %rsp,%rdi
  call   <localCvtDoubleToString@plt>
  pxor   %xmm0,%xmm0
  movq   %r14,%xmm5
  mov    $0x0,%ecx
  comisd %xmm5,%xmm0
  ja     L63
L109:
  movzbl (%rsp),%edx
  test   %dl,%dl
  je     L56
  lea    0x1(%rcx),%eax
  cltq
  mov    %rsp,%rsi
  movslq %ecx,%rcx
  sub    %rcx,%rsi
L158:
  mov    %eax,%ecx
  mov    %dl,-0x1(%rbx,%rax,1)
  add    $0x1,%rax
  movzbl -0x1(%rsi,%rax,1),%edx
  test   %dl,%dl
  jne    L158
L56:
  lea    0x1(%rcx),%eax
  movslq %ecx,%rdx
  movb   $0x65,(%rbx,%rdx,1)
  test   %ebp,%ebp
  jne    L62
  add    $0x2,%ecx
  cltq
  movb   $0x2b,(%rbx,%rax,1)
L33:
  movslq %ecx,%rdx
  movslq %ebp,%rax
  imul   $0x66666667,%rax,%rax
  sar    $0x22,%rax
  mov    %ebp,%esi
  sar    $0x1f,%esi
  sub    %esi,%eax
  lea    0x30(%rax),%esi
  mov    %sil,(%rbx,%rdx,1)
  lea    0x1(%rcx),%edx
  movslq %edx,%rdx
  lea    (%rax,%rax,4),%esi
  add    %esi,%esi
  mov    %ebp,%eax
  sub    %esi,%eax
  add    $0x30,%eax
  mov    %al,(%rbx,%rdx,1)
  add    $0x2,%ecx
  movslq %ecx,%rcx
  movb   $0x0,(%rbx,%rcx,1)
  jmp    L10
L168:
  mov    $0x0,%ebp
  movsd  D57(%rip),%xmm2
  movsd  D18(%rip),%xmm1
L141:
  mulsd  %xmm2,%xmm0
  add    $0x3,%ebp
  comisd %xmm0,%xmm1
  ja     L141
  jmp    L70
L63:
  movb   $0x2d,(%rbx)
  mov    $0x1,%ecx
  jmp    L109
L62:
  add    $0x2,%ecx
  cltq
  movb   $0x2d,(%rbx,%rax,1)
  jmp    L33
L25:
  movb   $0x2d,(%rbx)
  mov    $0x1,%ecx
  jmp    L92
L0:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: label: D17
type_guessed: qword[2]
name: extract_symbolic_data
arguments: label: D18
type_guessed: f64
name: extract_symbolic_data
arguments: label: D11
type_guessed: f64
name: extract_symbolic_data
arguments: label: D57
type_guessed: f64
name: extract_symbolic_data
arguments: label: D30
type_guessed: f64

tool: {"D17": [0x7fffffffffffffff,0x0000000000000000]}

tool: D18: 1

tool: D11: 0.001

tool: D57: 1000

tool: D30: 0

assistant: ```c
void localCvtDoubleToExpNotationString(double value, char *textField, unsigned short precision) {
  double absVal, newVal;
  int minus;
  int exp, k, l;
  char TF[128];
  absVal = fabs(value);
  minus = (value < 0.0 ? 1 : 0);
  newVal = absVal;
  if (absVal < 1.) {
    exp = 0;
    if (absVal != 0.) {
      do {
        newVal *= 1000.0;
        exp += 3;
      } while (newVal < 1.);
    }
    localCvtDoubleToString(newVal, TF, precision);
    k = 0;
    l = 0;
    if (minus)
      textField[k++] = '-';
    while (TF[l] != '\0')
      textField[k++] = TF[l++];
    textField[k++] = 'e';
    if (exp == 0) {
      textField[k++] = '+';
    } else {
      textField[k++] = '-';
    }
    textField[k++] = '0' + exp / 10;
    textField[k++] = '0' + exp % 10;
    textField[k++] = '\0';
  } else {
    exp = 0;
    while (newVal >= 1000.) {
      newVal *= 0.001;
      exp += 3;
    }
    localCvtDoubleToString(newVal, TF, precision);
    k = 0;
    l = 0;
    if (minus)
      textField[k++] = '-';
    while (TF[l] != '\0')
      textField[k++] = TF[l++];
    textField[k++] = 'e';
    textField[k++] = '+';
    textField[k++] = '0' + exp / 10;
    textField[k++] = '0' + exp % 10;
    textField[k++] = '\0';
  }
}
```