user: 下面的汇编指令对应的C源代码是什么:

```asm
<workload>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x148000(%rsp),%r11
L16:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L16
  sub    $0x858,%rsp
  xor    %ebx,%ebx
  mov    %fs:0x28,%rax
  mov    %rax,0x148848(%rsp)
  xor    %eax,%eax
  lea    0x840(%rsp),%rax
  mov    %rdi,%r13
  mov    %rsi,%r12
  mov    %rax,%rdi
  mov    %rdx,%rsi
  mov    $0x8000,%edx
  mov    %rcx,%rbp
  mov    %rax,0x30(%rsp)
  sub    $0x800,%rbp
  call   <memcpy@plt>
  lea    0x8840(%rsp),%rax
  mov    %rax,0x38(%rsp)
  lea    0x48840(%rsp),%rax
  mov    %rax,0x10(%rsp)
  lea    0x440(%rsp),%rax
  mov    %rax,0x28(%rsp)
  lea    0x28840(%rsp),%rax
  mov    %rax,0x8(%rsp)
  lea    0xc8840(%rsp),%rax
  mov    %rax,0x18(%rsp)
  lea    0x40(%rsp),%rax
  mov    %rax,0x20(%rsp)
  jmp    L3
  nopl   (%rax)
L20:
  mov    0x38(%rsp),%rcx
  mov    0x10(%rsp),%rsi
  mov    %r13,%rdx
  call   <load@plt>
  mov    0x30(%rsp),%rcx
  mov    0x8(%rsp),%rdx
  mov    %r15d,%edi
  mov    0x18(%rsp),%rsi
  mov    0x28(%rsp),%r8
  mov    $0x80,%r9d
  call   <compute@plt>
  mov    0x20(%rsp),%rdx
  mov    %rbp,%rsi
  mov    %r14d,%edi
  mov    $0x80,%ecx
  call   <store@plt>
L50:
  add    $0x1,%ebx
  add    $0x80000,%r13
  add    $0x20000,%r12
  add    $0x400,%rbp
  cmp    $0x22,%ebx
  je     L0
L3:
  xor    %edi,%edi
  lea    -0x1(%rbx),%eax
  cmp    $0x1f,%ebx
  mov    $0x80,%r9d
  setle  %dil
  xor    %r15d,%r15d
  cmp    $0x1f,%eax
  mov    %r12,%r8
  setbe  %r15b
  xor    %r14d,%r14d
  cmp    $0x1,%ebx
  setg   %r14b
  test   $0x1,%bl
  je     L20
  mov    0x8(%rsp),%rcx
  mov    0x18(%rsp),%rsi
  mov    %r13,%rdx
  call   <load@plt>
  mov    0x30(%rsp),%rcx
  mov    0x38(%rsp),%rdx
  mov    %r15d,%edi
  mov    0x10(%rsp),%rsi
  mov    0x20(%rsp),%r8
  mov    $0x80,%r9d
  call   <compute@plt>
  mov    0x28(%rsp),%rdx
  mov    %rbp,%rsi
  mov    %r14d,%edi
  mov    $0x80,%ecx
  call   <store@plt>
  jmp    L50
  nopw   0x0(%rax,%rax,1)
L0:
  mov    0x148848(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L33
  add    $0x148858,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L33:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void workload(double *nzval, short *cols, double *vec, double *out) {
#pragma HLS INTERFACE m_axi port = nzval offset = slave bundle = gmem1
#pragma HLS INTERFACE m_axi port = cols offset = slave bundle = gmem2
#pragma HLS INTERFACE m_axi port = vec offset = slave bundle = gmem1
#pragma HLS INTERFACE m_axi port = out offset = slave bundle = gmem1
#pragma HLS INTERFACE s_axilite port = nzval bundle = control
#pragma HLS INTERFACE s_axilite port = cols bundle = control
#pragma HLS INTERFACE s_axilite port = vec bundle = control
#pragma HLS INTERFACE s_axilite port = out bundle = control
#pragma HLS INTERFACE s_axilite port = return bundle = control
  int num_tiles = ((1 << 12) + 128 - 1) / 128;
  int tail_rows = (1 << 12) % 128;
  if (tail_rows == 0)
    tail_rows = 128;
  double local_nzval_x[4][((128 + 4 - 1) / 4)][(1 << 9)];
#pragma HLS array_partition variable = local_nzval_x dim = 1 complete
  short local_cols_x[4][((128 + 4 - 1) / 4)][(1 << 9)];
#pragma HLS array_partition variable = local_cols_x dim = 1 complete
  double local_nzval_y[4][((128 + 4 - 1) / 4)][(1 << 9)];
#pragma HLS array_partition variable = local_nzval_y dim = 1 complete
  short local_cols_y[4][((128 + 4 - 1) / 4)][(1 << 9)];
#pragma HLS array_partition variable = local_cols_y dim = 1 complete
  double local_vec[(1 << 12)];
  memcpy(local_vec, vec, sizeof(double) * (1 << 12));
  double local_out_x[4][((128 + 4 - 1) / 4)];
#pragma HLS array_partition variable = local_out_x dim = 1 complete
  double local_out_y[4][((128 + 4 - 1) / 4)];
#pragma HLS array_partition variable = local_out_y dim = 1 complete
  int i, j, k;
  for (i = 0; i < num_tiles + 2; i++) {
    int load_flag = i < num_tiles;
    int compute_flag = i > 0 && i < num_tiles + 1;
    int store_flag = i > 1;
    int load_rows = i == num_tiles - 1 ? tail_rows : 128;
    int compute_rows = i == num_tiles ? tail_rows : 128;
    int store_rows = i == num_tiles + 1 ? tail_rows : 128;
    if (i % 2 == 0) {
      load(load_flag, local_nzval_x, nzval + i * 128 * (1 << 9), local_cols_x, cols + i * 128 * (1 << 9), load_rows);
      compute(compute_flag, local_nzval_y, local_cols_y, local_vec, local_out_y, compute_rows);
      store(store_flag, out + (i - 2) * 128, local_out_x, store_rows);
    } else {
      load(load_flag, local_nzval_y, nzval + i * 128 * (1 << 9), local_cols_y, cols + i * 128 * (1 << 9), load_rows);
      compute(compute_flag, local_nzval_x, local_cols_x, local_vec, local_out_x, compute_rows);
      store(store_flag, out + (i - 2) * 128, local_out_y, store_rows);
    }
  }
  return;
}
```