LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/parse.c
// Function: parse_stmt_selection
ast_n *parse_stmt_selection(lexer *lx) {
	ast_n *node;
	if (lex_peek(lx).type == TOK_KW_IF) {
		node = astn_new(STMT, STMT_IF, lex_peek(lx));
		lex_adv(lx);

		node->dat.stmt.expr = parse_condition(lx, "if statement");
		node->dat.stmt.body = parse_stmt(lx);
		if (lex_peek(lx).type == TOK_KW_ELSE) {
			lex_adv(lx);
			node->dat.stmt.else_body = parse_stmt(lx);
		}
	} else if (lex_peek(lx).type == TOK_KW_SWITCH) {
		node = astn_new(STMT, STMT_SWITCH, lex_peek(lx));
		lex_adv(lx);

		node->dat.stmt.expr = parse_condition(lx, "switch statement");
		node->dat.stmt.body = parse_stmt(lx);
	}

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x36, (%r14)
jne 0xaa43
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x2, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a94
leaq 0x4264(%rip), %rsi      # 0xec5c
movq %rbx, %rdi
callq 0xaf85
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa846
movq %rax, 0x20(%r14)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x37, (%r15)
jne 0xaabe
movq %rbx, %rdi
callq 0x7a94
movq %rbx, %rdi
callq 0xa846
movq %rax, 0x28(%r14)
jmp 0xaabe
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x38, (%r14)
jne 0xaabe
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x3, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a94
leaq 0x41c3(%rip), %rsi      # 0xec69
movq %rbx, %rdi
callq 0xaf85
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa846
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/parse.c
// Function: parse_stmt_iteration
ast_n *parse_stmt_iteration(lexer *lx) {
	switch (lex_peek(lx).type) {
		case TOK_KW_WHILE: lex_adv(lx); return parse_stmt_while(lx);
		case TOK_KW_FOR:   lex_adv(lx); return parse_stmt_for(lx);
		case TOK_KW_DO:	   lex_adv(lx); return parse_stmt_do_while(lx);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
movl (%r14), %ecx
cmpl $0x3b, %ecx
je 0xab1e
cmpl $0x3a, %ecx
je 0xab0c
cmpl $0x39, %ecx
jne 0xab2e
movq %rbx, %rdi
callq 0x7a94
movq %rbx, %rdi
callq 0xb031
jmp 0xab2e
movq %rbx, %rdi
callq 0x7a94
movq %rbx, %rdi
callq 0xb0a3
jmp 0xab2e
movq %rbx, %rdi
callq 0x7a94
movq %rbx, %rdi
callq 0xb242
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/parse.c
// Function: parse_stmt_label
ast_n *parse_stmt_label(lexer *lx) {
	ast_n *node = NULL;

	token t = lex_peek(lx);
	switch (t.type) {
		case TOK_IDENT:
			node = astn_new(STMT, STMT_LABEL, t);
			symtable_def_label(lx->stb, t.dat.sval, &t.loc);
			node->dat.stmt.lbl = t.dat.sval;
			lex_adv(lx);
			break;
		case TOK_KW_CASE:
			node = astn_new(STMT, STMT_CASE, t);
			lex_adv(lx);
			node->dat.stmt.expr = parse_expr_cond(lx); //TODO: parse_constexpr();
			break;
		case TOK_KW_DEFAULT:
			node = astn_new(STMT, STMT_DEFAULT, t);
			lex_adv(lx);
			break;
		default:
			return NULL;
	}

	//Missing ':'
	t = lex_peek(lx);
	if (t.type != TOK_COL)
		c_error(&t.loc, "Missing ':' after label name\n");
	lex_adv(lx);

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
movl (%r14), %eax
cmpl $0x3d, %eax
je 0xac02
cmpl $0x3c, %eax
je 0xabbd
cmpl $0x35, %eax
jne 0xac8a
leaq 0x38(%rsp), %r15
movups -0x8(%r15), %xmm0
movups 0x8(%r15), %xmm1
movups 0x18(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x7, %esi
callq 0x356c
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq 0x18(%r15), %rsi
movq %r15, %rdx
callq 0xc1b6
movq 0x18(%r15), %rax
movq %rax, 0x10(%r14)
jmp 0xac31
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x8, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a94
movq %rbx, %rdi
callq 0x98cb
movq %rax, 0x18(%r14)
jmp 0xac39
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x9, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a94
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a57
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movaps %xmm2, 0x50(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
cmpl $0x2, 0x30(%rsp)
je 0xac80
leaq 0x38(%rsp), %rdi
leaq 0x40a8(%rip), %rsi      # 0xed21
xorl %eax, %eax
callq 0x3250
movq %rbx, %rdi
callq 0x7a94
jmp 0xac8d
xorl %r14d, %r14d
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/parse.c
// Function: parse_stmt_expr
ast_n *parse_stmt_expr(lexer *lx) {
	ast_n *node;
	if (lex_peek(lx).type == TOK_SEM) {
		lex_adv(lx);
		return NULL;
	}

	node = astn_new(STMT, STMT_EXPR, lex_peek(lx));
	node->dat.stmt.expr = parse_expr(lx);

	if (lex_peek(lx).type == TOK_SEM) {
		lex_adv(lx);
	} else {
		token t = lex_peek(lx);
		c_error(&t.loc, "Missing ';' after expression\n");
	}

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x1, (%r14)
jne 0xaeeb
movq %rbx, %rdi
callq 0x7a94
xorl %r14d, %r14d
jmp 0xaf75
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
xorl %esi, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x985d
movq %rax, 0x18(%r14)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x1, (%r15)
jne 0xaf55
movq %rbx, %rdi
callq 0x7a94
jmp 0xaf75
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x7a57
leaq 0x38(%rsp), %rdi
leaq 0x3cd0(%rip), %rsi      # 0xec3e
xorl %eax, %eax
callq 0x3250
movq %r14, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/parse.c
// Function: parse_condition
ast_n *parse_condition(lexer *lx, char *of) {
	if (lex_peek(lx).type == TOK_LPR) {
		lex_adv(lx);
	} else {
		c_error(&lx->tgt->loc, "Missing '(' before condition body\n");
	}

	ast_n *cond = parse_expr(lx);
	if (cond == NULL)
		c_error(&lx->tgt->loc, "Expected expression in %s condition\n", of);

	if (lex_peek(lx).type == TOK_RPR) {
		lex_adv(lx);
	} else {
		c_error(&lx->tgt->loc, "Missing ')' after condition body\n");
	}

	return cond;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x7, (%r14)
jne 0xafb4
movq %rbx, %rdi
callq 0x7a94
jmp 0xafc9
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3bef(%rip), %rsi      # 0xebb1
xorl %eax, %eax
callq 0x3250
movq %rbx, %rdi
callq 0x985d
movq %rax, %r14
testq %rax, %rax
jne 0xaff1
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3bed(%rip), %rsi      # 0xebd4
movq %r15, %rdx
xorl %eax, %eax
callq 0x3250
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x8, (%r15)
jne 0xb00f
movq %rbx, %rdi
callq 0x7a94
jmp 0xb024
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3bdc(%rip), %rsi      # 0xebf9
xorl %eax, %eax
callq 0x3250
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/parse.c
// Function: parse_stmt_while
ast_n *parse_stmt_while(lexer *lx) {
	ast_n *node = astn_new(STMT, STMT_WHILE, lex_peek(lx));
	node->dat.stmt.expr = parse_condition(lx, "while loop");
	node->dat.stmt.body = parse_stmt(lx);
	return node;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x4, %esi
callq 0x356c
movq %rax, %r14
leaq 0x3c70(%rip), %rsi      # 0xecf0
movq %rbx, %rdi
callq 0xaf85
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa846
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/parse.c
// Function: parse_stmt_do_while
ast_n *parse_stmt_do_while(lexer *lx) {
	ast_n *node = astn_new(STMT, STMT_DO_WHILE, lex_peek(lx));

	//Parse body
	node->dat.stmt.body = parse_stmt(lx);

	//Parse condition
	if (lex_peek(lx).type == TOK_KW_WHILE) {
		lex_adv(lx);
	} else {
		c_error(&lx->tgt->loc, "Expected 'while' after do-while body\n");
	}

	node->dat.stmt.expr = parse_condition(lx, "do-while loop");

	if (lex_peek(lx).type == TOK_SEM) {
		lex_adv(lx);
	} else {
		c_error(&lx->tgt->loc, "Missing ';' after do-while condition\n");
	}
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x6, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0xa846
movq %rax, 0x20(%r14)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x39, (%r15)
jne 0xb2be
movq %rbx, %rdi
callq 0x7a94
jmp 0xb2d3
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x39fb(%rip), %rsi      # 0xecc7
xorl %eax, %eax
callq 0x3250
leaq 0x3a13(%rip), %rsi      # 0xeced
movq %rbx, %rdi
callq 0xaf85
movq %rax, 0x18(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x1, (%r15)
jne 0xb306
movq %rbx, %rdi
callq 0x7a94
jmp 0xb31b
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x39e7(%rip), %rsi      # 0xecfb
xorl %eax, %eax
callq 0x3250
movq %r14, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_defparams
void ppd_defparams(lexer *lx, s_type *mtype) {
	token *t = &lx->ahead;
	s_pos *loc = &lx->tgt->loc;
	lex_advc(lx);
	lex_next(lx);
	if (t->nline) {
		c_error(loc, "Expected ')' before newline\n");
		return;
	}

	//Read parameters
	while (t->type != TOK_RPR) {
		if (t->nline) {
			c_error(loc, "Unexpected end of line in macro parameter list\n");
			return;
		}

		//Read identifier
		if (t->type != TOK_IDENT) {
			c_error(loc, "Missing identifier in macro parameter list\n");
			break;
		}
		vector_add(&mtype->param, param_new(type_new(TYPE_MACRO), t->dat.sval));
		lex_next(lx);

		//Read comma
		if (t->type != TOK_CMM && t->type != TOK_RPR) {
			c_error(loc, "Missing comma in macro parameter list\n");
			break;
		} else if (t->type == TOK_CMM) {
			lex_next(lx);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
callq 0x6776
movq %r15, %rdi
callq 0x719b
cmpl $0x0, 0x14(%r15)
je 0xb37a
leaq 0x3a23(%rip), %r12      # 0xed7e
addq $0x28, %rbx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3250
movl 0x10(%r15), %eax
cmpl $0x8, %eax
je 0xb3f0
addq $0x28, %r14
leaq 0x3a0d(%rip), %r12      # 0xed9b
leaq 0x3a36(%rip), %r13      # 0xedcb
leaq 0x3a5b(%rip), %rbp      # 0xedf7
cmpl $0x0, 0x14(%r15)
jne 0xb35b
cmpl $0x35, %eax
jne 0xb3ff
movl $0x1, %edi
callq 0xbfcd
movq 0x30(%r15), %rsi
movq %rax, %rdi
callq 0xc476
movq %r14, %rdi
movq %rax, %rsi
callq 0xc9fa
movq %r15, %rdi
callq 0x719b
movl 0x10(%r15), %eax
cmpl $0x8, %eax
je 0xb3e7
cmpl $0x3, %eax
jne 0xb407
movq %r15, %rdi
callq 0x719b
movl 0x10(%r15), %eax
cmpl $0x8, %eax
jne 0xb39c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r12
jmp 0xb35b
movq %rbp, %r12
jmp 0xb35b
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_error
void ppd_error(lexer *lx, int is_warn) {
	s_pos loc = lx->tgt->loc;

	//Read message
	int len = 0;
	int bsize = 256;
	char cur = lex_cur(lx);
	char *buf = malloc(bsize);
	while (isspace(cur)) cur = lex_advc(lx);
       	while (cur != '\n') {
		//Resize if needed
		if (len+2 == bsize) {
			bsize *= 2;
			buf = realloc(buf, bsize);
		}

		//Copy character to buffer
		buf[len++] = cur;
		cur = lex_advc(lx);
	}
	buf[len] = '\0';

	//Print error/warning
	if (is_warn) c_warn(&loc, "%s\n", buf);
	else c_error(&loc, "%s\n", buf);

	free(buf);
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rax
movq 0x38(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups 0x28(%rax), %xmm0
movaps %xmm0, (%rsp)
callq 0x6759
movl %eax, %r15d
movl $0x100, %edi            # imm = 0x100
callq 0x3170
movq %rax, %rbx
callq 0x3230
movq %rax, %r12
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xb62b
movq %r14, %rdi
callq 0x6776
movl %eax, %r15d
movq (%r12), %rax
jmp 0xb60f
cmpb $0xa, %r15b
jne 0xb635
xorl %eax, %eax
jmp 0xb675
movl $0x100, %r13d           # imm = 0x100
xorl %r12d, %r12d
leaq 0x2(%r12), %rax
movl %r13d, %ecx
cmpq %rcx, %rax
jne 0xb65c
addl %r13d, %r13d
movslq %r13d, %rsi
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rbx
movb %r15b, (%rbx,%r12)
incq %r12
movq %r14, %rdi
callq 0x6776
movl %eax, %r15d
cmpb $0xa, %al
jne 0xb63e
movl %r12d, %eax
movb $0x0, (%rbx,%rax)
leaq 0x37f5(%rip), %rsi      # 0xee75
movq %rsp, %rdi
movq %rbx, %rdx
xorl %eax, %eax
testl %ebp, %ebp
je 0xb693
callq 0x3338
jmp 0xb698
callq 0x3250
movq %rbx, %rdi
callq 0x3030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_undef
void ppd_undef(lexer *lx) {
	//Read macro name
	lex_next(lx);
	token mname = lex_peek(lx);
	if (mname.type != TOK_IDENT)
		c_error(&lx->tgt->loc, "Invalid macro name '%s'\n", mname.dat.sval);

	//Check the global scope
	symbol *s = map_get(&lx->stb->s_global->table, mname.dat.sval);
	if (s == NULL || s->type->kind != TYPE_MACRO)
		return;
	map_remove(&lx->stb->s_global->table, mname.dat.sval);

	return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x719b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x35, (%r14)
je 0xb8af
movq (%rbx), %rdi
addq $0x28, %rdi
movq 0x28(%rsp), %rdx
leaq 0x364b(%rip), %rsi      # 0xeef3
xorl %eax, %eax
callq 0x3250
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xc7db
testq %rax, %rax
je 0xb8e1
movq 0x8(%rax), %rax
cmpl $0x1, (%rax)
jne 0xb8e1
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xc8bd
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_constexpr
int ppd_constexpr(lexer *lx, int *err) {
	vector toks;
	vector_init(&toks, VECTOR_DEFAULT);

	//Get tokens until the end of the line
	//Expand macros by default, unless the previous token was "defined"
	//Function-like macros without parameters do not produce an error
	lx->m_exp = 1; lx->m_cexpr = 1;
	int nline = lex_wspace(lx);
	token t = BLANK_TOKEN;
	while (!(nline = lex_wspace(lx))) {
		lex_next(lx);
		t = lex_peek(lx);

		//Add the token to the vector
		token *tn = malloc(sizeof(struct TOKEN));
		if (t.type == TOK_IDENT && !strcmp(t.dat.sval, "defined"))
			t.type = TOK_DEFINED;
		*tn = t;
		vector_push(&toks, tn);
		lx->m_exp = !(t.type == TOK_DEFINED);
	}
	lx->m_exp = 0; lx->m_cexpr = 0;

	//Call the evaluator
	int res = eval_constexpr(lx, &toks, err);
	
	//Clean up
	for (int i = 0; i<toks.len; i++) {
		token *t = toks.table[i];
		if (t->dtype != NULL) {
			type_del(t->dtype);
		} else if (t->type == TOK_IDENT) {
			free(t->dat.sval);
		}
		free(t);
	}
	vector_close(&toks);
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0xc964
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x68(%r14)
movq %r14, %rdi
callq 0x78a3
leaq 0x8b0d(%rip), %rax      # 0x14438
movups 0x4(%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x2c(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %r14, %rdi
callq 0x78a3
testl %eax, %eax
jne 0xba03
leaq 0x4c(%rsp), %r12
movq %r14, %rdi
callq 0x719b
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x7a57
movl 0x48(%rsp), %r13d
movups (%r12), %xmm0
movups 0xc(%r12), %xmm1
movaps %xmm0, 0x20(%rsp)
movups %xmm1, 0x2c(%rsp)
movq 0x68(%rsp), %rbp
movq 0x70(%rsp), %r15
movl $0x30, %edi
callq 0x3170
movq %rax, %rbx
cmpl $0x35, %r13d
jne 0xb9bc
movq %rbp, %rdi
leaq 0x2795(%rip), %rsi      # 0xe13d
callq 0x3110
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,2), %r13d
addl $0x32, %r13d
movl %r13d, (%rbx)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x4(%rbx)
movups 0x2c(%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movq %rbp, 0x20(%rbx)
movq %r15, 0x28(%rbx)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xca91
xorl %eax, %eax
cmpl $0x32, %r13d
setne %al
movl %eax, 0x68(%r14)
movq %r14, %rdi
callq 0x78a3
testl %eax, %eax
je 0xb952
movq $0x0, 0x68(%r14)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq 0x18(%rsp), %rdx
callq 0x39c1
movl %eax, %ebx
cmpl $0x0, 0x8(%r15)
jle 0xba69
xorl %r15d, %r15d
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %r14
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0xba45
callq 0xc2c4
jmp 0xba54
cmpl $0x35, (%r14)
jne 0xba54
movq 0x20(%r14), %rdi
callq 0x3030
movq %r14, %rdi
callq 0x3030
incq %r15
movslq 0x10(%rsp), %rax
cmpq %rax, %r15
jl 0xba2c
leaq 0x8(%rsp), %rdi
callq 0xc9b1
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_if
void ppd_if(lexer *lx) {
	int err = 0;
	int res = (ppd_constexpr(lx, &err)) ? 1 : 0;
	lexer_add_cond(lx, res);
	return;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
callq 0xb8e9
xorl %esi, %esi
testl %eax, %eax
setne %sil
movq %rbx, %rdi
callq 0x5b19
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_ifdef
void ppd_ifdef(lexer *lx) {
	lex_next(lx);
	token t = lex_peek(lx);
	if (t.type != TOK_IDENT)
		c_error(&t.loc, "Expected identifier after #ifdef\n");

	int res = (symtable_search(lx->stb, t.dat.sval) != NULL) ? 1 : 0;
	lexer_add_cond(lx, res);
	return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x719b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x35, (%r14)
je 0xbaea
leaq 0x10(%rsp), %rdi
leaq 0x3429(%rip), %rsi      # 0xef0c
xorl %eax, %eax
callq 0x3250
movq 0x60(%rbx), %rdi
movq 0x28(%rsp), %rsi
callq 0xc219
xorl %esi, %esi
testq %rax, %rax
setne %sil
movq %rbx, %rdi
callq 0x5b19
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_ifndef
void ppd_ifndef(lexer *lx) {
	lex_next(lx);
	token t = lex_peek(lx);
	if (t.type != TOK_IDENT)
		c_error(&t.loc, "Expected identifier after #ifndef\n");

	int res = (symtable_search(lx->stb, t.dat.sval) != NULL) ? 0 : 1;
	lexer_add_cond(lx, res);
	return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x719b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7a57
cmpl $0x35, (%r14)
je 0xbb49
leaq 0x10(%rsp), %rdi
leaq 0x33ec(%rip), %rsi      # 0xef2e
xorl %eax, %eax
callq 0x3250
movq 0x60(%rbx), %rdi
movq 0x28(%rsp), %rsi
callq 0xc219
xorl %esi, %esi
testq %rax, %rax
sete %sil
movq %rbx, %rdi
callq 0x5b19
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_elif
void ppd_elif(lexer *lx) {
	lex_cond *cond = vector_top(&lx->conds);
	if (cond == NULL) {
		c_error(&lx->tgt->loc, "#elif before #if\n");
		return;
	}

	int err = 0;
	cond->was_true |= cond->is_true;
	cond->is_true = (ppd_constexpr(lx, &err)) ? 1 : 0;
	cond->is_true = 0;
	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xcabb
testq %rax, %rax
je 0xbbaf
movq %rax, %r14
xorl %ebp, %ebp
leaq 0xc(%rsp), %rsi
movl %ebp, (%rsi)
movl (%rax), %eax
orl %eax, 0x4(%r14)
movq %rbx, %rdi
callq 0xb8e9
movl %ebp, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3394(%rip), %rsi      # 0xef51
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_else
void ppd_else(lexer *lx) {
	lex_cond *cond = vector_top(&lx->conds);
	if (cond == NULL) {
		c_error(&lx->tgt->loc, "#else before #if\n");
		return;
	}
	if (cond->has_else) {
		c_error(&lx->tgt->loc, "#else after #else\n");
		return;
	}

	cond->was_true |= cond->is_true;
	cond->is_true = 1;
	cond->has_else = 1;
	return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xcabb
testq %rax, %rax
je 0xbbf4
cmpl $0x0, 0x8(%rax)
je 0xbc0a
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3383(%rip), %rsi      # 0xef75
jmp 0xbc02
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3361(%rip), %rsi      # 0xef63
xorl %eax, %eax
popq %rbx
jmp 0x3250
movl (%rax), %ecx
orl %ecx, 0x4(%rax)
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/ppd.c
// Function: ppd_endif
void ppd_endif(lexer *lx) {
	lex_cond *cond = vector_top(&lx->conds);
	if (cond == NULL) {
		c_error(&lx->tgt->loc, "#endif before #if\n");
		return;
	}

	lexer_del_cond(lx);
	return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xcabb
testq %rax, %rax
je 0xbc36
movq %rbx, %rdi
popq %rbx
jmp 0x5b4c
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3344(%rip), %rsi      # 0xef88
xorl %eax, %eax
popq %rbx
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: symtable_init
void symtable_init(symtable *stb) {
	stb->s_global = malloc(sizeof(struct SCOPE));
	stb->s_cur = stb->s_global;
	map_init(&stb->s_global->table, MAP_DEFAULT);
	stb->s_global->prev = NULL;
	stb->func = NULL;
	return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3170
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movq %rax, %rdi
movl $0x11, %esi
callq 0xc646
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: symtable_def
symbol *symtable_def(symtable *stb, char *name, s_type *type, s_pos *loc) {
	//Check for conflicts in current scope
	symbol *dup = map_get(&stb->s_cur->table, name);
	if (dup != NULL) {
		if (!type_compare(dup->type, type)) {
			c_error(loc, "Conflicting types for '%s'\n", name);
			return NULL;
		}

		if (stb->s_cur == stb->s_global) {
			return dup;
		} else {
			c_error(loc, "Redeclaration of '%s'\n", name);
			return NULL;
		}
	}

	//Create a new symbol and add it to the table
	//Macros always go in global scope
	symbol *s = sym_new(name, type);
	if (type->kind == TYPE_MACRO) {
		map_insert(&stb->s_global->table, name, s);
	} else {
		map_insert(&stb->s_cur->table, name, s);
	}
	if (stb->func != NULL)
		vector_add(&stb->func->lvars, s);

	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xc7db
testq %rax, %rax
je 0xbf6c
movq %rax, %rbx
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0xc157
testl %eax, %eax
je 0xbfaa
movq (%r15), %rax
cmpq 0x8(%r15), %rax
je 0xbfc0
leaq 0x30cc(%rip), %rsi      # 0xf036
jmp 0xbfb1
movq %r14, %rdi
movq %r13, %rsi
callq 0xc256
movq %rax, %rbx
xorl %eax, %eax
cmpl $0x1, (%r13)
sete %al
movq (%r15,%rax,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc840
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xbfc0
addq $0x20, %rdi
movq %rbx, %rsi
callq 0xc9fa
jmp 0xbfc0
leaq 0x3069(%rip), %rsi      # 0xf01a
xorl %ebx, %ebx
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3250
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: type_new
s_type *type_new(int kind) {
	s_type *type = malloc(sizeof(struct TYPE));
	type->kind = kind;
	type->size = -1;
	type->s_class = CLASS_UNDEF;
	type->is_signed = 1;
	type->is_const = 0;
	type->is_volatile = 0;

	type->ref = NULL;
	type->ref_len = 0;

	vector_init(&type->param, VECTOR_EMPTY);
	type->ret = NULL;
	
	return type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x40, %edi
callq 0x3170
movq %rax, %r14
movl %ebx, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x4(%r14)
movl $0x1, 0xc(%r14)
leaq 0x28(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x0, 0x20(%r14)
xorl %esi, %esi
callq 0xc964
movq $0x0, 0x38(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: symtable_close
void symtable_close(symtable *stb) {
	scope *sc = stb->s_cur;
	while (sc != NULL) {
		for (int i=0; i<sc->table.max; i++) {
			if (sc->table.table[i] != NULL)
				sym_del(sc->table.table[i]);
		}
		map_close(&sc->table);

		scope *prev = sc->prev;
		free(sc);
		sc = prev;
	}
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xc06f
cmpl $0x0, 0x14(%rbx)
jle 0xc053
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xc047
callq 0xc077
incq %r14
movslq 0x14(%rbx), %rax
cmpq %rax, %r14
jl 0xc036
movq %rbx, %rdi
callq 0xc696
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x3030
movq %r14, %rbx
testq %r14, %r14
jne 0xc02d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: sym_del
void sym_del(symbol *s) {
	if (s->name != NULL && !s->is_predef)
		free(s->name);
	if (s->type != NULL)
		type_del(s->type);

	/*
	 * s->fbody is part of the AST, so it will be freed elsewhere.
	 * s->labels also contains strings owned by the AST.
	 */
	for (int i=0; i<s->lvars.len; i++) {
		if (s->lvars.table[i] != NULL)
			sym_del(s->lvars.table[i]);
	}
	vector_close(&s->lvars);
	map_close(&s->labels);

	if (s->mac_exp != NULL && !s->is_predef)
		free(s->mac_exp);

	free(s);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc092
cmpl $0x0, 0x54(%rbx)
jne 0xc092
callq 0x3030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xc0a0
callq 0xc2c4
leaq 0x20(%rbx), %r14
cmpl $0x0, 0x28(%rbx)
jle 0xc0ca
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0xc0be
callq 0xc077
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0xc0ad
movq %r14, %rdi
callq 0xc9b1
leaq 0x30(%rbx), %rdi
callq 0xc696
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xc0ef
cmpl $0x0, 0x54(%rbx)
jne 0xc0ef
callq 0x3030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: symtable_scope_enter
void symtable_scope_enter(symtable *stb) {
	scope *sc = malloc(sizeof(struct SCOPE));
	sc->prev = stb->s_cur;
	map_init(&sc->table, MAP_DEFAULT);
	stb->s_cur = sc;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3170
movq %rax, %r14
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, %rdi
movl $0x11, %esi
callq 0xc646
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: symtable_scope_leave
void symtable_scope_leave(symtable *stb) {
	scope *sc = stb->s_cur;
	map_close(&sc->table);
	stb->s_cur = sc->prev;
	free(sc);
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0xc696
movq 0x18(%r14), %rax
movq %rax, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: type_compare
int type_compare(s_type *a, s_type *b) {
	if (a == NULL && b == NULL) return 1;
	if (a == NULL || b == NULL) return 0;
	if (!type_compare_noref(a, b)) return 0;

	//Compare reference types
	s_type *i = a->ref;
	s_type *j = b->ref;
	while (i != NULL) {
		if (j == NULL) return 0;
		if (!type_compare_noref(i, j)) return 0;
		i = i->ref;
		j = j->ref;
	}
	if (j != NULL) return 0;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x1, %ebx
movq %rdi, %rax
orq %rsi, %rax
je 0xc181
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
je 0xc189
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0xc4a9
testl %eax, %eax
je 0xc181
movq 0x18(%r14), %r14
movq 0x18(%r15), %r15
testq %r15, %r15
je 0xc1ac
testq %r14, %r14
jne 0xc189
jmp 0xc181
xorl %ebx, %ebx
testq %r14, %r14
sete %bl
jmp 0xc181
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: symtable_def_label
void symtable_def_label(symtable *stb, char *name, s_pos *loc) {
	if (stb->func == NULL) {
		c_error(loc, "Label '%s' declared outside of function\n", name);
		return;
	}
	
	//Check for duplicates
	symbol *dup = map_get(&stb->func->labels, name);
	if (dup != NULL) {
		c_error(loc, "Label '%s' is already declared\n", name);
		return;
	}

	map_insert(&stb->func->labels, name, name);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc1e7
addq $0x30, %rdi
movq %rbx, %rsi
callq 0xc7db
testq %rax, %rax
je 0xc200
leaq 0x2e91(%rip), %rsi      # 0xf076
jmp 0xc1ee
leaq 0x2e5f(%rip), %rsi      # 0xf04d
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x3250
movq 0x10(%r15), %rdi
addq $0x30, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xc840
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: symtable_search
symbol *symtable_search(symtable *stb, char *name) {
	scope *sc_ptr = stb->s_cur;
	while (sc_ptr != NULL) {
		symbol *s = map_get(&sc_ptr->table, name);
		if (s != NULL) return s;
		sc_ptr = sc_ptr->prev;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0xc249
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc7db
testq %rax, %rax
je 0xc23e
movq %rax, %r15
jmp 0xc242
movq 0x18(%r14), %r14
testq %rax, %rax
je 0xc224
jmp 0xc24c
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: sym_new
symbol *sym_new(char *name, s_type *type) {
	symbol *s = calloc(1, sizeof(struct SYMBOL));
	s->name = name;
	s->type = type;
	if (type->kind == TYPE_FUNC) {
		vector_init(&s->lvars, VECTOR_EMPTY);
		map_init(&s->labels, MAP_DEFAULT);
	}
	s->mac_exp = NULL;
	s->is_predef = 0;

	//Get base type from chain
	s_type *bt_ptr = type;
	while (bt_ptr->ref != NULL) 
		bt_ptr = bt_ptr->ref;
	s->btype = bt_ptr;

	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x1, %edi
movl $0x58, %esi
callq 0x3100
movq %rax, %r14
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
cmpl $0x4, (%rbx)
jne 0xc29b
leaq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xc964
movq %r14, %rdi
addq $0x30, %rdi
movl $0x11, %esi
callq 0xc646
movq $0x0, 0x48(%r14)
movl $0x0, 0x54(%r14)
movq %rbx, %rax
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xc2ab
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: type_del
void type_del(s_type *t) {
	//Reference data
	if (t->ref != NULL)
		type_del(t->ref);

	//Function/struct data
	for (int i=0; i<t->param.len; i++) {
		if (t->kind == TYPE_FUNC) {
			param_del(t->param.table[i]);
		} else {
			memb_del(t->param.table[i]);
		}
	}
	vector_close(&t->param);
	if (t->ret != NULL)
		type_del(t->ret);

	free(t);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xc2da
callq 0xc2c4
leaq 0x28(%rbx), %r14
cmpl $0x0, 0x30(%rbx)
jle 0xc30c
xorl %r15d, %r15d
cmpl $0x4, (%rbx)
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
jne 0xc2fb
callq 0x3030
jmp 0xc300
callq 0xc334
incq %r15
movslq 0x30(%rbx), %rax
cmpq %rax, %r15
jl 0xc2e7
movq %r14, %rdi
callq 0xc9b1
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xc322
callq 0xc2c4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: memb_del
void memb_del(s_param *m) {
	if (m->type != NULL)
		type_del(m->type);
	if (m->name != NULL)
		free(m->name);
	free(m);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xc346
callq 0xc2c4
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc353
callq 0x3030
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: type_clone
s_type *type_clone(s_type *from) {
	if (from == NULL) return NULL;
	s_type *type = malloc(sizeof(struct TYPE));
	*type = *from;
	type->ref = type_clone(from->ref);
	type->ret = type_clone(from->ret);

	//Copy parameters
	vector_init(&type->param, VECTOR_EMPTY);
	for (int i=0; i<from->param.len; i++) {
		s_param *p = from->param.table[i];
		char *pname = malloc(strlen(p->name)+1);
		strncpy(pname, p->name, strlen(p->name)+1);
		s_param *pclone = param_new(type_clone(p->type), pname);
		vector_add(&type->param, pclone);
	}
	return type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xc462
movq %rdi, %r14
movl $0x40, %edi
callq 0x3170
movq %rax, %rbx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm3, 0x30(%rax)
movq 0x18(%r14), %rdi
callq 0xc35c
movq %rax, 0x18(%rbx)
movq 0x38(%r14), %rdi
callq 0xc35c
movq %rax, 0x38(%rbx)
movq %rbx, %rdi
addq $0x28, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0xc964
cmpl $0x0, 0x30(%r14)
jle 0xc464
movq %rbx, 0x8(%rsp)
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movq (%rax,%rbx,8), %r15
movq (%r15), %r12
movq %r12, %rdi
callq 0x30b0
leaq 0x1(%rax), %r13
movq %r13, %rdi
callq 0x3170
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3060
movq 0x8(%r15), %rdi
callq 0xc35c
movq %rax, %r12
movl $0x18, %edi
callq 0x3170
movq %r12, 0x8(%rax)
movq %rbp, (%rax)
movq %r12, %rcx
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0xc431
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xc9fa
incq %rbx
movslq 0x30(%r14), %rax
cmpq %rax, %rbx
jl 0xc3e4
movq 0x8(%rsp), %rbx
jmp 0xc464
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: param_new
s_param *param_new(s_type *type, char *name) {
	s_param *param = malloc(sizeof(struct PARAM));
	param->type = type;
	param->name = name;

	//Get base type
	//TODO: just replace s_param with symbol
	s_type *bt_ptr = type;
	while (bt_ptr->ref != NULL) 
		bt_ptr = bt_ptr->ref;
	param->btype = bt_ptr;

	return param;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x3170
movq %rbx, 0x8(%rax)
movq %r14, (%rax)
movq %rbx, %rcx
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xc491
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: type_compare_noref
int type_compare_noref(s_type *a, s_type *b) {
	if (a->kind != b->kind) return 0;
	if (a->s_class != b->s_class) return 0;

	//TODO: qualifiers
	if (a->ref_len != b->ref_len) return 0;

	//Compare parameters/members
	if (a->param.len != b->param.len) return 0;
	for (int i=0; i<a->param.len; i++) {
		s_param *ap = a->param.table[i];
		s_param *bp = b->param.table[i];
		if (!type_compare(ap->type, bp->type)) return 0;
	}
	if (!type_compare(a->ret, b->ret)) return 0;

	return 1;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0xc547
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0xc547
movl 0x20(%r14), %eax
cmpl 0x20(%rbx), %eax
jne 0xc547
movl 0x30(%r14), %eax
movq %rax, (%rsp)
cmpl 0x30(%rbx), %eax
jne 0xc547
cmpl $0x0, (%rsp)
setg %bpl
jle 0xc558
movq 0x28(%r14), %r12
movq 0x28(%rbx), %r13
movq (%r12), %rax
movq (%r13), %rcx
movq 0x8(%rax), %rdi
movq 0x8(%rcx), %rsi
callq 0xc157
testl %eax, %eax
je 0xc542
movq (%rsp), %rax
leaq -0x1(%rax), %r15
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0xc558
movq 0x8(%r12,%rbp,8), %rax
movq 0x8(%r13,%rbp,8), %rcx
movq 0x8(%rax), %rdi
movq 0x8(%rcx), %rsi
callq 0xc157
incq %rbp
testl %eax, %eax
jne 0xc517
cmpq (%rsp), %rbp
setb %bpl
testb %bpl, %bpl
je 0xc558
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%r14), %rdi
movq 0x38(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc157
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/sym.c
// Function: type_sizeof
int type_sizeof(s_type *t) {
	//Base types
	switch (t->kind) {
		case TYPE_UNDEF:
		case TYPE_MACRO:
		case TYPE_LABEL:
			return -1;
		case TYPE_PTR:	
		case TYPE_FUNC:	
			return 8;
		case TYPE_VOID:
			return -1;
		case TYPE_INT:
		case TYPE_FLOAT:
			return t->size;
	}

	//User-defined types
	int ssum = 0;
	int smax = 0;
	for (int i=0; i<t->param.len; i++) {
		int msize = type_sizeof(t->param.table[i]);
		ssum += msize;
		if (msize > smax) smax = msize;
	}
	if (t->kind == TYPE_UNION)
		return smax;
	return ssum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %ebp
cmpl $0x7, %ebp
ja 0xc5aa
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0x27, %eax
btl %ebp, %eax
jb 0xc5e7
movl $0x18, %eax
btl %ebp, %eax
jae 0xc5a5
movl $0x8, %ebx
jmp 0xc5e7
movl 0x4(%rdi), %ebx
jmp 0xc5e7
movslq 0x30(%rdi), %r14
testq %r14, %r14
jle 0xc5db
movq 0x28(%rdi), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq (%r12,%r13,8), %rdi
callq 0xc573
addl %eax, %ebx
cmpl %r15d, %eax
cmovgl %eax, %r15d
incq %r13
cmpq %r13, %r14
jne 0xc5bf
jmp 0xc5e0
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpl $0x9, %ebp
cmovel %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/map.c
// Function: map_init
void map_init(map *m, int size) {
	m->table = calloc(size, sizeof(void*));
	m->keys = calloc(size, sizeof(char*));
	m->count = 0;
	m->max = size;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x3100
movq %rax, (%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x3100
movq %rax, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/map.c
// Function: map_close
void map_close(map *m) {
	if (m->table != NULL)
		free(m->table);
	if (m->table != NULL)
		free(m->keys);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc6a7
callq 0x3030
cmpq $0x0, (%rbx)
je 0xc6b7
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x3030
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/map.c
// Function: str_hash
unsigned int str_hash(const char *key) {
	//Jenkins one-at-a-time hash function
	unsigned int hash = 0;
	for (int i=0; i<strlen(key); i++) {
		hash += key[i++];
		hash += hash << 10;
		hash ^= hash >> 6;
	}
	hash += hash << 3;
	hash ^= hash >> 11;
	hash += hash << 15;

	return hash;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30b0
testq %rax, %rax
je 0xc6ed
xorl %ecx, %ecx
xorl %edx, %edx
movsbl (%rbx,%rcx), %esi
addl %edx, %esi
movl %esi, %edi
shll $0xa, %edi
addl %esi, %edi
movl %edi, %edx
shrl $0x6, %edx
xorl %edi, %edx
addq $0x2, %rcx
cmpq %rcx, %rax
ja 0xc6cb
leal (%rdx,%rdx,8), %eax
jmp 0xc6ef
xorl %eax, %eax
movl %eax, %ecx
shrl $0xb, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xf, %eax
addl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/map.c
// Function: map_expand
void map_expand(map *m) {
	//Allocate space for new table
	int n_max = m->max * 2;
	void **n_table = calloc(n_max, sizeof(void*));
	const char **n_keys = calloc(n_max, sizeof(char*));

	//Relocate all keys into new table
	for (int i=0; i<m->max; i++) {
		if (m->table[i] != NULL) {
			int n_index = str_hash(m->keys[i]) % n_max;
			while (n_keys[n_index] != NULL)
				n_index = (n_index + 1) % n_max;
			n_table[n_index] = m->table[i];
			n_keys[n_index] = m->keys[i];
		}
	}

	//Free old tables and switch to new ones
	free(m->table);
	free(m->keys);
	m->table = n_table;
	m->keys = n_keys;
	m->max = n_max;

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
movslq 0x14(%rdi), %rbx
leaq (%rbx,%rbx), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x3100
movq %rax, 0x8(%rsp)
movl $0x8, %esi
movq %r14, %rdi
callq 0x3100
movq %rax, %r12
movq %rbx, 0x10(%rsp)
testq %rbx, %rbx
jle 0xc7a7
movq (%rsp), %rax
movq (%rax), %rbp
xorl %r15d, %r15d
movq (%rbp,%r15,8), %rbx
testq %rbx, %rbx
je 0xc79d
movq (%rsp), %rax
movq 0x8(%rax), %r13
movq (%r13,%r15,8), %rdi
callq 0xc6b9
xorl %edx, %edx
divl %r14d
cmpq $0x0, (%r12,%rdx,8)
je 0xc78b
movl %edx, %eax
incl %eax
cltd
idivl %r14d
movl %edx, %eax
movslq %edx, %rdx
cmpq $0x0, (%r12,%rdx,8)
jne 0xc779
movq 0x8(%rsp), %rax
movq %rbx, (%rax,%rdx,8)
movq (%r13,%r15,8), %rax
movq %rax, (%r12,%rdx,8)
incq %r15
cmpq 0x10(%rsp), %r15
jne 0xc74f
movq (%rsp), %rbx
movq (%rbx), %rdi
callq 0x3030
movq 0x8(%rbx), %rdi
callq 0x3030
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq %r12, 0x8(%rbx)
movl %r14d, 0x14(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/map.c
// Function: map_get
void *map_get(map *m, const char *key) {
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		if (!strcmp(m->keys[index], key)) {
			return m->table[index];
		}
		index = (index + 1) % m->max;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc6b9
movl 0x14(%rbx), %r12d
xorl %edx, %edx
divl %r12d
movq 0x8(%rbx), %r13
movslq %edx, %r15
movq (%r13,%r15,8), %rdi
testq %rdi, %rdi
je 0xc826
movl %edx, %ebp
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0xc82a
incl %ebp
movl %ebp, %eax
cltd
idivl %r12d
jmp 0xc801
xorl %eax, %eax
jmp 0xc831
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/map.c
// Function: map_insert
void map_insert(map *m, const char *key, void *val) {
	//Expand the table capacity if load factor > 0.75
	if (m->count / (float)m->max > 0.75)
		map_expand(m);

	//Hash the key and perform linear probing if necessary
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		if (m->table[index] == NULL) break;
		index = (index + 1) % m->max;
	}

	//Insert the value and key
	m->table[index] = val;
	m->keys[index] = key;
	m->count++;

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cvtsi2ssl 0x10(%rdi), %xmm0
movq %rsi, %r15
cvtsi2ssl 0x14(%rdi), %xmm1
divss %xmm1, %xmm0
ucomiss 0x2835(%rip), %xmm0     # 0xf098
jbe 0xc86d
movq %rbx, %rdi
callq 0xc6ff
movq %r15, %rdi
callq 0xc6b9
movl 0x14(%rbx), %ecx
xorl %edx, %edx
divl %ecx
movq 0x8(%rbx), %rsi
movslq %edx, %rax
cmpq $0x0, (%rsi,%rax,8)
je 0xc8a5
movq (%rbx), %rdi
cmpq $0x0, (%rdi,%rax,8)
je 0xc8a5
incl %edx
movl %edx, %eax
cltd
idivl %ecx
movslq %edx, %rax
cmpq $0x0, (%rsi,%rax,8)
jne 0xc88d
movq (%rbx), %rcx
movq %r14, (%rcx,%rax,8)
movq 0x8(%rbx), %rcx
movq %r15, (%rcx,%rax,8)
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/map.c
// Function: map_remove
void map_remove(map *m, const char *key) {
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		/* The data pointer is set to NULL, but the key isn't.
		 * As a result, get operations will return NULL, and insertion
		 * does an additional check to see if the space has been
		 * previously removed. If not reused, these spaces disappear
		 * upon resizing.
		 */
		if (!strcmp(m->keys[index], key)) {
			m->table[index] = NULL;
			break;
		}
		index = (index + 1) % m->max;
	}

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc6b9
movl 0x14(%rbx), %r15d
xorl %edx, %edx
divl %r15d
movq 0x8(%rbx), %r12
movslq %edx, %r13
movq (%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0xc912
movl %edx, %ebp
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0xc907
incl %ebp
movl %ebp, %eax
cltd
idivl %r15d
jmp 0xc8e3
movq (%rbx), %rax
movq $0x0, (%rax,%r13,8)
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/Yamsman[P]scc/src/util/vector.c
// Function: vector_init
void vector_init(vector *v, int size) {
	if (size > 0) {
		v->table = malloc(sizeof(void*)*size);
	} else {
		v->table = NULL;
	}
	v->len = 0;
	v->max = size;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xc97e
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x3170
jmp 0xc980
xorl %eax, %eax
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movl %ebx, 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/vector.c
// Function: vector_expand
void vector_expand(vector *v) {
	int n_max = v->max * 2;
	v->table = realloc(v->table, sizeof(void*)*n_max);
	v->max = n_max;
	return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0xc(%rdi), %rsi
leal (%rsi,%rsi), %ebp
movq (%rdi), %rdi
shlq $0x4, %rsi
callq 0x31a0
movq %rax, (%rbx)
movl %ebp, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Yamsman[P]scc/src/util/vector.c
// Function: vector_add
void vector_add(vector *v, void *val) {
	//Allocate initial space if vector was initialized as empty
	if (v->max == VECTOR_EMPTY)
		vector_init(v, VECTOR_DEFAULT);

	//Expand the table if there is no room left
	if (v->len+1 >= v->max)
		vector_expand(v);

	//Add value to end of table
	int index = v->len;
	v->table[index] = val;
	v->len++;

	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
jne 0xca25
movl $0x80, %edi
callq 0x3170
movq %rax, (%rbx)
movabsq $0x1000000000, %rax     # imm = 0x1000000000
movq %rax, 0x8(%rbx)
movl 0x8(%rbx), %eax
incl %eax
movslq 0xc(%rbx), %rsi
cmpl %esi, %eax
jl 0xca47
leal (%rsi,%rsi), %ebp
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x31a0
movq %rax, (%rbx)
movl %ebp, 0xc(%rbx)
movslq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incl %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq