LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_ifndef
static void _gen_ifndef(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_DIRECTIVE_IFNDEF);
	assert(node->nchilds >= 1);

	_gen_ifxdef(ctx, node, true);

	LexerToken *token_endif = PP_IFXXX_AST_NODE_GET_TOKEN_ENDIF(node);
	assert(token_endif);
	_OUT_FMT(ctx, "#line %d \"%s\"", token_endif->line + 1, token_endif->file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ed4c
jmp 0x3ed6b
leaq 0xee0e(%rip), %rdi      # 0x4db61
leaq 0x1019b(%rip), %rsi     # 0x4eef5
movl $0x301, %edx            # imm = 0x301
leaq 0x10b53(%rip), %rcx     # 0x4f8b9
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3ed74
jmp 0x3ed93
leaq 0xc30c(%rip), %rdi      # 0x4b087
leaq 0x10173(%rip), %rsi     # 0x4eef5
movl $0x302, %edx            # imm = 0x302
leaq 0x10b2b(%rip), %rcx     # 0x4f8b9
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x205, (%rax)          # imm = 0x205
jne 0x3eda1
jmp 0x3edc0
leaq 0x10adb(%rip), %rdi     # 0x4f883
leaq 0x10146(%rip), %rsi     # 0x4eef5
movl $0x303, %edx            # imm = 0x303
leaq 0x10afe(%rip), %rcx     # 0x4f8b9
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jl 0x3edcc
jmp 0x3edeb
leaq 0x10799(%rip), %rdi     # 0x4f56c
leaq 0x1011b(%rip), %rsi     # 0x4eef5
movl $0x304, %edx            # imm = 0x304
leaq 0x10ad3(%rip), %rcx     # 0x4f8b9
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x40810
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ee12
jmp 0x3ee31
leaq 0x107a8(%rip), %rdi     # 0x4f5c1
leaq 0x100d5(%rip), %rsi     # 0x4eef5
movl $0x309, %edx            # imm = 0x309
leaq 0x10a8d(%rip), %rcx     # 0x4f8b9
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3ee66
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x10446(%rip), %rsi     # 0x4f2a3
movb $0x0, %al
callq 0xa100
jmp 0x3eea6
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0x10418(%rip), %rdx     # 0x4f2a3
movb $0x0, %al
callq 0xa0a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x420(%rbp), %rsi
callq 0xfd80
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_cmd_line
static void _gen_cmd_line(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_CMD_LINE);

	_OUT_STR(ctx, node->token->content, node->token->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3f4d9
jmp 0x3f4f8
leaq 0xe681(%rip), %rdi      # 0x4db61
leaq 0xfa0e(%rip), %rsi      # 0x4eef5
movl $0x37c, %edx            # imm = 0x37C
leaq 0x10537(%rip), %rcx     # 0x4fa2a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3f501
jmp 0x3f520
leaq 0xbb7f(%rip), %rdi      # 0x4b087
leaq 0xf9e6(%rip), %rsi      # 0x4eef5
movl $0x37d, %edx            # imm = 0x37D
leaq 0x1050f(%rip), %rcx     # 0x4fa2a
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x3f52e
jmp 0x3f54d
leaq 0x1052f(%rip), %rdi     # 0x4fa64
leaq 0xf9b9(%rip), %rsi      # 0x4eef5
movl $0x37e, %edx            # imm = 0x37E
leaq 0x104e2(%rip), %rcx     # 0x4fa2a
callq 0xa0b0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3f5c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3f592
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa0e0
jmp 0x3f5b3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0xfeb0
jmp 0x3f5b5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f554
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_line
static void _gen_line(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_LINE);

	pp_line_process(ctx, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3f5e9
jmp 0x3f608
leaq 0xe571(%rip), %rdi      # 0x4db61
leaq 0xf8fe(%rip), %rsi      # 0x4eef5
movl $0x387, %edx            # imm = 0x387
leaq 0x10480(%rip), %rcx     # 0x4fa83
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3f611
jmp 0x3f630
leaq 0xba6f(%rip), %rdi      # 0x4b087
leaq 0xf8d6(%rip), %rsi      # 0x4eef5
movl $0x388, %edx            # imm = 0x388
leaq 0x10458(%rip), %rcx     # 0x4fa83
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x302, (%rax)          # imm = 0x302
jne 0x3f63e
jmp 0x3f65d
leaq 0x10474(%rip), %rdi     # 0x4fab9
leaq 0xf8a9(%rip), %rsi      # 0x4eef5
movl $0x389, %edx            # imm = 0x389
leaq 0x1042b(%rip), %rcx     # 0x4fa83
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x419d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: include_file_from_include_path
static void _include_file_from_include_path(
	PPGeneratorContext *ctx,
	ParserASTNode *node,
	ResizableString *filename
) {
	assert(ctx);
	assert(node);
	assert(filename);

	bool included = false;
	LinkedListNode *n = ctx->include_paths.head;
	while (!included && n != NULL) {
		ResizableString filepath;
		rstr_init_with_rstr(&filepath, n->data);
		rstr_append_with_rstr(&filepath, filename);

		if (_include_file(ctx, RSTR_CSTR(&filepath))) {
			included = true;
		}

		rstr_free(&filepath);
		n = n->next;
	}
	if (!included) {
		_SYNERR_NODE(ctx, node, "cannot include file.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3f690
jmp 0x3f6af
leaq 0xe4ca(%rip), %rdi      # 0x4db61
leaq 0xf857(%rip), %rsi      # 0x4eef5
movl $0xb0, %edx
leaq 0xfc26(%rip), %rcx      # 0x4f2d0
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3f6b8
jmp 0x3f6d7
leaq 0xb9c8(%rip), %rdi      # 0x4b087
leaq 0xf82f(%rip), %rsi      # 0x4eef5
movl $0xb1, %edx
leaq 0xfbfe(%rip), %rcx      # 0x4f2d0
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x3f6e0
jmp 0x3f6ff
leaq 0xfc48(%rip), %rdi      # 0x4f32f
leaq 0xf807(%rip), %rsi      # 0x4eef5
movl $0xb2, %edx
leaq 0xfbd6(%rip), %rcx      # 0x4f2d0
callq 0xa0b0
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x441(%rbp)
jne 0x3f72b
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x441(%rbp)
movb -0x441(%rbp), %al
testb $0x1, %al
jne 0x3f73a
jmp 0x3f7bc
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x10090
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x10110
movq -0x8(%rbp), %rax
movq %rax, -0x450(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3f77a
leaq 0x8116(%rip), %rax      # 0x47887
movq %rax, -0x458(%rbp)
jmp 0x3f785
movq -0x30(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x450(%rbp), %rdi
movq -0x458(%rbp), %rsi
callq 0x3f800
testb $0x1, %al
jne 0x3f79e
jmp 0x3f7a2
movb $0x1, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10320
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3f70f
testb $0x1, -0x19(%rbp)
jne 0x3f7f6
leaq -0x440(%rbp), %rdi
leaq 0xfb68(%rip), %rsi      # 0x4f338
movb $0x0, %al
callq 0xa170
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x440(%rbp), %rdx
callq *%rax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: is_macro_defined
static bool _is_macro_defined(
	PPGeneratorContext *ctx,
	ResizableString *key
) {
	assert(ctx);
	assert(key);

	return map_exists_key(ctx->map_kv, key)
		|| map_exists_key(ctx->map_kv_with_params, key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3fb99
jmp 0x3fbb8
leaq 0xdfc1(%rip), %rdi      # 0x4db61
leaq 0xf34e(%rip), %rsi      # 0x4eef5
movl $0x118, %edx            # imm = 0x118
leaq 0xf881(%rip), %rcx      # 0x4f434
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3fbc1
jmp 0x3fbe0
leaq 0x72c5(%rip), %rdi      # 0x46e8d
leaq 0xf326(%rip), %rsi      # 0x4eef5
movl $0x119, %edx            # imm = 0x119
leaq 0xf859(%rip), %rcx      # 0x4f434
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd8f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x3fc11
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd8f0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: new_gen_func_macro
static PPGeneratorFuncMacro * _new_gen_func_macro(void) {
	PPGeneratorFuncMacro *macro = (PPGeneratorFuncMacro *) malloc(sizeof(PPGeneratorFuncMacro));
	llst_init(
		&(macro->params),
		NULL,
		(LinkedListReleaser) rstr_delete
	);
	rstr_init(&(macro->body));
	return macro;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0xa130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x2f8a5(%rip), %rdx    # 0x103a0
callq 0xc760
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xfca0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: delete_macro
static void _delete_macro(
	PPGeneratorContext *ctx,
	ResizableString *key
) {
	assert(ctx);
	assert(key);

	if (map_exists_key(ctx->map_kv, key)) {
		map_remove(ctx->map_kv, key, true, true);
	} else if (map_exists_key(ctx->map_kv_with_params, key)) {
		map_remove(ctx->map_kv_with_params, key, true, true);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3fc89
jmp 0x3fca8
leaq 0xded1(%rip), %rdi      # 0x4db61
leaq 0xf25e(%rip), %rsi      # 0x4eef5
movl $0x123, %edx            # imm = 0x123
leaq 0xf836(%rip), %rcx      # 0x4f4d9
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3fcb1
jmp 0x3fcd0
leaq 0x71d5(%rip), %rdi      # 0x46e8d
leaq 0xf236(%rip), %rsi      # 0x4eef5
movl $0x124, %edx            # imm = 0x124
leaq 0xf80e(%rip), %rcx      # 0x4f4d9
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd8f0
testb $0x1, %al
jne 0x3fce7
jmp 0x3fd01
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xd7f0
jmp 0x3fd32
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd8f0
testb $0x1, %al
jne 0x3fd18
jmp 0x3fd30
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xd7f0
jmp 0x3fd32
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_if_block
static void _gen_if_block(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_BLOCK);

	if (node->nchilds > 0) {
		ParserASTNode *child = node->childs[0];
		_OUT_FMT(ctx, "#line %d \"%s\"", child->line, child->file);
	}

	_gen_block(ctx, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3fd5c
jmp 0x3fd7b
leaq 0xddfe(%rip), %rdi      # 0x4db61
leaq 0xf18b(%rip), %rsi      # 0x4eef5
movl $0x3ee, %edx            # imm = 0x3EE
leaq 0xf857(%rip), %rcx      # 0x4f5cd
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3fd84
jmp 0x3fda3
leaq 0xb2fc(%rip), %rdi      # 0x4b087
leaq 0xf163(%rip), %rsi      # 0x4eef5
movl $0x3ef, %edx            # imm = 0x3EF
leaq 0xf82f(%rip), %rcx      # 0x4f5cd
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x3fdb1
jmp 0x3fdd0
leaq 0xf3a9(%rip), %rdi      # 0x4f161
leaq 0xf136(%rip), %rsi      # 0x4eef5
movl $0x3f0, %edx            # imm = 0x3F0
leaq 0xf802(%rip), %rcx      # 0x4f5cd
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jle 0x3fe5e
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3fe1f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xf48d(%rip), %rsi      # 0x4f2a3
movb $0x0, %al
callq 0xa100
jmp 0x3fe5c
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0xf462(%rip), %rdx      # 0x4f2a3
movb $0x0, %al
callq 0xa0a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x420(%rbp), %rsi
callq 0xfd80
jmp 0x3fe5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3d1b0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_elifxxx_and_else
static bool _gen_elifxxx_and_else(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	switch (node->type) {
		case PP_NODE_DIRECTIVE_ELIF:
		case PP_NODE_DIRECTIVE_ELIFDEF:
		case PP_NODE_DIRECTIVE_ELIFNDEF: {
			return _gen_elifxxx(ctx, node);
		}
		case PP_NODE_DIRECTIVE_ELSE: {
			_gen_else(ctx, node);
			return true;
		}
		default: {
			assert(0);
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3fe99
jmp 0x3feb8
leaq 0xdcc1(%rip), %rdi      # 0x4db61
leaq 0xf04e(%rip), %rsi      # 0x4eef5
movl $0x254, %edx            # imm = 0x254
leaq 0xf754(%rip), %rcx      # 0x4f607
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x3fec1
jmp 0x3fee0
leaq 0xb1bf(%rip), %rdi      # 0x4b087
leaq 0xf026(%rip), %rsi      # 0x4eef5
movl $0x255, %edx            # imm = 0x255
leaq 0xf72c(%rip), %rcx      # 0x4f607
callq 0xa0b0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
addl $0xfffffdfa, %eax       # imm = 0xFFFFFDFA
subl $0x3, %eax
jb 0x3ff01
jmp 0x3fef5
movl -0x1c(%rbp), %eax
subl $0x209, %eax            # imm = 0x209
je 0x3ff15
jmp 0x3ff28
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ff60
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3ff47
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x40060
movb $0x1, -0x1(%rbp)
jmp 0x3ff47
leaq 0x7536(%rip), %rdi      # 0x47465
leaq 0xefbf(%rip), %rsi      # 0x4eef5
movl $0x262, %edx            # imm = 0x262
leaq 0xf6c5(%rip), %rcx      # 0x4f607
callq 0xa0b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_elifxxx
static bool _gen_elifxxx(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	switch (node->type) {
		case PP_NODE_DIRECTIVE_ELIF: {
			return _gen_elif(ctx, node);
		}
		case PP_NODE_DIRECTIVE_ELIFDEF: {
			return _gen_elifxdef(ctx, node, false);
		}
		case PP_NODE_DIRECTIVE_ELIFNDEF: {
			return _gen_elifxdef(ctx, node, true);
		}
		default: {
			assert(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3ff79
jmp 0x3ff98
leaq 0xdbe1(%rip), %rdi      # 0x4db61
leaq 0xef6e(%rip), %rsi      # 0x4eef5
movl $0x22e, %edx            # imm = 0x22E
leaq 0xf6b7(%rip), %rcx      # 0x4f64a
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x3ffa1
jmp 0x3ffc0
leaq 0xb0df(%rip), %rdi      # 0x4b087
leaq 0xef46(%rip), %rsi      # 0x4eef5
movl $0x22f, %edx            # imm = 0x22F
leaq 0xf68f(%rip), %rcx      # 0x4f64a
callq 0xa0b0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x206, %eax            # imm = 0x206
je 0x3ffea
jmp 0x3ffd2
movl -0x1c(%rbp), %eax
subl $0x207, %eax            # imm = 0x207
je 0x3fffe
jmp 0x3ffde
movl -0x1c(%rbp), %eax
subl $0x208, %eax            # imm = 0x208
je 0x40014
jmp 0x4002d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x40170
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4004c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x40470
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4004c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x40470
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4004c
leaq 0x7431(%rip), %rdi      # 0x47465
leaq 0xeeba(%rip), %rsi      # 0x4eef5
movl $0x23c, %edx            # imm = 0x23C
leaq 0xf603(%rip), %rcx      # 0x4f64a
callq 0xa0b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_else
static void _gen_else(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_DIRECTIVE_ELSE);
	assert(node->nchilds == 1);

	ParserASTNode *node_block = node->childs[0];
	assert(node_block->type == PP_NODE_BLOCK);

	_gen_if_block(ctx, node_block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x40079
jmp 0x40098
leaq 0xdae1(%rip), %rdi      # 0x4db61
leaq 0xee6e(%rip), %rsi      # 0x4eef5
movl $0x245, %edx            # imm = 0x245
leaq 0xf6f9(%rip), %rcx      # 0x4f78c
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x400a1
jmp 0x400c0
leaq 0xafdf(%rip), %rdi      # 0x4b087
leaq 0xee46(%rip), %rsi      # 0x4eef5
movl $0x246, %edx            # imm = 0x246
leaq 0xf6d1(%rip), %rcx      # 0x4f78c
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x209, (%rax)          # imm = 0x209
jne 0x400ce
jmp 0x400ed
leaq 0xf6ed(%rip), %rdi      # 0x4f7c2
leaq 0xee19(%rip), %rsi      # 0x4eef5
movl $0x247, %edx            # imm = 0x247
leaq 0xf6a4(%rip), %rcx      # 0x4f78c
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x400f9
jmp 0x40118
leaq 0xa976(%rip), %rdi      # 0x4aa76
leaq 0xedee(%rip), %rsi      # 0x4eef5
movl $0x248, %edx            # imm = 0x248
leaq 0xf679(%rip), %rcx      # 0x4f78c
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x40135
jmp 0x40154
leaq 0xf463(%rip), %rdi      # 0x4f59f
leaq 0xedb2(%rip), %rsi      # 0x4eef5
movl $0x24b, %edx            # imm = 0x24B
leaq 0xf63d(%rip), %rcx      # 0x4f78c
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3fd40
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/lexer.c
// Function: pp_lexer_new_context
LexerContext * pp_lexer_new_context(
	const char *file,
	const char *source,
	int len
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	return lexer_new_context(file, source, len, _matchers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x40c1c
jmp 0x40c3b
leaq 0x5e4b(%rip), %rdi      # 0x46a6e
leaq 0xeee4(%rip), %rsi      # 0x4fb0e
movl $0xdc, %edx
leaq 0xeef6(%rip), %rcx      # 0x4fb2c
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x40c44
jmp 0x40c63
leaq 0x5950(%rip), %rdi      # 0x4659b
leaq 0xeebc(%rip), %rsi      # 0x4fb0e
movl $0xdd, %edx
leaq 0xeece(%rip), %rcx      # 0x4fb2c
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x40c6b
jmp 0x40c8a
leaq 0x5930(%rip), %rdi      # 0x465a2
leaq 0xee95(%rip), %rsi      # 0x4fb0e
movl $0xde, %edx
leaq 0xeea7(%rip), %rcx      # 0x4fb2c
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x1e744(%rip), %rcx     # 0x5f3e0
callq 0xb170
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/line.c
// Function: expand_macro_rstr
void expand_macro_rstr(
	ResizableString *rstr,
	PPGeneratorContext *genctx,
	const char *key,
	int len
) {
	assert(rstr);
	assert(genctx);
	assert(key);

	_expand_macro_rstr(rstr, genctx, key, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x41800
jmp 0x4181f
leaq 0x6318(%rip), %rdi      # 0x47b1f
leaq 0xe4e6(%rip), %rsi      # 0x4fcf4
movl $0x296, %edx            # imm = 0x296
leaq 0xe4f7(%rip), %rcx      # 0x4fd11
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x41828
jmp 0x41847
leaq 0xd395(%rip), %rdi      # 0x4ebc4
leaq 0xe4be(%rip), %rsi      # 0x4fcf4
movl $0x297, %edx            # imm = 0x297
leaq 0xe4cf(%rip), %rcx      # 0x4fd11
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x41850
jmp 0x4186f
leaq 0x5636(%rip), %rdi      # 0x46e8d
leaq 0xe496(%rip), %rsi      # 0x4fcf4
movl $0x298, %edx            # imm = 0x298
leaq 0xe4a7(%rip), %rcx      # 0x4fd11
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x41890
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/line.c
// Function: expand_macro_rstr
static void _expand_macro_rstr(
	ResizableString *rstr,
	PPGeneratorContext *genctx,
	const char *key,
	int len
) {
	assert(rstr);
	assert(genctx);
	assert(key);

	ResizableString rstr_key;
	rstr_init_with_raw(&rstr_key, key, len);

	if (map_exists_key(genctx->map_kv, &rstr_key)) {
		ResizableString *value = map_get(genctx->map_kv, &rstr_key);
		_expand_rstr(rstr, genctx, RSTR_CSTR(value), RSTR_LEN(value));
	} else {
		rstr_append_with_raw(rstr, key, len);
	}

	rstr_free(&rstr_key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x418b0
jmp 0x418cf
leaq 0x6268(%rip), %rdi      # 0x47b1f
leaq 0xe436(%rip), %rsi      # 0x4fcf4
movl $0x17a, %edx            # imm = 0x17A
leaq 0xe4d6(%rip), %rcx      # 0x4fda0
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x418d8
jmp 0x418f7
leaq 0xd2e5(%rip), %rdi      # 0x4ebc4
leaq 0xe40e(%rip), %rsi      # 0x4fcf4
movl $0x17b, %edx            # imm = 0x17B
leaq 0xe4ae(%rip), %rcx      # 0x4fda0
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x41900
jmp 0x4191f
leaq 0x5586(%rip), %rdi      # 0x46e8d
leaq 0xe3e6(%rip), %rsi      # 0x4fcf4
movl $0x17c, %edx            # imm = 0x17C
leaq 0xe486(%rip), %rcx      # 0x4fda0
callq 0xa0b0
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0xfef0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd8f0
testb $0x1, %al
jne 0x41946
jmp 0x419a9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd750
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x41983
leaq 0x5f0a(%rip), %rax      # 0x47887
movq %rax, -0x50(%rbp)
jmp 0x4198f
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
callq 0x41bd0
jmp 0x419b9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xffa0
leaq -0x30(%rbp), %rdi
callq 0x10320
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/line.c
// Function: pp_line_process
void pp_line_process(
	PPGeneratorContext *genctx,
	ParserASTNode *node
) {
	assert(genctx);
	assert(node);
	assert(node->type == PP_NODE_LINE);

	_expand(genctx, node->token->content, node->token->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x419e9
jmp 0x41a08
leaq 0xd1d4(%rip), %rdi      # 0x4ebc4
leaq 0xe2fd(%rip), %rsi      # 0x4fcf4
movl $0x2a1, %edx            # imm = 0x2A1
leaq 0xe361(%rip), %rcx      # 0x4fd64
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x41a11
jmp 0x41a30
leaq 0x966f(%rip), %rdi      # 0x4b087
leaq 0xe2d5(%rip), %rsi      # 0x4fcf4
movl $0x2a2, %edx            # imm = 0x2A2
leaq 0xe339(%rip), %rcx      # 0x4fd64
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x302, (%rax)          # imm = 0x302
jne 0x41a3e
jmp 0x41a5d
leaq 0xe074(%rip), %rdi      # 0x4fab9
leaq 0xe2a8(%rip), %rsi      # 0x4fcf4
movl $0x2a3, %edx            # imm = 0x2A3
leaq 0xe30c(%rip), %rcx      # 0x4fd64
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %edx
callq 0x41a90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/line.c
// Function: expand
static void _expand(
	PPGeneratorContext *genctx,
	const char *src,
	int len
) {
	assert(genctx);
	assert(src);

	ResizableString rstr;
	rstr_init(&rstr);

	_expand_rstr(&rstr, genctx, src, len);
	_OUT_STR(genctx, RSTR_CSTR(&rstr), RSTR_LEN(&rstr));

	rstr_free(&rstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x41aac
jmp 0x41acb
leaq 0xd111(%rip), %rdi      # 0x4ebc4
leaq 0xe23a(%rip), %rsi      # 0x4fcf4
movl $0x284, %edx            # imm = 0x284
leaq 0xe564(%rip), %rcx      # 0x5002a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x41ad4
jmp 0x41af3
leaq 0x64e1(%rip), %rdi      # 0x47fbc
leaq 0xe212(%rip), %rsi      # 0x4fcf4
movl $0x285, %edx            # imm = 0x285
leaq 0xe53c(%rip), %rcx      # 0x5002a
callq 0xa0b0
leaq -0x28(%rbp), %rdi
callq 0xfca0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x28(%rbp), %rdi
callq 0x41bd0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x41bb2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x41b65
cmpq $0x0, -0x20(%rbp)
jne 0x41b42
leaq 0x5d4b(%rip), %rax      # 0x47887
movq %rax, -0x38(%rbp)
jmp 0x41b4a
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa0e0
jmp 0x41ba2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x41b85
leaq 0x5d08(%rip), %rax      # 0x47887
movq %rax, -0x48(%rbp)
jmp 0x41b8d
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0xfeb0
jmp 0x41ba4
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x41b17
leaq -0x28(%rbp), %rdi
callq 0x10320
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/line_concat.c
// Function: pp_line_concat_process
void pp_line_concat_process(
	ResizableString *dst,
	const char *file,
	const char *src,
	int len
) {
	assert(dst);
	assert(file);
	assert(src);

	_process(dst, file, src, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x43570
jmp 0x4358f
leaq 0x2af2(%rip), %rdi      # 0x46069
leaq 0xcae2(%rip), %rsi      # 0x50060
movl $0x3a, %edx
leaq 0xcb3c(%rip), %rcx      # 0x500c6
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x43598
jmp 0x435b7
leaq 0x34cf(%rip), %rdi      # 0x46a6e
leaq 0xcaba(%rip), %rsi      # 0x50060
movl $0x3b, %edx
leaq 0xcb14(%rip), %rcx      # 0x500c6
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x435c0
jmp 0x435df
leaq 0x49f5(%rip), %rdi      # 0x47fbc
leaq 0xca92(%rip), %rsi      # 0x50060
movl $0x3c, %edx
leaq 0xcaec(%rip), %rcx      # 0x500c6
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x43340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/parser.c
// Function: pp_parser_new_context
_RULE_END

ParserContext * pp_parser_new_context(
	const char *file,
	const char *source,
	int len
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	LexerContext *lexctx = pp_lexer_new_context(file, source, len);
	lexer_parse(lexctx);

	ParserContext *ctx = parser_new_context(lexctx);
	ctx->arch = 0;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4361c
jmp 0x4363b
leaq 0x344b(%rip), %rdi      # 0x46a6e
leaq 0xcaec(%rip), %rsi      # 0x50116
movl $0x1b4, %edx            # imm = 0x1B4
leaq 0xcaff(%rip), %rcx      # 0x50135
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x43644
jmp 0x43663
leaq 0x2f50(%rip), %rdi      # 0x4659b
leaq 0xcac4(%rip), %rsi      # 0x50116
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0xcad7(%rip), %rcx      # 0x50135
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x4366b
jmp 0x4368a
leaq 0x2f30(%rip), %rdi      # 0x465a2
leaq 0xca9d(%rip), %rsi      # 0x50116
movl $0x1b6, %edx            # imm = 0x1B6
leaq 0xcab0(%rip), %rcx      # 0x50135
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x40c00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbe70
movq -0x20(%rbp), %rdi
callq 0xe870
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/parser.c
// Function: new_node
static ParserASTNode * _new_node(
	ParserContext *ctx,
	int32_t type,
	char *type_name,
	LexerToken *token
) {
	assert(ctx);
	assert(type_name);

	if (type == PP_NODE_DIRECTIVE_IF
			|| type == PP_NODE_DIRECTIVE_IFDEF
			|| type == PP_NODE_DIRECTIVE_IFNDEF) {
		PPParserIfxxxASTNodeData data;
		data.token_endif = NULL;

		return parser_new_node(ctx, type, type_name, token, sizeof(PPParserIfxxxASTNodeData), &data);
	} else {
		return parser_new_node(ctx, type, type_name, token, 0, NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43b50
jmp 0x43b6f
leaq 0xa00a(%rip), %rdi      # 0x4db61
leaq 0xc5b8(%rip), %rsi      # 0x50116
movl $0x18, %edx
leaq 0xa046(%rip), %rcx      # 0x4dbb0
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0x43b78
jmp 0x43b97
leaq 0xa07a(%rip), %rdi      # 0x4dbf9
leaq 0xc590(%rip), %rsi      # 0x50116
movl $0x19, %edx
leaq 0xa01e(%rip), %rcx      # 0x4dbb0
callq 0xa0b0
cmpl $0x203, -0x14(%rbp)     # imm = 0x203
je 0x43bb2
cmpl $0x204, -0x14(%rbp)     # imm = 0x204
je 0x43bb2
cmpl $0x205, -0x14(%rbp)     # imm = 0x205
jne 0x43bde
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x8, %r8d
leaq -0x30(%rbp), %r9
callq 0xea00
movq %rax, -0x8(%rbp)
jmp 0x43bfe
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0xea00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/12-VirtualMemory/grow_stack.c
// Function: recursion
void recursion() {
	char buf[BUF_SIZE];

	printf("Real allocation...");
	fflush(stdout);
	while( getchar() != '\n' );

	memset(buf, 0, sizeof(buf));

	printf("Virtual allocation...");
	fflush(stdout);
	while( getchar() != '\n' );
	recursion();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80000, %rsp          # imm = 0x80000
leaq 0xe72(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movq 0x2e40(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1070
callq 0x1060
cmpl $0xa, %eax
je 0x11b4
jmp 0x11a8
leaq -0x80000(%rbp), %rdi
xorl %esi, %esi
movl $0x80000, %edx          # imm = 0x80000
callq 0x1050
leaq 0xe49(%rip), %rdi       # 0x2017
movb $0x0, %al
callq 0x1040
movq 0x2e04(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1070
callq 0x1060
cmpl $0xa, %eax
je 0x11f0
jmp 0x11e4
callq 0x1180
addq $0x80000, %rsp          # imm = 0x80000
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/syslog.c
// Function: syslog_open
int syslog_open(void) {
  int fd;
  struct sockaddr_un addr = {
    .sun_family = AF_UNIX,
    .sun_path = "/dev/log"
  };

  if ((fd = socket(AF_UNIX, SOCK_DGRAM | SOCK_NONBLOCK, 0)) < 0)
    err(EXIT_FAILURE, "socket");

  unlink(addr.sun_path);
  umask(0111); /* Syslog socket should be writeable by everyone. */
  if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
    err(EXIT_FAILURE, "bind %s", addr.sun_path);

  if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &(int) { 1 },
        sizeof(int)) < 0)
    err(EXIT_FAILURE, "setsockopt SO_PASSCRED %s", addr.sun_path);
  return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x72(%rbp), %rdi
leaq 0xf20(%rip), %rsi       # 0x3206
movl $0x6e, %edx
callq 0x20e0
movl $0x1, %edi
movl $0x802, %esi            # imm = 0x802
xorl %edx, %edx
callq 0x21c0
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jge 0x231c
movl $0x1, %edi
leaq 0xdbc(%rip), %rsi       # 0x30d1
movb $0x0, %al
callq 0x2100
leaq -0x72(%rbp), %rdi
addq $0x2, %rdi
callq 0x2050
movl $0x49, %edi
callq 0x20d0
movl -0x4(%rbp), %edi
leaq -0x72(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
movl $0x6e, %edx
callq 0x2160
cmpl $0x0, %eax
jge 0x236c
leaq -0x72(%rbp), %rdx
addq $0x2, %rdx
movl $0x1, %edi
leaq 0xd73(%rip), %rsi       # 0x30d8
movb $0x0, %al
callq 0x2100
movl -0x4(%rbp), %edi
movl $0x1, -0x84(%rbp)
movl $0x1, %esi
movl $0x10, %edx
leaq -0x84(%rbp), %rcx
movl $0x4, %r8d
callq 0x2060
cmpl $0x0, %eax
jge 0x23b5
leaq -0x72(%rbp), %rdx
addq $0x2, %rdx
movl $0x1, %edi
leaq 0xd32(%rip), %rsi       # 0x30e0
movb $0x0, %al
callq 0x2100
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/syslog.c
// Function: usage
void usage(char *progname) {
  fprintf(stderr, "\
Usage: %s [OPTIONS]\n\
Options:\n\
  -b  include old messages from the kernel ring buffer\n\
  -n  print facility numbers instead of names\n\
", progname);
  exit(EX_USAGE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2c15(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xd09(%rip), %rsi       # 0x30fa
movb $0x0, %al
callq 0x20c0
movl $0x40, %edi
callq 0x21a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/syslog.c
// Function: main
int main(int argc, char **argv) {
  struct pollfd fds[2];
  int option;

  while ((option = getopt(argc, argv, ":bn")) > 0)
    switch (option) {
      case 'b':
        boot = 1;
        break;
      case 'n':
        numeric = 1;
        break;
      default:
        usage(argv[0]);
    }

  if (argc > optind)
    usage(argv[0]);

  if ((fds[0].fd = open("/dev/kmsg", O_RDONLY | O_NONBLOCK)) < 0)
    err(EXIT_FAILURE, "open /dev/kmsg");
  lseek(fds[0].fd, 0, boot ? SEEK_SET : SEEK_END);
  fds[1].fd = syslog_open();

  zone = getenv("TZ");

  fds[0].events = fds[1].events = POLLIN;
  while(1) {
    while (poll(fds, 2, -1) < 0)
      if (errno != EAGAIN && errno != EINTR)
        err(EXIT_FAILURE, "poll");
    if (fds[0].revents & POLLIN)
      kernel_read(fds[0].fd);
    if (fds[1].revents & POLLIN)
      syslog_recv(fds[1].fd);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xd49(%rip), %rdx       # 0x317d
callq 0x2180
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x247e
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x62, %eax
je 0x2458
jmp 0x244e
movl -0x28(%rbp), %eax
subl $0x6e, %eax
je 0x2464
jmp 0x2470
movl $0x1, 0x2eee(%rip)      # 0x5350
jmp 0x247c
movl $0x1, 0x2ee6(%rip)      # 0x5354
jmp 0x247c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x23d0
jmp 0x2426
movl -0x8(%rbp), %eax
movq 0x2b48(%rip), %rcx      # 0x4fd0
cmpl (%rcx), %eax
jle 0x2498
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x23d0
leaq 0xce7(%rip), %rdi       # 0x3186
movl $0x800, %esi            # imm = 0x800
movb $0x0, %al
callq 0x2170
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0x24c6
movl $0x1, %edi
leaq 0xcc2(%rip), %rsi       # 0x3181
movb $0x0, %al
callq 0x2100
movl -0x20(%rbp), %edi
movl 0x2e81(%rip), %ecx      # 0x5350
movl $0x2, %edx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x20a0
callq 0x22d0
movl %eax, -0x18(%rbp)
leaq 0xc9c(%rip), %rdi       # 0x3190
callq 0x2030
movq %rax, 0x2e58(%rip)      # 0x5358
movw $0x1, -0x14(%rbp)
movw $0x1, -0x1c(%rbp)
jmp 0x250e
leaq -0x20(%rbp), %rdi
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2150
cmpl $0x0, %eax
jge 0x254f
callq 0x2040
cmpl $0xb, (%rax)
je 0x254d
callq 0x2040
cmpl $0x4, (%rax)
je 0x254d
movl $0x1, %edi
leaq 0xc4d(%rip), %rsi       # 0x3193
movb $0x0, %al
callq 0x2100
jmp 0x250e
movswl -0x1a(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2563
movl -0x20(%rbp), %edi
callq 0x2580
movswl -0x12(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2577
movl -0x18(%rbp), %edi
callq 0x2820
jmp 0x250c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/syslog.c
// Function: syslog_facility
static char *syslog_facility(int priority) {
  for (size_t i = 0; facilitynames[i].c_val >= 0; i++)
    if (facilitynames[i].c_val == (priority & LOG_FACMASK))
      return facilitynames[i].c_name;
  return "unknown"; /* facility not found in facilitynames[] */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x2666(%rip), %rax      # 0x51d0
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jl 0x2bc4
movq -0x18(%rbp), %rcx
leaq 0x264e(%rip), %rax      # 0x51d0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl -0xc(%rbp), %ecx
andl $0x3f8, %ecx            # imm = 0x3F8
cmpl %ecx, %eax
jne 0x2bb4
movq -0x18(%rbp), %rcx
leaq 0x262c(%rip), %rax      # 0x51d0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2bcf
jmp 0x2bb6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2b5f
leaq 0x611(%rip), %rax       # 0x31dc
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/syslog.c
// Function: syslog_date
static int syslog_date(char *line, struct tm *date) {
  char *cursor;
  time_t now, offset;

  time(&now);
  (UTCLOG ? gmtime_r : localtime_r)(&now, date);
  if ((cursor = strptime(line, " %b %d %H:%M:%S ", date))) {
    /* Pick tm_year so the timestamp is closest to now. */
    offset = now - (UTCLOG ? timegm : mktime)(date);
    date->tm_year += (offset - 15778800) / 31557600;
    now = (UTCLOG ? timegm : mktime)(date);
  }

  (zone && zone[0] ? localtime_r : gmtime_r)(&now, date);
  return cursor ? cursor - line : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20f0
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x59f(%rip), %rsi       # 0x31f4
callq 0x21b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2cb5
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2130
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq $0xf0c3f0, %rax         # imm = 0xF0C3F0
movl $0x1e187e0, %ecx        # imm = 0x1E187E0
cqto
idivq %rcx
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x2699(%rip)      # 0x5358
movb %al, -0x31(%rbp)
je 0x2cd7
movq 0x268d(%rip), %rax      # 0x5358
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %dl
movq 0x22f7(%rip), %rax      # 0x4fd8
movq 0x22e0(%rip), %rcx      # 0x4fc8
testb $0x1, %dl
cmovneq %rcx, %rax
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq *%rax
cmpq $0x0, -0x18(%rbp)
je 0x2d11
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x2d19
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x2d19
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/examples/mnist/mnist_read_input.c
// Function: Mnist_PrintSize
void Mnist_PrintSize(char *name,SIZE_s *pSize)
{
	printf("======name:%s:\n",name);
	printf("pSize->h:%d\n",pSize->h);
	printf("pSize->w:%d\n",pSize->w);
	printf("pSize->n:%d\n",pSize->n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x94b5(%rip), %rdi      # 0xb140
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x94b1(%rip), %rdi      # 0xb150
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x94a9(%rip), %rdi      # 0xb15d
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x94a1(%rip), %rdi      # 0xb16a
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/examples/mnist/mnist_read_input.c
// Function: Mnist_GetData
int Mnist_GetData(char *file,double **data,SIZE_s *pSize)
{
	getSizeFromFilename(file,pSize);
	
	int allSize = pSize->w*pSize->h*pSize->n;
	*data = (double *)malloc(sizeof(double)*allSize);
	int ret = readMatFromFile(file,*data,allSize);
	CHECK_EXPR_RET(ret != 0,-1);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d90
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
imull (%rcx), %eax
movq -0x20(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0x24(%rbp), %edx
callq 0x1e90
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x1d77
leaq 0x92c1(%rip), %rdi      # 0xb015
leaq 0x941c(%rip), %rsi      # 0xb177
leaq 0x9428(%rip), %rdx      # 0xb18a
movl $0x39, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d7e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/examples/mnist/mnist_read_input.c
// Function: getSizeFromFilename
static int getSizeFromFilename(char *file,SIZE_s *pSize)
{
	char buf[256];
	memcpy(buf,file,strlen(file)+1);
	
	char *ptr = strrchr(buf,'_');
	pSize->n = atoi(ptr+1);
	*ptr = '*';
	
	ptr = strrchr(buf,'_');
	pSize->w = atoi(ptr+1);
	*ptr = '*';
	
	ptr = strrchr(buf,'_');
	pSize->h = atoi(ptr+1);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x1090
leaq -0x110(%rbp), %rdi
movl $0x5f, %esi
callq 0x10b0
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
addq $0x1, %rdi
callq 0x1120
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x118(%rbp), %rax
movb $0x2a, (%rax)
leaq -0x110(%rbp), %rdi
movl $0x5f, %esi
callq 0x10b0
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
addq $0x1, %rdi
callq 0x1120
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x118(%rbp), %rax
movb $0x2a, (%rax)
leaq -0x110(%rbp), %rdi
movl $0x5f, %esi
callq 0x10b0
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
addq $0x1, %rdi
callq 0x1120
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/examples/mnist/mnist_read_input.c
// Function: readMatFromFile
static int readMatFromFile(char *file,double *data,int size)
{
	FILE *fp = fopen(file,"rb");
	if (fp == NULL) {
		printf("fopen error!\n");
		return -1;
	}
	
	int nread = fread(data,sizeof(double),size,fp);
	if (nread != size) {
		printf("read error,size:%d needreadsize:%d\n",nread,size);
		return -1;
	} else {
		//printf("read success!\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9316(%rip), %rsi      # 0xb1c4
callq 0x10c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1ed5
leaq 0x9302(%rip), %rdi      # 0xb1c7
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f1c
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x8, %esi
callq 0x1110
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x1f13
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
leaq 0x92d2(%rip), %rdi      # 0xb1d5
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f1c
jmp 0x1f15
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/examples/mnist/mnist_read_input.c
// Function: Mnist_dataNormalie
int Mnist_dataNormalie(double *pData,SIZE_s *pSize)
{
	int allSize = pSize->w*pSize->h*pSize->n;
	for (int i= 0;i < allSize;i++) {
		pData[i] /= (double)255; 
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull (%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x226d
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x8edf(%rip), %xmm1     # 0xb138
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x223c
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)