LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xa113
movq %rax, %rbx
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x79dc
cmpl $0x7, (%r15)
jne 0xa101
movq %r14, %rdi
callq 0x7a19
leaq 0xa44d(%rip), %rax      # 0x14438
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 0x858c
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x9037
movq %rax, %r12
cmpl $-0x1, (%r15)
je 0xa03b
leaq 0x68(%rsp), %rdi
leaq 0x4a68(%rip), %rsi      # 0xea9c
xorl %eax, %eax
callq 0x3250
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x79dc
cmpl $0x8, (%r15)
je 0xa064
leaq 0x38(%rsp), %rdi
leaq 0x4a69(%rip), %rsi      # 0xeac6
xorl %eax, %eax
callq 0x3250
movq %r14, %rdi
callq 0x7a19
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x1, %edi
movl $0x15, %esi
callq 0x356c
movq %rax, %r15
movq %r12, 0x10(%rax)
movq %r14, %rdi
callq 0x9fa6
movq %rax, 0x20(%r15)
testq %rbx, %rbx
je 0xa0fe
movl 0x8(%rbx), %eax
cmpl $0x1c, %eax
jne 0xa0cb
leaq 0x4a29(%rip), %rsi      # 0xeae8
xorl %edi, %edi
xorl %eax, %eax
callq 0x3250
movl 0x8(%rbx), %eax
cmpl $0x1d, %eax
jne 0xa0e3
leaq 0x4a34(%rip), %rsi      # 0xeb0b
xorl %edi, %edi
xorl %eax, %eax
callq 0x3250
movl 0x8(%rbx), %eax
cmpl $0x16, %eax
jne 0xa0f8
leaq 0x4a3f(%rip), %rsi      # 0xeb2e
xorl %edi, %edi
xorl %eax, %eax
callq 0x3250
movq %r15, 0x20(%rbx)
jmp 0xa101
movq %r15, %rbx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
movl (%r14), %eax
addl $-0x10, %eax
cmpl $0x14, %eax
jae 0xa199
movl $0xe0127, %ecx          # imm = 0xE0127
btl %eax, %ecx
jae 0xa199
movl %eax, %eax
leaq 0x4564(%rip), %rcx      # 0xe6b0
movl (%rcx,%rax,4), %ebp
movq %rbx, %rdi
callq 0x7a19
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x1, %edi
movl %ebp, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1aa
testq %r14, %r14
je 0xa1a1
movq %rax, 0x20(%r14)
movq %r14, %rax
jmp 0xa1a1
movq %rbx, %rdi
callq 0xa1aa
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x9245
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x3, (%r15)
jne 0xa5a0
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0x7a19
movq %rbx, %rdi
callq 0x9245
movq %rax, %r12
movq %r14, 0x60(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x3, 0x8(%rsp)
movq %r12, %r14
je 0xa572
jmp 0xa5a3
movq %r14, %r12
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
movl (%r14), %ecx
leal -0x35(%rcx), %eax
cmpl $0xc, %eax
ja 0xa826
leaq 0x3e76(%rip), %rcx      # 0xe66c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0xac05
jmp 0xa8d7
movq %rbx, %rdi
callq 0xaa36
jmp 0xa8d7
movq %rbx, %rdi
callq 0xa8e4
jmp 0xa8d7
cmpl $0x5, %ecx
jne 0xa8cf
movq %rbx, %rdi
callq 0x93de
jmp 0xa8d7
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x7c14
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a19
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x7c14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7ba8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ba8
cmpl $0x2, (%r15)
jne 0xa8cf
movq %rbx, %rdi
callq 0xaa9e
jmp 0xa8d7
movq %rbx, %rdi
callq 0xae1b
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
cmpl $0x36, (%r14)
jne 0xa9ab
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x2, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a19
leaq 0x42fc(%rip), %rsi      # 0xec5c
movq %rbx, %rdi
callq 0xaeed
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa7c2
movq %rax, 0x20(%r14)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x37, (%r15)
jne 0xaa26
movq %rbx, %rdi
callq 0x7a19
movq %rbx, %rdi
callq 0xa7c2
movq %rax, 0x28(%r14)
jmp 0xaa26
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x38, (%r14)
jne 0xaa26
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x3, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a19
leaq 0x425b(%rip), %rsi      # 0xec69
movq %rbx, %rdi
callq 0xaeed
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa7c2
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_O3/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 0x79dc
movl (%r14), %ecx
cmpl $0x3b, %ecx
je 0xaa86
cmpl $0x3a, %ecx
je 0xaa74
cmpl $0x39, %ecx
jne 0xaa96
movq %rbx, %rdi
callq 0x7a19
movq %rbx, %rdi
callq 0xaf99
jmp 0xaa96
movq %rbx, %rdi
callq 0x7a19
movq %rbx, %rdi
callq 0xb00b
jmp 0xaa96
movq %rbx, %rdi
callq 0x7a19
movq %rbx, %rdi
callq 0xb1aa
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
movl (%r14), %eax
cmpl $0x3d, %eax
je 0xab6a
cmpl $0x3c, %eax
je 0xab25
cmpl $0x35, %eax
jne 0xabf2
leaq 0x38(%rsp), %r15
movups -0x8(%r15), %xmm0
movups 0x8(%r15), %xmm1
movups 0x18(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x7, %esi
callq 0x356c
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq 0x18(%r15), %rsi
movq %r15, %rdx
callq 0xc124
movq 0x18(%r15), %rax
movq %rax, 0x10(%r14)
jmp 0xab99
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x8, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a19
movq %rbx, %rdi
callq 0x9841
movq %rax, 0x18(%r14)
jmp 0xaba1
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x9, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a19
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
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 0xabe8
leaq 0x38(%rsp), %rdi
leaq 0x4140(%rip), %rsi      # 0xed21
xorl %eax, %eax
callq 0x3250
movq %rbx, %rdi
callq 0x7a19
jmp 0xabf5
xorl %r14d, %r14d
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
cmpl $0x1, (%r14)
jne 0xae53
movq %rbx, %rdi
callq 0x7a19
xorl %r14d, %r14d
jmp 0xaedd
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
xorl %esi, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0x97d3
movq %rax, 0x18(%r14)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x1, (%r15)
jne 0xaebd
movq %rbx, %rdi
callq 0x7a19
jmp 0xaedd
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x79dc
leaq 0x38(%rsp), %rdi
leaq 0x3d68(%rip), %rsi      # 0xec3e
xorl %eax, %eax
callq 0x3250
movq %r14, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
cmpl $0x7, (%r14)
jne 0xaf1c
movq %rbx, %rdi
callq 0x7a19
jmp 0xaf31
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3c87(%rip), %rsi      # 0xebb1
xorl %eax, %eax
callq 0x3250
movq %rbx, %rdi
callq 0x97d3
movq %rax, %r14
testq %rax, %rax
jne 0xaf59
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3c85(%rip), %rsi      # 0xebd4
movq %r15, %rdx
xorl %eax, %eax
callq 0x3250
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x8, (%r15)
jne 0xaf77
movq %rbx, %rdi
callq 0x7a19
jmp 0xaf8c
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3c74(%rip), %rsi      # 0xebf9
xorl %eax, %eax
callq 0x3250
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x4, %esi
callq 0x356c
movq %rax, %r14
leaq 0x3d08(%rip), %rsi      # 0xecf0
movq %rbx, %rdi
callq 0xaeed
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0xa7c2
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79dc
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x2, %edi
movl $0x6, %esi
callq 0x356c
movq %rax, %r14
movq %rbx, %rdi
callq 0xa7c2
movq %rax, 0x20(%r14)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x39, (%r15)
jne 0xb226
movq %rbx, %rdi
callq 0x7a19
jmp 0xb23b
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3a93(%rip), %rsi      # 0xecc7
xorl %eax, %eax
callq 0x3250
leaq 0x3aab(%rip), %rsi      # 0xeced
movq %rbx, %rdi
callq 0xaeed
movq %rax, 0x18(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x1, (%r15)
jne 0xb26e
movq %rbx, %rdi
callq 0x7a19
jmp 0xb283
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x3a7f(%rip), %rsi      # 0xecfb
xorl %eax, %eax
callq 0x3250
movq %r14, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/ppd.c
// Function: ppd_defparams
void ppd_defparams(lexer *lx, s_type *mtype) {
	token *t = &lx->ahead;
	s_pos *loc = &lx->tgt->loc;
	lex_advc(lx);
	lex_next(lx);
	if (t->nline) {
		c_error(loc, "Expected ')' before newline\n");
		return;
	}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
callq 0x6798
movq %r15, %rdi
callq 0x7142
cmpl $0x0, 0x14(%r15)
je 0xb2e2
leaq 0x3abb(%rip), %r12      # 0xed7e
addq $0x28, %rbx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3250
movl 0x10(%r15), %eax
cmpl $0x8, %eax
jne 0xb2fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x28, %r14
leaq 0x3a96(%rip), %r13      # 0xed9b
leaq 0x3abf(%rip), %rbp      # 0xedcb
leaq 0x3ae4(%rip), %r12      # 0xedf7
cmpl $0x0, 0x14(%r15)
jne 0xb372
cmpl $0x35, %eax
jne 0xb37a
movl $0x1, %edi
callq 0xbf35
movq 0x30(%r15), %rsi
movq %rax, %rdi
callq 0xc3e4
movq %r14, %rdi
movq %rax, %rsi
callq 0xc922
movq %r15, %rdi
callq 0x7142
movl 0x10(%r15), %eax
cmpl $0x3, %eax
jne 0xb364
movq %r15, %rdi
callq 0x7142
movl 0x10(%r15), %eax
cmpl $0x8, %eax
jne 0xb313
jmp 0xb2eb
cmpl $0x8, %eax
jne 0xb2c3
jmp 0xb2eb
movq %r13, %r12
jmp 0xb2c3
movq %rbp, %r12
jmp 0xb2c3
// File: /workspace/github_c_makefile_star2_O3/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 0x677e
movl %eax, %r15d
movl $0x100, %edi            # imm = 0x100
callq 0x3170
movq %rax, %rbx
callq 0x3230
movq %rax, %r12
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xb5ab
movq %r14, %rdi
callq 0x6798
movl %eax, %r15d
movq (%r12), %rax
jmp 0xb58f
cmpb $0xa, %r15b
jne 0xb5b5
xorl %eax, %eax
jmp 0xb5f5
movl $0x100, %r13d           # imm = 0x100
xorl %r12d, %r12d
leaq 0x2(%r12), %rax
movl %r13d, %ecx
cmpq %rcx, %rax
jne 0xb5dc
addl %r13d, %r13d
movslq %r13d, %rsi
movq %rbx, %rdi
callq 0x31a0
movq %rax, %rbx
movb %r15b, (%rbx,%r12)
incq %r12
movq %r14, %rdi
callq 0x6798
movl %eax, %r15d
cmpb $0xa, %al
jne 0xb5be
movl %r12d, %eax
movb $0x0, (%rbx,%rax)
leaq 0x3875(%rip), %rsi      # 0xee75
movq %rsp, %rdi
movq %rbx, %rdx
xorl %eax, %eax
testl %ebp, %ebp
je 0xb613
callq 0x3338
jmp 0xb618
callq 0x3250
movq %rbx, %rdi
callq 0x3030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7142
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x35, (%r14)
je 0xb82f
movq (%rbx), %rdi
addq $0x28, %rdi
movq 0x28(%rsp), %rdx
leaq 0x36cb(%rip), %rsi      # 0xeef3
xorl %eax, %eax
callq 0x3250
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xc70a
testq %rax, %rax
je 0xb861
movq 0x8(%rax), %rax
cmpl $0x1, (%rax)
jne 0xb861
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xc7e6
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/ppd.c
// Function: ppd_constexpr
int ppd_constexpr(lexer *lx, int *err) {
	vector toks;
	vector_init(&toks, VECTOR_DEFAULT);

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0xc88c
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x68(%r14)
movq %r14, %rdi
callq 0x7825
movq %r14, %rdi
callq 0x7825
testl %eax, %eax
jne 0xb96a
leaq 0x4c(%rsp), %r12
movq %r14, %rdi
callq 0x7142
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x79dc
movl 0x48(%rsp), %r13d
movups (%r12), %xmm0
movups 0xc(%r12), %xmm1
movaps %xmm0, 0x20(%rsp)
movups %xmm1, 0x2c(%rsp)
movq 0x68(%rsp), %rbp
movq 0x70(%rsp), %r15
movl $0x30, %edi
callq 0x3170
movq %rax, %rbx
cmpl $0x35, %r13d
jne 0xb923
movq %rbp, %rdi
leaq 0x282e(%rip), %rsi      # 0xe13d
callq 0x3110
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,2), %r13d
addl $0x32, %r13d
movl %r13d, (%rbx)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x4(%rbx)
movups 0x2c(%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movq %rbp, 0x20(%rbx)
movq %r15, 0x28(%rbx)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xc9d2
xorl %eax, %eax
cmpl $0x32, %r13d
setne %al
movl %eax, 0x68(%r14)
movq %r14, %rdi
callq 0x7825
testl %eax, %eax
je 0xb8b9
movq $0x0, 0x68(%r14)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq 0x18(%rsp), %rdx
callq 0x39f3
movl %eax, %ebx
cmpl $0x0, 0x8(%r15)
jle 0xb9d0
xorl %r15d, %r15d
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %r14
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0xb9ac
callq 0xc233
jmp 0xb9bb
cmpl $0x35, (%r14)
jne 0xb9bb
movq 0x20(%r14), %rdi
callq 0x3030
movq %r14, %rdi
callq 0x3030
incq %r15
movslq 0x10(%rsp), %rax
cmpq %rax, %r15
jl 0xb993
leaq 0x8(%rsp), %rdi
callq 0xc8d9
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_O3/Yamsman[P]scc/src/ppd.c
// Function: ppd_if
void ppd_if(lexer *lx) {
	int err = 0;
	int res = (ppd_constexpr(lx, &err)) ? 1 : 0;
	lexer_add_cond(lx, res);
	return;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
callq 0xb869
xorl %esi, %esi
testl %eax, %eax
setne %sil
movq %rbx, %rdi
callq 0x5b9d
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7142
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x35, (%r14)
je 0xba51
leaq 0x10(%rsp), %rdi
leaq 0x34c2(%rip), %rsi      # 0xef0c
xorl %eax, %eax
callq 0x3250
movq 0x60(%rbx), %rdi
movq 0x28(%rsp), %rsi
callq 0xc187
xorl %esi, %esi
testq %rax, %rax
setne %sil
movq %rbx, %rdi
callq 0x5b9d
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7142
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79dc
cmpl $0x35, (%r14)
je 0xbab0
leaq 0x10(%rsp), %rdi
leaq 0x3485(%rip), %rsi      # 0xef2e
xorl %eax, %eax
callq 0x3250
movq 0x60(%rbx), %rdi
movq 0x28(%rsp), %rsi
callq 0xc187
xorl %esi, %esi
testq %rax, %rax
sete %sil
movq %rbx, %rdi
callq 0x5b9d
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/ppd.c
// Function: ppd_elif
void ppd_elif(lexer *lx) {
	lex_cond *cond = vector_top(&lx->conds);
	if (cond == NULL) {
		c_error(&lx->tgt->loc, "#elif before #if\n");
		return;
	}

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xc9fc
testq %rax, %rax
je 0xbb16
movq %rax, %r14
xorl %ebp, %ebp
leaq 0xc(%rsp), %rsi
movl %ebp, (%rsi)
movl (%rax), %eax
orl %eax, 0x4(%r14)
movq %rbx, %rdi
callq 0xb869
movl %ebp, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x342d(%rip), %rsi      # 0xef51
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O3/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 0xc9fc
testq %rax, %rax
je 0xbb5b
cmpl $0x0, 0x8(%rax)
je 0xbb71
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x341c(%rip), %rsi      # 0xef75
jmp 0xbb69
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x33fa(%rip), %rsi      # 0xef63
xorl %eax, %eax
popq %rbx
jmp 0x3250
movl (%rax), %ecx
orl %ecx, 0x4(%rax)
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc9fc
testq %rax, %rax
je 0xbb9d
movq %rbx, %rdi
popq %rbx
jmp 0x5bd0
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x33dd(%rip), %rsi      # 0xef88
xorl %eax, %eax
popq %rbx
jmp 0x3250
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xc70a
testq %rax, %rax
je 0xbed4
movq %rax, %rbx
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0xc0c5
testl %eax, %eax
je 0xbf12
movq (%r15), %rax
cmpq 0x8(%r15), %rax
je 0xbf28
leaq 0x3164(%rip), %rsi      # 0xf036
jmp 0xbf19
movq %r14, %rdi
movq %r13, %rsi
callq 0xc1c5
movq %rax, %rbx
xorl %eax, %eax
cmpl $0x1, (%r13)
sete %al
movq (%r15,%rax,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc76f
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xbf28
addq $0x20, %rdi
movq %rbx, %rsi
callq 0xc922
jmp 0xbf28
leaq 0x3101(%rip), %rsi      # 0xf01a
xorl %ebx, %ebx
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3250
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbfda
movl 0x14(%rbx), %eax
testl %eax, %eax
jle 0xbfbe
xorl %r14d, %r14d
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0xbfb3
callq 0xbfe2
movl 0x14(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0xbf9f
movq %rbx, %rdi
callq 0xc5ca
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x3030
movq %r14, %rbx
testq %r14, %r14
jne 0xbf95
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbffd
cmpl $0x0, 0x54(%rbx)
jne 0xbffd
callq 0x3030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xc00b
callq 0xc233
leaq 0x20(%rbx), %r14
movl 0x28(%rbx), %eax
testl %eax, %eax
jle 0xc038
xorl %r15d, %r15d
movq (%r14), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0xc02d
callq 0xbfe2
movl 0x28(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0xc019
movq %r14, %rdi
callq 0xc8d9
leaq 0x30(%rbx), %rdi
callq 0xc5ca
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xc05d
cmpl $0x0, 0x54(%rbx)
jne 0xc05d
callq 0x3030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/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 0xc5ca
movq 0x18(%r14), %rax
movq %rax, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/sym.c
// Function: type_compare
int type_compare(s_type *a, s_type *b) {
	if (a == NULL && b == NULL) return 1;
	if (a == NULL || b == NULL) return 0;
	if (!type_compare_noref(a, b)) return 0;

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

	return 1;
}

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

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

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

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

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

	return s;
}

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

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

	free(t);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xc249
callq 0xc233
leaq 0x28(%rbx), %r14
cmpl $0x0, 0x30(%rbx)
jle 0xc27b
xorl %r15d, %r15d
cmpl $0x4, (%rbx)
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
jne 0xc26a
callq 0x3030
jmp 0xc26f
callq 0xc2a3
incq %r15
movslq 0x30(%rbx), %rax
cmpq %rax, %r15
jl 0xc256
movq %r14, %rdi
callq 0xc8d9
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xc291
callq 0xc233
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/sym.c
// Function: memb_del
void memb_del(s_param *m) {
	if (m->type != NULL)
		type_del(m->type);
	if (m->name != NULL)
		free(m->name);
	free(m);
}

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

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

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

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

	return param;
}

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

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

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

	return 1;	
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %ebp
cmpl $0x7, %ebp
ja 0xc4dd
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0x27, %eax
btl %ebp, %eax
jb 0xc51a
movl $0x18, %eax
btl %ebp, %eax
jae 0xc4d8
movl $0x8, %ebx
jmp 0xc51a
movl 0x4(%rdi), %ebx
jmp 0xc51a
movslq 0x30(%rdi), %r14
testq %r14, %r14
jle 0xc50e
movq 0x28(%rdi), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq (%r12,%r13,8), %rdi
callq 0xc4a6
addl %eax, %ebx
cmpl %r15d, %eax
cmovgl %eax, %r15d
incq %r13
cmpq %r13, %r14
jne 0xc4f2
jmp 0xc513
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpl $0x9, %ebp
cmovel %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/util/map.c
// Function: map_close
void map_close(map *m) {
	if (m->table != NULL)
		free(m->table);
	if (m->table != NULL)
		free(m->keys);
}

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

	return hash;
}

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

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

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

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x14(%rdi), %r15
leaq (%r15,%r15), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x3100
movq %rax, (%rsp)
movl $0x8, %esi
movq %r14, %rdi
callq 0x3100
movq %rax, %r12
movq %rbx, 0x8(%rsp)
movq (%rbx), %r13
movq %r15, 0x10(%rsp)
testq %r15, %r15
jle 0xc6d6
xorl %ebx, %ebx
movq (%r13,%rbx,8), %r15
testq %r15, %r15
je 0xc6cc
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax,%rbx,8), %rbp
movq %rbp, %rdi
callq 0xc5ed
xorl %edx, %edx
divl %r14d
cmpq $0x0, (%r12,%rdx,8)
je 0xc6c0
movl %edx, %eax
incl %eax
cltd
idivl %r14d
movl %edx, %eax
movslq %edx, %rdx
cmpq $0x0, (%r12,%rdx,8)
jne 0xc6ae
movq (%rsp), %rax
movq %r15, (%rax,%rdx,8)
movq %rbp, (%r12,%rdx,8)
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0xc681
movq %r13, %rdi
callq 0x3030
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdi
callq 0x3030
movq (%rsp), %rax
movq %rax, (%rbx)
movq %r12, 0x8(%rbx)
movl %r14d, 0x14(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq