user: 请从给定的汇编指令推导出C源代码:

```asm
<testQueryPlanning>:
  endbr64
  push   %r13
  lea    D55(%rip),%rdi
  lea    D99(%rip),%r13
  push   %r12
  push   %rbp
  lea    D42(%rip),%rbp
  call   <puts@plt>
  mov    %rbp,%rdi
  call   <strlen@plt>
  mov    %rbp,%rsi
  mov    %eax,%edi
  call   <parse_string@plt>
  mov    %rax,%rbp
  mov    %rax,%rdi
  call   <streamline_query@plt>
  xor    %esi,%esi
  xor    %edx,%edx
  mov    %rbp,%rdi
  call   <ast_to_string@plt>
  mov    %r13,%rsi
  mov    %rax,%rdi
  mov    %rax,%r12
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L48
  lea    D153(%rip),%rdi
  call   <puts@plt>
L31:
  mov    %r12,%rdi
  lea    D110(%rip),%r13
  call   <free@plt>
  mov    %rbp,%rdi
  lea    D152(%rip),%rbp
  call   <free_ast_node@plt>
  mov    %rbp,%rdi
  call   <strlen@plt>
  mov    %rbp,%rsi
  mov    %eax,%edi
  call   <parse_string@plt>
  mov    %rax,%rbp
  mov    %rax,%rdi
  call   <streamline_query@plt>
  xor    %esi,%esi
  xor    %edx,%edx
  mov    %rbp,%rdi
  call   <ast_to_string@plt>
  mov    %r13,%rsi
  mov    %rax,%rdi
  mov    %rax,%r12
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L79
  lea    D108(%rip),%rdi
  call   <puts@plt>
L130:
  mov    %r12,%rdi
  call   <free@plt>
  mov    %rbp,%rdi
  lea    D68(%rip),%rbp
  call   <free_ast_node@plt>
  mov    %rbp,%rdi
  call   <strlen@plt>
  mov    %rbp,%rsi
  mov    %eax,%edi
  call   <parse_string@plt>
  mov    %rax,%rbp
  mov    %rax,%rdi
  call   <streamline_query@plt>
  xor    %esi,%esi
  xor    %edx,%edx
  mov    %rbp,%rdi
  call   <ast_to_string@plt>
  mov    %r13,%rsi
  mov    %rax,%rdi
  mov    %rax,%r12
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L108
  lea    D93(%rip),%rdi
  call   <puts@plt>
L117:
  mov    %r12,%rdi
  lea    D79(%rip),%r13
  call   <free@plt>
  mov    %rbp,%rdi
  lea    D127(%rip),%rbp
  call   <free_ast_node@plt>
  mov    %rbp,%rdi
  call   <strlen@plt>
  mov    %rbp,%rsi
  mov    %eax,%edi
  call   <parse_string@plt>
  mov    %rax,%rbp
  mov    %rax,%rdi
  call   <streamline_query@plt>
  xor    %esi,%esi
  xor    %edx,%edx
  mov    %rbp,%rdi
  call   <ast_to_string@plt>
  mov    %r13,%rsi
  mov    %rax,%rdi
  mov    %rax,%r12
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L53
  lea    D185(%rip),%rdi
  call   <puts@plt>
L67:
  mov    %r12,%rdi
  lea    D192(%rip),%r13
  call   <free@plt>
  mov    %rbp,%rdi
  lea    D88(%rip),%rbp
  call   <free_ast_node@plt>
  mov    %rbp,%rdi
  call   <strlen@plt>
  mov    %rbp,%rsi
  mov    %eax,%edi
  call   <parse_string@plt>
  mov    %rax,%rbp
  mov    %rax,%rdi
  call   <streamline_query@plt>
  xor    %esi,%esi
  xor    %edx,%edx
  mov    %rbp,%rdi
  call   <ast_to_string@plt>
  mov    %r13,%rsi
  mov    %rax,%rdi
  mov    %rax,%r12
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L86
  lea    D81(%rip),%rdi
  call   <puts@plt>
L27:
  mov    %r12,%rdi
  lea    D236(%rip),%r13
  call   <free@plt>
  mov    %rbp,%rdi
  lea    D247(%rip),%rbp
  call   <free_ast_node@plt>
  mov    %rbp,%rdi
  call   <strlen@plt>
  mov    %rbp,%rsi
  mov    %eax,%edi
  call   <parse_string@plt>
  mov    %rax,%rbp
  mov    %rax,%rdi
  call   <streamline_query@plt>
  xor    %esi,%esi
  xor    %edx,%edx
  mov    %rbp,%rdi
  call   <ast_to_string@plt>
  mov    %r13,%rsi
  mov    %rax,%rdi
  mov    %rax,%r12
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L30
  lea    D3(%rip),%rdi
  call   <puts@plt>
L88:
  mov    %r12,%rdi
  lea    D262(%rip),%r13
  call   <free@plt>
  mov    %rbp,%rdi
  call   <free_ast_node@plt>
  mov    %r13,%rdi
  call   <strlen@plt>
  mov    %r13,%rsi
  mov    %eax,%edi
  call   <parse_string@plt>
  mov    %rax,%rbp
  mov    %rax,%rdi
  call   <streamline_query@plt>
  xor    %esi,%esi
  xor    %edx,%edx
  mov    %rbp,%rdi
  call   <ast_to_string@plt>
  mov    %r13,%rsi
  mov    %rax,%rdi
  mov    %rax,%r12
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L95
  lea    D210(%rip),%rdi
  call   <puts@plt>
L115:
  mov    %r12,%rdi
  call   <free@plt>
  mov    %rbp,%rdi
  pop    %rbp
  pop    %r12
  pop    %r13
  jmp    1160 <free_ast_node@plt>
  xchg   %ax,%ax
L48:
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D0(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L31
  nopl   0x0(%rax,%rax,1)
L95:
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D209(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L115
  nopl   0x0(%rax,%rax,1)
L30:
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D163(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L88
  nopl   0x0(%rax,%rax,1)
L86:
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D180(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L27
  nopl   0x0(%rax,%rax,1)
L53:
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D223(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L67
  nopl   0x0(%rax,%rax,1)
L108:
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D181(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L117
  nopl   0x0(%rax,%rax,1)
L79:
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D16(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  jmp    L130
```

