LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dissect.c
// Function: _lookup_member
static struct symbol *__lookup_member(struct symbol *type, struct ident *name, int *p_addr)
{
	struct symbol *node;
	int addr = 0;

	FOR_EACH_PTR(type->symbol_list, node)
		if (!name) {
			if (addr == *p_addr)
				return node;
		}
		else if (node->ident == NULL) {
			node = __lookup_member(node->ctype.base_type, name, NULL);
			if (node)
				goto found;
		}
		else if (node->ident == name) {
found:
			if (p_addr)
				*p_addr = addr;
			return node;
		}
		addr++;
	END_FOR_EACH_PTR(node);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x98(%rdi), %r12
testq %r12, %r12
je 0x13238
movq %rdx, %rbx
movq %rsi, %r14
xorl %r15d, %r15d
movq %r12, %r13
movzwl (%r13), %ecx
testb %cl, %cl
jle 0x1322b
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %rax
movzwl %cx, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x131e9
testq %rax, %rax
je 0x1321b
testq %r14, %r14
je 0x131fe
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x13205
cmpq %r14, %rcx
jne 0x13218
jmp 0x1323f
cmpl (%rbx), %r15d
jne 0x13218
jmp 0x1324e
movq 0x60(%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x131a6
testq %rax, %rax
jne 0x1323f
incl %r15d
incq %rbp
movl (%r13), %ecx
movsbq %cl, %rax
cmpq %rax, %rbp
jl 0x131d4
movq 0x10(%r13), %r13
cmpq %r12, %r13
jne 0x131c9
xorl %ecx, %ecx
jmp 0x1323d
movl $0x2, %ecx
jmp 0x13253
movl $0x1, %ecx
testq %rbx, %rbx
je 0x13253
movl %r15d, (%rbx)
jmp 0x13253
movl $0x1, %ecx
testb $0x1, %cl
jne 0x1325a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/test-inspect.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;
	struct symbol_list *view_syms = NULL;

	gtk_init(&argc,&argv);
	setlocale(LC_ALL, "C");
	expand_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		struct symbol_list *syms = sparse(file);
		expand_symbols(syms);
		concat_symbol_list(syms, &view_syms);
	} END_FOR_EACH_PTR(file);
	treeview_main(view_syms);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %rbx
movl %edi, (%rbx)
leaq 0x18(%rsp), %r14
movq %rsi, (%r14)
xorl %eax, %eax
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf4b0
leaq 0x37654(%rip), %rsi     # 0x472bc
movl $0x6, %edi
callq 0xf270
movl (%rbx), %edi
movq (%r14), %rsi
movq %r15, %rdx
callq 0x13056
movq %rax, %rdi
callq 0xfd03
movq (%r15), %r15
testq %r15, %r15
je 0xfcea
movq %rsp, %rbx
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0xfce0
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xfcb5
testq %rdi, %rdi
je 0xfcd0
callq 0x13396
movq %rax, %r14
movq %rax, %rdi
callq 0xfd03
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dc42
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0xfca1
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0xfc95
movq (%rsp), %rdi
callq 0x41c48
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/test-inspect.c
// Function: expand_symbols
static void expand_symbols(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		expand_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xfd54
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xfd46
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xfd32
testq %rdi, %rdi
je 0xfd37
callq 0xfff0
incq %r15
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0xfd1e
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xfd13
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_tree_model_init
static void
ast_tree_model_init (GtkTreeModelIface *iface)
{
	iface->get_flags       = ast_get_flags;
	iface->get_n_columns   = ast_get_n_columns;
	iface->get_column_type = ast_get_column_type;
	iface->get_iter        = ast_get_iter;
	iface->get_path        = ast_get_path;
	iface->get_value       = ast_get_value;
	iface->iter_next       = ast_iter_next;
	iface->iter_children   = ast_iter_children;
	iface->iter_has_child  = ast_iter_has_child;
	iface->iter_n_children = ast_iter_n_children;
	iface->iter_nth_child  = ast_iter_nth_child;
	iface->iter_parent     = ast_iter_parent;
}

// Assembly:
leaq 0xe1(%rip), %rax        # 0x4194a
movq %rax, 0x38(%rdi)
leaq 0xdc(%rip), %rax        # 0x41950
movq %rax, 0x40(%rdi)
leaq 0xd7(%rip), %rax        # 0x41956
movq %rax, 0x48(%rdi)
leaq 0xd2(%rip), %rax        # 0x4195c
movq %rax, 0x50(%rdi)
leaq 0x169(%rip), %rax       # 0x419fe
movq %rax, 0x58(%rdi)
leaq 0x1bb(%rip), %rax       # 0x41a5b
movq %rax, 0x60(%rdi)
leaq 0x237(%rip), %rax       # 0x41ae2
movq %rax, 0x68(%rdi)
leaq 0x2c2(%rip), %rax       # 0x41b78
movq %rax, 0x78(%rdi)
leaq 0x2dd(%rip), %rax       # 0x41b9e
movq %rax, 0x80(%rdi)
leaq 0x2f9(%rip), %rax       # 0x41bc8
movq %rax, 0x88(%rdi)
leaq 0x32c(%rip), %rax       # 0x41c09
movq %rax, 0x90(%rdi)
leaq 0x346(%rip), %rax       # 0x41c31
movq %rax, 0x98(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_new
AstNode *
ast_new (AstNode *parent, int index, const char *text, void *ptr, void (*inspect)(AstNode*))
{
	AstNode *node = (AstNode*) g_object_new (AST_TYPE_NODE, NULL);
	g_assert(node != NULL);
	node->parent = parent;
	node->index = index;
	node->text = text;
	node->inspect = inspect;
	node->ptr = ptr;
	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0x417d0
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xf030
testq %rax, %rax
je 0x4193b
movq %r12, 0x18(%rax)
movl %ebp, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xfad3
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_get_iter
static gboolean
ast_get_iter(GtkTreeModel *tree_model,
                  GtkTreeIter  *iter,
                  GtkTreePath  *path)
{
	AstNode    *node;
	gint          *indices, depth;
	int i;

	node = AST_NODE(tree_model);
	indices = gtk_tree_path_get_indices(path);
	depth   = gtk_tree_path_get_depth(path);

	for (i = 0; i < depth; i++)
		node = ast_nth_child(node, indices[i]);

	return ast_set_iter(iter, node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x417d0
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %r14
movq %r12, %rdi
callq 0xf1b0
movq %rax, %r15
movq %r12, %rdi
callq 0xf410
testl %eax, %eax
jle 0x419dc
movl %eax, %r12d
xorl %r13d, %r13d
testq %r14, %r14
je 0x419d1
movslq (%r15,%r13,4), %rbp
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x419bf
movq %r14, %rdi
callq *%rax
movq $0x0, 0x30(%r14)
movq 0x40(%r14), %rax
cmpl %ebp, 0x8(%rax)
jbe 0x419d1
movq (%rax), %rax
movq (%rax,%rbp,8), %r14
jmp 0x419d4
xorl %r14d, %r14d
incq %r13
cmpq %r13, %r12
jne 0x419a0
movq %r14, 0x8(%rbx)
xorl %eax, %eax
testq %r14, %r14
setne %al
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_get_path
static GtkTreePath *
ast_get_path(GtkTreeModel *tree_model,
                  GtkTreeIter  *iter)
{
	GtkTreePath  *path;
	AstNode   *root = AST_NODE(tree_model);
	AstNode   *node = AST_NODE(iter->user_data);

	path = gtk_tree_path_new();
	while (node != root) {
		gtk_tree_path_prepend_index(path, node->index);
		node = node->parent;
	}
	return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x417d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rbx
movq 0x8(%r14), %r14
callq 0x417d0
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %r14
callq 0xf3b0
movq %rax, %r15
cmpq %rbx, %r14
je 0x41a52
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0xf440
movq 0x18(%r14), %r14
jmp 0x41a3b
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_get_value
static void
ast_get_value(GtkTreeModel *tree_model,
                   GtkTreeIter  *iter,
                   gint          column,
                   GValue       *value)
{
	AstNode    *node = iter->user_data;

	g_assert(AST_IS_NODE(tree_model));
	if (column != 1)
		return;

	inspect_child_node(node);

	g_value_init(value, G_TYPE_STRING);
	g_value_set_string(value, node->text);
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r15
movq 0x8(%rsi), %r14
callq 0x417d0
testq %r15, %r15
je 0x41add
movq (%r15), %rcx
testq %rcx, %rcx
je 0x41a85
cmpq %rax, (%rcx)
je 0x41a94
movq %r15, %rdi
movq %rax, %rsi
callq 0xf3a0
testl %eax, %eax
je 0x41add
cmpl $0x1, %ebp
jne 0x41ad2
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x41aaf
movq %r14, %rdi
callq *%rax
movq $0x0, 0x30(%r14)
movl $0x40, %esi
movq %rbx, %rdi
callq 0xf4c0
movq 0x28(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf240
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xfaf5
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_iter_next
static gboolean
ast_iter_next(GtkTreeModel  *tree_model,
                   GtkTreeIter   *iter)
{
	AstNode    *node = iter->user_data;
	
	g_assert(AST_IS_NODE (tree_model));

	node = ast_nth_child(node->parent, node->index + 1);
	return ast_set_iter(iter, node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
callq 0x417d0
testq %r14, %r14
je 0x41b73
movq (%r14), %rcx
testq %rcx, %rcx
je 0x41b0a
cmpq %rax, (%rcx)
je 0x41b19
movq %r14, %rdi
movq %rax, %rsi
callq 0xf3a0
testl %eax, %eax
je 0x41b73
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x41b53
movslq 0x20(%r15), %r15
leal 0x1(%r15), %ebp
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x41b40
movq %r14, %rdi
callq *%rax
movq $0x0, 0x30(%r14)
movq 0x40(%r14), %rax
cmpl %ebp, 0x8(%rax)
jbe 0x41b53
movq (%rax), %rax
movq 0x8(%rax,%r15,8), %rcx
jmp 0x41b55
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
xorl %eax, %eax
testq %rcx, %rcx
setne %al
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xfb17
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_iter_nth_child
static gboolean
ast_iter_nth_child(GtkTreeModel *tree_model,
                        GtkTreeIter  *iter,
                        GtkTreeIter  *parent,
                        gint          n)
{
	AstNode    *node = parent ? parent->user_data : (AstNode*) tree_model;
	GArray *array = node->childnodes;
	if (n >= array->len)
		return FALSE;
	iter->user_data = g_array_index(array, AstNode *, n);
	return TRUE;
}

// Assembly:
testq %rdx, %rdx
je 0x41c12
movq 0x8(%rdx), %rdi
movq 0x40(%rdi), %rdx
xorl %eax, %eax
cmpl %ecx, 0x8(%rdx)
jbe 0x41c30
movq (%rdx), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_iter_n_children
static gint
ast_iter_n_children (GtkTreeModel *tree_model,
                          GtkTreeIter  *iter)
{
	AstNode  *node = iter ? iter->user_data
				: AST_NODE(tree_model);

	inspect_child_node(node);
	return node->childnodes->len;
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x41bd4
movq 0x8(%rsi), %rbx
jmp 0x41bea
movq %rdi, %rbx
callq 0x417d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rbx
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x41c00
movq %rbx, %rdi
callq *%rax
movq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %rax
movl 0x8(%rax), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-view.c
// Function: treeview_main
void
treeview_main (struct symbol_list *syms)
{
	GtkWidget *window, *view, *scrollwin;

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size (GTK_WINDOW(window), 600, 800);
	g_signal_connect(window, "delete_event", gtk_main_quit, NULL);

	scrollwin = gtk_scrolled_window_new(NULL,NULL);

	view = create_view_and_model(syms);

	gtk_container_add(GTK_CONTAINER(scrollwin), view);
	gtk_container_add(GTK_CONTAINER(window), scrollwin);

	gtk_widget_show_all(window);

	gtk_main();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %edi, %edi
callq 0xf320
movq %rax, %rbx
callq 0xf520
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
movl $0x258, %esi            # imm = 0x258
movl $0x320, %edx            # imm = 0x320
callq 0xf260
leaq 0xccb5(%rip), %rsi      # 0x4e93b
movq 0x2233b(%rip), %rdx     # 0x63fc8
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf290
xorl %edi, %edi
xorl %esi, %esi
callq 0xf200
movq %rax, %r14
leaq 0x1c1d(%rip), %rdx      # 0x438cd
leaq 0x8de(%rip), %r8        # 0x42595
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rcx
callq 0x418f3
movq %rax, %r12
callq 0xf370
movq %r12, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
callq 0xf490
movq %rax, %r15
movq %r12, %rdi
callq 0xf420
callq 0xf230
leaq 0xcbd3(%rip), %rdi      # 0x4e8c8
leaq 0x42aa(%rip), %rdx      # 0x45fa6
movq %rax, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xf0f0
movq %rax, %r12
callq 0xf310
movq %r15, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
movq %r12, %rsi
callq 0xf060
callq 0xf1a0
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %rax, %rdi
movq %r15, %rsi
callq 0xf250
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf0e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xf250
movq %rbx, %rdi
callq 0xf400
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf350
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-inspect.c
// Function: inspect_expression
void inspect_expression(AstNode *node)
{
	struct expression *expr = node->ptr;
	node->text = g_strdup_printf("%s %s", node->text, expression_type_name(expr->type));
	switch (expr->type) {
		case EXPR_STATEMENT:
			ast_append_child(node, "statement:", expr->statement, inspect_statement);
			break;
		case EXPR_BINOP:
		case EXPR_COMMA:
		case EXPR_COMPARE:
		case EXPR_LOGICAL:
		case EXPR_ASSIGNMENT:
			ast_append_child(node, "left:", expr->left, inspect_expression);
			ast_append_child(node, "right:", expr->right, inspect_expression);
			break;

		case EXPR_CAST:
		case EXPR_FORCE_CAST:
		case EXPR_IMPLIED_CAST:
			ast_append_child(node, "cast_type:", expr->cast_type, inspect_symbol);
			ast_append_child(node, "cast_expression:", expr->cast_expression, inspect_expression);
			break;

		case EXPR_PREOP:
			ast_append_child(node, "unop:", expr->unop, inspect_expression);
			break;
		
		default:
			break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq 0x38(%rdi), %r14
movzbl (%r14), %eax
testl %eax, %eax
je 0x422e7
leaq 0x2184f(%rip), %rcx     # 0x63b30
movq (%rcx,%rax,8), %rdx
jmp 0x422ee
leaq 0xcb73(%rip), %rdx      # 0x4ee61
leaq 0x49ad(%rip), %rdi      # 0x46ca2
xorl %eax, %eax
callq 0xf1f0
movq %rax, 0x28(%rbx)
movzbl (%r14), %eax
addl $-0x5, %eax
cmpl $0x11, %eax
ja 0x42427
leaq 0xc64d(%rip), %rcx      # 0x4e964
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x4235a
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc81c(%rip), %rdx      # 0x4eb53
leaq -0x7b(%rip), %r8        # 0x422c3
movq %rbx, %rdi
callq 0x418f3
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x42427
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc7e4(%rip), %rdx      # 0x4eb59
jmp 0x42404
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x423b4
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc7cf(%rip), %rdx      # 0x4eb60
leaq 0x97(%rip), %r8         # 0x4242f
movq %rbx, %rdi
callq 0x418f3
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x42427
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc7a0(%rip), %rdx      # 0x4eb6b
jmp 0x42404
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x42427
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc673(%rip), %rdx      # 0x4ea57
leaq -0x673(%rip), %r8       # 0x41d78
jmp 0x4240b
movq 0x20(%r14), %rcx
testq %rcx, %rcx
je 0x42427
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc778(%rip), %rdx      # 0x4eb7c
leaq -0x148(%rip), %r8       # 0x422c3
movq %rbx, %rdi
callq 0x418f3
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/ast-inspect.c
// Function: inspect_symbol
void inspect_symbol(AstNode *node)
{
	struct symbol *sym = node->ptr;
	node->text = g_strdup_printf("%s %s: %s", node->text, symbol_type_name(sym->type),
				      builtin_typename(sym) ?: show_ident(sym->ident));
	ast_append_child(node, "ctype.base_type:", sym->ctype.base_type,inspect_symbol);

	switch (sym->namespace) {
		case NS_PREPROCESSOR:
			break;
		default:
			ast_append_child(node, "arguments:", sym->arguments, inspect_symbol_list);
			ast_append_child(node, "symbol_list:", sym->symbol_list, inspect_symbol_list);
			ast_append_child(node, "stmt:", sym->stmt, inspect_statement);
			break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq 0x38(%rdi), %r14
movzbl (%r14), %eax
leaq 0xc597(%rip), %rcx      # 0x4e9e4
movslq (%rcx,%rax,4), %r12
addq %rcx, %r12
movq %r14, %rdi
callq 0x1e3a6
testq %rax, %rax
jne 0x4246a
movq 0x18(%r14), %rdi
callq 0x22ec5
leaq 0xc69d(%rip), %rdi      # 0x4eb0e
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xf1f0
movq %rax, 0x28(%rbx)
movq 0x60(%r14), %rcx
testq %rcx, %rcx
je 0x424bf
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc67c(%rip), %rdx      # 0x4eb18
leaq -0x74(%rip), %r8        # 0x4242f
movq %rbx, %rdi
callq 0x418f3
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movl $0x1ff00, %eax          # imm = 0x1FF00
andl (%r14), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x42589
movq 0x88(%r14), %rcx
testq %rcx, %rcx
je 0x4250f
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc63d(%rip), %rdx      # 0x4eb29
leaq 0xa2(%rip), %r8         # 0x42595
movq %rbx, %rdi
callq 0x418f3
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x98(%r14), %rcx
testq %rcx, %rcx
je 0x4254c
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc60b(%rip), %rdx      # 0x4eb34
leaq 0x65(%rip), %r8         # 0x42595
movq %rbx, %rdi
callq 0x418f3
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
movq 0x90(%r14), %rcx
testq %rcx, %rcx
je 0x42589
movq 0x40(%rbx), %rax
movl 0x8(%rax), %esi
leaq 0xc5db(%rip), %rdx      # 0x4eb41
leaq -0x7f5(%rip), %r8       # 0x41d78
movq %rbx, %rdi
callq 0x418f3
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x40(%rbx), %rdi
movl $0x1, %edx
callq 0xf1c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_tokens
void dump_tokens(const Vector* vec) {
    for (int i = 0; i < vec->size; ++i) {
        Token* token = vec->elements[i];
        printf("index=%d,token=\"%s\"", i, decode_token_type(token->type));
        if (token->type == TK_IDENT) {
            printf("=\"%s\"", token->str);
        }
        printf("\n");
        fflush(stdout);
    }
}

// Assembly:
cmpl $0x0, 0x8(%rdi)
jle 0x1444
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c31(%rip), %r14      # 0xa004
leaq 0x9010(%rip), %r15      # 0xa3ea
movq 0xdbef(%rip), %r13      # 0xefd0
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %rbp
movl (%rbp), %edi
callq 0x8a51
movq %r14, %rdi
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
cmpl $0x3, (%rbp)
jne 0x1417
movq 0x8(%rbp), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10a0
movl $0xa, %edi
callq 0x1040
movq (%r13), %rdi
callq 0x1110
incq %r12
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x13e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_nodes
void dump_nodes(const TransUnitNode* node) {
    printf("TransUnitNode\n");

    for (int i = 0; i < node->external_decl_nodes->size; ++i) {
        const ExternalDeclNode* external_decl_node = (const ExternalDeclNode*)(node->external_decl_nodes->elements[i]);
        dump_external_decl_node(external_decl_node, 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9023(%rip), %rdi      # 0xa47d
callq 0x1070
movq (%rbx), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1557
leaq 0x8ba5(%rip), %r14      # 0xa018
xorl %ebp, %ebp
movq (%rax), %rax
movq (%rax,%rbp,8), %r12
movl $0x2, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r12), %r15
testq %r15, %r15
je 0x14f9
movl $0x4, %edi
leaq 0x8b8a(%rip), %rsi      # 0xa02a
xorl %eax, %eax
callq 0x1566
movq (%r15), %rax
cmpl $0x0, 0x8(%rax)
jle 0x14d3
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %rdi
movl $0x6, %esi
callq 0x1707
incq %r13
movq (%r15), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r13
jl 0x14b3
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x14e6
movl $0x6, %esi
callq 0x1741
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x14f9
movl $0x6, %esi
callq 0x1797
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x150d
movl $0x4, %esi
callq 0x1616
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x1544
movl $0x4, %edi
leaq 0x8f33(%rip), %rsi      # 0xa456
xorl %eax, %eax
callq 0x1566
cmpq $0x0, 0x8(%r15)
je 0x1544
movl $0x6, %edi
leaq 0x8f2c(%rip), %rsi      # 0xa469
xorl %eax, %eax
callq 0x1566
incq %rbp
movq (%rbx), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %rbp
jl 0x1475
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: printf_indent
static void printf_indent(int indent, const char* fmt, ...) {
    for (int i = 0; i < indent; ++i) {
        putchar(' ');
    }

    va_list ap;
    va_start(ap, fmt);
    vfprintf(stdout, fmt, ap);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x15c1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testl %edi, %edi
jle 0x15d5
movl %edi, %ebp
movl $0x20, %edi
callq 0x1040
decl %ebp
jne 0x15c7
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0xd9cf(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1150
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_declaration_node
static void dump_declaration_node(const DeclarationNode* node, int indent) {
    printf_indent(indent, "DeclarationNode\n");
    for (int i = 0; i < node->decl_specifier_nodes->size; ++i) {
        dump_decl_specifier_node(node->decl_specifier_nodes->elements[i], indent + 2);
    }

    for (int i = 0; i < node->init_declarator_nodes->size; ++i) {
        dump_init_declarator_node(node->init_declarator_nodes->elements[i], indent + 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8d1e(%rip), %rsi      # 0xa34b
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1662
leal 0x2(%rbx), %ebp
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
callq 0x1707
incq %r15
movq (%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r15
jl 0x1645
movq 0x8(%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x16f8
leal 0x2(%rbx), %ebp
leal 0x4(%rbx), %r15d
addl $0x6, %ebx
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %r12
movl %ebp, %edi
leaq 0x8d8f(%rip), %rsi      # 0xa41c
xorl %eax, %eax
callq 0x1566
movq (%r12), %rdi
testq %rdi, %rdi
je 0x16a5
movl %r15d, %esi
callq 0x1741
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x16e8
movl %r15d, %edi
leaq 0x8d77(%rip), %rsi      # 0xa430
xorl %eax, %eax
callq 0x1566
movq (%r12), %rdi
testq %rdi, %rdi
je 0x16d0
movl %ebx, %esi
callq 0x1f32
cmpq $0x0, 0x8(%r12)
je 0x16e8
movl %ebx, %edi
leaq 0x8d60(%rip), %rsi      # 0xa441
xorl %eax, %eax
callq 0x1566
incq %r13
movq 0x8(%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r13
jl 0x167d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_decl_specifier_node
static void dump_decl_specifier_node(const DeclSpecifierNode* node, int indent) {
    printf_indent(
        indent, 
        "DeclSpecifierNode\n"
    );

    if (node->type_specifier_node != NULL) {
        dump_type_specifier_node(node->type_specifier_node, indent + 2);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8920(%rip), %rsi      # 0xa037
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1739
addl $0x2, %ebx
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x181e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_declarator_node
static void dump_declarator_node(const DeclaratorNode* node, int indent) {
    printf_indent(indent, "DeclaratorNode\n");

    if (node->pointer_node != NULL) {
        dump_pointer_node(node->pointer_node, indent + 2);
    }

    if (node->direct_declarator_node != NULL) {
        dump_direct_declarator_node(node->direct_declarator_node, indent + 2);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8ccf(%rip), %rsi      # 0xa420
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rax
testq %rax, %rax
je 0x1775
leal 0x2(%rbx), %edi
movl (%rax), %edx
leaq 0x895c(%rip), %rsi      # 0xa0ca
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x178f
addl $0x2, %ebx
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x192c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_compound_stmt_node
static void dump_compound_stmt_node(const CompoundStmtNode* node, int indent) {
    printf_indent(indent, "CompoundStmtNode\n");
    for (int i = 0; i < node->block_item_nodes->size; ++i) {
        const BlockItemNode* block_item_node = node->block_item_nodes->elements[i];
        dump_block_item_node(block_item_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8bae(%rip), %rsi      # 0xa35c
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x180f
leal 0x2(%rbx), %ebp
addl $0x4, %ebx
leaq 0x8ba1(%rip), %r15      # 0xa36e
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movl %ebp, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r13), %rdi
testq %rdi, %rdi
je 0x17f5
movl %ebx, %esi
callq 0x1616
jmp 0x1800
movq 0x8(%r13), %rdi
movl %ebx, %esi
callq 0x2022
incq %r12
movq (%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r12
jl 0x17d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_type_specifier_node
static void dump_type_specifier_node(const TypeSpecifierNode* node, int indent) {
    printf_indent(
        indent, 
        "TypeSpecifierNode,Type=\"%s\",StructName=\"%s\"\n",
        decode_type_specifier(node->type_specifier),
        node->struct_name
    );

    if (node->struct_specifier_node != NULL) {
        dump_struct_specifier_node(node->struct_specifier_node, indent + 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edi
callq 0x527f
movq 0x10(%r14), %rcx
leaq 0x8807(%rip), %rsi      # 0xa04a
movq %rbx, %r15
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x191d
leal 0x2(%r15), %edi
movq 0x8(%rsp), %rbx
movq (%rbx), %rdx
leaq 0x8800(%rip), %rsi      # 0xa077
xorl %eax, %eax
callq 0x1566
movq 0x8(%rbx), %rax
cmpl $0x0, 0x8(%rax)
jle 0x191d
leal 0x4(%r15), %ecx
movl %ecx, 0x4(%rsp)
leal 0x6(%r15), %r14d
addl $0x8, %r15d
leaq 0x880f(%rip), %r12      # 0xa0b2
xorl %edx, %edx
movq (%rax), %rax
movq %rdx, 0x10(%rsp)
movq (%rax,%rdx,8), %r13
movl 0x4(%rsp), %edi
leaq 0x87df(%rip), %rsi      # 0xa09b
xorl %eax, %eax
callq 0x1566
movq (%r13), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1903
xorl %ebp, %ebp
movq (%rax), %rax
movq (%rax,%rbp,8), %rbx
movl %r14d, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1566
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x18f3
movl %r15d, %esi
callq 0x181e
incq %rbp
movq (%r13), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %rbp
jl 0x18cf
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %rdx
jl 0x18a5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_direct_declarator_node
static void dump_direct_declarator_node(const DirectDeclaratorNode* node, int indent) {
    printf_indent(
        indent, 
        "DirectDeclaratorNode,Identifier=\"%s\"\n",
        node->identifier
    );

    if (node->declarator_node != NULL) {
        dump_declarator_node(node->declarator_node, indent + 2);
    }

    if (node->direct_declarator_node != NULL) {
        dump_direct_declarator_node(node->direct_declarator_node, indent + 2);
    }

    if (node->conditional_expr_node != NULL) {
        dump_conditional_expr_node(node->conditional_expr_node, indent + 2);
    }

    if (node->param_type_list_node != NULL) {
        dump_param_type_list_node(node->param_type_list_node, indent + 2);
    }

    for (int i = 0; i < node->identifier_list->size; ++i) {
        printf_indent(indent, "identifier[%d]=%s\n", i, node->identifier_list->elements[i]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x879d(%rip), %rsi      # 0xa0e0
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x195d
leal 0x2(%rbx), %esi
callq 0x1741
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x196e
leal 0x2(%rbx), %esi
callq 0x192c
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x197f
leal 0x2(%rbx), %esi
callq 0x19f0
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x19aa
leal 0x2(%rbx), %edi
leaq 0x8992(%rip), %rsi      # 0xa324
xorl %eax, %eax
callq 0x1566
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x19aa
leal 0x4(%rbx), %esi
callq 0x1f8a
movq 0x28(%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x19e4
leaq 0x874b(%rip), %r15      # 0xa106
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %rcx
movl %ebx, %edi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1566
incq %r12
movq 0x28(%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r12
jl 0x19be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_conditional_expr_node
static void dump_conditional_expr_node(const ConditionalExprNode* node, int indent) {
    printf_indent(indent, "ConditionalExprNode\n");

    if (node->logical_or_expr_node != NULL) {
        dump_logical_or_expr_node(node->logical_or_expr_node, indent + 2);
    }

    if (node->expr_node != NULL) {
        dump_expr_node(node->expr_node, indent + 2);
    }

    if (node->conditional_expr_node != NULL) {
        dump_conditional_expr_node(node->conditional_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8718(%rip), %r15      # 0xa119
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1a1d
leal 0x2(%rbx), %esi
callq 0x1a42
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1a2e
leal 0x2(%rbx), %esi
callq 0x1a83
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1a3c
addl $0x2, %ebx
jmp 0x1a01
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_logical_or_expr_node
static void dump_logical_or_expr_node(const LogicalOrExprNode* node, int indent) {
    printf_indent(indent, "LogicalOrExprNode\n");

    if (node->logical_and_expr_node != NULL) {
        dump_logical_and_expr_node(node->logical_and_expr_node, indent + 2);
    }

    if (node->logical_or_expr_node != NULL) {
        dump_logical_or_expr_node(node->logical_or_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x86db(%rip), %r15      # 0xa12e
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1a6f
leal 0x2(%rbx), %esi
callq 0x1ac4
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1a7d
addl $0x2, %ebx
jmp 0x1a53
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_expr_node
static void dump_expr_node(const ExprNode* node, int indent) {
    printf_indent(indent, "ExprNode\n");

    if (node->assign_expr_node != NULL) {
        dump_assign_expr_node(node->assign_expr_node, indent + 2);
    }

    if (node->expr_node != NULL) {
        dump_expr_node(node->expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x86b7(%rip), %r15      # 0xa14b
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1ab0
leal 0x2(%rbx), %esi
callq 0x1f32
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1abe
addl $0x2, %ebx
jmp 0x1a94
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_logical_and_expr_node
static void dump_logical_and_expr_node(const LogicalAndExprNode* node, int indent) {
    printf_indent(indent, "LogicalAndExprNode\n");

    if (node->inclusive_or_expr_node != NULL) {
        dump_inclusive_or_expr_node(node->inclusive_or_expr_node, indent + 2);
    }

    if (node->logical_and_expr_node != NULL) {
        dump_logical_and_expr_node(node->logical_and_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x866c(%rip), %r15      # 0xa141
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1af1
leal 0x2(%rbx), %esi
callq 0x1b05
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1aff
addl $0x2, %ebx
jmp 0x1ad5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_inclusive_or_expr_node
static void dump_inclusive_or_expr_node(const InclusiveOrExprNode* node, int indent) {
    printf_indent(indent, "InclusiveOrExprNode\n");

    if (node->exclusive_or_expr_node != NULL) {
        dump_exclusive_or_expr_node(node->exclusive_or_expr_node, indent + 2);
    }

    if (node->inclusive_or_expr_node != NULL) {
        dump_inclusive_or_expr_node(node->inclusive_or_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x863f(%rip), %r15      # 0xa155
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b32
leal 0x2(%rbx), %esi
callq 0x1b46
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1b40
addl $0x2, %ebx
jmp 0x1b16
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_exclusive_or_expr_node
static void dump_exclusive_or_expr_node(const ExclusiveOrExprNode* node, int indent) {
    printf_indent(indent, "ExclusiveOrExprNode\n");

    if (node->and_expr_node != NULL) {
        dump_and_expr_node(node->and_expr_node, indent + 2);
    }

    if (node->exclusive_or_expr_node != NULL) {
        dump_exclusive_or_expr_node(node->exclusive_or_expr_node, indent + 2);
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8613(%rip), %r15      # 0xa16a
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b73
leal 0x2(%rbx), %esi
callq 0x1b87
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1b81
addl $0x2, %ebx
jmp 0x1b57
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_and_expr_node
static void dump_and_expr_node(const AndExprNode* node, int indent) {
    printf_indent(indent, "AndExprNode\n");

    if (node->equality_expr_node != NULL) {
        dump_equality_expr_node(node->equality_expr_node, indent + 2);
    }

    if (node->and_expr_node != NULL) {
        dump_and_expr_node(node->and_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x85b0(%rip), %r15      # 0xa148
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bb4
leal 0x2(%rbx), %esi
callq 0x1bc8
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1bc2
addl $0x2, %ebx
jmp 0x1b98
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_equality_expr_node
static void dump_equality_expr_node(const EqualityExprNode* node, int indent) {
    printf_indent(
        indent, 
        "EqualityExprNode,CmpType=\"%s\"\n",
        decode_comparison_operator_type(node->cmp_type)
    );

    if (node->relational_expr_node != NULL) {
        dump_relational_expr_node(node->relational_expr_node, indent + 2);
    }

    if (node->equality_expr_node != NULL) {
        dump_equality_expr_node(node->equality_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x85a6(%rip), %r15      # 0xa17f
movl (%r14), %edi
callq 0x52bb
movl %ebx, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1c01
leal 0x2(%rbx), %esi
callq 0x1c15
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1c0f
addl $0x2, %ebx
jmp 0x1bd9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_relational_expr_node
static void dump_relational_expr_node(const RelationalExprNode* node, int indent) {
    printf_indent(
        indent,
        "RelationalExprNode,CmpType=\"%s\"\n",
        decode_comparison_operator_type(node->cmp_type)
    );

    if (node->shift_expr_node != NULL) {
        dump_shift_expr_node(node->shift_expr_node, indent + 2);
    }

    if (node->relational_expr_node != NULL) {
        dump_relational_expr_node(node->relational_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8578(%rip), %r15      # 0xa19e
movl (%r14), %edi
callq 0x52bb
movl %ebx, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1c4e
leal 0x2(%rbx), %esi
callq 0x1c62
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1c5c
addl $0x2, %ebx
jmp 0x1c26
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_shift_expr_node
static void dump_shift_expr_node(const ShiftExprNode* node, int indent) {
    printf_indent(indent, "ShiftExprNode\n");

    if (node->additive_expr_node != NULL) {
        dump_additive_expr_node(node->additive_expr_node, indent + 2);
    }

    if (node->shift_expr_node != NULL) {
        dump_shift_expr_node(node->shift_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x854c(%rip), %r15      # 0xa1bf
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c8f
leal 0x2(%rbx), %esi
callq 0x1ca3
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1c9d
addl $0x2, %ebx
jmp 0x1c73
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_additive_expr_node
static void dump_additive_expr_node(const AdditiveExprNode* node, int indent) {
    printf_indent(
        indent, 
        "AdditiveExprNode,OperatorType=\"%s\"\n", 
        decode_operator_type(node->operator_type)
    );

    if (node->multiplicative_expr_node != NULL) {
        dump_multiplicative_expr_node(node->multiplicative_expr_node, indent + 2);
    }

    if (node->additive_expr_node != NULL) {
        dump_additive_expr_node(node->additive_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x851a(%rip), %r15      # 0xa1ce
movl (%r14), %edi
callq 0x529d
movl %ebx, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1cdc
leal 0x2(%rbx), %esi
callq 0x1cf0
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1cea
addl $0x2, %ebx
jmp 0x1cb4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_multiplicative_expr_node
static void dump_multiplicative_expr_node(const MultiPlicativeExprNode* node, int indent) {
    printf_indent(
        indent,
        "MultiPlicativeExprNode,OperatorType=\"%s\"\n",
        decode_operator_type(node->operator_type)
    );

    if (node->cast_expr_node != NULL) {
        dump_cast_expr_node(node->cast_expr_node, indent + 2);
    }

    if (node->multiplicative_expr_node != NULL) {
        dump_multiplicative_expr_node(node->multiplicative_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x84f1(%rip), %r15      # 0xa1f2
movl (%r14), %edi
callq 0x529d
movl %ebx, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1d29
leal 0x2(%rbx), %esi
callq 0x1d3d
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1d37
addl $0x2, %ebx
jmp 0x1d01
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_cast_expr_node
static void dump_cast_expr_node(const CastExprNode* node, int indent) {
    printf_indent(indent, "CastExprNode\n");

    if (node->unary_expr_node != NULL) {
        dump_unary_expr_node(node->unary_expr_node, indent + 2);
    }

    if (node->cast_expr_node != NULL) {
        dump_cast_expr_node(node->cast_expr_node, indent + 2);
    }

    if (node->type_name_node != NULL) {
        dump_type_name_node(node->type_name_node, indent + 2);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x84cf(%rip), %rsi      # 0xa21c
movl %ebx, %edi
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1d66
leal 0x2(%rbx), %esi
callq 0x1da0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1d77
leal 0x2(%rbx), %esi
callq 0x1d3d
cmpq $0x0, 0x10(%r14)
je 0x1d98
addl $0x2, %ebx
leaq 0x858f(%rip), %rsi      # 0xa317
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1566
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_unary_expr_node
static void dump_unary_expr_node(const UnaryExprNode* node, int indent) {
    printf_indent(
        indent, 
        "UnaryExprNode,UnaryType=\"%s\",OperatorType=\"%s\"\n", 
        decode_unary_type(node->type),
        decode_operator_type(node->op_type)
    );

    if (node->postfix_expr_node != NULL) {
        dump_postfix_expr_node(node->postfix_expr_node, indent + 2);
    }

    if (node->unary_expr_node != NULL) {
        dump_unary_expr_node(node->unary_expr_node, indent + 2);
    }

    if (node->cast_expr_node != NULL) {
        dump_cast_expr_node(node->cast_expr_node, indent + 2);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x20(%rdi), %edi
callq 0x5315
movq %rax, %r15
movl 0x24(%r14), %edi
callq 0x529d
leaq 0x8465(%rip), %rsi      # 0xa22a
movl %ebx, %edi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1566
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1de4
leal 0x2(%rbx), %esi
callq 0x1e13
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1df5
leal 0x2(%rbx), %esi
callq 0x1da0
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x1e0d
addl $0x2, %ebx
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1d3d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chgzm[P]minic/debug.c
// Function: dump_postfix_expr_node
static void dump_postfix_expr_node(const PostfixExprNode* node, int indent) {
    printf_indent(
        indent, 
        "PostfixExprNode,PostfixExprType=\"%s\",Identifier=\"%s\"\n",
        decode_postfix_type(node->postfix_expr_type),
        node->identifier
    );

    if (node->primary_expr_node != NULL) {
        dump_primary_expr_node(node->primary_expr_node, indent + 2);
    }

    if (node->postfix_expr_node != NULL) {
        dump_postfix_expr_node(node->postfix_expr_node, indent + 2);
    }

    if (node->expr_node != NULL) {
        dump_expr_node(node->expr_node, indent + 2);
    }

    for (int i = 0; i < node->assign_expr_nodes->size; ++i) {
        dump_assign_expr_node(node->assign_expr_nodes->elements[i], indent + 2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x28(%rdi), %edi
callq 0x5333
movq 0x20(%r14), %rcx
leaq 0x8427(%rip), %rsi      # 0xa25a
movl %ebx, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movq (%r14), %r15
testq %r15, %r15
je 0x1ed9
leal 0x2(%rbx), %edi
movq 0x18(%r15), %rdx
leaq 0x8437(%rip), %rsi      # 0xa290
xorl %eax, %eax
callq 0x1566
movq (%r15), %r12
testq %r12, %r12
je 0x1ec8
leal 0x4(%rbx), %ebp
movl (%r12), %edi
callq 0x52d9
leaq 0x8436(%rip), %rsi      # 0xa2b1
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1566
movl (%r12), %eax
cmpl $0x2, %eax
je 0x1ea9
testl %eax, %eax
jne 0x1ebe
movl 0x4(%r12), %esi
leaq 0x842d(%rip), %rdi      # 0xa2cd
xorl %eax, %eax
callq 0x10a0
jmp 0x1ec8
movq 0x10(%r12), %rsi
leaq 0x842c(%rip), %rdi      # 0xa2e1
xorl %eax, %eax
callq 0x10a0
jmp 0x1ec8
movl $0xa, %edi
callq 0x1040
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1ed9
leal 0x4(%rbx), %esi
callq 0x1a83
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1eea
leal 0x2(%rbx), %esi
callq 0x1e13
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x1efb
leal 0x2(%rbx), %esi
callq 0x1a83
movq 0x18(%r14), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1f29
addl $0x2, %ebx
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x1f32
incq %r15
movq 0x18(%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %r15
jl 0x1f0b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq