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

```asm
<lud_omp>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbx
  and    $0xffffffffffffffc0,%rsp
  sub    $0x940,%rsp
  mov    %esi,0x9c(%rsp)
  mov    %rdi,0xb0(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x938(%rsp)
  xor    %eax,%eax
  movslq %esi,%rax
  lea    -0x10(%rax),%esi
  mov    %esi,0x5c(%rsp)
  test   %esi,%esi
  jle    L165
  mov    %eax,%esi
  lea    0x0(,%rax,4),%r15
  xor    %r10d,%r10d
  mov    %rdi,0xb8(%rsp)
  shl    $0x4,%esi
  lea    0x4(%r15),%r9
  lea    0x540(%rsp),%rax
  movl   $0x0,0x78(%rsp)
  movslq %esi,%rbx
  mov    %esi,0x3c(%rsp)
  mov    %r9,%r12
  mov    %r10,%r13
  lea    0x40(,%rbx,4),%rcx
  mov    %esi,0x64(%rsp)
  mov    %rcx,0x40(%rsp)
  movq   $0x0,0xa0(%rsp)
  mov    %rax,0x80(%rsp)
  mov    %rbx,0x48(%rsp)
  shl    $0x2,%rbx
  mov    %rbx,0x50(%rsp)
  lea    0x500(%rsp),%rbx
L62:
  mov    0x9c(%rsp),%r14d
  mov    0xb0(%rsp),%rdi
  mov    %r13d,%edx
  mov    %r13d,0x58(%rsp)
  mov    %r14d,%esi
  call   <lud_diagonal_omp@plt>
  mov    0x5c(%rsp),%edx
  sub    %r13d,%edx
  lea    0xf(%rdx),%eax
  cmovns %edx,%eax
  sar    $0x4,%eax
  mov    %eax,0x60(%rsp)
  imul   %eax,%eax
  mov    %eax,0x7c(%rsp)
  mov    %r14d,%eax
  sub    %r13d,%eax
  cmp    $0x1f,%eax
  jle    L71
  movslq 0x64(%rsp),%rax
  lea    0x10(%r13),%rsi
  mov    0xb0(%rsp),%rdi
  movl   $0x0,0x98(%rsp)
  lea    0x10(%r13),%ecx
  pxor   %xmm3,%xmm3
  add    %r13,%rax
  lea    (%rdi,%rax,4),%rax
  mov    %rax,0x70(%rsp)
  movslq 0x78(%rsp),%rax
  lea    (%rsi,%rax,1),%rdx
  lea    (%rdi,%rdx,4),%rdi
  mov    0xa0(%rsp),%rdx
  mov    %rdi,0x68(%rsp)
  sub    %rax,%rdx
  lea    0x0(,%rdx,4),%rax
  mov    %rax,0xa8(%rsp)
  lea    0x540(%rsp),%rax
  mov    %rax,0x90(%rsp)
  lea    0x900(%rsp),%rax
  mov    %rax,0x30(%rsp)
  lea    0x44(%rbx),%rax
  mov    %rax,0x88(%rsp)
L104:
  mov    0xb8(%rsp),%rdx
  mov    0x30(%rsp),%rdi
  mov    %rbx,%rax
L56:
  movdqu (%rdx),%xmm4
  add    $0x40,%rax
  movups %xmm4,-0x40(%rax)
  movdqu 0x10(%rdx),%xmm5
  movups %xmm5,-0x30(%rax)
  movdqu 0x20(%rdx),%xmm6
  movups %xmm6,-0x20(%rax)
  movdqu 0x30(%rdx),%xmm7
  add    %r15,%rdx
  movups %xmm7,-0x10(%rax)
  cmp    %rdi,%rax
  jne    L56
  addl   $0x1,0x98(%rsp)
  mov    0x68(%rsp),%r11
  mov    %ecx,%r14d
  lea    0x10(%rcx),%r8d
L244:
  mov    0xa8(%rsp),%rax
  mov    0x90(%rsp),%r10
  xor    %r9d,%r9d
  movaps %xmm3,%xmm1
  mov    0x88(%rsp),%rcx
  lea    (%r11,%rax,1),%rdi
  nopl   0x0(%rax)
L105:
  movss  (%rdi),%xmm0
  add    $0x1,%r9d
  subss  %xmm1,%xmm0
  movss  %xmm0,(%rdi)
  cmp    $0x10,%r9d
  je     L189
  mov    %r11,%rdx
  mov    %r10,%rax
  movaps %xmm3,%xmm1
  nop
L258:
  movss  (%rax),%xmm0
  mulss  (%rdx),%xmm0
  add    $0x4,%rax
  add    %r15,%rdx
  addss  %xmm0,%xmm1
  cmp    %rax,%rcx
  jne    L258
  add    %r15,%rdi
  add    $0x40,%r10
  add    $0x44,%rcx
  jmp    L105
L189:
  add    $0x1,%r14d
  add    $0x4,%r11
  cmp    %r8d,%r14d
  jne    L244
  mov    0x70(%rsp),%r9
  mov    $0x10,%r14d
L223:
  mov    0x80(%rsp),%rcx
  mov    %rbx,%r11
  mov    $0x1,%edi
  movaps %xmm3,%xmm1
  mov    0xb8(%rsp),%r10
  nopl   0x0(%rax,%rax,1)
L65:
  movss  -0x4(%r9,%rdi,4),%xmm0
  subss  %xmm1,%xmm0
  divss  (%r10),%xmm0
  movss  %xmm0,-0x4(%r9,%rdi,4)
  cmp    $0x10,%rdi
  je     L141
  mov    %r11,%rax
  mov    %r9,%rdx
  movaps %xmm3,%xmm1
  cs nopw 0x0(%rax,%rax,1)
L13:
  movss  (%rdx),%xmm0
  mulss  0x4(%rax),%xmm0
  add    $0x40,%rax
  add    $0x4,%rdx
  addss  %xmm0,%xmm1
  cmp    %rax,%rcx
  jne    L13
  add    $0x1,%rdi
  add    %r12,%r10
  add    $0x4,%r11
  add    $0x44,%rcx
  jmp    L65
L141:
  add    %r15,%r9
  sub    $0x1,%r14d
  jne    L223
  mov    0x50(%rsp),%rdi
  addq   $0x40,0x68(%rsp)
  add    %rdi,0x70(%rsp)
  mov    0x60(%rsp),%edi
  cmp    %edi,0x98(%rsp)
  jge    L237
  mov    %r8d,%ecx
  jmp    L104
L71:
  mov    0x7c(%rsp),%eax
  lea    0x10(%r13),%rsi
  test   %eax,%eax
  jne    L59
L60:
  mov    %rsi,%r13
  mov    0x48(%rsp),%rsi
  add    %rsi,0xa0(%rsp)
  mov    0x40(%rsp),%rsi
  add    %rsi,0xb8(%rsp)
  mov    0x3c(%rsp),%esi
  add    %esi,0x78(%rsp)
  add    %esi,0x64(%rsp)
  cmp    %r13d,0x5c(%rsp)
  jg     L62
  mov    0x9c(%rsp),%eax
  sub    $0x11,%eax
  and    $0xfffffff0,%eax
  lea    0x10(%rax),%edx
L94:
  mov    0x938(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L97
  mov    0x9c(%rsp),%esi
  mov    0xb0(%rsp),%rdi
  lea    -0x28(%rbp),%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  jmp    1060 <lud_diagonal_omp@plt>
L59:
  pxor   %xmm3,%xmm3
L237:
  sub    0xa0(%rsp),%r13
  lea    0x100(%rsp),%rcx
  movl   $0x0,0xa8(%rsp)
  lea    0xc0(%rsp),%r10
  mov    %r13,0x90(%rsp)
L259:
  mov    0xa8(%rsp),%eax
  mov    0x58(%rsp),%edi
  pxor   %xmm0,%xmm0
  mov    %rbx,%r11
  mov    0xb0(%rsp),%r14
  movaps %xmm0,0xc0(%rsp)
  cltd
  movaps %xmm0,0xd0(%rsp)
  idivl  0x60(%rsp)
  movaps %xmm0,0xe0(%rsp)
  movaps %xmm0,0xf0(%rsp)
  lea    0x1(%rax),%r8d
  lea    0x1(%rdx),%r13d
  mov    0xa0(%rsp),%rdx
  mov    0x90(%rsp),%rax
  shl    $0x4,%r8d
  shl    $0x4,%r13d
  add    %edi,%r8d
  add    %edi,%r13d
  mov    %rbx,%rdi
  imul   0x9c(%rsp),%r8d
  movslq %r13d,%r13
  add    %r13,%rdx
  lea    (%r14,%rdx,4),%rdx
  movslq %r8d,%r8
  lea    (%rax,%r8,1),%r14
  mov    %rcx,%rax
  sub    %r13,%r14
  shl    $0x2,%r14
L181:
  movdqu (%rdx),%xmm4
  lea    (%r14,%rdx,1),%r9
  add    $0x40,%rax
  add    $0x40,%rdi
  movups %xmm4,-0x40(%rax)
  movdqu 0x10(%rdx),%xmm5
  movups %xmm5,-0x30(%rax)
  movdqu 0x20(%rdx),%xmm6
  movups %xmm6,-0x20(%rax)
  movdqu 0x30(%rdx),%xmm7
  add    %r15,%rdx
  movups %xmm7,-0x10(%rax)
  movdqu (%r9),%xmm4
  movups %xmm4,-0x40(%rdi)
  movdqu 0x10(%r9),%xmm5
  movups %xmm5,-0x30(%rdi)
  movdqu 0x20(%r9),%xmm6
  movups %xmm6,-0x20(%rdi)
  movdqu 0x30(%r9),%xmm7
  movups %xmm7,-0x10(%rdi)
  cmp    %rax,%rbx
  jne    L181
  mov    0xb0(%rsp),%rax
  add    %r13,%r8
  lea    0x400(%rbx),%r14
  movaps %xmm3,%xmm0
  lea    (%rax,%r8,4),%r13
L36:
  mov    %rcx,%r8
  mov    %r11,%r9
  nopw   0x0(%rax,%rax,1)
L72:
  movss  (%r9),%xmm2
  mov    %r10,%rdi
  mov    %r10,%rax
  mov    %r8,%rdx
  jmp    L253
  nopl   0x0(%rax,%rax,1)
L157:
  movss  (%rax),%xmm0
L253:
  movss  (%rdx),%xmm1
  add    $0x4,%rax
  add    $0x4,%rdx
  mulss  %xmm2,%xmm1
  addss  %xmm1,%xmm0
  movss  %xmm0,-0x4(%rax)
  cmp    %rcx,%rax
  jne    L157
  add    $0x40,%r8
  add    $0x4,%r9
  movss  0xc0(%rsp),%xmm0
  cmp    %r8,%rbx
  jne    L72
  mov    %r13,%rax
  nopl   0x0(%rax,%rax,1)
L139:
  movss  (%rax),%xmm0
  subss  (%rdi),%xmm0
  add    $0x4,%rdi
  add    $0x4,%rax
  movl   $0x0,-0x4(%rdi)
  movss  %xmm0,-0x4(%rax)
  cmp    %rdi,%rcx
  jne    L139
  add    $0x40,%r11
  add    %r15,%r13
  cmp    %r11,%r14
  je     L78
  movss  0xc0(%rsp),%xmm0
  jmp    L36
L78:
  addl   $0x1,0xa8(%rsp)
  mov    0xa8(%rsp),%eax
  cmp    0x7c(%rsp),%eax
  jl     L259
  jmp    L60
L165:
  xor    %edx,%edx
  jmp    L94
L97:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void lud_omp(float *a, int size) {
#pragma omp_to_hclib
  {
    int offset, chunk_idx, size_inter, chunks_in_inter_row, chunks_per_inter;
    for (offset = 0; offset < size - 16; offset += 16) {
      lud_diagonal_omp(a, size, offset);
      size_inter = size - offset - 16;
      chunks_in_inter_row = size_inter / 16;
#pragma omp parallel for default(none) private(chunk_idx) firstprivate(size, a) shared(chunks_per_inter, chunks_in_inter_row, offset)
      for (chunk_idx = 0; chunk_idx < chunks_in_inter_row; chunk_idx++) {
        int i, j, k, i_global, j_global, i_here, j_here;
        float sum;
        float temp[16 * 16] __attribute__((aligned(64)));
        for (i = 0; i < 16; i++) {
#pragma omp simd
          for (j = 0; j < 16; j++) {
            temp[i * 16 + j] = a[size * (i + offset) + offset + j];
          }
        }
        i_global = offset;
        j_global = offset;
        j_global += 16 * (chunk_idx + 1);
        for (j = 0; j < 16; j++) {
          for (i = 0; i < 16; i++) {
            sum = 0.f;
            for (k = 0; k < i; k++) {
              sum += temp[16 * i + k] * a[(i_global + k) * size + (j_global + j)];
            }
            i_here = i_global + i;
            j_here = j_global + j;
            a[i_here * size + j_here] = a[i_here * size + j_here] - sum;
          }
        }
        j_global = offset;
        i_global += 16 * (chunk_idx + 1);
        for (i = 0; i < 16; i++) {
          for (j = 0; j < 16; j++) {
            sum = 0.f;
            for (k = 0; k < j; k++) {
              sum += a[(i_global + i) * size + (j_global + k)] * temp[16 * k + j];
            }
            i_here = i_global + i;
            j_here = j_global + j;
            a[size * i_here + j_here] = (a[size * i_here + j_here] - sum) / a[size * (offset + j) + offset + j];
          }
        }
      }
      chunks_per_inter = chunks_in_inter_row * chunks_in_inter_row;
#pragma omp parallel for schedule(auto) default(none) private(chunk_idx) firstprivate(size, a) shared(chunks_per_inter, chunks_in_inter_row, offset)
      for (chunk_idx = 0; chunk_idx < chunks_per_inter; chunk_idx++) {
        int i, j, k, i_global, j_global;
        float temp_top[16 * 16] __attribute__((aligned(64)));
        float temp_left[16 * 16] __attribute__((aligned(64)));
        float sum[16] __attribute__((aligned(64))) = {0.f};
        i_global = offset + 16 * (1 + chunk_idx / chunks_in_inter_row);
        j_global = offset + 16 * (1 + chunk_idx % chunks_in_inter_row);
        for (i = 0; i < 16; i++) {
#pragma omp simd
          for (j = 0; j < 16; j++) {
            temp_top[i * 16 + j] = a[size * (i + offset) + j + j_global];
            temp_left[i * 16 + j] = a[size * (i + i_global) + offset + j];
          }
        }
        for (i = 0; i < 16; i++) {
          for (k = 0; k < 16; k++) {
#pragma omp simd
            for (j = 0; j < 16; j++) {
              sum[j] += temp_left[16 * i + k] * temp_top[16 * k + j];
            }
          }
#pragma omp simd
          for (j = 0; j < 16; j++) {
            a[(i + i_global) * size + (j + j_global)] -= sum[j];
            sum[j] = 0.f;
          }
        }
      }
    }
    lud_diagonal_omp(a, size, offset);
  }
}
```