tool_calls: name: retrieve_data
arguments: data_label: D55
type: string
name: retrieve_data
arguments: data_label: D99
type: string
name: retrieve_data
arguments: data_label: D42
type: string
name: retrieve_data
arguments: data_label: D153
type: string
name: retrieve_data
arguments: data_label: D110
type: string
name: retrieve_data
arguments: data_label: D152
type: string
name: retrieve_data
arguments: data_label: D108
type: string
name: retrieve_data
arguments: data_label: D68
type: string
name: retrieve_data
arguments: data_label: D93
type: string
name: retrieve_data
arguments: data_label: D79
type: string
name: retrieve_data
arguments: data_label: D127
type: string
name: retrieve_data
arguments: data_label: D185
type: string
name: retrieve_data
arguments: data_label: D192
type: string
name: retrieve_data
arguments: data_label: D88
type: string
name: retrieve_data
arguments: data_label: D81
type: string
name: retrieve_data
arguments: data_label: D236
type: string
name: retrieve_data
arguments: data_label: D247
type: string
name: retrieve_data
arguments: data_label: D3
type: string
name: retrieve_data
arguments: data_label: D262
type: string
name: retrieve_data
arguments: data_label: D210
type: string
name: retrieve_data
arguments: data_label: D0
type: string
name: retrieve_data
arguments: data_label: D209
type: string
name: retrieve_data
arguments: data_label: D163
type: string
name: retrieve_data
arguments: data_label: D180
type: string
name: retrieve_data
arguments: data_label: D223
type: string
name: retrieve_data
arguments: data_label: D181
type: string
name: retrieve_data
arguments: data_label: D16
type: string

tool: D55: Starting Query Planning Tests..

tool: D99: (b|bb?)c

tool: D42: a*(b|b?bb?)c

tool: D153: Test 1 Passed.

tool: D110: (bc|d)

tool: D152: a*(bc|d)+

tool: D108: Test 2 Passed.

tool: D68: a*(bc|d)b?

tool: D93: Test 3 Passed.

tool: D79: (cd|fg?)h

tool: D127: a?(b*cd|e?fg?)h

tool: D185: Test 4 Passed.

tool: D192: cd

tool: D88: a*b?cd(e*|f)g?

tool: D81: Test 5 Passed.

tool: D236: abc

tool: D247: a+bc+

tool: D3: Test 6 Passed.

tool: D262: ab*c

