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

```asm
<RGBE_to_RGBdivA>:
  endbr64
  push   %r12
  mov    %edx,%r12d
  push   %rbp
  push   %rbx
  sub    $0x10,%rsp
  test   %esi,%esi
  setle  %al
  test   %edx,%edx
  setle  %dl
  or     %dl,%al
  jne    L96
  mov    %rdi,%rbx
  test   %rdi,%rdi
  je     L96
  movss  D56(%rip),%xmm7
  mov    %esi,%ebp
  movss  %xmm7,0xc(%rsp)
  test   %ecx,%ecx
  jne    L94
L33:
  imul   %r12d,%ebp
  movslq %ebp,%rbp
  lea    (%rbx,%rbp,4),%rbp
  jmp    L14
  nopw   0x0(%rax,%rax,1)
L17:
  mulss  D62(%rip),%xmm2
  mov    $0xffffffff,%eax
  mulss  D62(%rip),%xmm1
  mulss  D62(%rip),%xmm0
L46:
  addss  %xmm4,%xmm2
  mov    %al,0x3(%rbx)
  mov    $0xff,%edx
  addss  %xmm4,%xmm1
  addss  %xmm4,%xmm0
  cvttss2si %xmm2,%eax
  cmp    %edx,%eax
  cmovg  %edx,%eax
  mov    %al,(%rbx)
  cvttss2si %xmm1,%eax
  cmp    %edx,%eax
  cmovg  %edx,%eax
  mov    %al,0x1(%rbx)
  cvttss2si %xmm0,%eax
  cmp    %edx,%eax
  cmovg  %edx,%eax
  add    $0x4,%rbx
  mov    %al,-0x2(%rbx)
  cmp    %rbx,%rbp
  je     L13
L14:
  movzbl 0x3(%rbx),%edi
  movss  D33(%rip),%xmm0
  add    $0xffffff80,%edi
  call   <ldexp@plt>
  movzbl (%rbx),%eax
  pxor   %xmm2,%xmm2
  pxor   %xmm1,%xmm1
  movss  0xc(%rsp),%xmm3
  pxor   %xmm5,%xmm5
  movss  D59(%rip),%xmm4
  cvtsi2ss %eax,%xmm2
  movzbl 0x1(%rbx),%eax
  mulss  %xmm0,%xmm3
  pxor   %xmm0,%xmm0
  cvtsi2ss %eax,%xmm1
  movzbl 0x2(%rbx),%eax
  cvtsi2ss %eax,%xmm0
  mulss  %xmm3,%xmm2
  mulss  %xmm3,%xmm1
  mulss  %xmm3,%xmm0
  movaps %xmm2,%xmm3
  maxss  %xmm1,%xmm3
  movaps %xmm0,%xmm6
  maxss  %xmm3,%xmm6
  ucomiss %xmm5,%xmm6
  movaps %xmm6,%xmm3
  jp     L30
  mov    $0x1,%eax
  je     L46
L30:
  movss  D62(%rip),%xmm5
  divss  %xmm3,%xmm5
  pxor   %xmm3,%xmm3
  cvttss2si %xmm5,%eax
  cvtsi2ss %eax,%xmm3
  cvttss2si %xmm3,%eax
  cmp    $0xff,%eax
  jg     L17
  test   %eax,%eax
  mov    $0x1,%edx
  pxor   %xmm3,%xmm3
  cmovg  %eax,%edx
  cvtsi2ss %edx,%xmm3
  mov    %edx,%eax
  mulss  %xmm3,%xmm2
  mulss  %xmm3,%xmm1
  mulss  %xmm3,%xmm0
  jmp    L46
  nop
L96:
  add    $0x10,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
  nopl   0x0(%rax,%rax,1)
L13:
  add    $0x10,%rsp
  mov    $0x1,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
  xchg   %ax,%ax
L94:
  mov    %r12d,%edx
  call   <find_max_RGBE@plt>
  movss  D62(%rip),%xmm1
  divss  %xmm0,%xmm1
  movss  %xmm1,0xc(%rsp)
  jmp    L33
```

tool_calls: name: read_data
arguments: data_tag: D56
type_guessed: byte[4]
name: read_data
arguments: data_tag: D62
type_guessed: byte[4]
name: read_data
arguments: data_tag: D33
type_guessed: byte[4]
name: read_data
arguments: data_tag: D59
type_guessed: byte[4]

tool: {"D56": [0x00,0x00,0x80,0x3f]}

tool: {"D62": [0x00,0x00,0x7f,0x43]}

tool: {"D33": [0x81,0x80,0x80,0x3b]}

tool: {"D59": [0x00,0x00,0x00,0x3f]}

assistant: ```c
int RGBE_to_RGBdivA(unsigned char *image, int width, int height, int rescale_to_max) {
  int i, iv;
  unsigned char *img = image;
  float scale = 1.0f;
  if ((!image) || (width < 1) || (height < 1)) {
    return 0;
  }
  if (rescale_to_max) {
    scale = 255.0f / find_max_RGBE(image, width, height);
  }
  for (i = width * height; i > 0; --i) {
    float r, g, b, e, m;
    e = scale * ldexp(1.0f / 255.0f, (int)(img[3]) - 128);
    r = e * img[0];
    g = e * img[1];
    b = e * img[2];
    m = (r > g) ? r : g;
    m = (b > m) ? b : m;
    iv = (int)((m != 0.0f) ? (int)(255.0f / m) : 1.0f);
    iv = (iv < 1) ? 1 : iv;
    img[3] = (unsigned char)((iv > 255) ? 255 : iv);
    iv = (int)(img[3] * r + 0.5f);
    img[0] = (unsigned char)((iv > 255) ? 255 : iv);
    iv = (int)(img[3] * g + 0.5f);
    img[1] = (unsigned char)((iv > 255) ? 255 : iv);
    iv = (int)(img[3] * b + 0.5f);
    img[2] = (unsigned char)((iv > 255) ? 255 : iv);
    img += 4;
  }
  return 1;
}
```