user: 请显示与下面列出的汇编代码相匹配的C语言实现：

```asm
<blocked_multiplication>:
  endbr64
  push   %r15
  lea    0xc000(%rdi),%rax
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0xd8,%rsp
  mov    %rax,0x50(%rsp)
  lea    0x80(%rdx),%rax
  mov    %rdi,0x38(%rsp)
  mov    %rsi,-0x50(%rsp)
  mov    %rax,0x68(%rsp)
L31:
  mov    -0x50(%rsp),%rax
  movl   $0x0,0x44(%rsp)
  movq   $0x0,0x30(%rsp)
  lea    0xc000(%rax),%rbx
  lea    0x18000(%rax),%rsi
  lea    0x3c000(%rax),%rdi
  mov    %rbx,-0x48(%rsp)
  lea    0x24000(%rax),%rbx
  mov    %rsi,-0x40(%rsp)
  lea    0x30000(%rax),%rsi
  mov    %rbx,-0x38(%rsp)
  lea    0x48000(%rax),%rbx
  mov    %rsi,-0x30(%rsp)
  lea    0x54000(%rax),%rsi
  mov    %rdi,-0x28(%rsp)
  lea    0x60000(%rax),%rdi
  mov    %rbx,-0x20(%rsp)
  lea    0x6c000(%rax),%rbx
  mov    %rsi,-0x18(%rsp)
  lea    0x78000(%rax),%rsi
  mov    %rdi,-0x10(%rsp)
  lea    0x84000(%rax),%rdi
  mov    %rbx,-0x8(%rsp)
  lea    0x90000(%rax),%rbx
  mov    %rsi,(%rsp)
  lea    0x9c000(%rax),%rsi
  mov    %rdi,0x8(%rsp)
  lea    0xa8000(%rax),%rdi
  add    $0xb4000,%rax
  mov    %rax,0x28(%rsp)
  mov    0x38(%rsp),%rax
  mov    %rbx,0x10(%rsp)
  mov    %rsi,0x18(%rsp)
  lea    0x12000000(%rax),%rbx
  lea    0x8(%rax),%rsi
  mov    %rdi,0x20(%rsp)
  lea    0x10(%rax),%rdi
  mov    %rbx,0x48(%rsp)
  lea    0x18(%rax),%rbx
  mov    %rsi,0x90(%rsp)
  lea    0x20(%rax),%rsi
  mov    %rdi,0xa8(%rsp)
  lea    0x28(%rax),%rdi
  mov    %rbx,0xc0(%rsp)
  lea    0x30(%rax),%rbx
  mov    %rsi,0x58(%rsp)
  lea    0x38(%rax),%rsi
  mov    %rdi,0x78(%rsp)
  lea    0x40(%rax),%rdi
  mov    %rbx,0x88(%rsp)
  lea    0x48(%rax),%rbx
  mov    %rsi,0xa0(%rsp)
  lea    0x50(%rax),%rsi
  mov    %rdi,0xb8(%rsp)
  lea    0x58(%rax),%rdi
  mov    %rbx,0xd0(%rsp)
  lea    0x60(%rax),%rbx
  mov    %rsi,0x70(%rsp)
  lea    0x68(%rax),%rsi
  mov    %rdi,0x80(%rsp)
  lea    0x70(%rax),%rdi
  add    $0x78,%rax
  mov    %rbx,0x98(%rsp)
  mov    %rsi,0xb0(%rsp)
  mov    %rdi,0xc8(%rsp)
  mov    %rax,0x60(%rsp)
L34:
  mov    0x90(%rsp),%rax
  mov    0x58(%rsp),%r15
  mov    0x78(%rsp),%r14
  mov    0x88(%rsp),%r13
  mov    %rax,-0x58(%rsp)
  mov    0xa8(%rsp),%rax
  mov    0xa0(%rsp),%r12
  mov    0xb8(%rsp),%rbp
  mov    %rax,-0x60(%rsp)
  mov    0xc0(%rsp),%rax
  mov    0xd0(%rsp),%rbx
  mov    0x70(%rsp),%r11
  mov    %rax,-0x68(%rsp)
  mov    0x68(%rsp),%rax
  add    0x30(%rsp),%rax
  mov    0x80(%rsp),%r10
  mov    %rax,-0x78(%rsp)
  mov    0x98(%rsp),%r9
  mov    0xb0(%rsp),%r8
  mov    0xc8(%rsp),%rdi
  mov    0x60(%rsp),%rsi
  mov    0x38(%rsp),%rcx
L38:
  mov    -0x78(%rsp),%rax
  mov    0x30(%rsp),%rdx
  mov    %rcx,-0x70(%rsp)
  add    $0xffffffffffffff80,%rax
  nopw   0x0(%rax,%rax,1)
L29:
  mov    -0x70(%rsp),%rcx
  add    $0x8,%rax
  movsd  (%rcx),%xmm0
  mov    -0x50(%rsp),%rcx
  mulsd  (%rcx,%rdx,1),%xmm0
  mov    -0x58(%rsp),%rcx
  addsd  -0x8(%rax),%xmm0
  movsd  %xmm0,-0x8(%rax)
  movsd  (%rcx),%xmm1
  mov    -0x48(%rsp),%rcx
  mulsd  (%rcx,%rdx,1),%xmm1
  mov    -0x60(%rsp),%rcx
  addsd  %xmm0,%xmm1
  movsd  %xmm1,-0x8(%rax)
  movsd  (%rcx),%xmm0
  mov    -0x40(%rsp),%rcx
  mulsd  (%rcx,%rdx,1),%xmm0
  mov    -0x68(%rsp),%rcx
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  movsd  (%rcx),%xmm1
  mov    -0x38(%rsp),%rcx
  mulsd  (%rcx,%rdx,1),%xmm1
  mov    -0x30(%rsp),%rcx
  addsd  %xmm0,%xmm1
  movsd  %xmm1,-0x8(%rax)
  movsd  (%r15),%xmm0
  mulsd  (%rcx,%rdx,1),%xmm0
  mov    -0x28(%rsp),%rcx
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  movsd  (%r14),%xmm1
  mulsd  (%rcx,%rdx,1),%xmm1
  mov    -0x20(%rsp),%rcx
  addsd  %xmm0,%xmm1
  movsd  %xmm1,-0x8(%rax)
  movsd  0x0(%r13),%xmm0
  mulsd  (%rcx,%rdx,1),%xmm0
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  mov    -0x18(%rsp),%rcx
  movsd  (%r12),%xmm1
  mulsd  (%rcx,%rdx,1),%xmm1
  mov    -0x10(%rsp),%rcx
  addsd  %xmm0,%xmm1
  movsd  %xmm1,-0x8(%rax)
  movsd  0x0(%rbp),%xmm0
  mulsd  (%rcx,%rdx,1),%xmm0
  mov    -0x8(%rsp),%rcx
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  movsd  (%rbx),%xmm1
  mulsd  (%rcx,%rdx,1),%xmm1
  mov    (%rsp),%rcx
  addsd  %xmm0,%xmm1
  movsd  %xmm1,-0x8(%rax)
  movsd  (%r11),%xmm0
  mulsd  (%rcx,%rdx,1),%xmm0
  mov    0x8(%rsp),%rcx
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  movsd  (%r10),%xmm1
  mulsd  (%rcx,%rdx,1),%xmm1
  mov    0x10(%rsp),%rcx
  addsd  %xmm0,%xmm1
  movsd  %xmm1,-0x8(%rax)
  movsd  (%r9),%xmm0
  mulsd  (%rcx,%rdx,1),%xmm0
  mov    0x18(%rsp),%rcx
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  movsd  (%r8),%xmm1
  mulsd  (%rcx,%rdx,1),%xmm1
  mov    0x20(%rsp),%rcx
  addsd  %xmm0,%xmm1
  movsd  %xmm1,-0x8(%rax)
  movsd  (%rdi),%xmm0
  mulsd  (%rcx,%rdx,1),%xmm0
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  movsd  (%rsi),%xmm1
  mov    0x28(%rsp),%rcx
  mulsd  (%rcx,%rdx,1),%xmm1
  add    $0x8,%rdx
  addsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rax)
  cmp    -0x78(%rsp),%rax
  jne    L29
  mov    -0x70(%rsp),%rcx
  add    $0xc000,%rax
  addq   $0xc000,-0x58(%rsp)
  add    $0xc000,%r15
  addq   $0xc000,-0x60(%rsp)
  add    $0xc000,%r14
  add    $0xc000,%r13
  add    $0xc000,%r12
  addq   $0xc000,-0x68(%rsp)
  add    $0xc000,%rcx
  add    $0xc000,%rbp
  add    $0xc000,%rbx
  mov    %rax,-0x78(%rsp)
  add    $0xc000,%r11
  add    $0xc000,%r10
  add    $0xc000,%r9
  add    $0xc000,%r8
  add    $0xc000,%rdi
  add    $0xc000,%rsi
  cmp    0x48(%rsp),%rcx
  jne    L38
  addl   $0x10,0x44(%rsp)
  mov    0x44(%rsp),%eax
  subq   $0xffffffffffffff80,0x30(%rsp)
  cmp    $0x1800,%eax
  jne    L34
  subq   $0xffffffffffffff80,0x38(%rsp)
  mov    0x38(%rsp),%rax
  addq   $0xc0000,-0x50(%rsp)
  cmp    0x50(%rsp),%rax
  jne    L31
  add    $0xd8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
void blocked_multiplication(double A[][6144], double B[][6144], double C[][6144]) {
  int i, j, k, kk, jj;
  double sum;
  const int NUMBER_OF_BLOCKS = 16 * (6144 / 16);
  for (kk = 0; kk < NUMBER_OF_BLOCKS; kk += 16) {
    for (jj = 0; jj < NUMBER_OF_BLOCKS; jj += 16) {
      for (i = 0; i < 6144; i++) {
        for (j = jj; j < jj + 16; j++) {
          for (k = kk; k < kk + 16; k++) {
            C[i][j] += A[i][k] * B[k][j];
          }
        }
      }
    }
  }
}
```