LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_decltr
s_type *parse_decltr(lexer *lx, s_type *type, token *vname) {
	//Parse pointer types if applicable
	//s_type *ptr_type = parse_decltr_ptr(type);
	//if (ptr_type != type)
	//	return parse_decltr(ptr_type, vname);
	type = parse_decltr_ptr(lx, type); //should work the same?

	//If the asterisk is inside the parenthesis, it indicates that
	//the pointer is bound to what comes after it rather than the
	//preceeding base type
	if (lex_peek(lx).type == TOK_LPR) {
		lex_adv(lx);
		s_type *n_type = parse_decltr(lx, NULL, vname);
		
		//Missing ')'
		token t = lex_peek(lx);
		if (lex_peek(lx).type != TOK_RPR)
			c_error(&t.loc, "Missing ')' in declarator\n");
		lex_adv(lx);

		//Attach trailing array/func types to n_type
		s_type *b_type = parse_decltr_back(lx, type);
		if (n_type == NULL) {
			n_type = b_type;
		} else {
			for (s_type *i = n_type;; i = i->ref) {
				if (i->ref == NULL) {
					i->ref = b_type;
					break;
				}
			}
		}
		return n_type;
	}

	//Do not recurse to parse_decltr after this point
	//Read vname
	token t = lex_peek(lx);
	if (t.type == TOK_IDENT) {
		lex_adv(lx);
		*vname = t;
	}
	return parse_decltr_back(lx, type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb320
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x9790
cmpl $0x7, -0x50(%rbp)
jne 0xb77f
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xb660
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x9790
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x9790
cmpl $0x8, -0xb8(%rbp)
je 0xb6ff
leaq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x76bd(%rip), %rsi      # 0x12db5
movb $0x0, %al
callq 0x3880
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb410
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xb730
movq -0xc0(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0xb775
movq -0x58(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xb75d
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xb773
jmp 0xb75f
movq -0xc8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xc8(%rbp)
jmp 0xb73b
jmp 0xb775
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb7c7
movq -0x10(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x9790
cmpl $0x35, -0xf8(%rbp)
jne 0xb7b6
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x20(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
movl $0x30, %edx
callq 0x3160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb410
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_init_list
ast_n *parse_init_list(lexer *lx) {
	ast_n *list = NULL;
	ast_n *cur = NULL;

	//Parse first initialization
	

	//Parse subsequent elements
	while (lex_peek(lx).type != TOK_RBR) {
		//Check for premature end of input
		if (lex_peek(lx).type == TOK_END) {
			return NULL;
		}
	}

	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x9790
cmpl $0x6, -0x50(%rbp)
je 0xb841
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9790
cmpl $0x0, -0x80(%rbp)
jne 0xb83f
movq $0x0, -0x8(%rbp)
jmp 0xb849
jmp 0xb80f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_decl_init
ast_n *parse_decl_init(lexer *lx) {
	ast_n *node;
	if (lex_peek(lx).type == TOK_LBR) {
		//Read initializer list
		token lbr = lex_peek(lx);
		lex_adv(lx);
		node = parse_init_list(lx);

		//Optional ',' after list
		if (lex_peek(lx).type == TOK_CMM)
			lex_adv(lx);

		//Expect '}'
		token rbr = lex_peek(lx);
		if (rbr.type == TOK_RBR) {
			lex_adv(lx);
		} else if (rbr.type == TOK_END) {
			c_error(&lbr.loc, "Unexpected end of input in initializer\n");
		} else {
			c_error(&rbr.loc, "Expected '}' after initializer list\n");
		}
	} else {
		node = parse_expr_assign(lx);
	}

	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
cmpl $0x5, -0x40(%rbp)
jne 0xb92d
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x9790
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
callq 0xb7f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x9790
cmpl $0x3, -0xa0(%rbp)
jne 0xb8cb
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x9790
cmpl $0x6, -0xd0(%rbp)
jne 0xb8ef
movq -0x8(%rbp), %rdi
callq 0x97e0
jmp 0xb92b
cmpl $0x0, -0xd0(%rbp)
jne 0xb910
leaq -0x70(%rbp), %rdi
addq $0x8, %rdi
leaq 0x7510(%rip), %rsi      # 0x12e17
movb $0x0, %al
callq 0x3880
jmp 0xb929
leaq -0xd0(%rbp), %rdi
addq $0x8, %rdi
leaq 0x751d(%rip), %rsi      # 0x12e3f
movb $0x0, %al
callq 0x3880
jmp 0xb92b
jmp 0xb93a
movq -0x8(%rbp), %rdi
callq 0xb950
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_fparam
s_param *parse_fparam(lexer *lx) {
	//Parse type
	token vname = {0};
	s_type *base_type = parse_decl_spec(lx);

	//Parse declarator
	s_type *type = parse_decltr(lx, base_type, &vname);

	//Create parameter and return
	return param_new(type, vname.dat.sval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3100
movq -0x8(%rbp), %rdi
callq 0xa6d0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xb660
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff10
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_stmt_cmpd
ast_n *parse_stmt_cmpd(lexer *lx) {
	//Expect '{'
	token t = lex_peek(lx);
	if (t.type == TOK_LBR)
		lex_adv(lx);

	//Parse list of declarations/statements here
	ast_n *base = NULL;
	ast_n *last = NULL;
	while (lex_peek(lx).type != TOK_RBR) {
		//Premature end of file
		token t = lex_peek(lx);
		if (t.type == TOK_END) {
			c_error(&t.loc, "Expected '}' before end of input!\n");
			break;
		}

		//Parse a statement or a declaration
		ast_n *node;
		if (is_type_spec(lx, lex_peek(lx))) {
			node = parse_decl(lx);
		} else {
			node = parse_stmt(lx);
		}
		if (node == NULL) continue;

		//Add the node to the list
		if (base == NULL) {
			base = node;
		} else {
			last->next = node;
		}

		//Move to the end of the list
		//If node already has a next, move to the end of it
		if (node != NULL) {
			last = node;
			while (last->next != NULL)
				last = last->next;
		}
	}

	//Expect '}'
	if (lex_peek(lx).type == TOK_RBR)
		lex_adv(lx);

	ast_n *head = astn_new(STMT, STMT_CMPD, t);
	head->next = base;
	return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x9790
cmpl $0x5, -0x38(%rbp)
jne 0xbbcb
movq -0x8(%rbp), %rdi
callq 0x97e0
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9790
cmpl $0x6, -0x78(%rbp)
je 0xbd01
movq -0x8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x9790
cmpl $0x0, -0xa8(%rbp)
jne 0xbc29
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x7532(%rip), %rsi      # 0x1314f
movb $0x0, %al
callq 0x3880
jmp 0xbd01
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x9790
movq -0x120(%rbp), %rdi
movups -0xe0(%rbp), %xmm0
movups -0xd0(%rbp), %xmm1
movups -0xc0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x9a20
cmpl $0x0, %eax
je 0xbc8a
movq -0x8(%rbp), %rdi
callq 0xa380
movq %rax, -0xb0(%rbp)
jmp 0xbc9a
movq -0x8(%rbp), %rdi
callq 0xd9d0
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0xbca9
jmp 0xbbdb
cmpq $0x0, -0x40(%rbp)
jne 0xbcbd
movq -0xb0(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xbccc
movq -0xb0(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x60(%rax)
cmpq $0x0, -0xb0(%rbp)
je 0xbcfc
movq -0xb0(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xbcfa
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xbce1
jmp 0xbcfc
jmp 0xbbdb
movq -0x8(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x9790
cmpl $0x6, -0x110(%rbp)
jne 0xbd23
movq -0x8(%rbp), %rdi
callq 0x97e0
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups -0x18(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %edi
movl $0x1, %esi
callq 0x3350
movq %rax, -0x118(%rbp)
movq -0x40(%rbp), %rcx
movq -0x118(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x118(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_sdef_body
vector parse_sdef_body(lexer *lx) {
	//Advance past '{'
	lex_adv(lx);

	//Parse list of declarations
	vector memb;
	vector_init(&memb, VECTOR_EMPTY);
	while (lex_peek(lx).type != TOK_RBR) {
		if (lex_peek(lx).type == TOK_END) {
			c_error(&lx->tgt->loc, "Expected '}' before end of file\n");
		}

		//Get type
		//TODO: no type classes when parsing for specifier
		token mname = {0};
		s_type *base_type = parse_decl_spec(lx);

		//Parse declarator
		//TODO: bitfields
		s_type *mtype = parse_decltr(lx, type_clone(base_type), &mname);
		if (mname.dat.sval != NULL) {
			//Create new member
			s_param *m = param_new(mtype, mname.dat.sval);
			vector_add(&memb, m);
		} else {
			c_error(&mname.loc, "Declaration declares nothing\n");
		}
		type_del(base_type);

		//Expect ';'
		token t = lex_peek(lx);
		if (t.type != TOK_SEM)
			c_error(&t.loc, "Missing ';' after member definition\n");
		lex_adv(lx);
	}

	//Missing '}'
	token t = lex_peek(lx);
	if (t.type != TOK_RBR)
		c_error(&t.loc, "Missing '}' after struct/union declaration\n");
	lex_adv(lx);

	return memb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x97e0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x10680
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x6, -0x48(%rbp)
je 0xbed8
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9790
cmpl $0x0, -0x78(%rbp)
jne 0xbde6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x709b(%rip), %rsi      # 0x12e7a
movb $0x0, %al
callq 0x3880
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3100
movq -0x18(%rbp), %rdi
callq 0xa6d0
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xb0(%rbp), %rdi
callq 0xfdc0
movq -0x128(%rbp), %rdi
movq %rax, %rsi
leaq -0xa8(%rbp), %rdx
callq 0xb660
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0x88(%rbp)
je 0xbe73
movq -0xb8(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0xff10
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x107d0
jmp 0xbe8c
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x6d3b(%rip), %rsi      # 0x12bc0
movb $0x0, %al
callq 0x3880
movq -0xb0(%rbp), %rdi
callq 0xfca0
movq -0x18(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
callq 0x9790
cmpl $0x1, -0xf0(%rbp)
je 0xbeca
leaq -0xf0(%rbp), %rdi
addq $0x8, %rdi
leaq 0x6fd8(%rip), %rsi      # 0x12e9b
movb $0x0, %al
callq 0x3880
movq -0x18(%rbp), %rdi
callq 0x97e0
jmp 0xbda3
movq -0x18(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x9790
cmpl $0x6, -0x120(%rbp)
je 0xbf0a
leaq -0x120(%rbp), %rdi
addq $0x8, %rdi
leaq 0x6fbd(%rip), %rsi      # 0x12ec0
movb $0x0, %al
callq 0x3880
movq -0x18(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_enum
void parse_enum(lexer *lx, int *val) {
	//Read name
	token t = lex_peek(lx);
	if (t.type != TOK_IDENT) {
		c_error(&t.loc, "Invalid input in enumeration\n");
		return;
	}
	lex_adv(lx);

	//Read optional expression
	if (lex_peek(lx).type == TOK_ASSIGN) {
		lex_adv(lx);
		*val = parse_constexpr(lx);
	}

	//Define a macro for the enumeration
	char buf[64];
	snprintf(buf, 64, "%i", *val);
	symbol *sym = symtable_def(lx->stb, t.dat.sval, type_new(TYPE_MACRO), &t.loc);

	//Copy the expansion to a new string
	char *exp = malloc(strlen(buf)+1);
	strncpy(exp, buf, strlen(buf));
	sym->mac_exp = exp;
	
	(*val)++;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9790
cmpl $0x35, -0x40(%rbp)
je 0xbf71
leaq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq 0x6fc5(%rip), %rsi      # 0x12f2a
movb $0x0, %al
callq 0x3880
jmp 0xc08a
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x9790
cmpl $0x27, -0x70(%rbp)
jne 0xbfa7
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
callq 0xb570
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
leaq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x40, %esi
leaq 0x556a(%rip), %rdx      # 0x1152a
movb $0x0, %al
callq 0x30d0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0x1, %edi
callq 0xf720
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq %rax, %rdx
leaq -0x40(%rbp), %rcx
addq $0x8, %rcx
callq 0xf5f0
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x30b0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3190
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x30b0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
callq 0x3050
movq -0xc0(%rbp), %rcx
movq -0xb8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr
ast_n *parse_expr(lexer *lx) {
	ast_n *node = parse_expr_assign(lx);

	ast_n *n_node = node;
	while (lex_peek(lx).type == TOK_CMM) {
		lex_adv(lx);
		n_node->next = parse_expr_assign(lx);
		n_node = n_node->next;
	}

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb950
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x3, -0x48(%rbp)
jne 0xc0ff
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
callq 0xb950
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc0c1
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_cond
ast_n *parse_expr_cond(lexer *lx) {
	ast_n *node = parse_expr_logic_or(lx);

	if (lex_peek(lx).type == TOK_QMK) {
		//Construct ternary node
		ast_n *n_node = astn_new(EXPR, EXPR_COND, lex_peek(lx));
		ast_expr *n_expr = &n_node->dat.expr;
		n_expr->left = node;
		lex_adv(lx);

		//Read left result and check for ';'
		ast_n *res_true = parse_expr(lx);
		token t = lex_peek(lx);
		if (t.type != TOK_COL)
			c_error(&t.loc, "Expected ':' in ternary expression\n");
		lex_adv(lx);

		//Read right result and construct result node
		ast_n *res = astn_new(EXPR, EXPR_COND_RES, t);
		ast_n *res_false = parse_expr_cond(lx);
		res->dat.expr.left = res_true;
		res->dat.expr.right = res_false;
		n_expr->right = res;
		return n_node;
	}

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0xf, -0x48(%rbp)
jne 0xc278
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9790
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x3, %esi
callq 0x3350
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rdi
callq 0xc0a0
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x9790
cmpl $0x2, -0xc0(%rbp)
je 0xc1e6
leaq -0xc0(%rbp), %rdi
addq $0x8, %rdi
leaq 0x6dcd(%rip), %rsi      # 0x12fac
movb $0x0, %al
callq 0x3880
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0xc0(%rbp), %xmm0
movups -0xb0(%rbp), %xmm1
movups -0xa0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x4, %esi
callq 0x3350
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq %rax, -0xd0(%rbp)
movq -0x90(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0xd0(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0xc8(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc280
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_logic_or
ast_n *parse_expr_logic_or(lexer *lx) {
	ast_n *node = parse_expr_logic_and(lx);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc360
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x1f, -0x48(%rbp)
jne 0xc33e
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9790
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %esi
movl %esi, %edi
callq 0x3350
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xc360
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc346
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_logic_and
ast_n *parse_expr_logic_and(lexer *lx) {
	ast_n *node = parse_expr_or(lx);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc430
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x20, -0x48(%rbp)
jne 0xc415
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9790
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x2, %esi
callq 0x3350
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xc430
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc41d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_or
ast_n *parse_expr_or(lexer *lx) {
	ast_n *node = parse_expr_xor(lx);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc500
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x16, -0x48(%rbp)
jne 0xc4e5
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9790
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x5, %esi
callq 0x3350
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xc500
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc4ed
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_xor
ast_n *parse_expr_xor(lexer *lx) {
	ast_n *node = parse_expr_and(lx);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc5d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x17, -0x48(%rbp)
jne 0xc5b5
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9790
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x6, %esi
callq 0x3350
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xc5d0
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc5bd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_and
ast_n *parse_expr_and(lexer *lx) {
	ast_n *node = parse_expr_equal(lx);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x15, -0x48(%rbp)
jne 0xc685
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9790
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x7, %esi
callq 0x3350
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xc6a0
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc68d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_equal
ast_n *parse_expr_equal(lexer *lx) {
	ast_n *node = parse_expr_relation(lx);

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

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc7d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x9790
movl -0x58(%rbp), %eax
movl %eax, -0x5c(%rbp)
subl $0x1d, %eax
je 0xc6e3
jmp 0xc6d6
movl -0x5c(%rbp), %eax
subl $0x1e, %eax
je 0xc74f
jmp 0xc7bb
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0xe, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xc7d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc7c3
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0xf, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xc7d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc7c3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_shift
ast_n *parse_expr_shift(lexer *lx) {
	ast_n *node = parse_expr_addt(lx);

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

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x9790
movl -0x58(%rbp), %eax
movl %eax, -0x5c(%rbp)
subl $0x25, %eax
je 0xca33
jmp 0xca26
movl -0x5c(%rbp), %eax
subl $0x26, %eax
je 0xca9f
jmp 0xcb0b
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0xc, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xcb20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb13
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0xd, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xcb20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb13
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_addt
ast_n *parse_expr_addt(lexer *lx) {
	ast_n *node = parse_expr_mult(lx);

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

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcc50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x9790
movl -0x58(%rbp), %eax
movl %eax, -0x5c(%rbp)
subl $0x10, %eax
je 0xcb63
jmp 0xcb56
movl -0x5c(%rbp), %eax
subl $0x11, %eax
je 0xcbcf
jmp 0xcc3b
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xcb20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc43
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x11, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xcb20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc43
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Yamsman[P]scc/src/parse.c
// Function: parse_expr_mult
ast_n *parse_expr_mult(lexer *lx) {
	ast_n *node = parse_expr_cast(lx);

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

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xce10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x9790
movl -0x58(%rbp), %eax
movl %eax, -0x5c(%rbp)
subl $0x12, %eax
je 0xcca5
jmp 0xcc86
movl -0x5c(%rbp), %eax
subl $0x13, %eax
je 0xcd14
jmp 0xcc94
movl -0x5c(%rbp), %eax
subl $0x14, %eax
je 0xcd80
jmp 0xcdec
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x12, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xce10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcdf4
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x13, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xce10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcdf4
movq -0x10(%rbp), %rdi
callq 0x97e0
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %edi
movl $0x14, %esi
callq 0x3350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xce10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcdf4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb950
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x3, -0x48(%rbp)
jne 0xd730
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
callq 0xb950
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xd6f1
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9790
movl -0x40(%rbp), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0xb0(%rbp)
subl $0x3c, %eax
ja 0xdb27
movq -0xb0(%rbp), %rax
leaq 0x5092(%rip), %rcx      # 0x12aa4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0xdb50
movq %rax, -0x10(%rbp)
jmp 0xdb34
movq -0x8(%rbp), %rdi
callq 0xdcd0
movq %rax, -0x10(%rbp)
jmp 0xdb34
movq -0x8(%rbp), %rdi
callq 0xdd60
movq %rax, -0x10(%rbp)
jmp 0xdb34
movq -0x8(%rbp), %rdi
callq 0xdf00
movq %rax, -0x10(%rbp)
jmp 0xdb34
movq -0x8(%rbp), %rdi
callq 0xbba0
movq %rax, -0x10(%rbp)
jmp 0xdb34
movq -0x8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9790
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movups -0x58(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x9aa0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x9790
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movups -0xa8(%rbp), %xmm0
movups -0x98(%rbp), %xmm1
movups -0x88(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x9aa0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x99d0
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x99d0
cmpl $0x2, -0xa8(%rbp)
jne 0xdb25
movq -0x8(%rbp), %rdi
callq 0xdd60
movq %rax, -0x10(%rbp)
jmp 0xdb34
jmp 0xdb27
movq -0x8(%rbp), %rdi
callq 0xe160
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9790
cmpl $0x36, -0x40(%rbp)
jne 0xdc20
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x9790
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %esi
movl %esi, %edi
callq 0x3350
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
leaq 0x55cf(%rip), %rsi      # 0x13190
callq 0xe250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0xd9d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x9790
cmpl $0x37, -0xa0(%rbp)
jne 0xdc1b
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
callq 0xd9d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0xdcb9
movq -0x8(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x9790
cmpl $0x38, -0xd0(%rbp)
jne 0xdcb7
movq -0x8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x9790
movups -0x100(%rbp), %xmm0
movups -0xf0(%rbp), %xmm1
movups -0xe0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %edi
movl $0x3, %esi
callq 0x3350
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97e0
movq -0x8(%rbp), %rdi
leaq 0x550a(%rip), %rsi      # 0x1319d
callq 0xe250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0xd9d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0xdcb9
movq -0x10(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9790
movl -0x40(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x39, %eax
je 0xdd0a
jmp 0xdcf6
movl -0x44(%rbp), %eax
subl $0x3a, %eax
je 0xdd22
jmp 0xdd00
movl -0x44(%rbp), %eax
subl $0x3b, %eax
je 0xdd3a
jmp 0xdd50
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rdi
callq 0xe310
movq %rax, -0x8(%rbp)
jmp 0xdd50
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rdi
callq 0xe390
movq %rax, -0x8(%rbp)
jmp 0xdd50
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rdi
callq 0xe5e0
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/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
movl -0x48(%rbp), %eax
movl %eax, -0x7c(%rbp)
subl $0x35, %eax
je 0xddac
jmp 0xdd91
movl -0x7c(%rbp), %eax
subl $0x3c, %eax
je 0xde0c
jmp 0xdd9b
movl -0x7c(%rbp), %eax
subl $0x3d, %eax
je 0xde58
jmp 0xde90
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %edi
movl $0x7, %esi
callq 0x3350
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
addq $0x8, %rdx
callq 0xfac0
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x97e0
jmp 0xde9a
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %edi
movl $0x8, %esi
callq 0x3350
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x10(%rbp), %rdi
callq 0xc110
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xde9a
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %edi
movl $0x9, %esi
callq 0x3350
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97e0
jmp 0xde9a
movq $0x0, -0x8(%rbp)
jmp 0xdee6
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9790
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x30, %edx
callq 0x3160
cmpl $0x2, -0x48(%rbp)
je 0xded5
leaq -0x48(%rbp), %rdi
addq $0x8, %rdi
leaq 0x5387(%rip), %rsi      # 0x13255
movb $0x0, %al
callq 0x3880
movq -0x10(%rbp), %rdi
callq 0x97e0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9790
cmpl $0x1, -0x48(%rbp)
jne 0xe198
movq -0x10(%rbp), %rdi
callq 0x97e0
movq $0x0, -0x8(%rbp)
jmp 0xe23a
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9790
xorl %eax, %eax
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movups -0x58(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x2, %edi
xorl %esi, %esi
callq 0x3350
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc0a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x9790
cmpl $0x1, -0xa8(%rbp)
jne 0xe209
movq -0x10(%rbp), %rdi
callq 0x97e0
jmp 0xe232
movq -0x10(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x9790
leaq -0xd8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x4f47(%rip), %rsi      # 0x13172
movb $0x0, %al
callq 0x3880
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x9790
cmpl $0x7, -0x40(%rbp)
jne 0xe281
movq -0x8(%rbp), %rdi
callq 0x97e0
jmp 0xe29a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x4e52(%rip), %rsi      # 0x130e5
movb $0x0, %al
callq 0x3880
movq -0x8(%rbp), %rdi
callq 0xc0a0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xe2cb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rdx
leaq 0x4e44(%rip), %rsi      # 0x13108
movb $0x0, %al
callq 0x3880
movq -0x8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9790
cmpl $0x8, -0x78(%rbp)
jne 0xe2e9
movq -0x8(%rbp), %rdi
callq 0x97e0
jmp 0xe302
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
leaq 0x4e32(%rip), %rsi      # 0x1312d
movb $0x0, %al
callq 0x3880
movq -0x48(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %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 $0x4, %esi
callq 0x3350
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4ec3(%rip), %rsi      # 0x13224
callq 0xe250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0xd9d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop