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

```asm
<branchfree_search8_prefetch>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x58,%rsp
  mov    %rdi,0x48(%rsp)
  mov    %edx,0x38(%rsp)
  mov    %ecx,0x3c(%rsp)
  mov    %r8d,0x40(%rsp)
  mov    %r9d,0x44(%rsp)
  test   %rsi,%rsi
  je     L17
  mov    %rsi,%r12
  cmp    $0x1,%rsi
  jbe    L33
  mov    %rdi,0x28(%rsp)
  mov    %rdi,%r13
  mov    %rdi,%r14
  mov    %rdi,%r15
  mov    %rdi,0x20(%rsp)
  mov    %rdi,0x18(%rsp)
  mov    %rdi,0x10(%rsp)
  mov    %rdi,0x8(%rsp)
L11:
  mov    %r12,%rcx
  shr    %rcx
  mov    %rcx,0x30(%rsp)
  mov    %r12,%rbx
  shr    $0x2,%rbx
  mov    %r12,%rbp
  and    $0xfffffffffffffffc,%rbp
  mov    0x8(%rsp),%rax
  lea    (%rax,%rbp,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  add    0x30(%rsp),%rbx
  shl    $0x2,%rbx
  mov    0x8(%rsp),%rax
  lea    (%rax,%rbx,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x10(%rsp),%rsi
  lea    (%rsi,%rbp,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x10(%rsp),%rsi
  lea    (%rsi,%rbx,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x18(%rsp),%rdx
  lea    (%rdx,%rbp,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x18(%rsp),%rdx
  lea    (%rdx,%rbx,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x20(%rsp),%rdi
  add    %rbp,%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x20(%rsp),%rdi
  add    %rbx,%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  lea    (%r15,%rbp,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  lea    (%r15,%rbx,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  lea    (%r14,%rbp,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  lea    (%r14,%rbx,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  lea    0x0(%r13,%rbp,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  lea    0x0(%r13,%rbx,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x28(%rsp),%r10
  lea    (%r10,%rbp,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x28(%rsp),%rbp
  lea    0x0(%rbp,%rbx,1),%rdi
  mov    $0x0,%edx
  mov    $0x0,%esi
  call   <__builtin_prefetch@plt>
  mov    0x30(%rsp),%rcx
  lea    0x0(,%rcx,4),%rax
  mov    0x8(%rsp),%rbx
  lea    (%rbx,%rax,1),%rdx
  mov    0x38(%rsp),%r9d
  cmp    %r9d,(%rdx)
  mov    %rdx,%r11
  cmovge %rbx,%r11
  mov    %r11,0x8(%rsp)
  mov    0x10(%rsp),%rsi
  lea    (%rsi,%rax,1),%rdx
  mov    0x3c(%rsp),%r10d
  cmp    %r10d,(%rdx)
  mov    %rdx,%r8
  cmovge %rsi,%r8
  mov    %r8,0x10(%rsp)
  mov    0x18(%rsp),%rbx
  lea    (%rbx,%rax,1),%rdx
  mov    0x40(%rsp),%esi
  cmp    %esi,(%rdx)
  cmovge %rbx,%rdx
  mov    %rdx,0x18(%rsp)
  mov    0x20(%rsp),%rbx
  lea    (%rbx,%rax,1),%rdx
  mov    0x44(%rsp),%esi
  cmp    %esi,(%rdx)
  cmovge %rbx,%rdx
  mov    %rdx,0x20(%rsp)
  lea    (%r15,%rax,1),%rdx
  mov    0x90(%rsp),%esi
  cmp    %esi,(%rdx)
  cmovl  %rdx,%r15
  lea    (%r14,%rax,1),%rdx
  mov    0x98(%rsp),%esi
  cmp    %esi,(%rdx)
  cmovl  %rdx,%r14
  lea    0x0(%r13,%rax,1),%rdx
  mov    0xa0(%rsp),%esi
  cmp    %esi,(%rdx)
  cmovl  %rdx,%r13
  add    %rbp,%rax
  mov    0xa8(%rsp),%ebx
  cmp    %ebx,(%rax)
  cmovge %rbp,%rax
  mov    %rax,0x28(%rsp)
  sub    %rcx,%r12
  cmp    $0x1,%r12
  ja     L11
L2:
  mov    0x8(%rsp),%rcx
  mov    0x38(%rsp),%eax
  cmp    %eax,(%rcx)
  setl   %al
  movzbl %al,%eax
  lea    (%rcx,%rax,4),%rax
  mov    0x48(%rsp),%rcx
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xb0(%rsp),%rdx
  mov    %rax,(%rdx)
  mov    0x10(%rsp),%rsi
  mov    0x3c(%rsp),%eax
  cmp    %eax,(%rsi)
  setl   %al
  movzbl %al,%eax
  lea    (%rsi,%rax,4),%rax
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xb8(%rsp),%rdx
  mov    %rax,(%rdx)
  mov    0x18(%rsp),%rsi
  mov    0x40(%rsp),%eax
  cmp    %eax,(%rsi)
  setl   %al
  movzbl %al,%eax
  lea    (%rsi,%rax,4),%rax
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xc0(%rsp),%rdx
  mov    %rax,(%rdx)
  mov    0x20(%rsp),%rbx
  mov    0x44(%rsp),%eax
  cmp    %eax,(%rbx)
  setl   %al
  movzbl %al,%eax
  lea    (%rbx,%rax,4),%rax
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xc8(%rsp),%rdx
  mov    %rax,(%rdx)
  mov    0x90(%rsp),%eax
  cmp    %eax,(%r15)
  setl   %al
  movzbl %al,%eax
  lea    (%r15,%rax,4),%rax
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xd0(%rsp),%rdx
  mov    %rax,(%rdx)
  mov    0x98(%rsp),%eax
  cmp    %eax,(%r14)
  setl   %al
  movzbl %al,%eax
  lea    (%r14,%rax,4),%rax
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xd8(%rsp),%rdx
  mov    %rax,(%rdx)
  mov    0xa0(%rsp),%eax
  cmp    %eax,0x0(%r13)
  setl   %al
  movzbl %al,%eax
  lea    0x0(%r13,%rax,4),%rax
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xe0(%rsp),%rdx
  mov    %rax,(%rdx)
  mov    0x28(%rsp),%rsi
  mov    0xa8(%rsp),%eax
  cmp    %eax,(%rsi)
  setl   %al
  movzbl %al,%eax
  lea    (%rsi,%rax,4),%rax
  sub    %rcx,%rax
  sar    $0x2,%rax
  mov    0xe8(%rsp),%rdx
  mov    %rax,(%rdx)
L17:
  add    $0x58,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L33:
  mov    0x48(%rsp),%rax
  mov    %rax,0x28(%rsp)
  mov    %rax,%r13
  mov    %rax,%r14
  mov    %rax,%r15
  mov    %rax,0x20(%rsp)
  mov    %rax,0x18(%rsp)
  mov    %rax,0x10(%rsp)
  mov    %rax,0x8(%rsp)
  jmp    L2
```

