LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_and
ast_n *parse_expr_and(lexer *lx) {
	ast_n *node = parse_expr_equal(lx);

	if (lex_peek(lx).type == TOK_AND) {
		ast_n *n_node = astn_new(EXPR, EXPR_AND, lex_peek(lx));
		lex_adv(lx);
		ast_expr *n_expr = &n_node->dat.expr;
		n_expr->left = node;
		n_expr->right = parse_expr_equal(lx);
		return n_node;
	}
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
callq 0x9514
movq %rax, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x15, (%r15)
jne 0x9504
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
pushq $0x7
popq %rsi
callq 0x333c
movq %rax, %r15
movq %rbx, %rdi
callq 0x7522
movq %r14, 0x20(%r15)
movq %rbx, %rdi
callq 0x9514
movq %rax, 0x28(%r15)
movq %r15, %r14
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_equal
ast_n *parse_expr_equal(lexer *lx) {
	ast_n *node = parse_expr_relation(lx);

	ast_n *n_node;
	ast_expr *n_expr;
	token t = lex_peek(lx);
	switch (t.type) {
		case TOK_EQ:
			n_node = astn_new(EXPR, EXPR_EQ, t);
			lex_adv(lx);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_relation(lx);
			return n_node;
		case TOK_NEQ:
			n_node = astn_new(EXPR, EXPR_NEQ, t);
			lex_adv(lx);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_relation(lx);
			return n_node;
	}

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
callq 0x959c
movq %rax, %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
movl (%r15), %eax
cmpl $0x1d, %eax
je 0x9549
cmpl $0x1e, %eax
jne 0x958f
pushq $0xf
jmp 0x954b
pushq $0xe
popq %rsi
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
callq 0x333c
movq %rax, %r15
movq %rbx, %rdi
callq 0x7522
movq %r14, 0x20(%r15)
movq %rbx, %rdi
callq 0x959c
movq %rax, 0x28(%r15)
movq %r15, %r14
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_relation
ast_n *parse_expr_relation(lexer *lx) {
	ast_n *node = parse_expr_shift(lx);

	ast_n *n_node;
	ast_expr *n_expr;
	token t = lex_peek(lx);
	switch (t.type) {
		case TOK_LTH:
			n_node = astn_new(EXPR, EXPR_LTH, t);
			lex_adv(lx);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_shift(lx);
			return n_node;
		case TOK_GTH:
			n_node = astn_new(EXPR, EXPR_GTH, t);
			lex_adv(lx);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_shift(lx);
			return n_node;
		case TOK_LEQ:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_LEQ, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_shift(lx);
			return n_node;
		case TOK_GEQ:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_GEQ, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_shift(lx);
			return n_node;
	}

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
callq 0x96ba
movq %rax, %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
movl (%r15), %eax
addl $-0x19, %eax
cmpl $0x3, %eax
ja 0x96ad
leaq 0x4086(%rip), %rcx      # 0xd65c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
pushq $0x9
jmp 0x9689
movq %rbx, %rdi
callq 0x7522
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
pushq $0xb
jmp 0x965c
movq %rbx, %rdi
callq 0x7522
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
pushq $0xa
popq %rsi
callq 0x333c
movq %rax, %r15
jmp 0x969a
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x333c
movq %rax, %r15
movq %rbx, %rdi
callq 0x7522
movq %r14, 0x20(%r15)
movq %rbx, %rdi
callq 0x96ba
movq %rax, 0x28(%r15)
movq %r15, %r14
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_shift
ast_n *parse_expr_shift(lexer *lx) {
	ast_n *node = parse_expr_addt(lx);

	ast_n *n_node;
	ast_expr *n_expr;
	token t = lex_peek(lx);
	switch (t.type) {
		case TOK_LSHIFT:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_LSHIFT, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_addt(lx);
			return n_node;
		case TOK_RSHIFT:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_RSHIFT, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_addt(lx);
			return n_node;
	}

	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x9746
movq %rax, %r14
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
movl (%r15), %eax
cmpl $0x25, %eax
je 0x96f0
cmpl $0x26, %eax
jne 0x9738
pushq $0xd
jmp 0x96f2
pushq $0xc
popq %rbp
movq %rbx, %rdi
callq 0x7522
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
movl %ebp, %esi
callq 0x333c
movq %rax, %r15
movq %r14, 0x20(%rax)
movq %rbx, %rdi
callq 0x9746
movq %rax, 0x28(%r15)
movq %r15, %r14
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_addt
ast_n *parse_expr_addt(lexer *lx) {
	ast_n *node = parse_expr_mult(lx);

	ast_n *n_node;
	ast_expr *n_expr;
	token t = lex_peek(lx);
	switch (t.type) {
		case TOK_ADD:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_ADD, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_addt(lx);
			return n_node;
		case TOK_SUB:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_SUB, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_addt(lx);
			return n_node;
	}

	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
callq 0x97cb
movq %rax, %r14
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
movl (%r15), %ebp
movl %ebp, %eax
andl $-0x2, %eax
cmpl $0x10, %eax
jne 0x97bd
movq %rbx, %rdi
callq 0x7522
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
movl %ebp, %esi
callq 0x333c
movq %rax, %r15
movq %r14, 0x20(%rax)
movq %rbx, %rdi
callq 0x9746
movq %rax, 0x28(%r15)
movq %r15, %r14
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_mult
ast_n *parse_expr_mult(lexer *lx) {
	ast_n *node = parse_expr_cast(lx);

	ast_n *n_node;
	ast_expr *n_expr;
	token t = lex_peek(lx);
	switch (t.type) {
		case TOK_ASR:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_MUL, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_cast(lx);
			return n_node;
		case TOK_DIV:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_DIV, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_cast(lx);
			return n_node;
		case TOK_MOD:
			lex_adv(lx);
			n_node = astn_new(EXPR, EXPR_MOD, t);
			n_expr = &n_node->dat.expr;
			n_expr->left = node;
			n_expr->right = parse_expr_cast(lx);
			return n_node;
	}

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
callq 0x984e
movq %rax, %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
movl (%r15), %r15d
leal -0x12(%r15), %eax
cmpl $0x2, %eax
ja 0x9841
movq %rbx, %rdi
callq 0x7522
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
movl %r15d, %esi
callq 0x333c
movq %rax, %r15
movq %r14, 0x20(%rax)
movq %rbx, %rdi
callq 0x984e
movq %rax, 0x28(%r15)
movq %r15, %r14
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_cast
ast_n *parse_expr_cast(lexer *lx) {
	ast_n *node = parse_expr_unary(lx);
	
	ast_n *n_node;
	token t = lex_peek(lx);
	if (t.type == TOK_LPR) {
		lex_adv(lx);
		
		//Parse type
		token vname = BLANK_TOKEN;
		s_type *base_type = parse_decl_spec(lx);
		s_type *type = parse_decltr(lx, base_type, &vname);
		
		//Ensure the type didn't contain a variable name
		if (vname.type != -1)
			c_error(&vname.loc, "Unexpected identifier in cast expression\n");

		//Check for ')'
		token t = lex_peek(lx);
		if (t.type != TOK_RPR)
			c_error(&t.loc, "Missing ')' after parameter list\n");
		lex_adv(lx);

		//Parse following the type cast
		ast_n *n_node = astn_new(EXPR, EXPR_CAST, t);
		n_node->dat.expr.type = type;
		n_node->dat.expr.left = parse_expr_cast(lx);

		//Join to results of parse_expr_unary if needed
		//If the operation is a reference or inc/dec, flag an error
		if (node != NULL) {
			ast_expr *n_expr = &node->dat.expr;
			if (n_expr->kind == EXPR_INC_PRE)
				c_error(NULL, "lvalue required for pre-increment\n");
			if (n_expr->kind == EXPR_DEC_PRE)
				c_error(NULL, "lvalue required for pre-decrement\n");
			if (n_expr->kind == EXPR_REF)
				c_error(NULL, "lvalue required for reference operation\n");
			n_expr->left = n_node;
			return node;
		}
		return n_node;
	}
	
	return node; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
callq 0x99b7
movq %rax, %rbx
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x74e5
cmpl $0x7, (%r15)
jne 0x99a5
movq %r14, %rdi
callq 0x7522
leaq 0x9ba5(%rip), %rax      # 0x13438
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x60(%rsp), %r15
movaps %xmm2, 0x20(%r15)
movaps %xmm1, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r14, %rdi
callq 0x7f3f
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8998
movq %rax, %r12
cmpl $-0x1, (%r15)
je 0x98e3
leaq 0x68(%rsp), %rdi
leaq 0x41c0(%rip), %rsi      # 0xda9c
xorl %eax, %eax
callq 0x35e4
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x74e5
cmpl $0x8, (%r15)
je 0x990c
leaq 0x38(%rsp), %rdi
leaq 0x41c1(%rip), %rsi      # 0xdac6
xorl %eax, %eax
callq 0x35e4
movq %r14, %rdi
callq 0x7522
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
pushq $0x15
popq %rsi
callq 0x333c
movq %rax, %r15
movq %r12, 0x10(%rax)
movq %r14, %rdi
callq 0x984e
movq %rax, 0x20(%r15)
testq %rbx, %rbx
je 0x99a2
movl 0x8(%rbx), %eax
cmpl $0x1c, %eax
jne 0x996f
leaq 0x4185(%rip), %rsi      # 0xdae8
xorl %edi, %edi
xorl %eax, %eax
callq 0x35e4
movl 0x8(%rbx), %eax
cmpl $0x1d, %eax
jne 0x9987
leaq 0x4190(%rip), %rsi      # 0xdb0b
xorl %edi, %edi
xorl %eax, %eax
callq 0x35e4
movl 0x8(%rbx), %eax
cmpl $0x16, %eax
jne 0x999c
leaq 0x419b(%rip), %rsi      # 0xdb2e
xorl %edi, %edi
xorl %eax, %eax
callq 0x35e4
movq %r15, 0x20(%rbx)
jmp 0x99a5
movq %r15, %rbx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_unary
ast_n *parse_expr_unary(lexer *lx) {
	ast_n *n_node = NULL;
	token t = lex_peek(lx);
	switch (t.type) {
		case TOK_AND: lex_adv(lx); n_node = astn_new(EXPR, EXPR_REF, t); 	break;
		case TOK_ASR: lex_adv(lx); n_node = astn_new(EXPR, EXPR_DEREF, t); 	break;
		case TOK_ADD: lex_adv(lx); n_node = astn_new(EXPR, EXPR_POS, t); 	break;
		case TOK_SUB: lex_adv(lx); n_node = astn_new(EXPR, EXPR_NEG, t); 	break;
		case TOK_NOT: lex_adv(lx); n_node = astn_new(EXPR, EXPR_LOGIC_NOT, t); 	break;
		case TOK_TLD: lex_adv(lx); n_node = astn_new(EXPR, EXPR_NOT, t); 	break;
		case TOK_INC: lex_adv(lx); n_node = astn_new(EXPR, EXPR_INC_PRE, t);	break;
		case TOK_DEC: lex_adv(lx); n_node = astn_new(EXPR, EXPR_DEC_PRE, t); 	break;
		//TODO case TOK_KW_SIZEOF:
	}

	ast_n *node = parse_expr_postfix(lx);
	if (n_node != NULL) {
		n_node->dat.expr.left = node;
		return n_node;
	}

	return node;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
movl (%r14), %eax
addl $-0x10, %eax
cmpl $0x13, %eax
ja 0x9a27
movl $0xe0127, %ecx          # imm = 0xE0127
btl %eax, %ecx
jae 0x9a27
movl %eax, %eax
leaq 0x3cc0(%rip), %rcx      # 0xd6b0
movl (%rcx,%rax,4), %ebp
movq %rbx, %rdi
callq 0x7522
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
movl %ebp, %esi
callq 0x333c
movq %rax, %r14
jmp 0x9a2a
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x9a4c
testq %r14, %r14
je 0x9a3d
movq %rax, 0x20(%r14)
jmp 0x9a40
movq %rax, %r14
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_expr_arglist
ast_n *parse_expr_arglist(lexer *lx) {
	ast_n *node = parse_expr_assign(lx);

	//Arguments will be evaluated in reverse order, so the list will be backwards
	ast_n *head = node;
	while (lex_peek(lx).type == TOK_CMM) {
		lex_adv(lx);
		node = parse_expr_assign(lx);
		node->next = head;
		head = node;
	}

	return head;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x8ba6
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x3, (%rsp)
jne 0x9e0c
movq %rbx, %rdi
callq 0x7522
movq %rbx, %rdi
callq 0x8ba6
movq %r14, 0x60(%rax)
movq %rax, %r14
jmp 0x9de2
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/parse.c
// Function: parse_stmt
ast_n *parse_stmt(lexer *lx) {
	ast_n *node;
	switch (lex_peek(lx).type) {
		case TOK_KW_IF:
		case TOK_KW_SWITCH:
			node = parse_stmt_selection(lx);
			break;
		case TOK_KW_WHILE:
		case TOK_KW_FOR:
		case TOK_KW_DO:
			node = parse_stmt_iteration(lx);
			break;
		case TOK_KW_CASE:
		case TOK_KW_DEFAULT:
			node = parse_stmt_label(lx);
			break;
		case TOK_KW_GOTO:
		case TOK_KW_BREAK:
		case TOK_KW_CONTINUE:
		case TOK_KW_RETURN:
			node = parse_stmt_jump(lx);
			break;
		case TOK_LBR:
			node = parse_stmt_cmpd(lx);
			break;
		case TOK_IDENT: {
			//Check for label
			//TODO: clean
			token_n *tn = make_tok_node(lex_peek(lx));
			lex_adv(lx);
			token t = lex_peek(lx);
			lex_unget(lx, make_tok_node(t));
			lex_unget(lx, tn);
			if (t.type == TOK_COL) {
				node = parse_stmt_label(lx);
				break;
			}
			} //Fall through
		default:
			node = parse_stmt_expr(lx);
			break;
	}
	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 0x74e5
movl (%r14), %ecx
leal -0x35(%rcx), %eax
cmpl $0xc, %eax
ja 0xa070
leaq 0x362c(%rip), %rcx      # 0xd66c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0xa43a
jmp 0xa121
movq %rbx, %rdi
callq 0xa277
jmp 0xa121
movq %rbx, %rdi
callq 0xa12e
jmp 0xa121
cmpl $0x5, %ecx
jne 0xa119
movq %rbx, %rdi
callq 0x8d1e
jmp 0xa121
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x76dd
movq %rax, %r14
movq %rbx, %rdi
callq 0x7522
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x76dd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7673
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7673
cmpl $0x2, (%r15)
jne 0xa119
movq %rbx, %rdi
callq 0xa2df
jmp 0xa121
movq %rbx, %rdi
callq 0xa63f
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74e5
cmpl $0x36, (%r14)
jne 0xa1f0
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
movl %edi, %esi
callq 0x333c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7522
leaq 0x3ab7(%rip), %rsi      # 0xdc5c
movq %rbx, %rdi
callq 0xa70f
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa00c
movq %rax, 0x20(%r14)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x37, (%r15)
jne 0xa267
movq %rbx, %rdi
callq 0x7522
movq %rbx, %rdi
callq 0xa00c
movq %rax, 0x28(%r14)
jmp 0xa267
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x38, (%r14)
jne 0xa267
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
pushq $0x3
popq %rsi
callq 0x333c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7522
leaq 0x3a1a(%rip), %rsi      # 0xdc69
movq %rbx, %rdi
callq 0xa70f
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa00c
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_O2/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 0x74e5
movl (%r14), %ecx
cmpl $0x3b, %ecx
je 0xa2c7
cmpl $0x3a, %ecx
je 0xa2b5
cmpl $0x39, %ecx
jne 0xa2d7
movq %rbx, %rdi
callq 0x7522
movq %rbx, %rdi
callq 0xa7bb
jmp 0xa2d7
movq %rbx, %rdi
callq 0x7522
movq %rbx, %rdi
callq 0xa829
jmp 0xa2d7
movq %rbx, %rdi
callq 0x7522
movq %rbx, %rdi
callq 0xa9c4
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74e5
movl (%r14), %eax
cmpl $0x3d, %eax
je 0xa3a3
cmpl $0x3c, %eax
je 0xa362
cmpl $0x35, %eax
jne 0xa427
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)
pushq $0x2
popq %rdi
pushq $0x7
popq %rsi
callq 0x333c
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq 0x18(%r15), %rsi
movq %r15, %rdx
callq 0xb7bf
movq 0x18(%r15), %rax
movq %rax, 0x10(%r14)
jmp 0xa3ce
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
pushq $0x8
popq %rsi
callq 0x333c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7522
movq %rbx, %rdi
callq 0x912a
movq %rax, 0x18(%r14)
jmp 0xa3d6
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
pushq $0x9
popq %rsi
callq 0x333c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7522
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
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 0xa41d
leaq 0x38(%rsp), %rdi
leaq 0x390b(%rip), %rsi      # 0xdd21
xorl %eax, %eax
callq 0x35e4
movq %rbx, %rdi
callq 0x7522
jmp 0xa42a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74e5
cmpl $0x1, (%r14)
jne 0xa677
movq %rbx, %rdi
callq 0x7522
xorl %r14d, %r14d
jmp 0xa6ff
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
xorl %esi, %esi
callq 0x333c
movq %rax, %r14
movq %rbx, %rdi
callq 0x90d4
movq %rax, 0x18(%r14)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x1, (%r15)
jne 0xa6df
movq %rbx, %rdi
callq 0x7522
jmp 0xa6ff
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x74e5
leaq 0x38(%rsp), %rdi
leaq 0x3546(%rip), %rsi      # 0xdc3e
xorl %eax, %eax
callq 0x35e4
movq %r14, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74e5
cmpl $0x7, (%r14)
jne 0xa73e
movq %rbx, %rdi
callq 0x7522
jmp 0xa753
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3465(%rip), %rsi      # 0xdbb1
xorl %eax, %eax
callq 0x35e4
movq %rbx, %rdi
callq 0x90d4
movq %rax, %r14
testq %rax, %rax
jne 0xa77b
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3463(%rip), %rsi      # 0xdbd4
movq %r15, %rdx
xorl %eax, %eax
callq 0x35e4
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x8, (%r15)
jne 0xa799
movq %rbx, %rdi
callq 0x7522
jmp 0xa7ae
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3452(%rip), %rsi      # 0xdbf9
xorl %eax, %eax
callq 0x35e4
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74e5
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
pushq $0x4
popq %rsi
callq 0x333c
movq %rax, %r14
leaq 0x34ea(%rip), %rsi      # 0xdcf0
movq %rbx, %rdi
callq 0xa70f
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa00c
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74e5
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x2
popq %rdi
pushq $0x6
popq %rsi
callq 0x333c
movq %rax, %r14
movq %rbx, %rdi
callq 0xa00c
movq %rax, 0x20(%r14)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x39, (%r15)
jne 0xaa3c
movq %rbx, %rdi
callq 0x7522
jmp 0xaa51
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x327d(%rip), %rsi      # 0xdcc7
xorl %eax, %eax
callq 0x35e4
leaq 0x3295(%rip), %rsi      # 0xdced
movq %rbx, %rdi
callq 0xa70f
movq %rax, 0x18(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x1, (%r15)
jne 0xaa84
movq %rbx, %rdi
callq 0x7522
jmp 0xaa99
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3269(%rip), %rsi      # 0xdcfb
xorl %eax, %eax
callq 0x35e4
movq %r14, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %r12
movq (%rdi), %rbx
callq 0x64ad
movq %r12, %rdi
callq 0x6da8
cmpl $0x0, 0x14(%r12)
je 0xaafb
leaq 0x32a2(%rip), %r14      # 0xdd7e
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35e4
addq $0x28, %r15
leaq 0x3295(%rip), %r14      # 0xdd9b
leaq 0x32be(%rip), %r13      # 0xddcb
pushq $0x1
popq %rbp
movl 0x10(%r12), %eax
cmpl $0x8, %eax
je 0xab67
cmpl $0x0, 0x14(%r12)
jne 0xaadc
cmpl $0x35, %eax
jne 0xab76
movl %ebp, %edi
callq 0xb5ed
movq 0x30(%r12), %rsi
movq %rax, %rdi
callq 0xba37
movq %r15, %rdi
movq %rax, %rsi
callq 0xbf10
movq %r12, %rdi
callq 0x6da8
movl 0x10(%r12), %eax
cmpl $0x8, %eax
je 0xab10
cmpl $0x3, %eax
jne 0xab7e
movq %r12, %rdi
callq 0x6da8
jmp 0xab10
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
jmp 0xaadc
leaq 0x3272(%rip), %r14      # 0xddf7
jmp 0xaadc
// File: /workspace/github_c_makefile_star2_O2/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 0x6493
movl %eax, %r15d
movl $0x100, %edi            # imm = 0x100
callq 0x3170
movq %rax, %rbx
callq 0x3230
movq %rax, %r12
movq (%r12), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xada1
movq %r14, %rdi
callq 0x64ad
movl %eax, %r15d
jmp 0xad85
movl $0x100, %r13d           # imm = 0x100
xorl %r12d, %r12d
cmpb $0xa, %r15b
je 0xade2
leaq 0x2(%r12), %rax
movl %r13d, %ecx
cmpq %rcx, %rax
jne 0xadce
addl %r13d, %r13d
movslq %r13d, %rsi
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rbx
movb %r15b, (%rbx,%r12)
incq %r12
movq %r14, %rdi
callq 0x64ad
movl %eax, %r15d
jmp 0xadaa
movl %r12d, %eax
movb $0x0, (%rbx,%rax)
leaq 0x3085(%rip), %rsi      # 0xde75
movq %rsp, %rdi
movq %rbx, %rdx
xorl %eax, %eax
testl %ebp, %ebp
je 0xae03
callq 0x36cc
jmp 0xae08
callq 0x35e4
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_O2/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 0x6da8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x35, (%r14)
je 0xb03e
movq (%rbx), %rdi
addq $0x28, %rdi
movq 0x28(%rsp), %rdx
leaq 0x2ebc(%rip), %rsi      # 0xdef3
xorl %eax, %eax
callq 0x35e4
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xbd22
testq %rax, %rax
je 0xb070
movq 0x8(%rax), %rax
cmpl $0x1, (%rax)
jne 0xb070
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xbe00
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rsi
callq 0xbe8a
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x68(%r14)
movq %r14, %rdi
callq 0x7370
leaq 0x4c(%rsp), %r15
movq %r14, %rdi
callq 0x7370
testl %eax, %eax
jne 0xb169
movq %r14, %rdi
callq 0x6da8
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x74e5
movl 0x48(%rsp), %r13d
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movaps %xmm0, 0x20(%rsp)
movups %xmm1, 0x2c(%rsp)
movq 0x68(%rsp), %rbx
movq 0x70(%rsp), %r12
pushq $0x30
popq %rdi
callq 0x3170
movq %rax, %rbp
cmpl $0x35, %r13d
jne 0xb12c
movq %rbx, %rdi
leaq 0x2025(%rip), %rsi      # 0xd13d
callq 0x3110
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,2), %r13d
addl $0x32, %r13d
movl %r13d, (%rbp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x4(%rbp)
movups 0x2c(%rsp), %xmm0
movups %xmm0, 0x10(%rbp)
movq %rbx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xbf86
xorl %eax, %eax
cmpl $0x32, %r13d
setne %al
movl %eax, 0x68(%r14)
jmp 0xb0b6
andq $0x0, 0x68(%r14)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq 0x18(%rsp), %rdx
callq 0x3926
movl %eax, %ebx
xorl %r15d, %r15d
movslq 0x10(%rsp), %rax
cmpq %rax, %r15
jge 0xb1c4
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %r14
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0xb1a8
callq 0xb8ba
jmp 0xb1b7
cmpl $0x35, (%r14)
jne 0xb1b7
movq 0x20(%r14), %rdi
callq 0x3030
movq %r14, %rdi
callq 0x3030
incq %r15
jmp 0xb185
leaq 0x8(%rsp), %rdi
callq 0xbecc
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_O2/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
andl $0x0, (%rsi)
callq 0xb078
xorl %esi, %esi
testl %eax, %eax
setne %sil
movq %rbx, %rdi
callq 0x5962
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6da8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x35, (%r14)
je 0xb242
leaq 0x10(%rsp), %rdi
leaq 0x2cd1(%rip), %rsi      # 0xdf0c
xorl %eax, %eax
callq 0x35e4
movq 0x60(%rbx), %rdi
movq 0x28(%rsp), %rsi
callq 0xb822
xorl %esi, %esi
testq %rax, %rax
setne %sil
movq %rbx, %rdi
callq 0x5962
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6da8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74e5
cmpl $0x35, (%r14)
je 0xb2a1
leaq 0x10(%rsp), %rdi
leaq 0x2c94(%rip), %rsi      # 0xdf2e
xorl %eax, %eax
callq 0x35e4
movq 0x60(%rbx), %rdi
movq 0x28(%rsp), %rsi
callq 0xb822
xorl %esi, %esi
testq %rax, %rax
sete %sil
movq %rbx, %rdi
callq 0x5962
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xbfae
testq %rax, %rax
je 0xb302
movq %rax, %r14
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movl (%rax), %eax
orl %eax, 0x4(%r14)
movq %rbx, %rdi
callq 0xb078
andl $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x2c41(%rip), %rsi      # 0xdf51
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35e4
// File: /workspace/github_c_makefile_star2_O2/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 0xbfae
testq %rax, %rax
je 0xb346
cmpl $0x0, 0x8(%rax)
je 0xb35c
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x2c31(%rip), %rsi      # 0xdf75
jmp 0xb354
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x2c0f(%rip), %rsi      # 0xdf63
xorl %eax, %eax
popq %rbx
jmp 0x35e4
movl (%rax), %ecx
orl %ecx, 0x4(%rax)
pushq $0x1
popq %rcx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbfae
testq %rax, %rax
je 0xb386
movq %rbx, %rdi
popq %rbx
jmp 0x5990
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x2bf4(%rip), %rsi      # 0xdf88
xorl %eax, %eax
popq %rbx
jmp 0x35e4
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x3170
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
pushq $0x11
popq %rsi
movq %rax, %rdi
callq 0xbb9a
movq 0x8(%rbx), %rax
andq $0x0, 0x18(%rax)
andq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: symtable_predef
void symtable_predef(symtable *stb) {
	//Get date and time strings
	static char sdate[16];
	static char stime[16];
	time_t c_time = time(NULL);
	struct tm *l_time = localtime(&c_time);
	strftime(sdate, 16, "\"%b %d %Y\"", l_time);
	strftime(stime, 16, "\"%H:%M:%S\"", l_time);

	//Static buffer for __FILE__ and __LINE__ (filled in lex_expand_macro)
	static char sfili[256];
	
	//Predefine macros
	PREDEF_MACRO(stb, __DATE__, sdate);
	PREDEF_MACRO(stb, __FILE__, sfili);
	PREDEF_MACRO(stb, __LINE__, sfili);
	PREDEF_MACRO(stb, __STDC__, "1");
	PREDEF_MACRO(stb, __STDC_HOSTED__, "0");
	PREDEF_MACRO(stb, __STDC_VERSION__, "199901L");
	PREDEF_MACRO(stb, __TIME__, stime);
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3160
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x3050
movq %rax, %r12
leaq 0x81ac(%rip), %r15      # 0x135a0
leaq 0x2ba0(%rip), %rdx      # 0xdf9b
pushq $0x10
popq %r13
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rcx
callq 0x31b0
leaq 0x819c(%rip), %r14      # 0x135b0
leaq 0x2b8b(%rip), %rdx      # 0xdfa6
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rcx
callq 0x31b0
pushq $0x1
popq %rbp
movl %ebp, %edi
callq 0xb5ed
leaq 0x2b77(%rip), %rsi      # 0xdfb1
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb545
movq %r15, 0x48(%rax)
movl %ebp, 0x54(%rax)
movl %ebp, %edi
callq 0xb5ed
leaq 0x19de(%rip), %rsi      # 0xce3a
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb545
leaq 0x8150(%rip), %r15      # 0x135c0
movq %r15, 0x48(%rax)
movl %ebp, 0x54(%rax)
movl %ebp, %edi
callq 0xb5ed
leaq 0x19c3(%rip), %rsi      # 0xce48
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb545
movq %r15, 0x48(%rax)
movl %ebp, 0x54(%rax)
movl %ebp, %edi
callq 0xb5ed
leaq 0x2b13(%rip), %rsi      # 0xdfba
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb545
leaq 0x1256(%rip), %rcx      # 0xc711
movq %rcx, 0x48(%rax)
movl %ebp, 0x54(%rax)
movl %ebp, %edi
callq 0xb5ed
leaq 0x2af3(%rip), %rsi      # 0xdfc3
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb545
leaq 0x1229(%rip), %rcx      # 0xc70d
movq %rcx, 0x48(%rax)
movl %ebp, 0x54(%rax)
movl %ebp, %edi
callq 0xb5ed
leaq 0x2ada(%rip), %rsi      # 0xdfd3
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb545
leaq 0x2ad7(%rip), %rcx      # 0xdfe4
movq %rcx, 0x48(%rax)
movl %ebp, 0x54(%rax)
movl %ebp, %edi
callq 0xb5ed
leaq 0x2aca(%rip), %rsi      # 0xdfec
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb545
movq %r14, 0x48(%rax)
movl %ebp, 0x54(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbd22
testq %rax, %rax
je 0xb58c
movq %rax, %rbx
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0xb760
testl %eax, %eax
je 0xb5ca
movq (%r15), %rax
cmpq 0x8(%r15), %rax
je 0xb5e0
leaq 0x2a87(%rip), %rsi      # 0xe011
jmp 0xb5d1
movq %r14, %rdi
movq %r13, %rsi
callq 0xb858
movq %rax, %rbx
xorl %eax, %eax
cmpl $0x1, (%r13)
sete %al
movq (%r15,%rax,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xbd89
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xb5e0
addq $0x20, %rdi
movq %rbx, %rsi
callq 0xbf10
jmp 0xb5e0
leaq 0x2a24(%rip), %rsi      # 0xdff5
xorl %ebx, %ebx
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x35e4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x40
popq %rdi
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)
andl $0x0, 0x20(%r14)
xorl %esi, %esi
callq 0xbe8a
andq $0x0, 0x38(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb680
xorl %r14d, %r14d
movslq 0x14(%rbx), %rax
cmpq %rax, %r14
jge 0xb667
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xb662
callq 0xb688
incq %r14
jmp 0xb648
movq %rbx, %rdi
callq 0xbbe6
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x3030
movq %r14, %rbx
jmp 0xb640
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb6a3
cmpl $0x0, 0x54(%rbx)
jne 0xb6a3
callq 0x3030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb6b1
callq 0xb8ba
leaq 0x20(%rbx), %r14
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0xb6d7
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0xb6d2
callq 0xb688
incq %r15
jmp 0xb6b8
movq %r14, %rdi
callq 0xbecc
leaq 0x30(%rbx), %rdi
callq 0xbbe6
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xb6fc
cmpl $0x0, 0x54(%rbx)
jne 0xb6fc
callq 0x3030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x3170
movq %rax, %r14
movq (%rbx), %rax
movq %rax, 0x18(%r14)
pushq $0x11
popq %rsi
movq %r14, %rdi
callq 0xbb9a
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbbe6
movq 0x18(%r14), %rax
movq %rax, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030