LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/dissect.c
// Function: expr_symbol
static inline struct symbol *expr_symbol(struct expression *expr)
{
	struct symbol *sym = expr->symbol;

	if (!sym) {
		sym = lookup_symbol(expr->symbol_name, NS_SYMBOL);

		if (!sym) {
			sym = alloc_symbol(expr->pos, SYM_BAD);
			bind_symbol(sym, expr->symbol_name, NS_SYMBOL);
			sym->kind = expr->op ?: 'v'; /* see EXPR_CALL */
		}
	}

	if (!sym->ctype.base_type)
		sym->ctype.base_type = &bad_ctype;

	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16dca
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl $0x10, %esi
callq 0x2c1a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16dc8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x10, %esi
callq 0x2c220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x10, %edx
callq 0x2d790
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x16daf
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x16db9
movl $0x76, %eax
movl %eax, -0x18(%rbp)
jmp 0x16db9
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xd0(%rax)
jmp 0x16dca
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x16de4
movq -0x10(%rbp), %rax
leaq 0x84250(%rip), %rcx     # 0x9b030
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x124a0
movl $0x6, %edi
leaq 0x555bd(%rip), %rsi     # 0x67c5c
callq 0x12270
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x185c0
movq %rax, %rdi
callq 0x12790
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x126e0
jmp 0x12773
jmp 0x126e2
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1275b
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1272d
cmpq $0x0, -0x20(%rbp)
jne 0x1272d
jmp 0x12750
movq -0x20(%rbp), %rdi
callq 0x18a30
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x12790
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12840
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x126e9
jmp 0x1275d
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x126e2
movq -0x28(%rbp), %rdi
callq 0x62bb0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x127bd
jmp 0x12832
jmp 0x127bf
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1281e
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1280a
cmpq $0x0, -0x10(%rbp)
jne 0x1280a
jmp 0x12813
movq -0x10(%rbp), %rdi
callq 0x12d00
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x127c6
jmp 0x12820
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x127bf
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x19d(%rip), %rcx       # 0x625f0
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
leaq 0x19e(%rip), %rcx       # 0x62600
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x19f(%rip), %rcx       # 0x62610
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
leaq 0x1b0(%rip), %rcx       # 0x62630
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
leaq 0x231(%rip), %rcx       # 0x626c0
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
leaq 0x2b2(%rip), %rcx       # 0x62750
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
leaq 0x393(%rip), %rcx       # 0x62840
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
leaq 0x464(%rip), %rcx       # 0x62920
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0x485(%rip), %rcx       # 0x62950
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
leaq 0x4b3(%rip), %rcx       # 0x62990
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
leaq 0x511(%rip), %rcx       # 0x62a00
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
leaq 0x57f(%rip), %rcx       # 0x62a80
movq %rcx, 0x98(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x62340
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x12030
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6254b
jmp 0x6256e
xorl %eax, %eax
movl %eax, %edi
leaq 0xd14b(%rip), %rsi      # 0x6f6a1
movl $0x1cd, %edx            # imm = 0x1CD
leaq 0xd14b(%rip), %rcx      # 0x6f6ad
leaq 0xd14c(%rip), %r8       # 0x6f6b5
callq 0x124d0
jmp 0x62570
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x62340
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x121b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12400
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x626ac
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x62ac0
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x62681
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x62b30
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x62340
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x62340
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, -0x28(%rbp)
callq 0x12390
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x6273f
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x12430
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x62717
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x62340
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x62794
movl $0x0, -0x3c(%rbp)
jmp 0x627c9
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x627b7
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x38(%rbp), %rax
jne 0x627b7
movl $0x1, -0x3c(%rbp)
jmp 0x627c7
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x12380
movl %eax, -0x3c(%rbp)
jmp 0x627c9
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x627d7
jmp 0x627fa
xorl %eax, %eax
movl %eax, %edi
leaq 0xcebf(%rip), %rsi      # 0x6f6a1
movl $0x13e, %edx            # imm = 0x13E
leaq 0xced4(%rip), %rcx      # 0x6f6c2
leaq 0xcedb(%rip), %r8       # 0x6f6d0
callq 0x124d0
jmp 0x627fc
cmpl $0x1, -0x14(%rbp)
je 0x62804
jmp 0x6282c
movq -0x28(%rbp), %rdi
callq 0x62b70
movq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0x124b0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x12240
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x62340
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6287d
movl $0x0, -0x2c(%rbp)
jmp 0x628b2
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x628a0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x628a0
movl $0x1, -0x2c(%rbp)
jmp 0x628b0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12380
movl %eax, -0x2c(%rbp)
jmp 0x628b2
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x628c0
jmp 0x628e3
xorl %eax, %eax
movl %eax, %edi
leaq 0xcdd6(%rip), %rsi      # 0x6f6a1
movl $0x157, %edx            # imm = 0x157
leaq 0xce11(%rip), %rcx      # 0x6f6e8
leaq 0xce18(%rip), %r8       # 0x6f6f6
callq 0x124d0
jmp 0x628e5
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
addl $0x1, %esi
callq 0x62ac0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x62b30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x629b5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x629d2
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x62340
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62b70
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x8(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x62a28
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x62a30
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x62a59
movl $0x0, -0x4(%rbp)
jmp 0x62a77
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ast-model.c
// Function: ast_nth_child
static inline
AstNode* ast_nth_child(AstNode *node, int n)
{
	if (!node)
		return NULL;

	inspect_child_node(node);

	if (n >= node->childnodes->len)
		return NULL;
	return g_array_index(node->childnodes, AstNode *, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x62ae0
movq $0x0, -0x8(%rbp)
jmp 0x62b1a
movq -0x10(%rbp), %rdi
callq 0x62b70
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jb 0x62b03
movq $0x0, -0x8(%rbp)
jmp 0x62b1a
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0x12300
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x12510
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, %rdi
movl $0x258, %esi            # imm = 0x258
movl $0x320, %edx            # imm = 0x320
callq 0x12260
movq -0x10(%rbp), %rdi
leaq 0xcb12(%rip), %rsi      # 0x6f70f
movq 0x243dc(%rip), %rdx     # 0x86fe0
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movq %r8, %rcx
callq 0x12290
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x12200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x62c90
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x121a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x12250
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x121a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x12250
movq -0x10(%rbp), %rdi
callq 0x123e0
callq 0x12330
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ast-view.c
// Function: create_view_and_model
static GtkWidget *
create_view_and_model (void *ptr)
{
	GtkTreeViewColumn   *text;
	GtkCellRenderer *renderer;
	AstNode *root;
	GtkWidget *view;

	root = ast_new(NULL, 0, "", ptr, inspect_symbol_list);

	view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(root));

	g_object_unref(root); /* destroy store automatically with view */

	renderer = gtk_cell_renderer_text_new();
	text = gtk_tree_view_column_new_with_attributes("Node", renderer,
						       "text", AST_COL_NAME,
						       NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(view), text);

	return view;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
leaq 0x1b7c(%rip), %rdx      # 0x64829
leaq 0x8ac(%rip), %r8        # 0x63560
callq 0x62510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x12350
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, %rdi
callq 0x12480
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12410
callq 0x12230
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xc99d(%rip), %rdi      # 0x6f69c
leaq 0x3c26(%rip), %rdx      # 0x6692c
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x120f0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x122f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x120e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x12060
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./ast-model.h
// Function: ast_append_child
static inline
AstNode* ast_append_child(AstNode *parent, const char *text,
			   void *ptr, void (*inspect)(AstNode*))
{
	if (ptr) {
		AstNode *child = ast_new(parent, parent->childnodes->len,
						text, ptr, inspect);
		g_array_append_val(parent->childnodes, child);
		return child;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x63133
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x62510
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x121c0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6313b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x63590
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x4475(%rip), %rdi      # 0x67633
xorl %eax, %eax
callq 0x121f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x11, %eax
ja 0x632c2
movq -0x18(%rbp), %rax
leaq 0xc544(%rip), %rcx      # 0x6f738
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0xc59f(%rip), %rsi      # 0x6f7af
leaq -0x497(%rip), %rcx      # 0x62d80
callq 0x630d0
jmp 0x632c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0xc677(%rip), %rsi      # 0x6f8ab
leaq -0xbb(%rip), %rcx       # 0x63180
callq 0x630d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0xc65e(%rip), %rsi      # 0x6f8b1
leaq -0xda(%rip), %rcx       # 0x63180
callq 0x630d0
jmp 0x632c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0xc644(%rip), %rsi      # 0x6f8b8
leaq 0x55(%rip), %rcx        # 0x632d0
callq 0x630d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0xc630(%rip), %rsi      # 0x6f8c3
leaq -0x11a(%rip), %rcx      # 0x63180
callq 0x630d0
jmp 0x632c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0xc620(%rip), %rsi      # 0x6f8d4
leaq -0x13b(%rip), %rcx      # 0x63180
callq 0x630d0
jmp 0x632c4
jmp 0x632c4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
andl $0xff, %edi
callq 0x63520
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2abe0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x63326
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x63337
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x326a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq 0xc51c(%rip), %rdi      # 0x6f866
xorl %eax, %eax
callq 0x121f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdx
leaq 0xc501(%rip), %rsi      # 0x6f870
leaq -0xa6(%rip), %rcx       # 0x632d0
callq 0x630d0
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
subl $0x40, %eax
jne 0x63392
jmp 0x63390
jmp 0x633f8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdx
leaq 0xc4d9(%rip), %rsi      # 0x6f881
leaq 0x1b1(%rip), %rcx       # 0x63560
callq 0x630d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0xc4c2(%rip), %rsi      # 0x6f88c
leaq 0x18f(%rip), %rcx       # 0x63560
callq 0x630d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdx
leaq 0xc4ad(%rip), %rsi      # 0x6f899
leaq -0x673(%rip), %rcx      # 0x62d80
callq 0x630d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/ast-inspect.c
// Function: inspect_ptr_list
static inline void inspect_ptr_list(AstNode *node, const char *name, void (*inspect)(AstNode *))
{
	struct ptr_list *ptrlist = node->ptr;
	void *ptr;
	int i = 0;

	node->text = g_strdup_printf("%s %s:", node->text, name);
	FOR_EACH_PTR(ptrlist, ptr) {
		char *index = g_strdup_printf("%d: ", i++);
		ast_append_child(node, index, ptr, inspect);
	} END_FOR_EACH_PTR(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq 0xc346(%rip), %rdi      # 0x6f780
movb $0x0, %al
callq 0x121f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x63470
jmp 0x63515
jmp 0x63472
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x634fd
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x634bd
cmpq $0x0, -0x28(%rbp)
jne 0x634bd
jmp 0x634ef
movl -0x2c(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
leaq 0xc4c9(%rip), %rdi      # 0x6f998
movb $0x0, %al
callq 0x121f0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x630d0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x63479
jmp 0x634ff
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x63472
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x13d5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0xe050
movl -0x1c(%rbp), %esi
movq %rax, %rdx
leaq 0xdc80(%rip), %rdi      # 0xf004
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x13aa
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xe056(%rip), %rdi      # 0xf3f9
movb $0x0, %al
callq 0x1090
leaq 0xe262(%rip), %rdi      # 0xf613
movb $0x0, %al
callq 0x1090
movq 0x13c19(%rip), %rax     # 0x14fd8
movq (%rax), %rdi
callq 0x1100
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1343
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xdc25(%rip), %rdi      # 0xf018
movb $0x0, %al
callq 0x1090
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x143f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x1450
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1401
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_external_decl_node
static void dump_external_decl_node(const ExternalDeclNode* node, int indent) {
    printf_indent(indent, "ExternalDeclNode\n");

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xdbbe(%rip), %rsi      # 0xf027
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x148c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1590
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14aa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1640
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14c8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x16f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1508
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x154f
movl $0x20, %edi
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1532
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq 0x13a61(%rip), %rax     # 0x14fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1140
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_func_def_node
static void dump_func_def_node(const FuncDefNode* node, int indent) {
    printf_indent(indent, "FuncDefNode\n");

    for (int i = 0; i < node->decl_specifier_nodes->size; ++i) {
        const DeclSpecifierNode* n = (const DeclSpecifierNode*)(node->decl_specifier_nodes->elements[i]);
        dump_decl_specifier_node(n, indent + 2);
    }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xda90(%rip), %rsi      # 0xf039
movb $0x0, %al
callq 0x14d0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x15f6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1740
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15b7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1614
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1790
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1632
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x17f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xdd01(%rip), %rsi      # 0xf35a
movb $0x0, %al
callq 0x14d0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x169e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1740
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1667
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x16de
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2950
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16a5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd8ed(%rip), %rsi      # 0xf046
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x177c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1860
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xdc86(%rip), %rsi      # 0xf42f
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x17cc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x19f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17ea
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1a20
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xdb62(%rip), %rsi      # 0xf36b
movb $0x0, %al
callq 0x14d0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1856
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2540
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1817
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x7130
movl -0x10(%rbp), %edi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xd7c4(%rip), %rsi      # 0xf059
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x18ba
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x18c0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_struct_specifier_node
static void dump_struct_specifier_node(const StructSpecifierNode* node, int indent) {
    printf_indent(
        indent,
        "StructSpecifierNode,Identifer=\"%s\"\n",
        node->identifier
    );

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xd7a6(%rip), %rsi      # 0xf086
movb $0x0, %al
callq 0x14d0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1927
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1930
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18ee
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_pointer_node
static void dump_pointer_node(const PointerNode* node, int indent) {
    printf_indent(
        indent, 
        "PointerNode,Count=%d\n",
        node->count
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0xd6ca(%rip), %rsi      # 0xf0d9
movb $0x0, %al
callq 0x14d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xd6af(%rip), %rsi      # 0xf0ef
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a65
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1790
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1a83
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1a20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1aa1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1b10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1abf
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1b90
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1b08
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xd61f(%rip), %rsi      # 0xf115
movb $0x0, %al
callq 0x14d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1ac6
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd5ff(%rip), %rsi      # 0xf128
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1b4c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1be0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1b6a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1b88
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1b10
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chgzm[P]minic/debug.c
// Function: dump_param_type_list_node
static void dump_param_type_list_node(const ParamTypeListNode* node, int indent) {
    printf_indent(
        indent,
        "ParamTypeListNode\n"
    );

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd78a(%rip), %rsi      # 0xf333
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1bce
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2450
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd544(%rip), %rsi      # 0xf13d
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c1c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1ca0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c3a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1be0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd501(%rip), %rsi      # 0xf15a
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c7c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x2330
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c9a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1c40
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xd497(%rip), %rsi      # 0xf150
movb $0x0, %al
callq 0x14d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1cdc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1d00
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1cfa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1ca0
addq $0x10, %rsp
popq %rbp
retq