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

```asm
<IncompleteGamma>:
  endbr64
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x40,%rsp
  movq   %xmm0,%rbx
  movq   %xmm1,%r12
  movq   %xmm2,%rbp
  mov    %fs:0x28,%rax
  mov    %rax,0x38(%rsp)
  xor    %eax,%eax
  ucomisd D2(%rip),%xmm0
  jp     L106
  pxor   %xmm0,%xmm0
  je     L50
L106:
  pxor   %xmm0,%xmm0
  movq   %rbx,%xmm7
  comisd %xmm7,%xmm0
  ja     L162
  movsd  D179(%rip),%xmm0
  pxor   %xmm1,%xmm1
  movq   %r12,%xmm6
  comisd %xmm6,%xmm1
  jae    L50
  movq   %rbx,%xmm0
  call   <log@plt>
  movq   %r12,%xmm6
  mulsd  %xmm6,%xmm0
  movq   %rbx,%xmm7
  subsd  %xmm7,%xmm0
  movq   %rbp,%xmm6
  subsd  %xmm6,%xmm0
  call   <exp@plt>
  movq   %xmm0,%rsi
  movq   %rbx,%xmm7
  comisd D100(%rip),%xmm7
  jbe    L112
  movq   %r12,%xmm6
  comisd %xmm6,%xmm7
  jae    L57
  movq   %r12,%xmm2
  movsd  D100(%rip),%xmm1
  movapd %xmm1,%xmm3
  jmp    L91
L57:
  movsd  D100(%rip),%xmm0
  movapd %xmm0,%xmm3
  subsd  %xmm6,%xmm3
  movq   %rbx,%xmm2
  addsd  %xmm3,%xmm2
  addsd  %xmm0,%xmm2
  movsd  %xmm0,(%rsp)
  mov    %rbx,0x8(%rsp)
  addsd  %xmm7,%xmm0
  movsd  %xmm0,0x10(%rsp)
  movq   %rbx,%xmm1
  mulsd  %xmm2,%xmm1
  movsd  %xmm1,0x18(%rsp)
  divsd  %xmm1,%xmm0
  movq   %xmm0,%rcx
  pxor   %xmm4,%xmm4
  movsd  D100(%rip),%xmm5
  movsd  D118(%rip),%xmm8
  movapd %xmm4,%xmm7
  movapd %xmm4,%xmm9
  movq   D38(%rip),%xmm11
  movsd  D97(%rip),%xmm6
  jmp    L49
L188:
  movq   %rcx,%xmm1
  movq   %rsi,%xmm6
  mulsd  %xmm6,%xmm1
  movsd  D100(%rip),%xmm0
  subsd  %xmm1,%xmm0
  jmp    L50
L104:
  movq   %xmm0,%rcx
L37:
  movsd  %xmm14,(%rsp)
  movsd  %xmm12,0x8(%rsp)
  movsd  %xmm1,0x10(%rsp)
  movsd  %xmm13,0x18(%rsp)
  andpd  %xmm11,%xmm1
  comisd D97(%rip),%xmm1
  jae    L199
L49:
  addsd  %xmm5,%xmm3
  addsd  %xmm8,%xmm2
  addsd  %xmm5,%xmm4
  movapd %xmm3,%xmm15
  mulsd  %xmm4,%xmm15
  movsd  0x10(%rsp),%xmm14
  movapd %xmm2,%xmm1
  mulsd  %xmm14,%xmm1
  movapd %xmm15,%xmm0
  mulsd  (%rsp),%xmm0
  subsd  %xmm0,%xmm1
  movsd  %xmm1,0x20(%rsp)
  movsd  0x18(%rsp),%xmm12
  movapd %xmm12,%xmm13
  mulsd  %xmm2,%xmm13
  mulsd  0x8(%rsp),%xmm15
  subsd  %xmm15,%xmm13
  movsd  %xmm13,0x28(%rsp)
  ucomisd %xmm7,%xmm13
  jp     L2
  ucomisd %xmm9,%xmm13
  je     L37
L2:
  movapd %xmm1,%xmm0
  divsd  %xmm13,%xmm0
  movq   %rcx,%xmm15
  subsd  %xmm0,%xmm15
  andpd  D38(%rip),%xmm15
  movsd  D171(%rip),%xmm10
  comisd %xmm15,%xmm10
  jb     L104
  movapd %xmm0,%xmm10
  mulsd  D171(%rip),%xmm10
  comisd %xmm15,%xmm10
  jae    L188
  movq   %xmm0,%rcx
  jmp    L37
L199:
  mov    %rsp,%rax
  lea    0x20(%rsp),%rdx
L163:
  movsd  (%rax),%xmm1
  divsd  %xmm6,%xmm1
  movsd  %xmm1,(%rax)
  add    $0x8,%rax
  cmp    %rdx,%rax
  jne    L163
  jmp    L49
L112:
  movq   %r12,%xmm2
  movsd  D100(%rip),%xmm1
  movapd %xmm1,%xmm3
L91:
  movsd  D100(%rip),%xmm5
  movsd  D171(%rip),%xmm4
L12:
  addsd  %xmm5,%xmm2
  movq   %rbx,%xmm0
  divsd  %xmm2,%xmm0
  mulsd  %xmm0,%xmm1
  addsd  %xmm1,%xmm3
  comisd %xmm4,%xmm1
  ja     L12
  movq   %rsi,%xmm0
  movq   %r12,%xmm4
  divsd  %xmm4,%xmm0
  mulsd  %xmm3,%xmm0
L50:
  mov    0x38(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L187
  add    $0x40,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
L162:
  movsd  D179(%rip),%xmm0
  jmp    L50
L187:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: data_label: D2
type: f64
name: unpack_data
arguments: data_label: D179
type: byte[8]
name: unpack_data
arguments: data_label: D100
type: byte[16]
name: unpack_data
arguments: data_label: D118
type: byte[8]
name: unpack_data
arguments: data_label: D38
type: qword[2]
name: unpack_data
arguments: data_label: D97
type: f64[2]
name: unpack_data
arguments: data_label: D171
type: byte[8]

tool: D2: 0

tool: {"D179": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0xbf]}

tool: {"D100": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0xbf]}

tool: {"D118": [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40]}

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

tool: {"D97": [1e60,0.0]}

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

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);
}
```