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

```asm
<f_prob>:
  endbr64
  test   %edi,%edi
  jns    L43
  mov    $0x0,%eax
  ret
L43:
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x8,%rsp
  mov    %edi,%r12d
  mov    %r8,%rbx
  mov    %rsi,%rdi
  call   <code_table_4_9_location@plt>
  mov    %rax,%rbp
  test   %rax,%rax
  je     L111
  movzbl (%rax),%edx
  lea    D41(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <sprintf@plt>
  cmpb   $0x4,0x0(%rbp)
  ja     L123
  movzbl 0x0(%rbp),%eax
  lea    D94(%rip),%rdx
  movslq (%rdx,%rax,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    0x2(%rbp),%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x1(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  cvttsd2si %xmm0,%edx
  movzbl %dl,%edx
  lea    D36(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <sprintf@plt>
L123:
  cmp    $0x63,%r12d
  je     L107
L52:
  mov    %rbx,%rdi
  call   <strlen@plt>
  movzbl -0x1(%rbp),%ecx
  movzbl -0x2(%rbp),%edx
  cltq
  lea    (%rbx,%rax,1),%rdi
  lea    D19(%rip),%rsi
  mov    $0x0,%eax
  call   <sprintf@plt>
L111:
  mov    $0x0,%eax
  add    $0x8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  lea    0x7(%rbp),%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x6(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  cvttsd2si %xmm0,%edx
  movzbl %dl,%edx
  lea    D79(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <sprintf@plt>
  jmp    L123
  lea    0x2(%rbp),%r14
  mov    %r14,%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x1(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  movq   %xmm0,%r13
  lea    0x7(%rbp),%r15
  mov    %r15,%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x6(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  movq   %r13,%xmm1
  ucomisd %xmm0,%xmm1
  jp     L129
  jne    L129
  mov    %r14,%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x1(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  cvttsd2si %xmm0,%edx
  movzbl %dl,%edx
  lea    D70(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <sprintf@plt>
  jmp    L123
L129:
  mov    %r15,%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x6(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  movq   %xmm0,%r13
  mov    %r14,%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x1(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  cvttsd2si %xmm0,%edx
  movzbl %dl,%edx
  movq   %r13,%xmm0
  lea    D91(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x1,%eax
  call   <sprintf@plt>
  jmp    L123
  lea    0x2(%rbp),%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x1(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  cvttsd2si %xmm0,%edx
  movzbl %dl,%edx
  lea    D79(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <sprintf@plt>
  jmp    L123
  lea    0x7(%rbp),%rdi
  call   <int4@plt>
  mov    %eax,%esi
  movzbl 0x6(%rbp),%edx
  mov    %edx,%eax
  and    $0x7f,%eax
  neg    %eax
  mov    %edx,%edi
  and    $0x7f,%edi
  test   %dl,%dl
  cmovs  %eax,%edi
  call   <scaled2flt@plt>
  cvttsd2si %xmm0,%edx
  movzbl %dl,%edx
  lea    D36(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <sprintf@plt>
  jmp    L123
L107:
  mov    %rbx,%rdi
  call   <strlen@plt>
  cltq
  add    %rax,%rbx
  movzbl 0x5(%rbp),%esi
  movzbl 0x4(%rbp),%r9d
  movzbl 0x3(%rbp),%r8d
  movzbl 0x2(%rbp),%ecx
  movzbl 0x1(%rbp),%eax
  mov    %eax,%edx
  and    $0x7f,%edx
  test   %al,%al
  js     L91
L96:
  sub    $0x8,%rsp
  push   %rsi
  lea    D90(%rip),%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <sprintf@plt>
  add    $0x10,%rsp
  jmp    L52
L91:
  and    $0x7f,%eax
  neg    %eax
  movzbl %al,%edx
  jmp    L96
```

tool_calls: name: read_data
arguments: data_tag: D41
type_guessed: string
name: read_data
arguments: data_tag: D36
type_guessed: string
name: read_data
arguments: data_tag: D19
type_guessed: string
name: read_data
arguments: data_tag: D79
type_guessed: string
name: read_data
arguments: data_tag: D70
type_guessed: string
name: read_data
arguments: data_tag: D91
type_guessed: string
name: read_data
arguments: data_tag: D90
type_guessed: string

tool: D41: probtype=%d 

tool: D36: prob <%g

tool: D19: :prob fcst %u/%u

tool: D79: prob >%g

tool: D70: prob =%g

tool: D91: prob >=%g <%g

tool: D90:  LOWER LIMIT scale=%d, val= 0x%.2x 0x%.2x 0x%.2x 0x%.2x

assistant: ```c
int f_prob(int mode, unsigned char **sec, float *data, unsigned int ndata, char *inv_out, void **local) {
  unsigned char *p;
  if (mode == -1) {
    return 0;
  } else if (mode >= 0) {
    p = code_table_4_9_location(sec);
    if (p == NULL)
      return 0;
    sprintf(inv_out, "probtype=%d ", *p);
    switch (*p) {
    case 0:
      sprintf(inv_out, "prob <%g", scaled2flt(((p[1] & 0x80) ? -(int)(p[1] & 127) : (int)(p[1] & 127)), int4(p + 2)));
      break;
    case 1:
      sprintf(inv_out, "prob >%g", scaled2flt(((p[6] & 0x80) ? -(int)(p[6] & 127) : (int)(p[6] & 127)), int4(p + 7)));
      break;
    case 2:
      if (scaled2flt(((p[1] & 0x80) ? -(int)(p[1] & 127) : (int)(p[1] & 127)), int4(p + 2)) == scaled2flt(((p[6] & 0x80) ? -(int)(p[6] & 127) : (int)(p[6] & 127)), int4(p + 7))) {
        sprintf(inv_out, "prob =%g", scaled2flt(((p[1] & 0x80) ? -(int)(p[1] & 127) : (int)(p[1] & 127)), int4(p + 2)));
        break;
      }
      sprintf(inv_out, "prob >=%g <%g", scaled2flt(((p[1] & 0x80) ? -(int)(p[1] & 127) : (int)(p[1] & 127)), int4(p + 2)), scaled2flt(((p[6] & 0x80) ? -(int)(p[6] & 127) : (int)(p[6] & 127)), int4(p + 7)));
      break;
    case 3:
      sprintf(inv_out, "prob >%g", scaled2flt(((p[1] & 0x80) ? -(int)(p[1] & 127) : (int)(p[1] & 127)), int4(p + 2)));
      break;
    case 4:
      sprintf(inv_out, "prob <%g", scaled2flt(((p[6] & 0x80) ? -(int)(p[6] & 127) : (int)(p[6] & 127)), int4(p + 7)));
      break;
    }
    if (mode == 99) {
      inv_out += strlen(inv_out);
      sprintf(inv_out, " LOWER LIMIT scale=%d, val= 0x%.2x 0x%.2x 0x%.2x 0x%.2x", ((p[1] & 0x80) ? -(int)(p[1] & 127) : (int)(p[1] & 127)), p[2], p[3], p[4], p[5]);
    }
    inv_out += strlen(inv_out);
    sprintf(inv_out, ":prob fcst %u/%u", p[-2], p[-1]);
  }
  return 0;
}
```