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

```asm
<layer_cloud>:
  endbr64
  test   %r8,%r8
  jle    L93
  mov    %rdx,%r10
  lea    0x1(%rdx),%r9
  mov    %r8,%rdx
  mov    %rdi,%r11
  imul   %r10,%rdx
  mov    %rcx,%rdi
  push   %rbx
  lea    0x8(,%rdx,8),%rax
  lea    (%r11,%rax,1),%rcx
  cmp    %rcx,%rsi
  je     L40
  lea    -0x1(%r8),%rcx
  cmp    $0x1,%rcx
  jbe    L40
  mov    %r8,%rcx
  movapd D23(%rip),%xmm0
  lea    -0x8(%r11,%rax,1),%rbx
  xor    %eax,%eax
  shr    %rcx
  shl    $0x4,%rcx
  xchg   %ax,%ax
L68:
  movupd (%rbx,%rax,1),%xmm7
  movapd %xmm0,%xmm1
  subpd  %xmm7,%xmm1
  movups %xmm1,(%rsi,%rax,1)
  add    $0x10,%rax
  cmp    %rcx,%rax
  jne    L68
  mov    %r8,%rcx
  and    $0xfffffffffffffffe,%rcx
  test   $0x1,%r8b
  je     L117
  lea    (%rdx,%rcx,1),%rax
  movsd  D23(%rip),%xmm3
  subsd  (%r11,%rax,8),%xmm3
  movsd  %xmm3,(%rsi,%rcx,8)
L117:
  cmp    %r9,%rdi
  jl     L139
  mov    %r10,%rax
  movsd  D23(%rip),%xmm3
  movsd  D17(%rip),%xmm4
  lea    0x0(,%r8,8),%r10
  imul   %r8,%rax
  movsd  D69(%rip),%xmm5
  lea    (%r11,%rax,8),%rcx
  add    %r8,%rax
  lea    (%r11,%rax,8),%rdx
  nopl   0x0(%rax)
L1:
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L148:
  movsd  (%rcx,%rax,8),%xmm0
  comisd %xmm0,%xmm4
  movapd %xmm0,%xmm2
  maxsd  (%rdx,%rax,8),%xmm2
  jbe    L17
  movapd %xmm3,%xmm1
  subsd  %xmm2,%xmm1
  movapd %xmm3,%xmm2
  subsd  %xmm0,%xmm2
  movsd  (%rsi,%rax,8),%xmm0
  divsd  %xmm2,%xmm1
  mulsd  %xmm1,%xmm0
  movsd  %xmm0,(%rsi,%rax,8)
  add    $0x1,%rax
  cmp    %r8,%rax
  jne    L148
  add    $0x1,%r9
  add    %r10,%rcx
  add    %r10,%rdx
  cmp    %r9,%rdi
  jge    L1
L139:
  cmp    $0x1,%r8
  je     L44
  mov    %r8,%rdx
  movapd D23(%rip),%xmm0
  mov    %rsi,%rax
  shr    %rdx
  shl    $0x4,%rdx
  add    %rsi,%rdx
  nopl   0x0(%rax)
L176:
  movupd (%rax),%xmm6
  movapd %xmm0,%xmm1
  add    $0x10,%rax
  subpd  %xmm6,%xmm1
  movups %xmm1,-0x10(%rax)
  cmp    %rdx,%rax
  jne    L176
  mov    %r8,%rax
  and    $0xfffffffffffffffe,%rax
  and    $0x1,%r8d
  je     L35
L82:
  lea    (%rsi,%rax,8),%rax
  movsd  D23(%rip),%xmm0
  subsd  (%rax),%xmm0
  movsd  %xmm0,(%rax)
L35:
  pop    %rbx
  ret
  nopl   0x0(%rax)
L17:
  movapd %xmm3,%xmm0
  subsd  %xmm2,%xmm0
  divsd  %xmm5,%xmm0
  mulsd  (%rsi,%rax,8),%xmm0
  movsd  %xmm0,(%rsi,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%r8
  jne    L148
  add    $0x1,%r9
  add    %r10,%rcx
  add    %r10,%rdx
  cmp    %r9,%rdi
  jge    L1
  jmp    L139
L40:
  movsd  D23(%rip),%xmm3
  lea    (%r11,%rdx,8),%rdx
  xor    %eax,%eax
  nopl   0x0(%rax)
L110:
  movapd %xmm3,%xmm0
  subsd  (%rdx,%rax,8),%xmm0
  movsd  %xmm0,(%rsi,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%r8
  jne    L110
  jmp    L117
L93:
  ret
L44:
  xor    %eax,%eax
  jmp    L82
```

tool_calls: name: retrieve_data
arguments: tag: D23
data_type: f64[2]
name: retrieve_data
arguments: tag: D17
data_type: byte[8]
name: retrieve_data
arguments: tag: D69
data_type: byte[8]

tool: {"D23": [1.0,1.0]}

tool: {"D17": [0xd1,0xdc,0xff,0xff,0xff,0xff,0xef,0x3f]}

tool: {"D69": [0x00,0x00,0x00,0x00,0x80,0x97,0x71,0x3d]}

assistant: ```c
void layer_cloud(const double *cc, double *ll, long MaxLev, long MinLev, long dimgp) {
  long i, k;
  double maxval, minval;
  double ZEPSEC;
  ZEPSEC = 1. - 1.0e-12;
  for (i = 0; i < dimgp; i++)
    ll[i] = 1. - cc[i + MaxLev * dimgp];
  for (k = MaxLev + 1; k <= MinLev; k++) {
    for (i = 0; i < dimgp; i++) {
      maxval = ((cc[i + (k - 1) * dimgp]) > (cc[i + k * dimgp]) ? (cc[i + (k - 1) * dimgp]) : (cc[i + k * dimgp]));
      minval = ((cc[i + (k - 1) * dimgp]) < (ZEPSEC) ? (cc[i + (k - 1) * dimgp]) : (ZEPSEC));
      ll[i] *= (1. - maxval) / (1. - minval);
    }
  }
  for (i = 0; i < dimgp; i++)
    ll[i] = 1. - ll[i];
}
```