LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: fe_sem_process
void fe_sem_process(
	ParserContext *ctx
) {
	assert(ctx);
	assert(ctx->ast);

	ParserASTNode *node_module = ctx->ast;
	_module(ctx, node_module);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4cd15
jmp 0x4cd34
leaq 0x2f83a(%rip), %rdi     # 0x7c556
leaq 0x31527(%rip), %rsi     # 0x7e24a
movl $0x1587, %edx           # imm = 0x1587
leaq 0x31539(%rip), %rcx     # 0x7e268
callq 0x30a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4cd41
jmp 0x4cd60
leaq 0x276a7(%rip), %rdi     # 0x743ef
leaq 0x314fb(%rip), %rsi     # 0x7e24a
movl $0x1588, %edx           # imm = 0x1588
leaq 0x3150d(%rip), %rcx     # 0x7e268
callq 0x30a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4cd80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: module
static void _module(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	for (int i = 0; i < node->nchilds; i++) {
		ParserASTNode *child = node->childs[i];

		_module_item(ctx, child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4cd99
jmp 0x4cdb8
leaq 0x2f7b6(%rip), %rdi     # 0x7c556
leaq 0x314a3(%rip), %rsi     # 0x7e24a
movl $0x157a, %edx           # imm = 0x157A
leaq 0x31555(%rip), %rcx     # 0x7e308
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4cdc1
jmp 0x4cde0
leaq 0x2920b(%rip), %rdi     # 0x75fd3
leaq 0x3147b(%rip), %rsi     # 0x7e24a
movl $0x157b, %edx           # imm = 0x157B
leaq 0x3152d(%rip), %rcx     # 0x7e308
callq 0x30a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x4ce1f
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4dfe0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4cde7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_struct_member_index
static int _get_struct_member_index(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *struct_token,
	LexerToken *id_token
) {
	assert(ctx);
	assert(node);
	assert(struct_token);
	assert(id_token);

	ParserSymbol *struct_symbol = parser_get_symbol_from_node(
		ctx, node, FE_SYM_STRUCT, struct_token
	);
	if (struct_symbol == NULL) {
		_SYNERR_TOKEN(ctx, struct_token, "undefined struct.");
	}

	int index = parser_get_symbol_index_from_symbol(
		ctx, struct_symbol, FE_SYM_STRUCT_MEMBER_VAR, id_token	
	);
	if (index < 0) {
		_SYNERR_TOKEN(ctx, id_token, "undefined struct member.");
	}

	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4ce91
jmp 0x4ceb0
leaq 0x2f6be(%rip), %rdi     # 0x7c556
leaq 0x313ab(%rip), %rsi     # 0x7e24a
movl $0xcbc, %edx            # imm = 0xCBC
leaq 0x34227(%rip), %rcx     # 0x810d2
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4ceb9
jmp 0x4ced8
leaq 0x29113(%rip), %rdi     # 0x75fd3
leaq 0x31383(%rip), %rsi     # 0x7e24a
movl $0xcbd, %edx            # imm = 0xCBD
leaq 0x341ff(%rip), %rcx     # 0x810d2
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4cee1
jmp 0x4cf00
leaq 0x34245(%rip), %rdi     # 0x8112d
leaq 0x3135b(%rip), %rsi     # 0x7e24a
movl $0xcbe, %edx            # imm = 0xCBE
leaq 0x341d7(%rip), %rcx     # 0x810d2
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x4cf09
jmp 0x4cf28
leaq 0x3422a(%rip), %rdi     # 0x8113a
leaq 0x31333(%rip), %rsi     # 0x7e24a
movl $0xcbf, %edx            # imm = 0xCBF
leaq 0x341af(%rip), %rcx     # 0x810d2
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x2, %edx
callq 0x82f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4cf62
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x316b2(%rip), %rdx     # 0x7e612
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x5, %edx
callq 0x8ac0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x4cf9a
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x341ab(%rip), %rdx     # 0x81143
callq *%rax
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_struct_member_type_node
static ParserASTNode * _get_struct_member_type_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *struct_token,
	LexerToken *id_token
) {
	assert(ctx);
	assert(node);
	assert(struct_token);
	assert(id_token);

	ParserSymbol *struct_symbol = parser_get_symbol_from_node(
		ctx, node, FE_SYM_STRUCT, struct_token
	);
	if (struct_symbol == NULL) {
		_SYNERR_TOKEN(ctx, struct_token, "undefined struct.");
	}

	ParserSymbol *struct_member = parser_get_symbol_from_symbol(
		ctx, struct_symbol, FE_SYM_STRUCT_MEMBER_VAR, id_token
	);
	if (struct_member == NULL) {
		_SYNERR_TOKEN(ctx, id_token, "undefined struct member.");
	}

	return FE_STRUCT_MEMBER_VAR_SYMBOL_GET_TYPE_NODE(struct_member);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4d011
jmp 0x4d030
leaq 0x2f53e(%rip), %rdi     # 0x7c556
leaq 0x3122b(%rip), %rsi     # 0x7e24a
movl $0xca0, %edx            # imm = 0xCA0
leaq 0x34131(%rip), %rcx     # 0x8115c
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4d039
jmp 0x4d058
leaq 0x28f93(%rip), %rdi     # 0x75fd3
leaq 0x31203(%rip), %rsi     # 0x7e24a
movl $0xca1, %edx            # imm = 0xCA1
leaq 0x34109(%rip), %rcx     # 0x8115c
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4d061
jmp 0x4d080
leaq 0x340c5(%rip), %rdi     # 0x8112d
leaq 0x311db(%rip), %rsi     # 0x7e24a
movl $0xca2, %edx            # imm = 0xCA2
leaq 0x340e1(%rip), %rcx     # 0x8115c
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x4d089
jmp 0x4d0a8
leaq 0x340aa(%rip), %rdi     # 0x8113a
leaq 0x311b3(%rip), %rsi     # 0x7e24a
movl $0xca3, %edx            # imm = 0xCA3
leaq 0x340b9(%rip), %rcx     # 0x8115c
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x2, %edx
callq 0x82f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4d0e2
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x31532(%rip), %rdx     # 0x7e612
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x5, %edx
callq 0x8a10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4d11c
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x34029(%rip), %rdx     # 0x81143
callq *%rax
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_primitive_type_weight
static int32_t _get_primitive_type_weight(
	uint8_t type
) {
	switch (type) {
		case FE_TYPE_CHAR: {
			return 1;
		}
		case FE_TYPE_INT8: {
			return 2;
		}
		case FE_TYPE_UINT8: {
			return 3;
		}
		case FE_TYPE_INT16: {
			return 4;
		}
		case FE_TYPE_UINT16: {
			return 5;
		}
		case FE_TYPE_INT32: {
			return 6;
		}
		case FE_TYPE_UINT32: {
			return 7;
		}
		case FE_TYPE_INT64: {
			return 8;
		}
		case FE_TYPE_UINT64: {
			return 9;
		}
		case FE_TYPE_FLOAT: {
			return 10;
		}
		case FE_TYPE_DOUBLE: {
			return 11;
		}
		default: {
			assert(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xa, %eax
ja 0x4d1e6
movq -0x10(%rbp), %rax
leaq 0x3065a(%rip), %rcx     # 0x7d7d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x4d205
movl $0x2, -0x4(%rbp)
jmp 0x4d205
movl $0x3, -0x4(%rbp)
jmp 0x4d205
movl $0x4, -0x4(%rbp)
jmp 0x4d205
movl $0x5, -0x4(%rbp)
jmp 0x4d205
movl $0x6, -0x4(%rbp)
jmp 0x4d205
movl $0x7, -0x4(%rbp)
jmp 0x4d205
movl $0x8, -0x4(%rbp)
jmp 0x4d205
movl $0x9, -0x4(%rbp)
jmp 0x4d205
movl $0xa, -0x4(%rbp)
jmp 0x4d205
movl $0xb, -0x4(%rbp)
jmp 0x4d205
leaq 0x2526e(%rip), %rdi     # 0x7245b
leaq 0x31056(%rip), %rsi     # 0x7e24a
movl $0x144, %edx            # imm = 0x144
leaq 0x33fc6(%rip), %rcx     # 0x811c6
callq 0x30a0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_primitive_type_size
static size_t _get_primitive_type_size(
	uint8_t type
) {
	switch (type) {
		case FE_TYPE_CHAR: {
			return 1;
		}
		case FE_TYPE_INT8: {
			return 1;
		}
		case FE_TYPE_UINT8: {
			return 1;
		}
		case FE_TYPE_INT16: {
			return 2;
		}
		case FE_TYPE_UINT16: {
			return 2;
		}
		case FE_TYPE_INT32: {
			return 4;
		}
		case FE_TYPE_UINT32: {
			return 4;
		}
		case FE_TYPE_INT64: {
			return 8;
		}
		case FE_TYPE_UINT64: {
			return 8;
		}
		case FE_TYPE_FLOAT: {
			return 4;
		}
		case FE_TYPE_DOUBLE: {
			return 8;
		}
		default: {
			assert(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xa, %eax
ja 0x4d2d8
movq -0x18(%rbp), %rax
leaq 0x305a2(%rip), %rcx     # 0x7d800
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, -0x8(%rbp)
jmp 0x4d2f7
movq $0x1, -0x8(%rbp)
jmp 0x4d2f7
movq $0x1, -0x8(%rbp)
jmp 0x4d2f7
movq $0x2, -0x8(%rbp)
jmp 0x4d2f7
movq $0x2, -0x8(%rbp)
jmp 0x4d2f7
movq $0x4, -0x8(%rbp)
jmp 0x4d2f7
movq $0x4, -0x8(%rbp)
jmp 0x4d2f7
movq $0x8, -0x8(%rbp)
jmp 0x4d2f7
movq $0x8, -0x8(%rbp)
jmp 0x4d2f7
movq $0x4, -0x8(%rbp)
jmp 0x4d2f7
movq $0x8, -0x8(%rbp)
jmp 0x4d2f7
leaq 0x2517c(%rip), %rdi     # 0x7245b
leaq 0x30f64(%rip), %rsi     # 0x7e24a
movl $0x119, %edx            # imm = 0x119
leaq 0x33f00(%rip), %rcx     # 0x811f2
callq 0x30a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_signed_type
static bool _is_signed_type(
	uint8_t type
) {
	switch (type) {
		case FE_TYPE_CHAR:
		case FE_TYPE_INT8:
		case FE_TYPE_INT16:
		case FE_TYPE_INT32:
		case FE_TYPE_INT64: {
			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
decl %eax
subl $0x4, %eax
ja 0x4d34d
jmp 0x4d347
movb $0x1, -0x1(%rbp)
jmp 0x4d351
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_unsigned_type
static bool _is_unsigned_type(
	uint8_t type
) {
	switch (type) {
		case FE_TYPE_UINT8:
		case FE_TYPE_UINT16:
		case FE_TYPE_UINT32:
		case FE_TYPE_UINT64: {
			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
addl $-0x6, %eax
subl $0x3, %eax
ja 0x4d39e
jmp 0x4d398
movb $0x1, -0x1(%rbp)
jmp 0x4d3a2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_float_type
static bool _is_float_type(
	uint8_t type
) {
	switch (type) {
		case FE_TYPE_FLOAT:
		case FE_TYPE_DOUBLE: {
			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
addl $-0xa, %eax
subl $0x1, %eax
ja 0x4d43e
jmp 0x4d438
movb $0x1, -0x1(%rbp)
jmp 0x4d442
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: fe_sem_search_node_along_parent
ParserASTNode * fe_sem_search_node_along_parent(
	ParserASTNode *node,
	...
) {
	assert(node);

	va_list arg_ptr;
	va_start(arg_ptr, node);
	
	return __search_node_along_parent(node, arg_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x4d975
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4d9a5
jmp 0x4d9c4
leaq 0x28627(%rip), %rdi     # 0x75fd3
leaq 0x30897(%rip), %rsi     # 0x7e24a
movl $0x15ea, %edx           # imm = 0x15EA
leaq 0x308ce(%rip), %rcx     # 0x7e28d
callq 0x30a0
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4da00
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: _search_node_along_parent
static ParserASTNode * __search_node_along_parent(
	ParserASTNode *node,
	va_list arg_ptr
) {
	assert(node);
	assert(arg_ptr);

	unsigned int types[32];
	size_t count = 0;

	for (;;) {
		unsigned int type = va_arg(arg_ptr, unsigned int);
		if (type == FE_NODE_INVALID) {
			break;
		}
		if (count >= sizeof(types) / sizeof(unsigned int)) {
			assert(0);
		}
		types[count++] = type;
	}

	ParserASTNode *parent = node;
	while (parent != NULL) {
		for (int i = 0; i < count; i++) {
			if (parent->type == types[i]) {
				return parent;
			}
		}
		parent = parent->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4da1c
jmp 0x4da3b
leaq 0x285b0(%rip), %rdi     # 0x75fd3
leaq 0x30820(%rip), %rsi     # 0x7e24a
movl $0x561, %edx            # imm = 0x561
leaq 0x339f9(%rip), %rcx     # 0x8142f
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4da44
jmp 0x4da63
leaq 0x33a37(%rip), %rdi     # 0x81482
leaq 0x307f8(%rip), %rsi     # 0x7e24a
movl $0x562, %edx            # imm = 0x562
leaq 0x339d1(%rip), %rcx     # 0x8142f
callq 0x30a0
movq $0x0, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl (%rax), %eax
movl %eax, -0xc0(%rbp)
cmpl $0x28, %eax
ja 0x4daa8
movq -0xc8(%rbp), %rcx
movl -0xc0(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xd0(%rbp)
jmp 0x4dac5
movq -0xc8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jne 0x4dadf
jmp 0x4db2f
cmpq $0x20, -0xa8(%rbp)
jb 0x4db08
leaq 0x2496b(%rip), %rdi     # 0x7245b
leaq 0x30753(%rip), %rsi     # 0x7e24a
movl $0x56d, %edx            # imm = 0x56D
leaq 0x3392c(%rip), %rcx     # 0x8142f
callq 0x30a0
movl -0xac(%rbp), %ecx
movq -0xa8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0xa8(%rbp)
movl %ecx, -0xa0(%rbp,%rax,4)
jmp 0x4da6e
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
je 0x4dbab
movl $0x0, -0xbc(%rbp)
movslq -0xbc(%rbp), %rax
cmpq -0xa8(%rbp), %rax
jae 0x4db97
movq -0xb8(%rbp), %rax
movl (%rax), %eax
movslq -0xbc(%rbp), %rcx
cmpl -0xa0(%rbp,%rcx,4), %eax
jne 0x4db84
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4dbb3
jmp 0x4db86
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
jmp 0x4db4e
movq -0xb8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xb8(%rbp)
jmp 0x4db3a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_func_symbol_by_node
static ParserSymbol * _get_func_symbol_by_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	ParserASTNode *parent = node->parent;
	while (parent != NULL) {
		if (parent->type == FE_NODE_FUNC) {
			ParserSymbol *symbol = FE_FUNC_AST_NODE_GET_SYMBOL(parent);
			assert(symbol);
			return symbol;
		}
		parent = parent->parent;
	}

	assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4dc09
jmp 0x4dc28
leaq 0x2e946(%rip), %rdi     # 0x7c556
leaq 0x30633(%rip), %rsi     # 0x7e24a
movl $0x65f, %edx            # imm = 0x65F
leaq 0x33867(%rip), %rcx     # 0x8148a
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4dc31
jmp 0x4dc50
leaq 0x2839b(%rip), %rdi     # 0x75fd3
leaq 0x3060b(%rip), %rsi     # 0x7e24a
movl $0x660, %edx            # imm = 0x660
leaq 0x3383f(%rip), %rcx     # 0x8148a
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4dcbb
movq -0x18(%rbp), %rax
cmpl $0xa00, (%rax)          # imm = 0xA00
jne 0x4dcad
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4dc84
jmp 0x4dca3
leaq 0x284ed(%rip), %rdi     # 0x76178
leaq 0x305b8(%rip), %rsi     # 0x7e24a
movl $0x666, %edx            # imm = 0x666
leaq 0x337ec(%rip), %rcx     # 0x8148a
callq 0x30a0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4dc5c
leaq 0x24799(%rip), %rdi     # 0x7245b
leaq 0x30581(%rip), %rsi     # 0x7e24a
movl $0x66c, %edx            # imm = 0x66C
leaq 0x337b5(%rip), %rcx     # 0x8148a
callq 0x30a0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: module_item
static void _module_item(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	switch (node->type) {
		case FE_NODE_VAR: {
			_var(ctx, node);
			break;
		}
		case FE_NODE_STRUCT: {
			_struct(ctx, node);
			break;
		}
		case FE_NODE_FUNC: {
			_func(ctx, node);
			break;
		}
		default: {
			assert(0);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4dff9
jmp 0x4e018
leaq 0x2e556(%rip), %rdi     # 0x7c556
leaq 0x30243(%rip), %rsi     # 0x7e24a
movl $0x155f, %edx           # imm = 0x155F
leaq 0x30324(%rip), %rcx     # 0x7e337
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4e021
jmp 0x4e040
leaq 0x27fab(%rip), %rdi     # 0x75fd3
leaq 0x3021b(%rip), %rsi     # 0x7e24a
movl $0x1560, %edx           # imm = 0x1560
leaq 0x302fc(%rip), %rcx     # 0x7e337
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xa00, %eax            # imm = 0xA00
je 0x4e088
jmp 0x4e052
movl -0x14(%rbp), %eax
subl $0xc00, %eax            # imm = 0xC00
je 0x4e06a
jmp 0x4e05e
movl -0x14(%rbp), %eax
subl $0xd00, %eax            # imm = 0xD00
je 0x4e079
jmp 0x4e097
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4e0c0
jmp 0x4e0b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4e1d0
jmp 0x4e0b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4e430
jmp 0x4e0b6
leaq 0x243bd(%rip), %rdi     # 0x7245b
leaq 0x301a5(%rip), %rsi     # 0x7e24a
movl $0x1570, %edx           # imm = 0x1570
leaq 0x30286(%rip), %rcx     # 0x7e337
callq 0x30a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: var
static void _var(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_VAR);
	assert(node->nchilds > 0);

	ParserASTNode *node_parent = node->parent;
	assert(node_parent);

	return _var_with_parent(ctx, node, node_parent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4e0d9
jmp 0x4e0f8
leaq 0x2e476(%rip), %rdi     # 0x7c556
leaq 0x30163(%rip), %rsi     # 0x7e24a
movl $0x4b7, %edx            # imm = 0x4B7
leaq 0x30278(%rip), %rcx     # 0x7e36b
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4e101
jmp 0x4e120
leaq 0x27ecb(%rip), %rdi     # 0x75fd3
leaq 0x3013b(%rip), %rsi     # 0x7e24a
movl $0x4b8, %edx            # imm = 0x4B8
leaq 0x30250(%rip), %rcx     # 0x7e36b
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xc00, (%rax)          # imm = 0xC00
jne 0x4e12e
jmp 0x4e14d
leaq 0x306a1(%rip), %rdi     # 0x7e7d6
leaq 0x3010e(%rip), %rsi     # 0x7e24a
movl $0x4b9, %edx            # imm = 0x4B9
leaq 0x30223(%rip), %rcx     # 0x7e36b
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jle 0x4e159
jmp 0x4e178
leaq 0x26455(%rip), %rdi     # 0x745b5
leaq 0x300e3(%rip), %rsi     # 0x7e24a
movl $0x4ba, %edx            # imm = 0x4BA
leaq 0x301f8(%rip), %rcx     # 0x7e36b
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4e18d
jmp 0x4e1ac
leaq 0x30203(%rip), %rdi     # 0x7e397
leaq 0x300af(%rip), %rsi     # 0x7e24a
movl $0x4bd, %edx            # imm = 0x4BD
leaq 0x301c4(%rip), %rcx     # 0x7e36b
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4ea00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_node_catagory
static int _get_node_catagory(
	int32_t node_type
) {
	if (FE_IS_TYPE_NODE(node_type)) {
		return FE_SEM_NODE_CATEGORY_TYPE;
	} else if (FE_IS_EXPR_NODE(node_type)) {
		return FE_SEM_NODE_CATAGORY_EXPR;
	} else {
		return FE_SEM_NODE_CATEGORY_UNKNOWN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0x400, %eax            # imm = 0x400
jne 0x4f09f
movl $0x1, -0x4(%rbp)
jmp 0x4f0be
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x4f0b7
movl $0x2, -0x4(%rbp)
jmp 0x4f0be
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_var_scope_type
static uint8_t _get_var_scope_type(
	ParserASTNode *node,
	ParserSymbol **symbol_func
) {
	assert(node);
	assert(node->type == FE_NODE_VAR);

	if (symbol_func != NULL) {
		*symbol_func = NULL;
	}

	ParserASTNode *parent = node->parent;
	while (parent != NULL) {
		switch (parent->type) {
			case FE_NODE_MODULE: {
				return FE_VAR_TYPE_GLOBAL;
			}
			case FE_NODE_FUNC: {
				if (symbol_func != NULL) {
					*symbol_func = FE_FUNC_AST_NODE_GET_SYMBOL(parent);
				}
				return FE_VAR_TYPE_LOCAL;
			}
			case FE_NODE_STRUCT: {
				return FE_VAR_TYPE_STRUCT_MEMBER;
			}
		}
		parent = parent->parent;
	}

	assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4f579
jmp 0x4f598
leaq 0x26a53(%rip), %rdi     # 0x75fd3
leaq 0x2ecc3(%rip), %rsi     # 0x7e24a
movl $0x413, %edx            # imm = 0x413
leaq 0x30b21(%rip), %rcx     # 0x800b4
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xc00, (%rax)          # imm = 0xC00
jne 0x4f5a6
jmp 0x4f5c5
leaq 0x2f229(%rip), %rdi     # 0x7e7d6
leaq 0x2ec96(%rip), %rsi     # 0x7e24a
movl $0x414, %edx            # imm = 0x414
leaq 0x30af4(%rip), %rcx     # 0x800b4
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4f5d7
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4f64a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x100, %eax            # imm = 0x100
je 0x4f614
jmp 0x4f5fc
movl -0x24(%rbp), %eax
subl $0xa00, %eax            # imm = 0xA00
je 0x4f61a
jmp 0x4f608
movl -0x24(%rbp), %eax
subl $0xd00, %eax            # imm = 0xD00
je 0x4f636
jmp 0x4f63c
movb $0x1, -0x1(%rbp)
jmp 0x4f669
cmpq $0x0, -0x18(%rbp)
je 0x4f630
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x2, -0x1(%rbp)
jmp 0x4f669
movb $0x3, -0x1(%rbp)
jmp 0x4f669
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4f5e3
leaq 0x22e0a(%rip), %rdi     # 0x7245b
leaq 0x2ebf2(%rip), %rsi     # 0x7e24a
movl $0x42d, %edx            # imm = 0x42D
leaq 0x30a50(%rip), %rcx     # 0x800b4
callq 0x30a0
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_wrapper
static void _expr_wrapper(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_EXPR);

	ParserASTNode *child = node->childs[0];

	_expr(ctx, child);

	FE_EXPR_AST_NODE_COPY(node, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4f699
jmp 0x4f6b8
leaq 0x2ceb6(%rip), %rdi     # 0x7c556
leaq 0x2eba3(%rip), %rsi     # 0x7e24a
movl $0x13d1, %edx           # imm = 0x13D1
leaq 0x30a3f(%rip), %rcx     # 0x800f2
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4f6c1
jmp 0x4f6e0
leaq 0x2690b(%rip), %rdi     # 0x75fd3
leaq 0x2eb7b(%rip), %rsi     # 0x7e24a
movl $0x13d2, %edx           # imm = 0x13D2
leaq 0x30a17(%rip), %rcx     # 0x800f2
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x4f6ee
jmp 0x4f70d
leaq 0x255af(%rip), %rdi     # 0x74ca4
leaq 0x2eb4e(%rip), %rsi     # 0x7e24a
movl $0x13d3, %edx           # imm = 0x13D3
leaq 0x309ea(%rip), %rcx     # 0x800f2
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f4b0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
movl $0x30, %edx
callq 0x3110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_type_for_assign
static bool _is_compatible_type_for_assign(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_is_compatible_primitive_type(ctx, target, source, same)) {
		return true;
	}
	if (_is_compatible_struct_type(ctx, target, source, same)) {
		return true;
	}
	if (_is_compatible_func_type(ctx, target, source, same)) {
		return true;
	}
	if (_is_compatible_pointer_type(ctx, target, source, same)) {
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4f774
jmp 0x4f793
leaq 0x2cddb(%rip), %rdi     # 0x7c556
leaq 0x2eac8(%rip), %rsi     # 0x7e24a
movl $0x329, %edx            # imm = 0x329
leaq 0x30999(%rip), %rcx     # 0x80127
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4f79c
jmp 0x4f7bb
leaq 0x2bf7f(%rip), %rdi     # 0x7b722
leaq 0x2eaa0(%rip), %rsi     # 0x7e24a
movl $0x32a, %edx            # imm = 0x32A
leaq 0x30971(%rip), %rcx     # 0x80127
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x4f7c4
jmp 0x4f7e3
leaq 0x21dc6(%rip), %rdi     # 0x71591
leaq 0x2ea78(%rip), %rsi     # 0x7e24a
movl $0x32b, %edx            # imm = 0x32B
leaq 0x30949(%rip), %rcx     # 0x80127
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5c9c0
testb $0x1, %al
jne 0x4f802
jmp 0x4f808
movb $0x1, -0x1(%rbp)
jmp 0x4f87b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5cb00
testb $0x1, %al
jne 0x4f827
jmp 0x4f82d
movb $0x1, -0x1(%rbp)
jmp 0x4f87b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5cc00
testb $0x1, %al
jne 0x4f84c
jmp 0x4f852
movb $0x1, -0x1(%rbp)
jmp 0x4f87b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5ce60
testb $0x1, %al
jne 0x4f871
jmp 0x4f877
movb $0x1, -0x1(%rbp)
jmp 0x4f87b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_is_lvalue
static int _expr_is_lvalue(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	if (node->type == FE_NODE_EXPR_ATOM
			&& node->childs[0]->type == FE_NODE_IDENTIFIER) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_MEMBER) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_PMEMBER) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_ARRAY_INDEX) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_DEREF) {
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x510d9
jmp 0x510f8
leaq 0x2b476(%rip), %rdi     # 0x7c556
leaq 0x2d163(%rip), %rsi     # 0x7e24a
movl $0x6d6, %edx            # imm = 0x6D6
leaq 0x2d7c4(%rip), %rcx     # 0x7e8b7
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x51101
jmp 0x51120
leaq 0x24ecb(%rip), %rdi     # 0x75fd3
leaq 0x2d13b(%rip), %rsi     # 0x7e24a
movl $0x6d7, %edx            # imm = 0x6D7
leaq 0x2d79c(%rip), %rcx     # 0x7e8b7
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0xee0, (%rax)          # imm = 0xEE0
jne 0x51148
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x51148
movl $0x1, -0x4(%rbp)
jmp 0x511a3
movq -0x18(%rbp), %rax
cmpl $0xed0, (%rax)          # imm = 0xED0
jne 0x5115d
movl $0x1, -0x4(%rbp)
jmp 0x511a3
movq -0x18(%rbp), %rax
cmpl $0xed1, (%rax)          # imm = 0xED1
jne 0x51172
movl $0x1, -0x4(%rbp)
jmp 0x511a3
movq -0x18(%rbp), %rax
cmpl $0xed2, (%rax)          # imm = 0xED2
jne 0x51187
movl $0x1, -0x4(%rbp)
jmp 0x511a3
movq -0x18(%rbp), %rax
cmpl $0xeca, (%rax)          # imm = 0xECA
jne 0x5119c
movl $0x1, -0x4(%rbp)
jmp 0x511a3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: check_expr_assign_operands
static void _check_expr_assign_operands(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_oprd1,
	ParserASTNode *node_oprd2,
	const char *operator,
	bool set_type
) {
	assert(ctx);
	assert(node);
	assert(node_oprd1);
	assert(node_oprd2);
	assert(operator);

	ParserASTNode *node_oprd1_type = FE_EXPR_AST_NODE_GET_TYPE_NODE(node_oprd1);
	ParserASTNode *node_oprd2_type = FE_EXPR_AST_NODE_GET_TYPE_NODE(node_oprd2);
	if (_is_compatible_type_for_assign(ctx, node_oprd1_type, node_oprd2_type, false)) {
		if (set_type) {
			FE_EXPR_AST_NODE_COPY(node, node_oprd1);
		}
	} else {
		_SYNERR_NODE(
			ctx,
			node,
			"binary operator '%s' do not support this operand combination.",
			operator
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x514e0
jmp 0x514ff
leaq 0x2b06f(%rip), %rdi     # 0x7c556
leaq 0x2cd5c(%rip), %rsi     # 0x7e24a
movl $0x12de, %edx           # imm = 0x12DE
leaq 0x2e6c2(%rip), %rcx     # 0x7fbbc
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x51508
jmp 0x51527
leaq 0x24ac4(%rip), %rdi     # 0x75fd3
leaq 0x2cd34(%rip), %rsi     # 0x7e24a
movl $0x12df, %edx           # imm = 0x12DF
leaq 0x2e69a(%rip), %rcx     # 0x7fbbc
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x51530
jmp 0x5154f
leaq 0x2e6ff(%rip), %rdi     # 0x7fc36
leaq 0x2cd0c(%rip), %rsi     # 0x7e24a
movl $0x12e0, %edx           # imm = 0x12E0
leaq 0x2e672(%rip), %rcx     # 0x7fbbc
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x51558
jmp 0x51577
leaq 0x2e6e2(%rip), %rdi     # 0x7fc41
leaq 0x2cce4(%rip), %rsi     # 0x7e24a
movl $0x12e1, %edx           # imm = 0x12E1
leaq 0x2e64a(%rip), %rcx     # 0x7fbbc
callq 0x30a0
cmpq $0x0, -0x28(%rbp)
je 0x51580
jmp 0x5159f
leaq 0x2e6c5(%rip), %rdi     # 0x7fc4c
leaq 0x2ccbc(%rip), %rsi     # 0x7e24a
movl $0x12e2, %edx           # imm = 0x12E2
leaq 0x2e622(%rip), %rcx     # 0x7fbbc
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4f750
testb $0x1, %al
jne 0x515d0
jmp 0x515f2
testb $0x1, -0x29(%rbp)
je 0x515f0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
movl $0x30, %edx
callq 0x3110
jmp 0x51624
leaq -0x440(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x2e651(%rip), %rsi     # 0x7fc55
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x440(%rbp), %rdx
callq *%rax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: check_expr_shift_operands
static void _check_expr_shift_operands(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_oprd1,
	ParserASTNode *node_oprd2,
	const char *operator,
	bool set_type
) {
	assert(ctx);
	assert(node);
	assert(node_oprd1);
	assert(node_oprd2);
	assert(operator);

	if (_is_integer_type_node(ctx, node_oprd1) && _is_integer_type_node(ctx, node_oprd2)) {
		if (set_type) {
			FE_EXPR_AST_NODE_COPY(node, node_oprd1);
		}
	} else {
		_SYNERR_NODE(
			ctx,
			node,
			"binary operator '%s' do not support this operand combination.",
			operator
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x52340
jmp 0x5235f
leaq 0x2a20f(%rip), %rdi     # 0x7c556
leaq 0x2befc(%rip), %rsi     # 0x7e24a
movl $0x104d, %edx           # imm = 0x104D
leaq 0x2dce1(%rip), %rcx     # 0x8003b
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x52368
jmp 0x52387
leaq 0x23c64(%rip), %rdi     # 0x75fd3
leaq 0x2bed4(%rip), %rsi     # 0x7e24a
movl $0x104e, %edx           # imm = 0x104E
leaq 0x2dcb9(%rip), %rcx     # 0x8003b
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x52390
jmp 0x523af
leaq 0x2d89f(%rip), %rdi     # 0x7fc36
leaq 0x2beac(%rip), %rsi     # 0x7e24a
movl $0x104f, %edx           # imm = 0x104F
leaq 0x2dc91(%rip), %rcx     # 0x8003b
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x523b8
jmp 0x523d7
leaq 0x2d882(%rip), %rdi     # 0x7fc41
leaq 0x2be84(%rip), %rsi     # 0x7e24a
movl $0x1050, %edx           # imm = 0x1050
leaq 0x2dc69(%rip), %rcx     # 0x8003b
callq 0x30a0
cmpq $0x0, -0x28(%rbp)
je 0x523e0
jmp 0x523ff
leaq 0x2d865(%rip), %rdi     # 0x7fc4c
leaq 0x2be5c(%rip), %rsi     # 0x7e24a
movl $0x1051, %edx           # imm = 0x1051
leaq 0x2dc41(%rip), %rcx     # 0x8003b
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x526c0
testb $0x1, %al
jne 0x52412
jmp 0x52447
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x526c0
testb $0x1, %al
jne 0x52425
jmp 0x52447
testb $0x1, -0x29(%rbp)
je 0x52445
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
movl $0x30, %edx
callq 0x3110
jmp 0x52479
leaq -0x430(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x2d7fc(%rip), %rsi     # 0x7fc55
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x430(%rbp), %rdx
callq *%rax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_integer_type_node
static bool _is_integer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_integer_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x526d9
jmp 0x526f8
leaq 0x29e76(%rip), %rdi     # 0x7c556
leaq 0x2bb63(%rip), %rsi     # 0x7e24a
movl $0x1b1, %edx            # imm = 0x1B1
leaq 0x2d2cb(%rip), %rcx     # 0x7f9be
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x52701
jmp 0x52720
leaq 0x238cb(%rip), %rdi     # 0x75fd3
leaq 0x2bb3b(%rip), %rsi     # 0x7e24a
movl $0x1b2, %edx            # imm = 0x1B2
leaq 0x2d2a3(%rip), %rcx     # 0x7f9be
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x52734
jmp 0x52753
leaq 0x2ccdc(%rip), %rdi     # 0x7f417
leaq 0x2bb08(%rip), %rsi     # 0x7e24a
movl $0x1b3, %edx            # imm = 0x1B3
leaq 0x2d270(%rip), %rcx     # 0x7f9be
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4d3d0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_pointer_type_node
static bool _is_pointer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_pointer_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x52789
jmp 0x527a8
leaq 0x29dc6(%rip), %rdi     # 0x7c556
leaq 0x2bab3(%rip), %rsi     # 0x7e24a
movl $0x1fd, %edx            # imm = 0x1FD
leaq 0x2d259(%rip), %rcx     # 0x7f9fc
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x527b1
jmp 0x527d0
leaq 0x2381b(%rip), %rdi     # 0x75fd3
leaq 0x2ba8b(%rip), %rsi     # 0x7e24a
movl $0x1fe, %edx            # imm = 0x1FE
leaq 0x2d231(%rip), %rcx     # 0x7f9fc
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x527e4
jmp 0x52803
leaq 0x2cc2c(%rip), %rdi     # 0x7f417
leaq 0x2ba58(%rip), %rsi     # 0x7e24a
movl $0x1ff, %edx            # imm = 0x1FF
leaq 0x2d1fe(%rip), %rcx     # 0x7f9fc
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4d4c0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_primitive_type_node
static bool _is_primitive_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_primitive_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x52839
jmp 0x52858
leaq 0x29d16(%rip), %rdi     # 0x7c556
leaq 0x2ba03(%rip), %rsi     # 0x7e24a
movl $0x21f, %edx            # imm = 0x21F
leaq 0x2d1e7(%rip), %rcx     # 0x7fa3a
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x52861
jmp 0x52880
leaq 0x2376b(%rip), %rdi     # 0x75fd3
leaq 0x2b9db(%rip), %rsi     # 0x7e24a
movl $0x220, %edx            # imm = 0x220
leaq 0x2d1bf(%rip), %rcx     # 0x7fa3a
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x52894
jmp 0x528b3
leaq 0x2cb7c(%rip), %rdi     # 0x7f417
leaq 0x2b9a8(%rip), %rsi     # 0x7e24a
movl $0x221, %edx            # imm = 0x221
leaq 0x2d18c(%rip), %rcx     # 0x7fa3a
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4d470
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_primitive_type_weight_by_expr_node
static int32_t _get_primitive_type_weight_by_expr_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	return _get_primitive_type_weight(
		FE_EXPR_AST_NODE_GET_TYPE(node)
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x528e9
jmp 0x52908
leaq 0x29c66(%rip), %rdi     # 0x7c556
leaq 0x2b953(%rip), %rsi     # 0x7e24a
movl $0x159, %edx            # imm = 0x159
leaq 0x2d177(%rip), %rcx     # 0x7fa7a
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x52911
jmp 0x52930
leaq 0x236bb(%rip), %rdi     # 0x75fd3
leaq 0x2b92b(%rip), %rsi     # 0x7e24a
movl $0x15a, %edx            # imm = 0x15A
leaq 0x2d14f(%rip), %rcx     # 0x7fa7a
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4d150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_bor
static void _expr_bor(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	#define	_CHECK	\
	{	\
		assert(node->nchilds == 2);	\
	}

	uint32_t node_type = node->type;

	switch (node_type) {
		case FE_NODE_EXPR_BOR: {
			_CHECK
			ParserASTNode *node_oprd1 = node->childs[0];
			ParserASTNode *node_oprd2 = node->childs[1];
			_expr_bxor(ctx, node_oprd1);
			_expr_bxor(ctx, node_oprd2);

			const char *operator = "|";

			_check_expr_bor_operands(
				ctx, node, node_oprd1, node_oprd2, operator, true
			);

			FE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (FE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_bxor(ctx, node);
			break;
		}
	}

	#undef	_CHECK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54e29
jmp 0x54e48
leaq 0x27726(%rip), %rdi     # 0x7c556
leaq 0x29413(%rip), %rsi     # 0x7e24a
movl $0x11f4, %edx           # imm = 0x11F4
leaq 0x29c42(%rip), %rcx     # 0x7ea85
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x54e51
jmp 0x54e70
leaq 0x2117b(%rip), %rdi     # 0x75fd3
leaq 0x293eb(%rip), %rsi     # 0x7e24a
movl $0x11f5, %edx           # imm = 0x11F5
leaq 0x29c1a(%rip), %rcx     # 0x7ea85
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0xe40, %eax            # imm = 0xE40
jne 0x54f61
jmp 0x54e89
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x54e95
jmp 0x54eb4
leaq 0x297d8(%rip), %rdi     # 0x7e674
leaq 0x293a7(%rip), %rsi     # 0x7e24a
movl $0x1200, %edx           # imm = 0x1200
leaq 0x29bd6(%rip), %rcx     # 0x7ea85
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x54f80
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x54f80
leaq 0x260b2(%rip), %rax     # 0x7afa6
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x1, %r9d
callq 0x51f90
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x70(%rcx)
movb %al, -0x31(%rbp)
je 0x54f30
movq -0x28(%rbp), %rax
movb 0x70(%rax), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x70(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x70(%rax)
je 0x54f5f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x52e70
jmp 0x54f6e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_bxor
static void _expr_bxor(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	#define	_CHECK	\
	{	\
		assert(node->nchilds == 2);	\
	}

	uint32_t node_type = node->type;

	switch (node_type) {
		case FE_NODE_EXPR_BXOR: {
			_CHECK
			ParserASTNode *node_oprd1 = node->childs[0];
			ParserASTNode *node_oprd2 = node->childs[1];
			_expr_band(ctx, node_oprd1);
			_expr_band(ctx, node_oprd2);

			const char *operator = "^";

			_check_expr_bxor_operands(
				ctx, node, node_oprd1, node_oprd2, operator, true
			);

			FE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (FE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_band(ctx, node);
			break;
		}
	}

	#undef	_CHECK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54f99
jmp 0x54fb8
leaq 0x275b6(%rip), %rdi     # 0x7c556
leaq 0x292a3(%rip), %rsi     # 0x7e24a
movl $0x11a6, %edx           # imm = 0x11A6
leaq 0x29b03(%rip), %rcx     # 0x7eab6
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x54fc1
jmp 0x54fe0
leaq 0x2100b(%rip), %rdi     # 0x75fd3
leaq 0x2927b(%rip), %rsi     # 0x7e24a
movl $0x11a7, %edx           # imm = 0x11A7
leaq 0x29adb(%rip), %rcx     # 0x7eab6
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0xe50, %eax            # imm = 0xE50
jne 0x550d1
jmp 0x54ff9
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x55005
jmp 0x55024
leaq 0x29668(%rip), %rdi     # 0x7e674
leaq 0x29237(%rip), %rsi     # 0x7e24a
movl $0x11b2, %edx           # imm = 0x11B2
leaq 0x29a97(%rip), %rcx     # 0x7eab6
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x550f0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x550f0
leaq 0x25fe4(%rip), %rax     # 0x7b048
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x1, %r9d
callq 0x52150
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x70(%rcx)
movb %al, -0x31(%rbp)
je 0x550a0
movq -0x28(%rbp), %rax
movb 0x70(%rax), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x70(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x70(%rax)
je 0x550cf
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x52e70
jmp 0x550de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x550f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)