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

```asm
<compression_G>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  sub    $0x38,%rsp
  xor    %ebp,%ebp
  mov    %rdi,0x8(%rsp)
  lea    0x20(%rsp),%r12
  lea    0x1020(%rsp),%r13
  mov    %rsi,0x10(%rsp)
  mov    %r12,%rdi
  mov    %rdx,0x18(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x2028(%rsp)
  xor    %eax,%eax
  call   <xor_blocks@plt>
  lea    0x1220(%rsp),%rax
  mov    %rax,(%rsp)
  mov    %rax,%rbx
  nopw   0x0(%rax,%rax,1)
L36:
  mov    %rbp,%rsi
  lea    -0x200(%rbx),%r14
  shl    $0x6,%rsi
  lea    (%r12,%rsi,1),%r15
  nopw   0x0(%rax,%rax,1)
L64:
  mov    %r15,%rsi
  mov    %r14,%rdi
  mov    $0x10,%edx
  add    $0x40,%r14
  call   <memcpy@plt>
  add    $0x40,%r15
  cmp    %rbx,%r14
  jne    L64
  add    $0x8,%rbp
  lea    0x200(%r14),%rbx
  cmp    $0x40,%rbp
  jne    L36
  lea    0x1000(%r13),%rbx
  mov    %r13,%rbp
  nopl   0x0(%rax,%rax,1)
L21:
  lea    0x1c0(%rbp),%rax
  lea    0x40(%rbp),%rsi
  mov    %rbp,%rdi
  push   %rax
  lea    0x180(%rbp),%rax
  lea    0xc0(%rbp),%rcx
  push   %rax
  lea    0x80(%rbp),%rdx
  lea    0x140(%rbp),%r9
  lea    0x100(%rbp),%r8
  add    $0x200,%rbp
  call   <P@plt>
  pop    %rcx
  pop    %rsi
  cmp    %rbx,%rbp
  jne    L21
  mov    %r13,%rbx
  nopl   0x0(%rax)
L33:
  lea    0xe00(%rbx),%rax
  lea    0x400(%rbx),%rdx
  mov    %rbx,%rdi
  push   %rax
  lea    0xc00(%rbx),%rax
  lea    0x600(%rbx),%rcx
  push   %rax
  lea    0x200(%rbx),%rsi
  lea    0xa00(%rbx),%r9
  lea    0x800(%rbx),%r8
  add    $0x40,%rbx
  call   <P@plt>
  pop    %rax
  pop    %rdx
  cmp    (%rsp),%rbx
  jne    L33
  lea    0x200(%r12),%rbx
  xor    %ebp,%ebp
  nopl   0x0(%rax)
L48:
  mov    %rbp,%rcx
  lea    -0x200(%rbx),%r14
  shl    $0x6,%rcx
  lea    (%rcx,%r13,1),%r15
  nopw   0x0(%rax,%rax,1)
L56:
  mov    %r15,%rsi
  mov    %r14,%rdi
  mov    $0x10,%edx
  add    $0x40,%r14
  call   <memcpy@plt>
  add    $0x40,%r15
  cmp    %r14,%rbx
  jne    L56
  add    $0x8,%rbp
  add    $0x200,%rbx
  cmp    $0x40,%rbp
  jne    L48
  mov    0x8(%rsp),%rbx
  mov    0x18(%rsp),%rdx
  mov    0x10(%rsp),%rsi
  mov    %rbx,%rdi
  call   <xor_blocks@plt>
  mov    %r12,%rdx
  mov    %rbx,%rsi
  mov    %rbx,%rdi
  call   <xor_blocks@plt>
  mov    0x2028(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L9
  add    $0x2038,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L9:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void compression_G(uint8_t *Result, uint8_t *X, uint8_t *Y) {
  uint8_t R_array[1024];
  xor_blocks(R_array, X, Y);
  uint8_t R[8][8][16];
  int h = 0;
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      memcpy(R[i][j], R_array + 16 * h, 16);
      h++;
    }
  }
  for (int i = 0; i < 8; i++) {
    P(R[i][0], R[i][1], R[i][2], R[i][3], R[i][4], R[i][5], R[i][6], R[i][7]);
  }
  for (int j = 0; j < 8; j++) {
    P(R[0][j], R[1][j], R[2][j], R[3][j], R[4][j], R[5][j], R[6][j], R[7][j]);
  }
  h = 0;
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      memcpy(R_array + 16 * h, R[i][j], 16);
      h++;
    }
  }
  xor_blocks(Result, X, Y);
  xor_blocks(Result, Result, R_array);
}
```