LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9790
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups -0x20(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %edi
movl $0x6, %esi
callq 0x3350
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd9d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x9790
cmpl $0x39, -0x70(%rbp)
jne 0xe65b
movq -0x8(%rbp), %rdi
callq 0x97e0
jmp 0xe674
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x4b8e(%rip), %rsi      # 0x131fb
movb $0x0, %al
callq 0x3880
movq -0x8(%rbp), %rdi
leaq 0x4ba2(%rip), %rsi      # 0x13221
callq 0xe250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x9790
cmpl $0x1, -0xa0(%rbp)
jne 0xe6b3
movq -0x8(%rbp), %rdi
callq 0x97e0
jmp 0xe6cc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x4b6a(%rip), %rsi      # 0x1322f
movb $0x0, %al
callq 0x3880
movq -0x10(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x81f0
movq -0x8(%rbp), %rdi
callq 0x8e20
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xe73e
movq -0x20(%rbp), %rdi
leaq 0x4b80(%rip), %rsi      # 0x132b2
movb $0x0, %al
callq 0x3880
jmp 0xe805
jmp 0xe740
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
je 0xe805
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xe76e
movq -0x20(%rbp), %rdi
leaq 0x4b6d(%rip), %rsi      # 0x132cf
movb $0x0, %al
callq 0x3880
jmp 0xe805
movq -0x18(%rbp), %rax
cmpl $0x35, (%rax)
je 0xe78b
movq -0x20(%rbp), %rdi
leaq 0x4b7d(%rip), %rsi      # 0x132ff
movb $0x0, %al
callq 0x3880
jmp 0xe805
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0xf720
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0xff10
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x107d0
movq -0x8(%rbp), %rdi
callq 0x8e20
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
je 0xe7ec
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
je 0xe7ec
movq -0x20(%rbp), %rdi
leaq 0x4b48(%rip), %rsi      # 0x1332b
movb $0x0, %al
callq 0x3880
jmp 0xe805
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xe7fe
movq -0x8(%rbp), %rdi
callq 0x8e20
jmp 0xe800
jmp 0xe740
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x100, -0x30(%rbp)     # imm = 0x100
movq -0x8(%rbp), %rdi
callq 0x81b0
movb %al, -0x31(%rbp)
movslq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, -0x40(%rbp)
callq 0x3240
movq (%rax), %rax
movsbl -0x31(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xeac0
movq -0x8(%rbp), %rdi
callq 0x81f0
movb %al, -0x31(%rbp)
jmp 0xea95
jmp 0xeac2
movsbl -0x31(%rbp), %eax
cmpl $0xa, %eax
je 0xeb15
movl -0x2c(%rbp), %eax
addl $0x2, %eax
cmpl -0x30(%rbp), %eax
jne 0xeaef
movl -0x30(%rbp), %eax
shll %eax
movl %eax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x31c0
movq %rax, -0x40(%rbp)
movb -0x31(%rbp), %dl
movq -0x40(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x81f0
movb %al, -0x31(%rbp)
jmp 0xeac2
movq -0x40(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0xc(%rbp)
je 0xeb3f
movq -0x40(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x4873(%rip), %rsi      # 0x133a9
movb $0x0, %al
callq 0x3980
jmp 0xeb55
movq -0x40(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x485b(%rip), %rsi      # 0x133a9
movb $0x0, %al
callq 0x3880
movq -0x40(%rbp), %rdi
callq 0x3030
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8e20
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x9790
cmpl $0x35, -0x38(%rbp)
je 0xee25
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rdx
leaq 0x4609(%rip), %rsi      # 0x13427
movb $0x0, %al
callq 0x3880
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xee52
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, (%rax)
je 0xee54
jmp 0xee69
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x105c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x10680
movq -0x8(%rbp), %rax
movl $0x1, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x6c(%rax)
movq -0x8(%rbp), %rdi
callq 0x95f0
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0x85aa(%rip), %rsi      # 0x17468
movl $0x30, %edx
callq 0x3160
movq -0x8(%rbp), %rdi
callq 0x95f0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xeee5
jmp 0xef85
movq -0x8(%rbp), %rdi
callq 0x8e20
movq -0x8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x9790
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x30, %edx
callq 0x3160
movl $0x30, %edi
callq 0x3190
movq %rax, -0x90(%rbp)
cmpl $0x35, -0x58(%rbp)
jne 0xef46
movq -0x38(%rbp), %rdi
leaq 0x34be(%rip), %rsi      # 0x123f3
callq 0x3120
cmpl $0x0, %eax
jne 0xef46
movl $0x32, -0x58(%rbp)
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x30, %edx
callq 0x3160
movq -0x90(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x108d0
cmpl $0x32, -0x58(%rbp)
sete %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
jmp 0xeec8
movq -0x8(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rsi
callq 0x3e40
movl %eax, -0x94(%rbp)
movl $0x0, -0x98(%rbp)
movl -0x98(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xf038
movq -0x20(%rbp), %rax
movslq -0x98(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xeffd
movq -0xa0(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xfca0
jmp 0xf01b
movq -0xa0(%rbp), %rax
cmpl $0x35, (%rax)
jne 0xf019
movq -0xa0(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
jmp 0xf01b
movq -0xa0(%rbp), %rdi
callq 0x3030
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
jmp 0xefbc
leaq -0x20(%rbp), %rdi
callq 0x10710
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xee70
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x7110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8e20
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x9790
cmpl $0x35, -0x38(%rbp)
je 0xf0de
leaq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq 0x4369(%rip), %rsi      # 0x13440
movb $0x0, %al
callq 0x3880
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xfb60
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x7110
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8e20
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x9790
cmpl $0x35, -0x38(%rbp)
je 0xf15e
leaq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq 0x430b(%rip), %rsi      # 0x13462
movb $0x0, %al
callq 0x3880
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xfb60
movq %rax, %rdx
movl $0x1, %eax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x7110
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x10970
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf1df
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x42af(%rip), %rsi      # 0x13485
movb $0x0, %al
callq 0x3880
jmp 0xf222
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xee70
movl %eax, %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x10970
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf26f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x4231(%rip), %rsi      # 0x13497
movb $0x0, %al
callq 0x3880
jmp 0xf2b9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xf294
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x421e(%rip), %rsi      # 0x134a9
movb $0x0, %al
callq 0x3880
jmp 0xf2b9
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x10970
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf2ff
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x41c6(%rip), %rsi      # 0x134bc
movb $0x0, %al
callq 0x3880
jmp 0xf308
movq -0x8(%rbp), %rdi
callq 0x7170
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x3190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x11, %esi
callq 0x101b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xf69a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xf9d0
cmpl $0x0, %eax
jne 0xf65c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3f02(%rip), %rsi      # 0x1354a
movb $0x0, %al
callq 0x3880
movq $0x0, -0x8(%rbp)
jmp 0xf707
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xf67a
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf707
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3edd(%rip), %rsi      # 0x13566
movb $0x0, %al
callq 0x3880
movq $0x0, -0x8(%rbp)
jmp 0xf707
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xfbe0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xf6cb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x104f0
jmp 0xf6df
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x104f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf6ff
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x20, %rdi
movq -0x38(%rbp), %rsi
callq 0x107d0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x40, %edi
callq 0x3190
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
callq 0x10680
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf84c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0xf824
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xf817
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf860
jmp 0xf819
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf7e5
movq -0x10(%rbp), %rdi
callq 0x10240
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3030
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf7d7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf88c
movq -0x8(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0xf88c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf8a4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfca0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0xf8ec
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xf8df
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xf860
jmp 0xf8e1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf8ab
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x10710
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x10240
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xf928
movq -0x8(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0xf928
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x3190
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movl $0x11, %esi
callq 0x101b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10240
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf9fa
cmpq $0x0, -0x18(%rbp)
jne 0xf9fa
movl $0x1, -0x4(%rbp)
jmp 0xfaaa
cmpq $0x0, -0x10(%rbp)
je 0xfa08
cmpq $0x0, -0x18(%rbp)
jne 0xfa14
movl $0x0, -0x4(%rbp)
jmp 0xfaaa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff80
cmpl $0x0, %eax
jne 0xfa2f
movl $0x0, -0x4(%rbp)
jmp 0xfaaa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xfa93
cmpq $0x0, -0x28(%rbp)
jne 0xfa5e
movl $0x0, -0x4(%rbp)
jmp 0xfaaa
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xff80
cmpl $0x0, %eax
jne 0xfa79
movl $0x0, -0x4(%rbp)
jmp 0xfaaa
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xfa47
cmpq $0x0, -0x28(%rbp)
je 0xfaa3
movl $0x0, -0x4(%rbp)
jmp 0xfaaa
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xfaf7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3a8f(%rip), %rsi      # 0x1357d
movb $0x0, %al
callq 0x3880
jmp 0xfb48
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x10460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xfb2f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3a80(%rip), %rsi      # 0x135a6
movb $0x0, %al
callq 0x3880
jmp 0xfb48
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x104f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xfbb2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xfba4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfbba
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xfb7b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x3110
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xfc44
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x10680
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl $0x11, %esi
callq 0x101b0
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x54(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xfc7c
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xfc63
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xfcc4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xfca0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xfd19
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xfcf7
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xfd50
jmp 0xfd0c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xfd70
jmp 0xfd0e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfccb
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x10710
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfd3e
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xfca0
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xfd94
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfca0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xfdaa
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xfde0
movq $0x0, -0x8(%rbp)
jmp 0xfefd
movl $0x40, %edi
callq 0x3190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x3160
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xfdc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xfdc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
callq 0x10680
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xfef5
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x30b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3190
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x30b0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x3050
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfdc0
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0xff10
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x38(%rbp), %rsi
callq 0x107d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfe46
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x3190
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xff66
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xff4d
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xffaa
movl $0x0, -0x4(%rbp)
jmp 0x10093
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xffc6
movl $0x0, -0x4(%rbp)
jmp 0x10093
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0xffe2
movl $0x0, -0x4(%rbp)
jmp 0x10093
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
je 0xfffe
movl $0x0, -0x4(%rbp)
jmp 0x10093
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x10069
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xf9d0
cmpl $0x0, %eax
jne 0x1005c
movl $0x0, -0x4(%rbp)
jmp 0x10093
jmp 0x1005e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10005
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xf9d0
cmpl $0x0, %eax
jne 0x1008c
movl $0x0, -0x4(%rbp)
jmp 0x10093
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0x10100
movq -0x28(%rbp), %rax
leaq 0x3409(%rip), %rcx      # 0x134d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10174
movl $0x8, -0x4(%rbp)
jmp 0x10174
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10174
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x10174
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x1015d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x100a0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x10150
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x10152
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10115
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x1016e
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x10174
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10262
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10279
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x102f6
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0xa, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1029a
movl -0xc(%rbp), %eax
shll $0x3, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0xb, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0xf, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3110
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3110
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x10417
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x10407
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10280
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x103d0
movl -0x28(%rbp), %eax
addl $0x1, %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x28(%rbp)
jmp 0x103b2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x10409
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10373
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10280
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x14(%rcx)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x104de
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3120
cmpl $0x0, %eax
jne 0x104cb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x104e6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cltd
idivl 0x14(%rcx)
movl %edx, -0x1c(%rbp)
jmp 0x10485
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x14(%rax), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x30a2(%rip), %xmm1     # 0x135c8
ucomisd %xmm1, %xmm0
jbe 0x10535
movq -0x8(%rbp), %rdi
callq 0x10330
movq -0x10(%rbp), %rdi
callq 0x10280
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x14(%rcx)
movl %edx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x10584
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x10571
jmp 0x10584
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x14(%rcx)
movl %edx, -0x1c(%rbp)
jmp 0x1054a
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10280
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x14(%rcx)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1063e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x3120
cmpl $0x0, %eax
jne 0x1062b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x1063e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x14(%rcx)
movl %edx, -0x14(%rbp)
jmp 0x105e5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x106ae
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x106b9
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)