tool: D210: Test 7 Passed.

tool: D0: Test 1 Failed: %s compared to %s


tool: D209: Test 7 Failed: %s compared to %s


tool: D163: Test 6 Failed: %s compared to %s


tool: D180: Test 5 Failed: %s compared to %s


tool: D223: Test 4 Failed: %s compared to %s


tool: D181: Test 3 Failed: %s compared to %s


tool: D16: Test 2 Failed: %s compared to %s


assistant: ```c
void testQueryPlanning(void) {
  printf("Starting Query Planning Tests..\n");
  {
    struct ast_node *result;
    char *stringResult;
    char *query1 = "a*(b|b?bb?)c";
    char *valid = "(b|bb?)c";
    result = parse_string(strlen(query1), query1);
    streamline_query(result);
    stringResult = ast_to_string(result, 0, 0);
    if (0 == strcmp(stringResult, valid)) {
      printf("Test 1 Passed.\n");
    } else {
      printf("Test 1 Failed: %s compared to %s\n", stringResult, valid);
      exit(1);
    }
    free(stringResult);
    free_ast_node(result);
  }
  {
    struct ast_node *result;
    char *stringResult;
    char *query1 = "a*(bc|d)+";
    char *valid = "(bc|d)";
    result = parse_string(strlen(query1), query1);
    streamline_query(result);
    stringResult = ast_to_string(result, 0, 0);
    if (0 == strcmp(stringResult, valid)) {
      printf("Test 2 Passed.\n");
    } else {
      printf("Test 2 Failed: %s compared to %s\n", stringResult, valid);
      exit(1);
    }
    free(stringResult);
    free_ast_node(result);
  }
  {
    struct ast_node *result;
    char *stringResult;
    char *query1 = "a*(bc|d)b?";
    char *valid = "(bc|d)";
    result = parse_string(strlen(query1), query1);
    streamline_query(result);
    stringResult = ast_to_string(result, 0, 0);
    if (0 == strcmp(stringResult, valid)) {
      printf("Test 3 Passed.\n");
    } else {
      printf("Test 3 Failed: %s compared to %s\n", stringResult, valid);
      exit(1);
    }
    free(stringResult);
    free_ast_node(result);
  }
  {
    struct ast_node *result;
    char *stringResult;
    char *query1 = "a?(b*cd|e?fg?)h";
    char *valid = "(cd|fg?)h";
    result = parse_string(strlen(query1), query1);
    streamline_query(result);
    stringResult = ast_to_string(result, 0, 0);
    if (0 == strcmp(stringResult, valid)) {
      printf("Test 4 Passed.\n");
    } else {
      printf("Test 4 Failed: %s compared to %s\n", stringResult, valid);
      exit(1);
    }
    free(stringResult);
    free_ast_node(result);
  }
  {
    struct ast_node *result;
    char *stringResult;
    char *query1 = "a*b?cd(e*|f)g?";
    char *valid = "cd";
    result = parse_string(strlen(query1), query1);
    streamline_query(result);
    stringResult = ast_to_string(result, 0, 0);
    if (0 == strcmp(stringResult, valid)) {
      printf("Test 5 Passed.\n");
    } else {
      printf("Test 5 Failed: %s compared to %s\n", stringResult, valid);
      exit(1);
    }
    free(stringResult);
    free_ast_node(result);
  }
  {
    struct ast_node *result;
    char *stringResult;
    char *query1 = "a+bc+";
    char *valid = "abc";
    result = parse_string(strlen(query1), query1);
    streamline_query(result);
    stringResult = ast_to_string(result, 0, 0);
    if (0 == strcmp(stringResult, valid)) {
      printf("Test 6 Passed.\n");
    } else {
      printf("Test 6 Failed: %s compared to %s\n", stringResult, valid);
      exit(1);
    }
    free(stringResult);
    free_ast_node(result);
  }
  {
    struct ast_node *result;
    char *stringResult;
    char *query1 = "ab*c";
    char *valid = "ab*c";
    result = parse_string(strlen(query1), query1);
    streamline_query(result);
    stringResult = ast_to_string(result, 0, 0);
    if (0 == strcmp(stringResult, valid)) {
      printf("Test 7 Passed.\n");
    } else {
      printf("Test 7 Failed: %s compared to %s\n", stringResult, valid);
      exit(1);
    }
    free(stringResult);
    free_ast_node(result);
  }
}
```