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

```asm
<compute_root_count>:
  endbr64
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0xe0,%rsp
  mov    %rdi,%rbx
  mov    %fs:0x28,%rax
  mov    %rax,0xd8(%rsp)
  xor    %eax,%eax
  call   <syscon_read_standard_system@plt>
  lea    D39(%rip),%rdi
  call   <puts@plt>
  mov    $0x0,%eax
  call   <syscon_write_standard_system@plt>
  mov    $0x0,%eax
  call   <supporting_set_structure@plt>
  lea    D43(%rip),%rdi
  call   <puts@plt>
  mov    $0x0,%eax
  call   <write_set_structure@plt>
  lea    0x10(%rsp),%rbp
  lea    0xc(%rsp),%r12
  mov    %rbp,%rsi
  mov    %r12,%rdi
  call   <set_structure_string@plt>
  mov    %rbp,%rsi
  lea    D48(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D87(%rip),%rdi
  call   <puts@plt>
  mov    $0x0,%eax
  call   <clear_set_structure@plt>
  lea    D31(%rip),%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    0xc(%rsp),%edi
  call   <parse_set_structure@plt>
  lea    D33(%rip),%rdi
  call   <puts@plt>
  mov    $0x0,%eax
  call   <write_set_structure@plt>
  movl   $0x1,0xc(%rsp)
  mov    %r12,%rdi
  call   <is_set_structure_supporting@plt>
  cmpl   $0x1,0xc(%rsp)
  je     L14
  lea    D18(%rip),%rdi
  call   <puts@plt>
L8:
  mov    %rbx,%rdi
  call   <linear_product_root_count@plt>
  mov    %eax,%ebp
  mov    (%rbx),%esi
  lea    D75(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    0xd8(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L1
  mov    %ebp,%eax
  add    $0xe0,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
L14:
  lea    D19(%rip),%rdi
  call   <puts@plt>
  jmp    L8
L1:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: data_tag: D39
datatype: string
name: disassemble_data
arguments: data_tag: D43
datatype: string
name: disassemble_data
arguments: data_tag: D48
datatype: string
name: disassemble_data
arguments: data_tag: D87
datatype: string
name: disassemble_data
arguments: data_tag: D31
datatype: string
name: disassemble_data
arguments: data_tag: D33
datatype: string
name: disassemble_data
arguments: data_tag: D18
datatype: string
name: disassemble_data
arguments: data_tag: D75
datatype: string
name: disassemble_data
arguments: data_tag: D19
datatype: string

tool: D39: 
The system in the container : 

tool: D43: 
A supporting set structure : 

tool: D48: 
the set structure string : 
%s


tool: D87: clearing the set structure ...

tool: D31: parsing the set structure string ...

tool: D33: after parsing the set structure string :

tool: D18: The set structure does not support the polynomial system.

tool: D75: 
The linear-product root count : %d


tool: D19: The set structure supports the polynomial system.

assistant: ```c
int compute_root_count(int *r) {
  int fail, inout;
  fail = syscon_read_standard_system();
  printf("\nThe system in the container : \n");
  fail = syscon_write_standard_system();
  fail = supporting_set_structure();
  printf("\nA supporting set structure : \n");
  fail = write_set_structure();
  {
    int nc;
    char ss[200];
    fail = set_structure_string(&nc, ss);
    printf("\nthe set structure string : \n%s\n", ss);
    printf("clearing the set structure ...\n");
    clear_set_structure();
    printf("parsing the set structure string ...\n");
    parse_set_structure(nc, ss);
    printf("after parsing the set structure string :\n");
    fail = write_set_structure();
  }
  inout = 1;
  fail = is_set_structure_supporting(&inout);
  if (inout == 1)
    printf("The set structure supports the polynomial system.\n");
  else
    printf("The set structure does not support the polynomial system.\n");
  fail = linear_product_root_count(r);
  printf("\nThe linear-product root count : %d\n", *r);
  return fail;
}
```