assistant: ```c
void branchfree_search8_prefetch(int *source, size_t n, int target1, int target2, int target3, int target4, int target5, int target6, int target7, int target8, size_t *index1, size_t *index2, size_t *index3, size_t *index4, size_t *index5, size_t *index6, size_t *index7, size_t *index8) {
  int *base1 = source;
  int *base2 = source;
  int *base3 = source;
  int *base4 = source;
  int *base5 = source;
  int *base6 = source;
  int *base7 = source;
  int *base8 = source;
  if (n == 0)
    return;
  while (n > 1) {
    size_t half = n >> 1;
    __builtin_prefetch(base1 + (half >> 1), 0, 0);
    __builtin_prefetch(base1 + half + (half >> 1), 0, 0);
    __builtin_prefetch(base2 + (half >> 1), 0, 0);
    __builtin_prefetch(base2 + half + (half >> 1), 0, 0);
    __builtin_prefetch(base3 + (half >> 1), 0, 0);
    __builtin_prefetch(base3 + half + (half >> 1), 0, 0);
    __builtin_prefetch(base4 + (half >> 1), 0, 0);
    __builtin_prefetch(base4 + half + (half >> 1), 0, 0);
    __builtin_prefetch(base5 + (half >> 1), 0, 0);
    __builtin_prefetch(base5 + half + (half >> 1), 0, 0);
    __builtin_prefetch(base6 + (half >> 1), 0, 0);
    __builtin_prefetch(base6 + half + (half >> 1), 0, 0);
    __builtin_prefetch(base7 + (half >> 1), 0, 0);
    __builtin_prefetch(base7 + half + (half >> 1), 0, 0);
    __builtin_prefetch(base8 + (half >> 1), 0, 0);
    __builtin_prefetch(base8 + half + (half >> 1), 0, 0);
    base1 = (base1[half] < target1) ? &base1[half] : base1;
    base2 = (base2[half] < target2) ? &base2[half] : base2;
    base3 = (base3[half] < target3) ? &base3[half] : base3;
    base4 = (base4[half] < target4) ? &base4[half] : base4;
    base5 = (base5[half] < target5) ? &base5[half] : base5;
    base6 = (base6[half] < target6) ? &base6[half] : base6;
    base7 = (base7[half] < target7) ? &base7[half] : base7;
    base8 = (base8[half] < target8) ? &base8[half] : base8;
    n -= half;
  }
  *index1 = (*base1 < target1) + base1 - source;
  *index2 = (*base2 < target2) + base2 - source;
  *index3 = (*base3 < target3) + base3 - source;
  *index4 = (*base4 < target4) + base4 - source;
  *index5 = (*base5 < target5) + base5 - source;
  *index6 = (*base6 < target6) + base6 - source;
  *index7 = (*base7 < target7) + base7 - source;
  *index8 = (*base8 < target8) + base8 - source;
}
```