user: What would the C source look like for the assembly code provided here?

```asm
<innerPredict>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x88,%rsp
  mov    %rdi,0x38(%rsp)
  mov    %rsi,%r15
  mov    %edx,0x40(%rsp)
  mov    %rcx,0x10(%rsp)
  mov    %r8,0x18(%rsp)
  mov    %r9,(%rsp)
  mov    0xc0(%rsp),%r12
  test   %edx,%edx
  jle    L227
  mov    %rdi,%rax
  lea    -0x1(%rdx),%edx
  lea    0x4(%rdi,%rdx,4),%rdx
L12:
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  cmp    %rdx,%rax
  jne    L12
L227:
  cmpl   $0x0,0xe8(%rsp)
  jle    L5
  imul   $0x32,0xe0(%rsp),%eax
  mov    %eax,0x74(%rsp)
  cltq
  shl    $0x2,%rax
  mov    %rax,0x78(%rsp)
  movslq 0xe0(%rsp),%rax
  shl    $0x2,%rax
  mov    %rax,0x58(%rsp)
  movl   $0x0,0x70(%rsp)
  movq   $0x0,0x68(%rsp)
  movl   $0x0,0x64(%rsp)
  jmp    L146
L89:
  movslq 0x0(%rbp),%rax
  mov    0xd8(%rsp),%rcx
  cmpl   $0x0,(%rcx,%rax,4)
  jne    L103
  movss  (%r12,%rbx,1),%xmm0
  movd   %r13d,%xmm1
  comiss %xmm1,%xmm0
  jbe    L49
  mov    0x10(%rsp),%rax
  mov    (%rax,%rbx,1),%ebx
L233:
  add    0x28(%rsp),%ebx
  movslq %ebx,%rbx
  shl    $0x2,%rbx
  mov    %rbx,%rbp
  add    0xc8(%rsp),%rbp
  mov    0x0(%rbp),%eax
  cmp    $0xffffffff,%eax
  je     L179
L64:
  cltq
  mov    (%r14,%rax,8),%rax
  mov    (%rax,%r15,1),%r13d
  movd   %r13d,%xmm0
  call   <isnan@plt>
  test   %rax,%rax
  je     L89
  mov    (%rsp),%rax
  mov    (%rax,%rbx,1),%ebx
  jmp    L233
L49:
  mov    0x18(%rsp),%rax
  mov    (%rax,%rbx,1),%ebx
  jmp    L233
L103:
  cvttss2si (%r12,%rbx,1),%eax
  imul   0xf0(%rsp),%eax
  movd   %r13d,%xmm2
  cvttss2si %xmm2,%edx
  add    %edx,%eax
  cltq
  mov    0xd0(%rsp),%rsi
  mov    (%rsi,%rax,4),%eax
  cmp    $0xffffffff,%eax
  je     L190
  cmp    $0x1,%eax
  je     L224
  mov    (%rsp),%rax
  mov    (%rax,%rbx,1),%ebx
  jmp    L233
L190:
  mov    0x10(%rsp),%rax
  mov    (%rax,%rbx,1),%ebx
  jmp    L233
L224:
  mov    0x18(%rsp),%rax
  mov    (%rax,%rbx,1),%ebx
  jmp    L233
L179:
  mov    0x8(%rsp),%r13
L189:
  mov    0x38(%rsp),%rax
  movss  (%rax,%r13,4),%xmm0
  addss  (%r12,%rbx,1),%xmm0
  movss  %xmm0,(%rax,%r13,4)
  add    $0x1,%r13
L123:
  mov    0x40(%rsp),%esi
  mov    0x2c(%rsp),%edi
  call   <min@plt>
  cmp    %r13d,%eax
  jle    L139
  mov    0xc8(%rsp),%rax
  mov    0x20(%rsp),%rbx
  mov    (%rax,%rbx,1),%eax
  lea    0x0(,%r13,4),%r15
  mov    0x30(%rsp),%rbp
  cmp    $0xffffffff,%eax
  je     L189
  mov    %r13,0x8(%rsp)
  jmp    L64
L139:
  addl   $0x1,0x44(%rsp)
  mov    0x58(%rsp),%rdi
  add    %rdi,0x20(%rsp)
  mov    0xe0(%rsp),%edi
  add    %edi,0x50(%rsp)
L65:
  mov    0xe8(%rsp),%esi
  mov    0x54(%rsp),%edi
  call   <min@plt>
  cmp    0x44(%rsp),%eax
  jle    L21
  mov    0x50(%rsp),%eax
  mov    %eax,0x28(%rsp)
  mov    0x20(%rsp),%rax
  add    0xc8(%rsp),%rax
  mov    %rax,0x30(%rsp)
  mov    0x48(%rsp),%r15
  mov    0x60(%rsp),%eax
  add    $0x3c,%eax
  mov    %eax,0x2c(%rsp)
  mov    %r15,%r13
  jmp    L123
L21:
  addq   $0x3c,0x48(%rsp)
  mov    0x48(%rsp),%rax
  cmp    %eax,0x40(%rsp)
  jle    L56
L24:
  mov    0x48(%rsp),%eax
  mov    %eax,0x60(%rsp)
  mov    0x70(%rsp),%eax
  mov    %eax,0x50(%rsp)
  mov    0x68(%rsp),%rax
  mov    %rax,0x20(%rsp)
  mov    0x64(%rsp),%eax
  mov    %eax,0x44(%rsp)
  jmp    L65
L56:
  mov    %r14,%r15
L115:
  addl   $0x32,0x64(%rsp)
  mov    0x64(%rsp),%eax
  mov    0x78(%rsp),%rdx
  add    %rdx,0x68(%rsp)
  mov    0x74(%rsp),%edx
  add    %edx,0x70(%rsp)
  cmp    %eax,0xe8(%rsp)
  jle    L5
L146:
  movq   $0x0,0x48(%rsp)
  mov    0x64(%rsp),%eax
  add    $0x32,%eax
  mov    %eax,0x54(%rsp)
  mov    %r15,%r14
  cmpl   $0x0,0x40(%rsp)
  jg     L24
  jmp    L115
L5:
  add    $0x88,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
void innerPredict(float radPredF[], float **dataMatrix, int nCtxs, int left[], int right[], int missing[], float splitCode[], int splitVar[], int cSplits[], int varTypes[], float initialValue, int treeSize, int numTrees, int maxCSplitSize) {
  int tStep = 50;
  int obsStep = 60;
  for (int i = 0; i < nCtxs; i++) {
    radPredF[i] = initialValue;
  }
  for (int t0 = 0; t0 < numTrees; t0 += tStep) {
    for (int obs0 = 0; obs0 < nCtxs; obs0 += obsStep) {
      for (int t = t0; t < min(t0 + tStep, numTrees); t++) {
        int offset = t * treeSize;
        for (int iObs = obs0; iObs < min(obs0 + obsStep, nCtxs); iObs++) {
          int iCurrentNode = 0;
          while (splitVar[offset + iCurrentNode] != -1) {
            float dX = dataMatrix[splitVar[offset + iCurrentNode]][iObs];
            if (isnan(dX)) {
              iCurrentNode = missing[offset + iCurrentNode];
            } else if (varTypes[splitVar[offset + iCurrentNode]] == 0) {
              if (dX < splitCode[offset + iCurrentNode]) {
                iCurrentNode = left[offset + iCurrentNode];
              } else {
                iCurrentNode = right[offset + iCurrentNode];
              }
            } else {
              int iCatSplitIndicator = cSplits[((int)splitCode[offset + iCurrentNode] * maxCSplitSize) + (int)dX];
              if (iCatSplitIndicator == -1) {
                iCurrentNode = left[offset + iCurrentNode];
              } else if (iCatSplitIndicator == 1) {
                iCurrentNode = right[offset + iCurrentNode];
              } else {
                iCurrentNode = missing[offset + iCurrentNode];
              }
            }
          }
          radPredF[iObs] += (float)splitCode[offset + iCurrentNode];
        }
      }
    }
  }
}
```