user: Please show me the C implementation that matches the assembly code listed below:

```asm
<GoLGrid_evolve_strip_keep_bit_0>:
  endbr64
  mov    %rdi,%rax
  mov    %ecx,%r10d
  lea    0x0(,%rdx,8),%rcx
  push   %r14
  sub    %rcx,%rax
  push   %r13
  mov    %rsi,%r9
  xor    %r11d,%r11d
  push   %r12
  push   %rbp
  push   %rbx
  mov    (%rdi),%r8
  add    %rcx,%rdi
  mov    (%rax),%rax
  mov    (%rdi),%rsi
  cmp    $0x1,%rdx
  je     L28
  jmp    L36
  nopw   0x0(%rax,%rax,1)
L27:
  add    $0x8,%rdi
  mov    %r8,%rax
  mov    %rsi,%r8
  mov    (%rdi),%rsi
L28:
  mov    %rax,%rdx
  lea    (%rax,%rax,1),%rcx
  shr    %rdx
  mov    %rcx,%rbx
  mov    %rdx,%rbp
  xor    %rax,%rdx
  and    %rax,%rbp
  mov    %r8,%rax
  xor    %rdx,%rcx
  and    %rdx,%rbx
  shr    %rax
  or     %rbp,%rbx
  mov    %rax,%rdx
  xor    %rcx,%rax
  and    %rcx,%rdx
  lea    (%r8,%r8,1),%rcx
  mov    %rdx,%r12
  xor    %rbx,%rdx
  and    %rbx,%r12
  mov    %rcx,%rbx
  xor    %rax,%rcx
  and    %rax,%rbx
  mov    %rsi,%rax
  shr    %rax
  mov    %rbx,%rbp
  xor    %rdx,%rbx
  and    %rdx,%rbp
  mov    %rax,%rdx
  xor    %rcx,%rax
  and    %rcx,%rdx
  or     %r12,%rbp
  mov    %rdx,%r12
  xor    %rbx,%rdx
  and    %rbx,%r12
  or     %rbp,%r12
  mov    %rax,%rbp
  xor    %rsi,%rax
  and    %rsi,%rbp
  mov    %rbp,%rbx
  xor    %rdx,%rbp
  and    %rdx,%rbx
  lea    (%rsi,%rsi,1),%rdx
  mov    %rdx,%rcx
  or     %r12,%rbx
  and    %rax,%rcx
  xor    %rdx,%rax
  mov    %rcx,%rdx
  or     %r8,%rax
  xor    %rbp,%rdx
  and    %rdx,%rax
  and    %rbp,%rcx
  mov    (%r9),%rdx
  sub    $0x1,%r10d
  or     %rbx,%rcx
  add    $0x8,%r9
  not    %rcx
  and    $0x1,%edx
  and    %rcx,%rax
  and    $0xfffffffffffffffe,%rax
  or     %rax,%r11
  or     %rdx,%rax
  mov    %rax,-0x8(%r9)
  test   %r10d,%r10d
  jg     L27
  pop    %rbx
  mov    %r11,%rax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  nopl   0x0(%rax,%rax,1)
L26:
  add    %rcx,%rdi
  mov    %r8,%rax
  mov    %rsi,%r8
  mov    (%rdi),%rsi
L36:
  mov    %rax,%rdx
  mov    %rax,%rbp
  shr    %rdx
  and    %rdx,%rbp
  xor    %rax,%rdx
  add    %rax,%rax
  mov    %rdx,%rbx
  xor    %rax,%rdx
  and    %rax,%rbx
  mov    %rdx,%rax
  or     %rbp,%rbx
  mov    %r8,%rbp
  shr    %rbp
  mov    %rbx,%r14
  and    %rbp,%rax
  xor    %rbp,%rdx
  lea    (%r8,%r8,1),%rbp
  and    %rax,%r14
  mov    %rdx,%r12
  xor    %rbx,%rax
  xor    %rbp,%rdx
  and    %rbp,%r12
  mov    %rax,%r13
  mov    %rsi,%rbp
  xor    %r12,%rax
  shr    %rbp
  and    %r12,%r13
  mov    %rdx,%r12
  and    %rbp,%r12
  mov    %rax,%rbx
  xor    %rbp,%rdx
  or     %r14,%r13
  and    %r12,%rbx
  xor    %r12,%rax
  mov    %rsi,%rbp
  and    %rdx,%rbp
  or     %rbx,%r13
  mov    %rax,%rbx
  xor    %rsi,%rdx
  xor    %rbp,%rax
  and    %rbp,%rbx
  lea    (%rsi,%rsi,1),%rbp
  or     %r13,%rbx
  mov    %rax,%r12
  mov    %rdx,%r13
  mov    %rdx,%rax
  and    %rbp,%r13
  xor    %rbp,%rax
  mov    %r12,%rdx
  xor    %r13,%rdx
  or     %r8,%rax
  and    %rdx,%rax
  mov    %r12,%rdx
  sub    $0x1,%r10d
  and    %r13,%rdx
  or     %rbx,%rdx
  not    %rdx
  and    %rdx,%rax
  mov    (%r9),%rdx
  and    $0xfffffffffffffffe,%rax
  and    $0x1,%edx
  or     %rax,%r11
  or     %rdx,%rax
  mov    %rax,(%r9)
  add    %rcx,%r9
  test   %r10d,%r10d
  jg     L26
  pop    %rbx
  mov    %r11,%rax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
```

assistant: ```c
unsigned long long int GoLGrid_evolve_strip_keep_bit_0(const unsigned long long int *in_entry, unsigned long long int *out_entry, unsigned long long int row_offset, int row_count) {
  unsigned long long int upper_word = *(in_entry - row_offset);
  unsigned long long int mid_word = *in_entry;
  in_entry += row_offset;
  unsigned long long int lower_word = *in_entry;
  unsigned long long int or_of_out_words = 0;
  while (1) {
    unsigned long long int nb_to_add = (upper_word >> 1);
    unsigned long long int nb_sum_bit_0 = nb_to_add;
    nb_to_add = upper_word;
    unsigned long long int nb_sum_bit_1 = nb_sum_bit_0 & nb_to_add;
    nb_sum_bit_0 = nb_sum_bit_0 ^ nb_to_add;
    nb_to_add = (upper_word << 1);
    unsigned long long int carry_0_to_1 = nb_sum_bit_0 & nb_to_add;
    nb_sum_bit_1 = nb_sum_bit_1 | carry_0_to_1;
    nb_sum_bit_0 = nb_sum_bit_0 ^ nb_to_add;
    nb_to_add = (mid_word >> 1);
    carry_0_to_1 = nb_sum_bit_0 & nb_to_add;
    unsigned long long int nb_sum_overflow = nb_sum_bit_1 & carry_0_to_1;
    nb_sum_bit_1 = nb_sum_bit_1 ^ carry_0_to_1;
    nb_sum_bit_0 = nb_sum_bit_0 ^ nb_to_add;
    nb_to_add = (mid_word << 1);
    carry_0_to_1 = nb_sum_bit_0 & nb_to_add;
    unsigned long long int carry_1_to_2 = nb_sum_bit_1 & carry_0_to_1;
    nb_sum_overflow = nb_sum_overflow | carry_1_to_2;
    nb_sum_bit_1 = nb_sum_bit_1 ^ carry_0_to_1;
    nb_sum_bit_0 = nb_sum_bit_0 ^ nb_to_add;
    nb_to_add = (lower_word >> 1);
    carry_0_to_1 = nb_sum_bit_0 & nb_to_add;
    carry_1_to_2 = nb_sum_bit_1 & carry_0_to_1;
    nb_sum_overflow = nb_sum_overflow | carry_1_to_2;
    nb_sum_bit_1 = nb_sum_bit_1 ^ carry_0_to_1;
    nb_sum_bit_0 = nb_sum_bit_0 ^ nb_to_add;
    nb_to_add = lower_word;
    carry_0_to_1 = nb_sum_bit_0 & nb_to_add;
    carry_1_to_2 = nb_sum_bit_1 & carry_0_to_1;
    nb_sum_overflow = nb_sum_overflow | carry_1_to_2;
    nb_sum_bit_1 = nb_sum_bit_1 ^ carry_0_to_1;
    nb_sum_bit_0 = nb_sum_bit_0 ^ nb_to_add;
    nb_to_add = (lower_word << 1);
    carry_0_to_1 = nb_sum_bit_0 & nb_to_add;
    carry_1_to_2 = nb_sum_bit_1 & carry_0_to_1;
    nb_sum_overflow = nb_sum_overflow | carry_1_to_2;
    nb_sum_bit_1 = nb_sum_bit_1 ^ carry_0_to_1;
    nb_sum_bit_0 = nb_sum_bit_0 ^ nb_to_add;
    unsigned long long int out_word = (~(nb_sum_overflow)&nb_sum_bit_1 & (nb_sum_bit_0 | mid_word)) & 0xfffffffffffffffeULL;
    or_of_out_words |= out_word;
    *out_entry = (*out_entry & 0x0000000000000001ULL) | out_word;
    out_entry += row_offset;
    row_count--;
    if (row_count <= 0)
      break;
    upper_word = mid_word;
    mid_word = lower_word;
    in_entry += row_offset;
    lower_word = *in_entry;
  }
  return or_of_out_words;
}
```