user: Translate the below assembly code into C programming language:

```asm
<IncompleteGamma>:
  endbr64
  pxor   %xmm9,%xmm9
  movapd %xmm0,%xmm3
  ucomisd %xmm9,%xmm0
  jp     L19
  movapd %xmm9,%xmm0
  je     L3
L19:
  sub    $0x28,%rsp
  comisd %xmm3,%xmm9
  movsd  D21(%rip),%xmm0
  movsd  %xmm2,(%rsp)
  ja     L134
  comisd %xmm1,%xmm9
  movsd  %xmm1,0x8(%rsp)
  jae    L134
  movapd %xmm3,%xmm0
  movsd  %xmm3,0x18(%rsp)
  call   <log@plt>
  movsd  0x8(%rsp),%xmm1
  movsd  0x18(%rsp),%xmm3
  movsd  (%rsp),%xmm2
  mulsd  %xmm1,%xmm0
  movsd  %xmm1,0x10(%rsp)
  movsd  %xmm3,0x8(%rsp)
  subsd  %xmm3,%xmm0
  subsd  %xmm2,%xmm0
  call   <exp@plt>
  movsd  D32(%rip),%xmm7
  movsd  0x8(%rsp),%xmm3
  movsd  0x10(%rsp),%xmm1
  movsd  %xmm0,(%rsp)
  comisd %xmm7,%xmm3
  jbe    L118
  comisd %xmm1,%xmm3
  pxor   %xmm9,%xmm9
  jb     L118
  movapd %xmm7,%xmm8
  movapd %xmm3,%xmm4
  movapd %xmm3,%xmm5
  movq   D12(%rip),%xmm13
  subsd  %xmm1,%xmm8
  movapd %xmm3,%xmm6
  movsd  D43(%rip),%xmm12
  movsd  D51(%rip),%xmm11
  addsd  %xmm7,%xmm6
  movapd %xmm7,%xmm1
  movapd %xmm9,%xmm10
  addsd  %xmm8,%xmm4
  movapd %xmm6,%xmm14
  addsd  %xmm7,%xmm4
  mulsd  %xmm4,%xmm5
  divsd  %xmm5,%xmm14
  jmp    L80
  nopw   0x0(%rax,%rax,1)
L18:
  movapd %xmm5,%xmm3
  movapd %xmm1,%xmm5
  movapd %xmm6,%xmm1
  movapd %xmm0,%xmm6
L80:
  addsd  %xmm7,%xmm8
  addsd  %xmm7,%xmm10
  movapd %xmm6,%xmm0
  addsd  D24(%rip),%xmm4
  movapd %xmm8,%xmm2
  mulsd  %xmm10,%xmm2
  mulsd  %xmm4,%xmm0
  mulsd  %xmm2,%xmm1
  mulsd  %xmm3,%xmm2
  subsd  %xmm1,%xmm0
  movapd %xmm4,%xmm1
  mulsd  %xmm5,%xmm1
  subsd  %xmm2,%xmm1
  ucomisd %xmm9,%xmm1
  jp     L67
  je     L106
L67:
  movapd %xmm0,%xmm3
  movapd %xmm14,%xmm2
  divsd  %xmm1,%xmm3
  subsd  %xmm3,%xmm2
  andpd  %xmm13,%xmm2
  comisd %xmm2,%xmm12
  jb     L27
  movapd %xmm3,%xmm15
  mulsd  %xmm12,%xmm15
  comisd %xmm2,%xmm15
  jae    L145
L27:
  movapd %xmm3,%xmm14
L106:
  movapd %xmm0,%xmm2
  andpd  %xmm13,%xmm2
  comisd %xmm11,%xmm2
  jb     L18
  divsd  %xmm11,%xmm6
  divsd  %xmm11,%xmm5
  divsd  %xmm11,%xmm0
  divsd  %xmm11,%xmm1
  jmp    L18
  nopl   0x0(%rax)
L3:
  ret
  nopl   0x0(%rax)
L118:
  movapd %xmm1,%xmm4
  movapd %xmm7,%xmm2
  movapd %xmm7,%xmm5
  movsd  D43(%rip),%xmm12
  nopl   (%rax)
L148:
  addsd  %xmm7,%xmm4
  movapd %xmm3,%xmm6
  divsd  %xmm4,%xmm6
  mulsd  %xmm6,%xmm2
  comisd %xmm12,%xmm2
  addsd  %xmm2,%xmm5
  ja     L148
  movsd  (%rsp),%xmm0
  divsd  %xmm1,%xmm0
  mulsd  %xmm5,%xmm0
L134:
  add    $0x28,%rsp
  ret
L145:
  mulsd  (%rsp),%xmm14
  subsd  %xmm14,%xmm7
  movapd %xmm7,%xmm0
  jmp    L134
```

tool_calls: name: extract_symbolic_data
arguments: tag: D21
datatype: f32[2]
name: extract_symbolic_data
arguments: tag: D32
datatype: f32[2]
name: extract_symbolic_data
arguments: tag: D12
datatype: qword
name: extract_symbolic_data
arguments: tag: D43
datatype: byte[8]
name: extract_symbolic_data
arguments: tag: D51
datatype: f64
name: extract_symbolic_data
arguments: tag: D24
datatype: f32[2]

tool: {"D21": [0.0,-1.875]}

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

tool: D12: 9223372036854775807

tool: {"D43": [0xbb,0xbd,0xd7,0xd9,0xdf,0x7c,0xdb,0x3d]}

tool: D51: 1e+60

tool: {"D24": [0.0,2.0]}

assistant: ```c
double IncompleteGamma(double x, double alpha, double ln_gamma_alpha) {
  int i;
  double p = alpha, g = ln_gamma_alpha;
  const double ACCURACY_TOL = 1e-10;
  const double OVERFLOW_VAL = 1e60;
  double factor, gin = 0, rn = 0, a = 0, b = 0, an = 0, dif = 0, term = 0, pn[6];
  if (x == 0)
    return 0;
  if (x < 0 || p <= 0)
    return -1;
  factor = exp(p * log(x) - x - g);
  if (x > 1 && x >= p) {
    a = 1 - p;
    b = a + x + 1;
    term = 0;
    pn[0] = 1;
    pn[1] = x;
    pn[2] = x + 1;
    pn[3] = x * b;
    gin = pn[2] / pn[3];
    for (;;) {
      a++;
      b += 2;
      term++;
      an = a * term;
      for (i = 0; i < 2; i++)
        pn[i + 4] = b * pn[i + 2] - an * pn[i];
      if (pn[5] != 0) {
        rn = pn[4] / pn[5];
        dif = fabs(gin - rn);
        if ((dif <= ACCURACY_TOL) && (dif <= ACCURACY_TOL * rn))
          return 1 - factor * gin;
        gin = rn;
      }
      for (i = 0; i < 4; i++)
        pn[i] = pn[i + 2];
      if (fabs(pn[4]) >= OVERFLOW_VAL) {
        for (i = 0; i < 4; i++)
          pn[i] /= OVERFLOW_VAL;
      }
    }
  } else {
    gin = 1;
    term = 1;
    rn = p;
    while (term > ACCURACY_TOL) {
      rn++;
      term *= x / rn;
      gin += term;
    }
    gin *= factor / p;
  }
  return (gin);
}
```