user: Demonstrate the C code that generates the assembly output below:

```asm
<rate_matching_lte>:
  endbr64
  push   %r15
  lea    0x0(,%rsi,4),%eax
  push   %r14
  push   %r13
  mov    %edi,%r13d
  push   %r12
  mov    %esi,%r12d
  push   %rbp
  mov    %rdx,%rbp
  lea    (%rdi,%rdi,8),%edx
  push   %rbx
  sub    $0x8,%rsp
  cmp    %eax,%edx
  jb     L159
  mov    %edi,%eax
  shr    %eax
  cmp    %esi,%eax
  ja     L159
  mov    %ecx,%edi
  test   %esi,%esi
  je     L32
  lea    -0x1(%rsi),%eax
  cmp    $0xe,%eax
  jbe    L196
  mov    %esi,%edx
  movdqa D16(%rip),%xmm1
  mov    %rbp,%rax
  shr    $0x4,%edx
  sub    $0x1,%edx
  shl    $0x4,%rdx
  lea    0x10(%rbp,%rdx,1),%rdx
  nopl   0x0(%rax,%rax,1)
L187:
  movdqu (%rax),%xmm0
  add    $0x10,%rax
  por    %xmm1,%xmm0
  movups %xmm0,-0x10(%rax)
  cmp    %rax,%rdx
  jne    L187
  mov    %r12d,%eax
  and    $0xfffffff0,%eax
  test   $0xf,%r12b
  je     L32
L20:
  mov    %r12d,%ecx
  sub    %eax,%ecx
  lea    -0x1(%rcx),%edx
  cmp    $0x6,%edx
  jbe    L125
  movq   D16(%rip),%xmm1
  mov    %eax,%edx
  add    %rbp,%rdx
  movq   (%rdx),%xmm0
  por    %xmm1,%xmm0
  movq   %xmm0,(%rdx)
  mov    %ecx,%edx
  and    $0xfffffff8,%edx
  add    %edx,%eax
  cmp    %edx,%ecx
  je     L32
L125:
  mov    %eax,%edx
  orb    $0x80,0x0(%rbp,%rdx,1)
  lea    0x1(%rax),%edx
  cmp    %r12d,%edx
  jae    L32
  orb    $0x80,0x0(%rbp,%rdx,1)
  lea    0x2(%rax),%edx
  cmp    %edx,%r12d
  jbe    L32
  orb    $0x80,0x0(%rbp,%rdx,1)
  lea    0x3(%rax),%edx
  cmp    %edx,%r12d
  jbe    L32
  orb    $0x80,0x0(%rbp,%rdx,1)
  lea    0x4(%rax),%edx
  cmp    %edx,%r12d
  jbe    L32
  orb    $0x80,0x0(%rbp,%rdx,1)
  lea    0x5(%rax),%edx
  cmp    %edx,%r12d
  jbe    L32
  add    $0x6,%eax
  orb    $0x80,0x0(%rbp,%rdx,1)
  cmp    %eax,%r12d
  jbe    L32
  orb    $0x80,0x0(%rbp,%rax,1)
L32:
  call   <pset_taus_seed@plt>
  mov    %r12d,%r14d
  sub    %r13d,%r14d
  js     L82
  mov    %r12d,%edi
  mov    $0x1,%ebx
  xor    %r15d,%r15d
  call   <log2_approx@plt>
  lea    0x1(%rax),%ecx
  shl    %cl,%ebx
  sub    $0x1,%ebx
  test   %r14d,%r14d
  je     L126
L78:
  xor    %r13d,%r13d
  nopl   0x0(%rax,%rax,1)
L157:
  xor    %eax,%eax
  call   <ptaus@plt>
  and    %ebx,%eax
  cmp    %eax,%r12d
  jbe    L157
  movzbl 0x0(%rbp,%rax,1),%edx
  test   %dl,%dl
  jns    L157
  and    $0xffffffc0,%edx
  cmp    $0xc0,%dl
  je     L157
  add    %rbp,%rax
  movzbl (%rax),%edx
  mov    %edx,%ecx
  or     $0xffffffc0,%edx
  and    $0x7f,%ecx
  test   %r15d,%r15d
  cmove  %ecx,%edx
  add    $0x1,%r13d
  mov    %dl,(%rax)
  cmp    %r14d,%r13d
  jb     L157
L126:
  xor    %eax,%eax
L99:
  add    $0x8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L82:
  mov    %r12d,%edi
  mov    $0x1,%ebx
  neg    %r14d
  mov    $0x1,%r15d
  call   <log2_approx@plt>
  lea    0x1(%rax),%ecx
  shl    %cl,%ebx
  sub    $0x1,%ebx
  jmp    L78
L196:
  xor    %eax,%eax
  jmp    L20
L159:
  mov    %r12d,%edx
  mov    %r13d,%esi
  lea    D0(%rip),%rdi
  call   <msg@plt>
  mov    $0xffffffff,%eax
  jmp    L99
```

tool_calls: name: retrieve_data
arguments: data_label: D16
datatype: byte[16]
name: retrieve_data
arguments: data_label: D0
datatype: string

tool: {"D16": [0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80]}

tool: D0: [PHY][CODING] Rate matching parameter error (N_coded %d, N_input %d), exiting


assistant: ```c
int rate_matching_lte(unsigned int N_coded, unsigned int N_input, unsigned char *inPtr, unsigned int off) {
  unsigned int i, U, Umod, rep_flag = 0;
  unsigned int Mod_input;
  int N_punctured;
  if ((9 * N_coded < (N_input << 2)) || (N_input < (N_coded >> 1))) {
    msg("[PHY][CODING] Rate matching parameter error (N_coded %d, N_input %d), exiting\n", N_coded, N_input);
    return (-1);
  }
  for (i = 0; i < N_input; i++)
    inPtr[i] |= 0x80;
  i = 0;
  pset_taus_seed(off);
  N_punctured = N_input - N_coded;
  if (N_punctured < 0) {
    N_punctured = -N_punctured;
    rep_flag = 1;
  }
  Mod_input = (1 << (1 + log2_approx(N_input))) - 1;
  while (i < N_punctured) {
    do {
      U = ptaus();
      Umod = U & Mod_input;
      if ((Umod < N_input) && (((inPtr[Umod] & 0x80) == 0) || ((inPtr[Umod] & 0xc0) == 0xc0)))
        Umod = N_input;
    } while (Umod >= N_input);
    if (rep_flag == 0)
      inPtr[Umod] &= 0x7f;
    else
      inPtr[Umod] |= 0xc0;
    i++;
  }
  return (0);
}
```