LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::destroy_ast(neteruhsp::list_t*)
void destroy_ast( list_t* ast )
{
	auto node = ast->head_;
	while( node != nullptr )
	{
		const auto ast_node = reinterpret_cast<ast_node_t*>( node->value_ );
		destroy_ast_node( ast_node );
		node = node->next_;
	}

	list_free_all( *ast );
	destroy_list( ast );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x546b
movq 0x10(%r14), %rdi
callq 0x5032
movq 0x8(%r14), %r14
jmp 0x5457
movq %rbx, %rdi
callq 0x2d06
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_label_safe(neteruhsp::parse_context_t&)
ast_node_t* parse_label_safe( parse_context_t& c )
{
	const auto token = read_token( c );
	if ( token->tag_ != TOKEN_OP_MUL )
	{
		unread_token( c );
		return nullptr;
	}

	const auto ident = read_token( c );
	if ( ident->tag_ != TOKEN_IDENTIFIER )
	{
		unread_token( c, 2 );
		return nullptr;
	}

	return create_ast_node( NODE_LABEL, ident );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x367d
cmpl $0x17, (%rax)
jne 0x54c7
movq %rbx, %rdi
callq 0x367d
cmpl $0x23, (%rax)
jne 0x54ce
movq %rax, %r14
movl $0x28, %edi
callq 0x21d0
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x0, 0x20(%rax)
jmp 0x54dd
movl $0x1, %esi
jmp 0x54d3
movl $0x2, %esi
movq %rbx, %rdi
callq 0x36fe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_command_safe(neteruhsp::parse_context_t&)
ast_node_t* parse_command_safe( parse_context_t& c )
{
	const auto ident = read_token( c );
	if ( ident->tag_ != TOKEN_IDENTIFIER )
	{
		unread_token( c );
		return nullptr;
	}

	const auto next = read_token( c );

	bool is_not_command = false;
	switch( next->tag_ )
	{
	case TOKEN_ASSIGN:
	case TOKEN_ADD_ASSIGN:
	case TOKEN_SUB_ASSIGN:
	case TOKEN_MUL_ASSIGN:
	case TOKEN_DIV_ASSIGN:
	case TOKEN_MOD_ASSIGN:
	case TOKEN_BOR_ASSIGN:
	case TOKEN_BAND_ASSIGN:
	case TOKEN_BXOR_ASSIGN:
		is_not_command = true;
		break;
	default: break;
	}

	// "("チェック
	if ( !ident->right_space_ && next->tag_==TOKEN_LPARENTHESIS )
	{ is_not_command = true; }

	if ( is_not_command )
	{
		unread_token( c, 2 );
		return nullptr;
	}

	// あるなら引数の解析
	ast_node_t* args = nullptr;
	if ( !is_eos_like_token( next->tag_ ) )
	{
		unread_token( c );
		args = parse_arguments( c );
	}
	else
	{
		unread_token( c );
	}

	const auto command = create_ast_node( NODE_COMMAND, ident, args );
 	return command;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x367d
cmpl $0x23, (%rax)
jne 0x5c83
movq %rax, %rbx
movq %r14, %rdi
callq 0x367d
movl (%rax), %eax
leal -0x1a(%rax), %edx
cmpl $0x6, %eax
sete %cl
cmpl $0x9, %edx
jb 0x5c8a
movb 0x1d(%rbx), %dl
xorb $0x1, %dl
andb %dl, %cl
jne 0x5c8a
cmpl $0x5, %eax
ja 0x5ca1
movl $0x27, %ecx
btl %eax, %ecx
jae 0x5ca1
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
xorl %r14d, %r14d
movl $0x28, %edi
callq 0x21d0
movl $0x3, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x20(%rax)
jmp 0x5c99
movl $0x1, %esi
jmp 0x5c8f
movl $0x2, %esi
movq %r14, %rdi
callq 0x36fe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
movq %r14, %rdi
callq 0x5d32
movq %rax, %r14
jmp 0x5c5a
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_assign_safe(neteruhsp::parse_context_t&)
ast_node_t* parse_assign_safe( parse_context_t& c )
{
	auto variable = parse_variable_safe( c );
	if ( variable == nullptr )
	{ return nullptr; }

	const auto next = read_token( c );

	int node =-1;
	switch( next->tag_ )
	{
	case TOKEN_ASSIGN:			node = NODE_ASSIGN; break;
	case TOKEN_ADD_ASSIGN:		node = NODE_ADD_ASSIGN; break;
	case TOKEN_SUB_ASSIGN:		node = NODE_SUB_ASSIGN; break;
	case TOKEN_MUL_ASSIGN:		node = NODE_MUL_ASSIGN; break;
	case TOKEN_DIV_ASSIGN:		node = NODE_DIV_ASSIGN; break;
	case TOKEN_MOD_ASSIGN:		node = NODE_MOD_ASSIGN; break;
	case TOKEN_BOR_ASSIGN:		node = NODE_BOR_ASSIGN; break;
	case TOKEN_BAND_ASSIGN:		node = NODE_BAND_ASSIGN; break;
	case TOKEN_BXOR_ASSIGN:		node = NODE_BXOR_ASSIGN; break;
	default:
		raise_error( "代入 : =が必要です@@ %d行目", next->appear_line_ );
		break;
	}

	if ( node == -1 )
	{ return nullptr; }

	auto expr = parse_expression( c );
	auto assign = create_ast_node( static_cast<node_tag>( node ), variable, expr );
	return assign;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x5dde
testq %rax, %rax
je 0x5d19
movq %rax, %rbx
movq %r14, %rdi
callq 0x367d
movl (%rax), %r15d
leal -0x1a(%r15), %ecx
cmpl $0x9, %ecx
jae 0x5d21
addl $-0x15, %r15d
movq %r14, %rdi
callq 0x5ea4
movq %rax, %r14
movl $0x28, %edi
callq 0x21d0
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
movl $0x0, 0x20(%rax)
jmp 0x5d1b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%rax), %esi
leaq 0x9376(%rip), %rdi      # 0xf0a1
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_arguments(neteruhsp::parse_context_t&)
ast_node_t* parse_arguments( parse_context_t& c )
{
	auto arg = parse_expression( c );
	auto res = create_ast_node( NODE_ARGUMENTS, arg );
	auto args = res;

	for( ; ; )
	{
		const auto token = read_token( c );
		if ( token->tag_ != TOKEN_COMMA )
		{
			unread_token( c );
			break;
		}

		auto next =parse_expression( c );
		args->right_ = create_ast_node( NODE_ARGUMENTS, next );
		args = args->right_;
	}
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5ea4
movq %rax, %r15
movl $0x28, %edi
callq 0x21d0
movq %rax, %r14
movl $0x4, (%rax)
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r12, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, %r13
movq %rbx, %rdi
callq 0x367d
movl (%rax), %ebp
cmpl $0x8, %ebp
jne 0x5dba
movq %rbx, %rdi
callq 0x5ea4
movq %rax, %r15
movl $0x28, %edi
callq 0x21d0
movl $0x4, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r12, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x18(%r13)
movq %rax, %r13
jmp 0x5dc7
movl $0x1, %esi
movq %rbx, %rdi
callq 0x36fe
cmpl $0x8, %ebp
je 0x5d74
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_variable_safe(neteruhsp::parse_context_t&)
ast_node_t* parse_variable_safe( parse_context_t& c )
{
	const auto ident = read_token( c );
	if ( ident->tag_ != TOKEN_IDENTIFIER )
	{
		unread_token( c );
		return nullptr;
	}

	const auto next = read_token( c );
	if ( next->tag_ != TOKEN_LPARENTHESIS )
	{
		unread_token( c );
		return create_ast_node( NODE_VARIABLE, ident );
	}

	const auto idx = parse_expression( c );
	const auto nn = read_token( c );
	if ( nn->tag_ != TOKEN_RPARENTHESIS )
	{
		// 多そうなので個別対処
		if ( nn->tag_ == TOKEN_COMMA )
		{ raise_error( "配列変数 : 二次元以上の配列はサポートしていません@@ %d行目", nn->appear_line_ ); }
		raise_error( "配列変数 : 括弧が正しく閉じられていません@@ %d行目", nn->appear_line_ );
	}

	return create_ast_node( NODE_VARIABLE, ident, idx );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x367d
cmpl $0x23, (%rax)
jne 0x5e3c
movq %rax, %rbx
movq %r14, %rdi
callq 0x367d
cmpl $0x6, (%rax)
jne 0x5e4d
movq %r14, %rdi
callq 0x5ea4
movq %rax, %r15
movq %r14, %rdi
callq 0x367d
movl (%rax), %ecx
cmpl $0x7, %ecx
jne 0x5e82
movl $0x28, %edi
callq 0x21d0
movl $0xe, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq $0x0, 0x18(%rax)
jmp 0x5e75
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
xorl %eax, %eax
jmp 0x5e7c
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
movl $0x28, %edi
callq 0x21d0
movl $0xe, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x0, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x8, %ecx
jne 0x5e93
movl 0x18(%rax), %esi
leaq 0x9235(%rip), %rdi      # 0xf0c6
jmp 0x5e9d
movl 0x18(%rax), %esi
leaq 0x962c(%rip), %rdi      # 0xf4c9
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_borand(neteruhsp::parse_context_t&)
ast_node_t* parse_borand( parse_context_t& c )
{
	auto node =parse_eqneq(c);

	for( ; ; )
	{
		bool is_continue = true;
		const auto token = read_token( c );
		switch( token->tag_ )
		{
			case TOKEN_OP_BOR:
			case TOKEN_OP_BAND:
			case TOKEN_OP_BXOR:
			{
				auto r = parse_eqneq( c );
				if ( r == nullptr )
				{ raise_error( "|,&の演算子で、右項の解析が出来ません@@ %d行目", token->appear_line_ ); }

				switch( token->tag_ )
				{
					case TOKEN_OP_BOR:	node = create_ast_node( NODE_BOR, node, r ); break;
					case TOKEN_OP_BAND:	node = create_ast_node( NODE_BAND, node, r ); break;
					case TOKEN_OP_BXOR:	node = create_ast_node( NODE_BXOR, node, r ); break;
					default: assert( false ); break;
				}
				break;
			}
			default:
				is_continue = false;
				break;
		}
		if ( !is_continue )
		{
			unread_token( c );
			break;
		}
	}
	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5f65
movq %rax, %r14
movq %rbx, %rdi
callq 0x367d
movl (%rax), %ebp
addl $-0xc, %ebp
cmpl $0x2, %ebp
ja 0x5f15
movq %rax, %r12
movq %rbx, %rdi
callq 0x5f65
testq %rax, %rax
je 0x5f33
movq %rax, %r15
movl (%r12), %r12d
leal -0xc(%r12), %eax
cmpl $0x3, %eax
jae 0x5f46
addl $0x4, %r12d
movl $0x28, %edi
callq 0x21d0
movl %r12d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, %r14
cmpl $0x3, %ebp
jb 0x5eb7
movl $0x1, %esi
movq %rbx, %rdi
callq 0x36fe
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r12), %esi
leaq 0x91db(%rip), %rdi      # 0xf11a
xorl %eax, %eax
callq 0x34a8
leaq 0x88aa(%rip), %rdi      # 0xe7f7
leaq 0x7985(%rip), %rsi      # 0xd8d9
leaq 0x9201(%rip), %rcx      # 0xf15c
movl $0xdd2, %edx            # imm = 0xDD2
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_eqneq(neteruhsp::parse_context_t&)
ast_node_t* parse_eqneq( parse_context_t& c )
{
	auto node =parse_gtlt(c);

	for( ; ; )
	{
		bool is_continue = true;
		const auto token = read_token( c );
		switch( token->tag_ )
		{
			case TOKEN_OP_EQ:
			case TOKEN_OP_NEQ:
			case TOKEN_ASSIGN:
			{
				auto r = parse_gtlt( c );
				if ( r == nullptr )
				{ raise_error( "==,!=の演算子で、右項の解析が出来ません@@ %d行目", token->appear_line_ ); }

				switch( token->tag_ )
				{
					case TOKEN_OP_EQ:
					case TOKEN_ASSIGN:
						node = create_ast_node( NODE_EQ, node, r );
						break;
					case TOKEN_OP_NEQ:	node = create_ast_node( NODE_NEQ, node, r ); break;
					default: assert( false ); break;
				}
				break;
			}
			default:
				is_continue = false;
				break;
		}
		if ( !is_continue )
		{
			unread_token( c );
			break;
		}
	}
	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x603d
movq %rax, %r14
movl $0x4018000, %ebp        # imm = 0x4018000
movq %rbx, %rdi
callq 0x367d
movq %rax, %r12
movl (%rax), %eax
xorl %ecx, %ecx
cmpl $0x1a, %eax
ja 0x5fee
btl %eax, %ebp
jae 0x5fee
movq %rbx, %rdi
callq 0x603d
testq %rax, %rax
je 0x600b
movq %rax, %r15
movl (%r12), %eax
movl $0x13, %r12d
cmpl $0xf, %eax
je 0x5fc5
cmpl $0x1a, %eax
je 0x5fc5
cmpl $0x10, %eax
jne 0x601e
movl $0x14, %r12d
movl $0x28, %edi
callq 0x21d0
movl %r12d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x0, 0x20(%rax)
movb $0x1, %cl
movq %rax, %r14
testb %cl, %cl
jne 0x5f7d
movl $0x1, %esi
movq %rbx, %rdi
callq 0x36fe
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r12), %esi
leaq 0x917c(%rip), %rdi      # 0xf193
xorl %eax, %eax
callq 0x34a8
leaq 0x87d2(%rip), %rdi      # 0xe7f7
leaq 0x78ad(%rip), %rsi      # 0xd8d9
leaq 0x91a4(%rip), %rcx      # 0xf1d7
movl $0xdfc, %edx            # imm = 0xDFC
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_gtlt(neteruhsp::parse_context_t&)
ast_node_t* parse_gtlt( parse_context_t& c )
{
	auto node =parse_addsub(c);

	for( ; ; )
	{
		bool is_continue = true;
		const auto token = read_token( c );
		switch( token->tag_ )
		{
			case TOKEN_OP_GT:
			case TOKEN_OP_GTOE:
			case TOKEN_OP_LT:
			case TOKEN_OP_LTOE:
			{
				auto r = parse_addsub( c );
				if ( r == nullptr )
				{ raise_error( ">,>=,<,<=の演算子で、右項の解析が出来ません@@ %d行目", token->appear_line_ ); }

				switch( token->tag_ )
				{
					case TOKEN_OP_GT:	node = create_ast_node( NODE_GT, node, r ); break;
					case TOKEN_OP_GTOE:	node = create_ast_node( NODE_GTOE, node, r ); break;
					case TOKEN_OP_LT:	node = create_ast_node( NODE_LT, node, r ); break;
					case TOKEN_OP_LTOE:	node = create_ast_node( NODE_LTOE, node, r ); break;
					default: assert( false ); break;
				}
				break;
			}
			default:
				is_continue = false;
				break;
		}
		if ( !is_continue )
		{
			unread_token( c );
			break;
		}
	}
	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x60fe
movq %rax, %r14
movq %rbx, %rdi
callq 0x367d
movl (%rax), %ebp
addl $-0x11, %ebp
cmpl $0x3, %ebp
ja 0x60ae
movq %rax, %r12
movq %rbx, %rdi
callq 0x60fe
testq %rax, %rax
je 0x60cc
movq %rax, %r15
movl (%r12), %r12d
leal -0x11(%r12), %eax
cmpl $0x4, %eax
jae 0x60df
addl $0x4, %r12d
movl $0x28, %edi
callq 0x21d0
movl %r12d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, %r14
cmpl $0x4, %ebp
jb 0x6050
movl $0x1, %esi
movq %rbx, %rdi
callq 0x36fe
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r12), %esi
leaq 0x9135(%rip), %rdi      # 0xf20d
xorl %eax, %eax
callq 0x34a8
leaq 0x8711(%rip), %rdi      # 0xe7f7
leaq 0x77ec(%rip), %rsi      # 0xd8d9
leaq 0x9161(%rip), %rcx      # 0xf255
movl $0xe26, %edx            # imm = 0xE26
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_addsub(neteruhsp::parse_context_t&)
ast_node_t* parse_addsub( parse_context_t& c )
{
	auto node =parse_muldivmod(c);

	for( ; ; )
	{
		bool is_continue = true;
		const auto token = read_token( c );
		switch( token->tag_ )
		{
			case TOKEN_OP_ADD:
			case TOKEN_OP_SUB:
			{
				auto r = parse_muldivmod( c );
				if ( r == nullptr )
				{ raise_error( "+-の演算子で、右項の解析が出来ません@@ %d行目", token->appear_line_ ); }

				switch( token->tag_ )
				{
					case TOKEN_OP_ADD:	node = create_ast_node( NODE_ADD, node, r ); break;
					case TOKEN_OP_SUB:	node = create_ast_node( NODE_SUB, node, r ); break;
					default: assert( false ); break;
				}
				break;
			}
			default:
				is_continue = false;
				break;
		}
		if ( !is_continue )
		{
			unread_token( c );
			break;
		}
	}
	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x61c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x367d
movl (%rax), %ebp
addl $-0x15, %ebp
cmpl $0x1, %ebp
ja 0x6177
movq %rax, %r12
movq %rbx, %rdi
callq 0x61c7
testq %rax, %rax
je 0x6195
movq %rax, %r15
movl (%r12), %eax
movl $0x19, %r12d
cmpl $0x15, %eax
je 0x6150
cmpl $0x16, %eax
jne 0x61a8
movl $0x1a, %r12d
movl $0x28, %edi
callq 0x21d0
movl %r12d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, %r14
cmpl $0x2, %ebp
jb 0x6111
movl $0x1, %esi
movq %rbx, %rdi
callq 0x36fe
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r12), %esi
leaq 0x90e9(%rip), %rdi      # 0xf28a
xorl %eax, %eax
callq 0x34a8
leaq 0x8648(%rip), %rdi      # 0xe7f7
leaq 0x7723(%rip), %rsi      # 0xd8d9
leaq 0x910e(%rip), %rcx      # 0xf2cb
movl $0xe4c, %edx            # imm = 0xE4C
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_muldivmod(neteruhsp::parse_context_t&)
ast_node_t* parse_muldivmod( parse_context_t& c )
{
	auto node =parse_term(c);

	for( ; ; )
	{
		bool is_continue = true;
		const auto token = read_token( c );
		switch( token->tag_ )
		{
			case TOKEN_OP_MUL:
			case TOKEN_OP_DIV:
			case TOKEN_OP_MOD:
			{
				auto r = parse_term( c );
				if ( r == nullptr )
				{ raise_error( "*/\\の演算子で、右項の解析が出来ません@@ %d行目", token->appear_line_ ); }

				switch( token->tag_ )
				{
					case TOKEN_OP_MUL:	node = create_ast_node( NODE_MUL, node, r ); break;
					case TOKEN_OP_DIV:	node = create_ast_node( NODE_DIV, node, r ); break;
					case TOKEN_OP_MOD:	node = create_ast_node( NODE_MOD, node, r ); break;
					default: assert( false ); break;
				}
				break;
			}
			default:
				is_continue = false;
				break;
		}
		if ( !is_continue )
		{
			unread_token( c );
			break;
		}
	}
	return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x6288
movq %rax, %r14
movq %rbx, %rdi
callq 0x367d
movl (%rax), %ebp
addl $-0x17, %ebp
cmpl $0x2, %ebp
ja 0x6238
movq %rax, %r12
movq %rbx, %rdi
callq 0x6288
testq %rax, %rax
je 0x6256
movq %rax, %r15
movl (%r12), %r12d
leal -0x17(%r12), %eax
cmpl $0x3, %eax
jae 0x6269
addl $0x4, %r12d
movl $0x28, %edi
callq 0x21d0
movl %r12d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, %r14
cmpl $0x3, %ebp
jb 0x61da
movl $0x1, %esi
movq %rbx, %rdi
callq 0x36fe
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r12), %esi
leaq 0x90a0(%rip), %rdi      # 0xf302
xorl %eax, %eax
callq 0x34a8
leaq 0x8587(%rip), %rdi      # 0xe7f7
leaq 0x7662(%rip), %rsi      # 0xd8d9
leaq 0x90c6(%rip), %rcx      # 0xf344
movl $0xe74, %edx            # imm = 0xE74
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_term(neteruhsp::parse_context_t&)
ast_node_t* parse_term( parse_context_t& c )
{
	const auto token = read_token( c );
	switch( token->tag_ )
	{
		case TOKEN_OP_SUB:		return create_ast_node( NODE_UNARY_MINUS, parse_primitive( c ) );
		default: break;
	}

	unread_token( c );
	return parse_primitive( c );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x367d
cmpl $0x16, (%rax)
jne 0x62c8
movq %rbx, %rdi
callq 0x62de
movq %rax, %rbx
movl $0x28, %edi
callq 0x21d0
movl $0x1e, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl $0x0, 0x20(%rax)
popq %rbx
retq
movl $0x1, %esi
movq %rbx, %rdi
callq 0x36fe
movq %rbx, %rdi
popq %rbx
jmp 0x62de
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_primitive(neteruhsp::parse_context_t&)
ast_node_t* parse_primitive( parse_context_t& c )
{
	const auto token = read_token( c );
	switch( token->tag_ )
	{
		case TOKEN_LPARENTHESIS:
		{
			const auto node = parse_expression( c );
			const auto next = read_token( c );
			if ( next->tag_ != TOKEN_RPARENTHESIS )
			{
				raise_error( "括弧が閉じられていません@@ %d行目", token->appear_line_ );
			}
			return create_ast_node( NODE_EXPRESSION, node );
		}

		case TOKEN_INTEGER:
		case TOKEN_REAL:
		case TOKEN_STRING:
			return create_ast_node( NODE_PRIMITIVE_VALUE, token );

		case TOKEN_OP_MUL:
		{
			unread_token( c );
			const auto label = parse_label_safe( c );
			if ( label == nullptr )
			{
				raise_error( "ラベルが正しく解析できませんでした@@ %d行目", token->appear_line_ );
			}
			raise_error( "式中にラベル型を使うことはできません@@ %d行目", token->appear_line_ );
			return label;
		}

		case TOKEN_IDENTIFIER:
		{
			unread_token( c );
			const auto expr = parse_identifier_expression( c );
			if ( expr == nullptr )
			{
				raise_error( "関数または変数を正しく解析できませんでした@@ %d行目", token->appear_line_ );
			}
			return expr;
		}
		default: break;
	}

	raise_error( "プリミティブな値を取得できません@@ %d行目[%s]", token->appear_line_, token->content_ );
	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x367d
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x16, %eax
jg 0x631a
leal -0x9(%rax), %ecx
cmpl $0x3, %ecx
jae 0x6348
movl $0x28, %edi
callq 0x21d0
movl $0x1f, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
jmp 0x6383
cmpl $0x23, %eax
jne 0x6390
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
movq %r14, %rdi
callq 0x63ea
testq %rax, %rax
jne 0x638a
movl 0x18(%rbx), %esi
leaq 0x90ec(%rip), %rdi      # 0xf42f
jmp 0x63e3
cmpl $0x6, %eax
jne 0x63bb
movq %r14, %rdi
callq 0x5ea4
movq %rax, %r15
movq %r14, %rdi
callq 0x367d
cmpl $0x7, (%rax)
jne 0x63d0
movl $0x28, %edi
callq 0x21d0
movl $0xf, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl $0x0, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x17, %eax
jne 0x63bb
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
movq %r14, %rdi
callq 0x5482
movl 0x18(%rbx), %esi
testq %rax, %rax
jne 0x63dc
leaq 0x8ff5(%rip), %rdi      # 0xf3ae
jmp 0x63e3
movl 0x18(%rbx), %esi
movq 0x8(%rbx), %rdx
leaq 0x90b1(%rip), %rdi      # 0xf47a
xorl %eax, %eax
callq 0x34a8
movl 0x18(%rbx), %esi
leaq 0x8fa4(%rip), %rdi      # 0xf37e
jmp 0x63e3
leaq 0x900a(%rip), %rdi      # 0xf3ed
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_identifier_expression(neteruhsp::parse_context_t&)
ast_node_t* parse_identifier_expression( parse_context_t& c )
{
	const auto ident = read_token( c );
	if ( ident->tag_ != TOKEN_IDENTIFIER )
	{
		unread_token( c );
		return nullptr;
	}

	const auto next = read_token( c );
	if ( next->tag_ != TOKEN_LPARENTHESIS )
	{
		unread_token( c );
		return create_ast_node( NODE_IDENTIFIER_EXPR, ident );
	}

	// 引数なしの即閉じ？
	{
		const auto nn = read_token( c );
		if ( nn->tag_ == TOKEN_RPARENTHESIS )
		{
			return create_ast_node( NODE_IDENTIFIER_EXPR, ident, create_ast_node( NODE_ARGUMENTS ) );
		}
		unread_token( c );
	}

	// 引数あり
	const auto idx = parse_arguments( c );
	const auto nn = read_token( c );
	if ( nn->tag_ != TOKEN_RPARENTHESIS )
	{
		raise_error( "関数または配列変数 : 括弧が正しく閉じられていません@@ %d行目", nn->appear_line_ );
	}

	return create_ast_node( NODE_IDENTIFIER_EXPR, ident, idx );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x367d
cmpl $0x23, (%rax)
jne 0x646a
movq %rax, %rbx
movq %r14, %rdi
callq 0x367d
cmpl $0x6, (%rax)
jne 0x647b
movq %r14, %rdi
callq 0x367d
movl (%rax), %ebp
cmpl $0x7, %ebp
jne 0x64a5
movl $0x28, %edi
callq 0x21d0
movq %rax, %r15
movl $0x4, (%rax)
movl $0x28, %edi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x14(%r15)
movl $0x20, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x20(%rax)
jmp 0x64b2
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
xorl %eax, %eax
jmp 0x64f6
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
movl $0x28, %edi
callq 0x21d0
movl $0x20, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
jmp 0x64ef
movl $0x1, %esi
movq %r14, %rdi
callq 0x36fe
cmpl $0x7, %ebp
je 0x64f6
movq %r14, %rdi
callq 0x5d32
movq %rax, %r15
movq %r14, %rdi
callq 0x367d
cmpl $0x7, (%rax)
jne 0x6501
movl $0x28, %edi
callq 0x21d0
movl $0x20, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%rax), %esi
leaq 0x8faf(%rip), %rdi      # 0xf4ba
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_variable(char const*)
variable_t* create_variable( const char* name )
{
	const auto res = reinterpret_cast<variable_t*>( xmalloc( sizeof(variable_t) ) );
	res->name_ = create_string( name );
	res->type_ = VALUE_NONE;
	res->granule_size_  = 0;
	res->length_ = 0;
	res->data_ = nullptr;
	res->data_size_ = 0;
	prepare_variable( res, VALUE_INT, 64, 16 );
	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %edi
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3a4c
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq %rax, 0x18(%r14)
movl %eax, 0x20(%r14)
movq %r14, %rdi
movl $0x1, %esi
movl $0x40, %edx
movl $0x10, %ecx
callq 0x6565
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::prepare_variable(neteruhsp::variable_t*, neteruhsp::value_tag, int, int)
void prepare_variable( variable_t* v, value_tag type, int granule_size, int length )
{
	if ( v->data_ != nullptr )
	{
		xfree( v->data_ );
		v->data_ = nullptr;
		v->data_size_ = 0;
	}

	v->type_ = type;
	v->granule_size_ = granule_size;
	v->length_ = length;

	size_t areasize = 0;
	switch( type )
	{
		case VALUE_INT:
			areasize = sizeof(int) *v->length_;
			break;
		case VALUE_DOUBLE:
			areasize = sizeof(double) *v->length_;
			break;
		case VALUE_STRING:
			areasize = sizeof(char) *v->granule_size_ *v->length_;
			break;
		default: assert( false ); break;
	}

	assert( areasize > 0 );
	v->data_ = xmalloc( areasize );
	memset( v->data_, 0, areasize );
	v->data_size_ = static_cast<int>( areasize );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x6594
callq 0x21a0
movq $0x0, 0x18(%rbx)
movl $0x0, 0x20(%rbx)
movl %r14d, 0x8(%rbx)
movl %r15d, 0xc(%rbx)
movl %ebp, 0x10(%rbx)
cmpl $0x3, %r14d
je 0x65c3
cmpl $0x2, %r14d
je 0x65ba
cmpl $0x1, %r14d
jne 0x6619
movslq %ebp, %r14
shlq $0x2, %r14
jmp 0x65cd
movslq %ebp, %r14
shlq $0x3, %r14
jmp 0x65cd
movslq %r15d, %rax
movslq %ebp, %r14
imulq %rax, %r14
testq %r14, %r14
je 0x65fa
movq %r14, %rdi
callq 0x21d0
movq %rax, 0x18(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20d0
movl %r14d, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8f54(%rip), %rdi      # 0xf555
leaq 0x72d1(%rip), %rsi      # 0xd8d9
leaq 0x8f02(%rip), %rcx      # 0xf511
movl $0xf1c, %edx            # imm = 0xF1C
callq 0x20f0
leaq 0x81d7(%rip), %rdi      # 0xe7f7
leaq 0x72b2(%rip), %rsi      # 0xd8d9
leaq 0x8ee3(%rip), %rcx      # 0xf511
movl $0xf19, %edx            # imm = 0xF19
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::destroy_variable(neteruhsp::variable_t*)
void destroy_variable( variable_t* v )
{
	xfree( v->name_ );
	xfree( v->data_ );
	v->data_size_ = 0;
	xfree( v );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x21a0
movq 0x18(%rbx), %rdi
callq 0x21a0
movl $0x0, 0x20(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::destroy_variable_table(neteruhsp::list_t*)
void destroy_variable_table( list_t* table )
{
	auto node =table->head_;
	while( node != nullptr )
	{
		const auto var =reinterpret_cast<variable_t*>( node->value_ );
		destroy_variable( var );
		node = node->next_;
	}

	list_free_all( *table );
	destroy_list( table );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x668e
movq 0x10(%r14), %rdi
callq 0x6638
movq 0x8(%r14), %r14
jmp 0x667a
movq %rbx, %rdi
callq 0x2d06
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::search_variable(neteruhsp::list_t*, char const*)
variable_t* search_variable( list_t* table, const char* name )
{
	auto node =table->head_;
	while( node != nullptr )
	{
		const auto var =reinterpret_cast<variable_t*>( node->value_ );
		if ( string_equal_igcase( var->name_, name ) )
		{ return var; }
		node = node->next_;
	}
	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x66e0
movq 0x10(%r15), %r12
movq (%r12), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2da2
testb %al, %al
je 0x66d6
movq %r12, %r14
jmp 0x66da
movq 0x8(%r15), %r15
testb %al, %al
je 0x66b3
jmp 0x66e3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_set(neteruhsp::list_t*, neteruhsp::value_t const&, char const*, int)
void variable_set( list_t* table, const value_t& v, const char* name, int idx )
{
	auto var =search_variable( table, name );
	if ( var == nullptr )
	{
		var = create_variable( name );
		auto node = create_list_node();
		node->value_ = var;
		list_append( *table, node );
	}

	variable_set( var, v, idx );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbp
testq %rbp, %rbp
je 0x673a
movq 0x10(%rbp), %r12
movq (%r12), %rdi
movq %r13, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2da2
testb %al, %al
je 0x6730
movq %r12, %rbx
jmp 0x6734
movq 0x8(%rbp), %rbp
testb %al, %al
je 0x670d
jmp 0x673c
xorl %ebx, %ebx
testq %rbx, %rbx
jne 0x676b
movq %r13, %rdi
callq 0x6512
movq %rax, %rbx
movl $0x18, %edi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2c58
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6788
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_set(neteruhsp::variable_t*, neteruhsp::value_t const&, int)
void variable_set( variable_t* var, const value_t& v, int idx )
{
	assert( var != nullptr );
	if ( var->type_ != v.type_ )
	{
		if ( idx > 0 )
		{
			raise_error( "型の異なる変数への代入@@ %s(%d)", var->name_, idx );
		}
		prepare_variable( var, v.type_, 64, 16 );
	}

	bool init_required = false;

	int granule_size = 0;
	if ( v.type_ == VALUE_STRING )
	{
		granule_size = static_cast<int>( strlen( v.svalue_ ) ) + 1;
	}
	if ( var->granule_size_ < granule_size )
	{
		init_required = true;
	}

	int len = var->length_;
	if ( idx < 0 )
	{
		raise_error( "負の添え字は無効です@@ %s(%d)", var->name_, idx );
	}
	if ( len <= idx )
	{
		raise_error( "存在しない添え字への代入@@ %s(%d)", var->name_, idx );
	}

	if ( init_required )
	{
		prepare_variable( var, v.type_, granule_size, len );
	}

	assert( var->type_ == v.type_ );
	auto data_ptr = variable_data_ptr( *var, idx );
	switch( var->type_ )
	{
		case VALUE_INT:
		{
			reinterpret_cast<int*>( data_ptr )[0] = v.ivalue_;
			break;
		}
		case VALUE_DOUBLE:
		{
			reinterpret_cast<double*>( data_ptr )[0] = v.dvalue_;
			break;
		}
		case VALUE_STRING:
		{
			strcpy( reinterpret_cast<char*>( data_ptr ), v.svalue_ );
			break;
		}
		default:
			assert( false );
			break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6853
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
je 0x67c2
testl %ebx, %ebx
jg 0x68a9
movl (%r14), %esi
movq %r15, %rdi
movl $0x40, %edx
movl $0x10, %ecx
callq 0x6565
xorl %eax, %eax
cmpl $0x3, (%r14)
jne 0x67d5
movq 0x8(%r14), %rdi
callq 0x20b0
incl %eax
testl %ebx, %ebx
js 0x6872
movl 0x10(%r15), %ecx
cmpl %ebx, %ecx
jle 0x687e
cmpl %eax, 0xc(%r15)
jge 0x67fc
movl (%r14), %esi
movq %r15, %rdi
movl %eax, %edx
callq 0x6565
movl 0x8(%r15), %eax
cmpl (%r14), %eax
jne 0x688a
movq %r15, %rdi
movl %ebx, %esi
callq 0x68db
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x6842
cmpl $0x2, %ecx
je 0x6832
cmpl $0x1, %ecx
jne 0x68bc
movl 0x8(%r14), %ecx
movl %ecx, (%rax)
jmp 0x683c
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2140
leaq 0x8d08(%rip), %rdi      # 0xf562
leaq 0x7078(%rip), %rsi      # 0xd8d9
leaq 0x8d09(%rip), %rcx      # 0xf571
movl $0xf52, %edx            # imm = 0xF52
callq 0x20f0
movq (%r15), %rsi
leaq 0x8d61(%rip), %rdi      # 0xf5dd
jmp 0x68b3
movq (%r15), %rsi
leaq 0x8d7d(%rip), %rdi      # 0xf605
jmp 0x68b3
leaq 0x8da2(%rip), %rdi      # 0xf633
leaq 0x7041(%rip), %rsi      # 0xd8d9
leaq 0x8cd2(%rip), %rcx      # 0xf571
movl $0xf77, %edx            # imm = 0xF77
callq 0x20f0
movq (%r15), %rsi
leaq 0x8cff(%rip), %rdi      # 0xf5b2
movl %ebx, %edx
xorl %eax, %eax
callq 0x34a8
leaq 0x7f34(%rip), %rdi      # 0xe7f7
leaq 0x700f(%rip), %rsi      # 0xd8d9
leaq 0x8ca0(%rip), %rcx      # 0xf571
movl $0xf8b, %edx            # imm = 0xF8B
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_data_ptr(neteruhsp::variable_t const&, int)
void* variable_data_ptr( const variable_t& v, int idx )
{
	if ( idx<0 || idx>=v.length_ )
	{
		raise_error( "変数への配列アクセスが範囲外です@@ %s(%d)", v.name_, idx );
	}

	switch( v.type_ )
	{
		case VALUE_INT:
		{
			return reinterpret_cast<int*>( v.data_ ) +idx;
		}
		case VALUE_DOUBLE:
		{
			return reinterpret_cast<double*>( v.data_ ) +idx;
		}
		case VALUE_STRING:
		{
			return reinterpret_cast<char*>( v.data_ ) + v.granule_size_ *idx;
		}
		default:
			assert( false );
			break;
	}
	return nullptr;
}

// Assembly:
pushq %rax
movl %esi, %edx
testl %esi, %esi
js 0x691a
cmpl %edx, 0x10(%rdi)
jle 0x691a
movl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0x6909
cmpl $0x2, %eax
je 0x6901
cmpl $0x1, %eax
jne 0x692b
movl %edx, %eax
shlq $0x2, %rax
jmp 0x6914
movl %edx, %eax
shlq $0x3, %rax
jmp 0x6914
movslq 0xc(%rdi), %rcx
movslq %edx, %rax
imulq %rcx, %rax
addq 0x18(%rdi), %rax
popq %rcx
retq
movq (%rdi), %rsi
leaq 0x9453(%rip), %rdi      # 0xfd77
xorl %eax, %eax
callq 0x34a8
leaq 0x7ec5(%rip), %rdi      # 0xe7f7
leaq 0x6fa0(%rip), %rsi      # 0xd8d9
leaq 0x9471(%rip), %rcx      # 0xfdb1
movl $0x10dd, %edx           # imm = 0x10DD
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_add(neteruhsp::variable_t*, neteruhsp::value_t const&, int)
void variable_add( variable_t* var, const value_t& v, int idx )
{
	assert( var != nullptr );
	if ( var->type_ != v.type_ )
	{
		raise_error( "型の異なる変数への加算代入（+=）操作@@ %s(%d)", var->name_, idx );
		return;
	}

	assert( var->type_ == v.type_ );
	auto* data_ptr = variable_data_ptr( *var, idx );
	switch( var->type_ )
	{
	case VALUE_INT:
	{
		reinterpret_cast<int*>( data_ptr )[0] += v.ivalue_;
		break;
	}
	case VALUE_DOUBLE:
	{
		reinterpret_cast<double*>( data_ptr )[0] += v.dvalue_;
		break;
	}
	case VALUE_STRING:
	{
		auto* varstr = reinterpret_cast<char*>( data_ptr );
		const auto varstrlen = static_cast<int>( strlen( varstr ) );
		const auto vstrlen = static_cast<int>( strlen( v.svalue_ ) );
		// 再確保必要？
		if ( ( varstrlen + vstrlen ) > var->granule_size_ )
		{
			if ( idx > 0 )
			{
				raise_error( "文字列変数への加算代入操作：バッファオーバーフロー@@ %s(%d)", var->name_, idx );
				return;
			}
			// 再確保してコピー
			auto* pstr = create_string( varstr );
			prepare_variable( var, VALUE_STRING, varstrlen + vstrlen + 4, 1 );
			varstr = reinterpret_cast<char*>( data_ptr );
			strcpy( varstr, pstr );
			destroy_string( pstr );
		}
		strcpy( varstr + varstrlen, v.svalue_ );
		break;
	}
	default:
		assert( false );
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6a3a
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x6a59
movq %r15, %rdi
movl %ebp, %esi
callq 0x68db
movq %rax, %r14
movl 0x8(%r15), %eax
cmpl $0x3, %eax
je 0x69bb
cmpl $0x2, %eax
je 0x699d
cmpl $0x1, %eax
jne 0x6a6c
movl 0x8(%rbx), %eax
addl %eax, (%r14)
jmp 0x69ac
movsd 0x8(%rbx), %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x20b0
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0x20b0
movq %rax, %r13
addl %r12d, %r13d
cmpl 0xc(%r15), %r13d
jle 0x6a1a
testl %ebp, %ebp
jg 0x6a8b
movq %r14, %rdi
callq 0x3a4c
movq %rax, %rbp
addl $0x4, %r13d
movq %r15, %rdi
movl $0x3, %esi
movl %r13d, %edx
movl $0x1, %ecx
callq 0x6565
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2140
movq %rbp, %rdi
callq 0x21a0
movslq %r12d, %rax
addq %rax, %r14
movq 0x8(%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2140
leaq 0x8b21(%rip), %rdi      # 0xf562
leaq 0x6e91(%rip), %rsi      # 0xd8d9
leaq 0x8bfa(%rip), %rcx      # 0xf649
movl $0xf92, %edx            # imm = 0xF92
callq 0x20f0
movq (%r15), %rsi
leaq 0x8c27(%rip), %rdi      # 0xf68a
movl %ebp, %edx
xorl %eax, %eax
callq 0x34a8
leaq 0x7d84(%rip), %rdi      # 0xe7f7
leaq 0x6e5f(%rip), %rsi      # 0xd8d9
leaq 0x8bc8(%rip), %rcx      # 0xf649
movl $0xfbf, %edx            # imm = 0xFBF
callq 0x20f0
movq (%r15), %rsi
leaq 0x8c34(%rip), %rdi      # 0xf6c9
jmp 0x6a63
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_sub(neteruhsp::variable_t*, neteruhsp::value_t const&, int)
void variable_sub( variable_t* var, const value_t& v, int idx )
{
	assert( var != nullptr );
	if ( var->type_ != v.type_ )
	{
		raise_error( "型の異なる変数への減算代入（-=）操作@@ %s(%d)", var->name_, idx );
		return;
	}

	assert( var->type_ == v.type_ );
	auto* data_ptr = variable_data_ptr( *var, idx );
	switch( var->type_ )
	{
	case VALUE_INT:
	{
		reinterpret_cast<int*>( data_ptr )[0] -= v.ivalue_;
		break;
	}
	case VALUE_DOUBLE:
	{
		reinterpret_cast<double*>( data_ptr )[0] -= v.dvalue_;
		break;
	}
	case VALUE_STRING:
	{
		raise_error( "文字列に対する減算代入（-=）操作は定義されてません@@ %s(%d)", var->name_, idx );
		break;
	}
	default:
		assert( false );
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x6ae4
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x6b03
movq %r14, %rdi
movl %ebx, %esi
callq 0x68db
movl 0x8(%r14), %ecx
cmpl $0x1, %ecx
je 0x6ad8
cmpl $0x2, %ecx
jne 0x6b0f
movsd (%rax), %xmm0
subsd 0x8(%r15), %xmm0
movsd %xmm0, (%rax)
jmp 0x6ade
movl 0x8(%r15), %ecx
subl %ecx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8a77(%rip), %rdi      # 0xf562
leaq 0x6de7(%rip), %rsi      # 0xd8d9
leaq 0x8c25(%rip), %rcx      # 0xf71e
movl $0xfc6, %edx            # imm = 0xFC6
callq 0x20f0
movq (%r14), %rsi
leaq 0x8c52(%rip), %rdi      # 0xf75f
jmp 0x6b1e
cmpl $0x3, %ecx
jne 0x6b27
movq (%r14), %rsi
leaq 0x8c80(%rip), %rdi      # 0xf79e
movl %ebx, %edx
xorl %eax, %eax
callq 0x34a8
leaq 0x7cc9(%rip), %rdi      # 0xe7f7
leaq 0x6da4(%rip), %rsi      # 0xd8d9
leaq 0x8be2(%rip), %rcx      # 0xf71e
movl $0xfe1, %edx            # imm = 0xFE1
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_mod(neteruhsp::variable_t*, neteruhsp::value_t const&, int)
void variable_mod( variable_t* var, const value_t& v, int idx )
{
	assert( var != nullptr );
	if ( var->type_ != v.type_ )
	{
		raise_error( "型の異なる変数への剰余代入（\\=）操作@@ %s(%d)", var->name_, idx );
		return;
	}

	assert( var->type_ == v.type_ );
	auto* data_ptr = variable_data_ptr( *var, idx );
	switch( var->type_ )
	{
	case VALUE_INT:
	{
		if ( v.ivalue_ == 0 )
		{
			raise_error( "0剰余が行われました@@ %s(%d)", var->name_, idx );
			break;
		}
		reinterpret_cast<int*>( data_ptr )[0] %= v.ivalue_;
		break;
	}
	case VALUE_DOUBLE:
	{
		if ( v.dvalue_ == 0.0 )
		{
			raise_error( "0.0剰余が行われました@@ %s(%d)", var->name_, idx );
			break;
		}
		auto* const vp = reinterpret_cast<double*>( data_ptr );
		vp[0] = std::fmod( vp[0], v.dvalue_ );
		break;
	}
	case VALUE_STRING:
	{
		raise_error( "文字列に対する剰余代入（\\=）操作は定義されてません@@ %s(%d)", var->name_, idx );
		break;
	}
	default:
		assert( false );
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6d50
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x6d6f
movq %r14, %rdi
movl %ebx, %esi
callq 0x68db
movq %rax, %r15
movl 0x8(%r14), %eax
cmpl $0x1, %eax
je 0x6d32
cmpl $0x2, %eax
jne 0x6d7b
movsd 0x8(%r12), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x6d21
jnp 0x6dab
movsd (%r15), %xmm0
callq 0x21f0
movsd %xmm0, (%r15)
jmp 0x6d44
movl 0x8(%r12), %ecx
testl %ecx, %ecx
je 0x6db7
movl (%r15), %eax
cltd
idivl %ecx
movl %edx, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x880b(%rip), %rdi      # 0xf562
leaq 0x6b7b(%rip), %rsi      # 0xd8d9
leaq 0x8c5b(%rip), %rcx      # 0xf9c0
movl $0x1036, %edx           # imm = 0x1036
callq 0x20f0
movq (%r14), %rsi
leaq 0x8c88(%rip), %rdi      # 0xfa01
jmp 0x6dc1
cmpl $0x3, %eax
jne 0x6d8c
movq (%r14), %rsi
leaq 0x8cde(%rip), %rdi      # 0xfa68
jmp 0x6dc1
leaq 0x7a64(%rip), %rdi      # 0xe7f7
leaq 0x6b3f(%rip), %rsi      # 0xd8d9
leaq 0x8c1f(%rip), %rcx      # 0xf9c0
movl $0x105c, %edx           # imm = 0x105C
callq 0x20f0
movq (%r14), %rsi
leaq 0x8c8b(%rip), %rdi      # 0xfa40
jmp 0x6dc1
movq (%r14), %rsi
leaq 0x8c81(%rip), %rdi      # 0xfa42
movl %ebx, %edx
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_calc_int(neteruhsp::variable_t const&, int)
int variable_calc_int( const variable_t& r, int idx )
{
	const auto* const data_ptr = variable_data_ptr( r, idx );
	switch( r.type_ )
	{
		case VALUE_INT:		return *reinterpret_cast<const int*>( data_ptr );
		case VALUE_DOUBLE:	return static_cast<int>(*reinterpret_cast<const double*>( data_ptr ));
		case VALUE_STRING:	return atoi( reinterpret_cast<const char*>( data_ptr ) );
		default:
			assert( false );
			break;
	}
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x68db
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x6fd8
cmpl $0x2, %ecx
je 0x6fd2
cmpl $0x1, %ecx
jne 0x6fe1
movl (%rax), %eax
jmp 0x6fd6
cvttsd2si (%rax), %eax
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x2250
leaq 0x780f(%rip), %rdi      # 0xe7f7
leaq 0x68ea(%rip), %rsi      # 0xd8d9
leaq 0x8df7(%rip), %rcx      # 0xfded
movl $0x10ec, %edx           # imm = 0x10EC
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_calc_double(neteruhsp::variable_t const&, int)
double variable_calc_double( const variable_t& r, int idx )
{
	const auto* const data_ptr = variable_data_ptr( r, idx );
	switch( r.type_ )
	{
		case VALUE_INT:		return static_cast<double>(*reinterpret_cast<const int*>( data_ptr ));
		case VALUE_DOUBLE:	return *reinterpret_cast<const double*>( data_ptr );
		case VALUE_STRING:	return atof( reinterpret_cast<const char*>( data_ptr ) );
		default:
			assert( false );
			break;
	}
	return 0.0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x68db
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x7027
cmpl $0x2, %ecx
je 0x7021
cmpl $0x1, %ecx
jne 0x7030
cvtsi2sdl (%rax), %xmm0
jmp 0x7025
movsd (%rax), %xmm0
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x21c0
leaq 0x77c0(%rip), %rdi      # 0xe7f7
leaq 0x689b(%rip), %rsi      # 0xd8d9
leaq 0x8de2(%rip), %rcx      # 0xfe27
movl $0x10fb, %edx           # imm = 0x10FB
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_calc_string(neteruhsp::variable_t const&, int)
char* variable_calc_string( const variable_t& r, int idx )
{
	const auto* const data_ptr = variable_data_ptr( r, idx );
	switch( r.type_ )
	{
		case VALUE_INT:		return create_string_from( *reinterpret_cast<const int*>( data_ptr ) );
		case VALUE_DOUBLE:	return create_string_from( *reinterpret_cast<const double*>( data_ptr ) );
		case VALUE_STRING:	return create_string( reinterpret_cast<const char*>( data_ptr ) );
		default:
			assert( false );
			break;
	}
	return create_string("");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x68db
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x7086
cmpl $0x2, %ecx
je 0x707f
cmpl $0x1, %ecx
jne 0x708f
movl (%rax), %edi
popq %rbx
jmp 0x523a
movsd (%rax), %xmm0
popq %rbx
jmp 0x70ae
movq %rax, %rdi
popq %rbx
jmp 0x3a4c
leaq 0x7761(%rip), %rdi      # 0xe7f7
leaq 0x683c(%rip), %rsi      # 0xd8d9
leaq 0x8dc3(%rip), %rcx      # 0xfe67
movl $0x1113, %edx           # imm = 0x1113
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::create_string_from(double)
char* create_string_from( double v )
{
	const auto len = snprintf( nullptr, 0, "%lf", v );
	auto res = create_string( len );
	sprintf( res, "%lf", v );
	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
leaq 0x9ce1(%rip), %rbx      # 0x10d9f
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movb $0x1, %al
callq 0x2270
movslq %eax, %rdi
incq %rdi
callq 0x21d0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x2080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(int)
value_t* create_value( int v )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_INT;
	res->ivalue_ = v;
	return res;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movslq 0x1029f(%rip), %rax     # 0x173a0
cmpq $0x3f, %rax
jg 0x711d
leal 0x1(%rax), %ecx
movl %ecx, 0x10290(%rip)     # 0x173a0
leaq 0x10089(%rip), %rcx     # 0x171a0
movq (%rcx,%rax,8), %rax
jmp 0x7127
movl $0x18, %edi
callq 0x21d0
movl $0x1, (%rax)
movl %ebx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(double)
value_t* create_value( double v )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_DOUBLE;
	res->dvalue_ = v;
	return res;
}

// Assembly:
pushq %rax
movslq 0x10266(%rip), %rax     # 0x173a0
cmpq $0x3f, %rax
jg 0x7156
leal 0x1(%rax), %ecx
movl %ecx, 0x10257(%rip)     # 0x173a0
leaq 0x10050(%rip), %rcx     # 0x171a0
movq (%rcx,%rax,8), %rax
jmp 0x716a
movl $0x18, %edi
movsd %xmm0, (%rsp)
callq 0x21d0
movsd (%rsp), %xmm0
movl $0x2, (%rax)
movsd %xmm0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(char const*)
value_t* create_value( const char* v )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_STRING;
	res->svalue_ = create_string( v );
	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x1021b(%rip), %rax     # 0x173a0
cmpq $0x3f, %rax
jg 0x71a1
leal 0x1(%rax), %ecx
movl %ecx, 0x1020c(%rip)     # 0x173a0
leaq 0x10005(%rip), %rcx     # 0x171a0
movq (%rcx,%rax,8), %r14
jmp 0x71ae
movl $0x18, %edi
callq 0x21d0
movq %rax, %r14
movl $0x3, (%r14)
movq %rbx, %rdi
callq 0x3a4c
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(neteruhsp::variable_t*, int)
value_t* create_value( variable_t* v, int idx )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_VARIABLE;
	res->variable_ = v;
	res->index_ = idx;
	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq 0x101c4(%rip), %rax     # 0x173a0
cmpq $0x3f, %rax
jg 0x71f8
leal 0x1(%rax), %ecx
movl %ecx, 0x101b5(%rip)     # 0x173a0
leaq 0xffae(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rax
jmp 0x7202
movl $0x18, %edi
callq 0x21d0
movl $0x4, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq