user: What would the C source look like for the assembly code provided here:

```asm
<test_cgcore_no_internal_process_constraint_on_threads>:
  endbr64
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x8,%rsp
  mov    %rdi,%rbx
  lea    D71(%rip),%rdx
  lea    D44(%rip),%rsi
  call   <cg_read_strstr@plt>
  test   %rax,%rax
  jne    L46
  lea    D77(%rip),%rdx
  lea    D116(%rip),%rsi
  mov    %rbx,%rdi
  call   <cg_write@plt>
  test   %rax,%rax
  jne    L46
  lea    D78(%rip),%rsi
  mov    %rbx,%rdi
  call   <cg_name@plt>
  mov    %rax,%rbp
  lea    D1(%rip),%rsi
  mov    %rbx,%rdi
  call   <cg_name@plt>
  mov    %rax,%r12
  test   %rbp,%rbp
  je     L0
  test   %rax,%rax
  je     L0
  mov    %rbp,%rdi
  call   <cg_create@plt>
  mov    $0x1,%r13d
  test   %rax,%rax
  je     L60
L14:
  mov    %rbx,%rdi
  call   <cg_enter_current@plt>
  mov    %rbx,%rdi
  call   <cg_enter_current@plt>
  jmp    L115
L60:
  mov    %r12,%rdi
  call   <cg_create@plt>
  test   %rax,%rax
  jne    L14
  lea    D19(%rip),%rdx
  lea    D41(%rip),%rsi
  mov    %rbp,%rdi
  call   <cg_write@plt>
  test   %rax,%rax
  jne    L14
  lea    D19(%rip),%rdx
  lea    D41(%rip),%rsi
  mov    %r12,%rdi
  call   <cg_write@plt>
  test   %rax,%rax
  jne    L14
  lea    D77(%rip),%rdx
  lea    D116(%rip),%rsi
  mov    %rbp,%rdi
  call   <cg_write@plt>
  test   %rax,%rax
  jne    L14
  mov    %rbp,%rdi
  call   <cg_enter_current@plt>
  test   %rax,%rax
  setne  %r13b
  movzbl %r13b,%r13d
  jmp    L14
L0:
  mov    %rbx,%rdi
  call   <cg_enter_current@plt>
  mov    %rbx,%rdi
  call   <cg_enter_current@plt>
  test   %r12,%r12
  je     L149
  mov    $0x1,%r13d
L115:
  mov    %r12,%rdi
  call   <cg_destroy@plt>
L23:
  test   %rbp,%rbp
  je     L80
  mov    %rbp,%rdi
  call   <cg_destroy@plt>
L80:
  mov    %r12,%rdi
  call   <free@plt>
  mov    %rbp,%rdi
  call   <free@plt>
  mov    %r13d,%eax
  add    $0x8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  ret
L149:
  mov    $0x1,%r13d
  jmp    L23
L46:
  mov    %rbx,%rdi
  call   <cg_enter_current@plt>
  mov    %rbx,%rdi
  call   <cg_enter_current@plt>
  mov    $0x0,%r12d
  mov    $0x0,%ebp
  mov    $0x4,%r13d
  jmp    L80
```

tool_calls: name: unpack_data
arguments: data_label: D71
data_type: string
name: unpack_data
arguments: data_label: D44
data_type: string
name: unpack_data
arguments: data_label: D77
data_type: string
name: unpack_data
arguments: data_label: D116
data_type: string
name: unpack_data
arguments: data_label: D78
data_type: string
name: unpack_data
arguments: data_label: D1
data_type: string
name: unpack_data
arguments: data_label: D19
data_type: string
name: unpack_data
arguments: data_label: D41
data_type: string

tool: D71: cpu

tool: D44: cgroup.controllers

tool: D77: +cpu

tool: D116: cgroup.subtree_control

tool: D78: cg_test_parent

tool: D1: cg_test_parent/cg_test_child

tool: D19: threaded

tool: D41: cgroup.type

assistant: ```c
int test_cgcore_no_internal_process_constraint_on_threads(const char *root) {
  int ret = 1;
  char *parent = NULL, *child = NULL;
  if (cg_read_strstr(root, "cgroup.controllers", "cpu") || cg_write(root, "cgroup.subtree_control", "+cpu")) {
    ret = 4;
    goto cleanup;
  }
  parent = cg_name(root, "cg_test_parent");
  child = cg_name(root, "cg_test_parent/cg_test_child");
  if (!parent || !child)
    goto cleanup;
  if (cg_create(parent))
    goto cleanup;
  if (cg_create(child))
    goto cleanup;
  if (cg_write(parent, "cgroup.type", "threaded"))
    goto cleanup;
  if (cg_write(child, "cgroup.type", "threaded"))
    goto cleanup;
  if (cg_write(parent, "cgroup.subtree_control", "+cpu"))
    goto cleanup;
  if (cg_enter_current(parent))
    goto cleanup;
  ret = 0;
cleanup:
  cg_enter_current(root);
  cg_enter_current(root);
  if (child)
    cg_destroy(child);
  if (parent)
    cg_destroy(parent);
  free(child);
  free(parent);
  return ret;
}
```