LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3619
cmpl $0x17, (%rax)
jne 0x5103
movq %rbx, %rdi
callq 0x3619
cmpl $0x23, (%rax)
jne 0x510a
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 0x5119
movl $0x1, %esi
jmp 0x510f
movl $0x2, %esi
movq %rbx, %rdi
callq 0x3669
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3619
cmpl $0x23, (%rax)
jne 0x587b
movq %rax, %rbx
movq %r14, %rdi
callq 0x3619
movl (%rax), %eax
leal -0x1a(%rax), %edx
cmpl $0x6, %eax
sete %cl
cmpl $0x9, %edx
jb 0x5882
movb 0x1d(%rbx), %dl
xorb $0x1, %dl
andb %dl, %cl
jne 0x5882
cmpl $0x5, %eax
ja 0x5899
movl $0x27, %ecx
btl %eax, %ecx
jae 0x5899
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
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 0x5891
movl $0x1, %esi
jmp 0x5887
movl $0x2, %esi
movq %r14, %rdi
callq 0x3669
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
movq %r14, %rdi
callq 0x592a
movq %rax, %r14
jmp 0x5852
// File: /workspace/github_cpp_makefile_star2_O3/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 0x59e0
testq %rax, %rax
je 0x5911
movq %rax, %rbx
movq %r14, %rdi
callq 0x3619
movl (%rax), %r15d
leal -0x1a(%r15), %ecx
cmpl $0x9, %ecx
jae 0x5919
addl $-0x15, %r15d
movq %r14, %rdi
callq 0x5aa6
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 0x5913
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%rax), %esi
leaq 0x8678(%rip), %rdi      # 0xdf9b
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5aa6
movq %rax, %r15
movl $0x28, %edi
callq 0x21d0
movq %rax, %r14
movl $0x4, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %rax, 0x18(%r14)
movl $0x0, 0x20(%r14)
movq %rbx, %rdi
callq 0x3619
cmpl $0x8, (%rax)
jne 0x59c1
xorl %r13d, %r13d
movq %r14, %rbp
movq %rbx, %rdi
callq 0x5aa6
movq %rax, %r15
movl $0x28, %edi
callq 0x21d0
movq %rax, %r12
movl $0x4, (%rax)
movq %r13, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r13, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x18(%rbp)
movq %rbx, %rdi
callq 0x3619
cmpl $0x8, (%rax)
movq %r12, %rbp
je 0x597c
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3669
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_O3/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 0x3619
cmpl $0x23, (%rax)
jne 0x5a3e
movq %rax, %rbx
movq %r14, %rdi
callq 0x3619
cmpl $0x6, (%rax)
jne 0x5a4f
movq %r14, %rdi
callq 0x5aa6
movq %rax, %r15
movq %r14, %rdi
callq 0x3619
movl (%rax), %ecx
cmpl $0x7, %ecx
jne 0x5a84
movl $0x28, %edi
callq 0x21d0
movl $0xe, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq $0x0, 0x18(%rax)
jmp 0x5a77
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
xorl %eax, %eax
jmp 0x5a7e
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
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 0x5a95
movl 0x18(%rax), %esi
leaq 0x852d(%rip), %rdi      # 0xdfc0
jmp 0x5a9f
movl 0x18(%rax), %esi
leaq 0x8924(%rip), %rdi      # 0xe3c3
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5b7e
movq %rax, %r14
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0xc, %eax
cmpl $0x2, %eax
ja 0x5b30
movq %rbx, %rdi
callq 0x5b7e
testq %rax, %rax
je 0x5b4d
movq %rax, %r13
movl (%r15), %r15d
leal -0xc(%r15), %eax
cmpl $0x3, %eax
jae 0x5b5f
addl $0x4, %r15d
movl $0x28, %edi
callq 0x21d0
movq %rax, %r12
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r13, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0xc, %eax
movq %r12, %r14
cmpl $0x3, %eax
jb 0x5acf
jmp 0x5b33
movq %r14, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3669
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x18(%r15), %esi
leaq 0x84bc(%rip), %rdi      # 0xe014
xorl %eax, %eax
callq 0x344d
leaq 0x7c1f(%rip), %rdi      # 0xd785
leaq 0x6d2c(%rip), %rsi      # 0xc899
leaq 0x84e2(%rip), %rcx      # 0xe056
movl $0xdd2, %edx            # imm = 0xDD2
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5c50
movq %rax, %r14
movl $0x4018000, %ebp        # imm = 0x4018000
movq %rbx, %rdi
callq 0x3619
movq %rax, %r12
movl (%rax), %eax
cmpl $0x1a, %eax
ja 0x5c05
btl %eax, %ebp
jae 0x5c05
movq %rbx, %rdi
callq 0x5c50
testq %rax, %rax
je 0x5c1e
movq %rax, %r15
movl (%r12), %eax
movl $0x13, %r12d
cmpl $0xf, %eax
je 0x5bdc
cmpl $0x1a, %eax
je 0x5bdc
cmpl $0x10, %eax
jne 0x5c31
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)
movq %rax, %r14
jmp 0x5b96
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3669
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r12), %esi
leaq 0x8463(%rip), %rdi      # 0xe08d
xorl %eax, %eax
callq 0x344d
leaq 0x7b4d(%rip), %rdi      # 0xd785
leaq 0x6c5a(%rip), %rsi      # 0xc899
leaq 0x848b(%rip), %rcx      # 0xe0d1
movl $0xdfc, %edx            # imm = 0xDFC
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5d28
movq %rax, %r14
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0x11, %eax
cmpl $0x3, %eax
ja 0x5cda
movq %rbx, %rdi
callq 0x5d28
testq %rax, %rax
je 0x5cf7
movq %rax, %r13
movl (%r15), %r15d
leal -0x11(%r15), %eax
cmpl $0x4, %eax
jae 0x5d09
addl $0x4, %r15d
movl $0x28, %edi
callq 0x21d0
movq %rax, %r12
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r13, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0x11, %eax
movq %r12, %r14
cmpl $0x4, %eax
jb 0x5c79
jmp 0x5cdd
movq %r14, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3669
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x18(%r15), %esi
leaq 0x8405(%rip), %rdi      # 0xe107
xorl %eax, %eax
callq 0x344d
leaq 0x7a75(%rip), %rdi      # 0xd785
leaq 0x6b82(%rip), %rsi      # 0xc899
leaq 0x8431(%rip), %rcx      # 0xe14f
movl $0xe26, %edx            # imm = 0xE26
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5e0d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0x15, %eax
cmpl $0x1, %eax
ja 0x5dba
movq %rbx, %rdi
callq 0x5e0d
testq %rax, %rax
je 0x5ddc
movq %rax, %r13
movl (%r15), %eax
movl $0x19, %ebp
cmpl $0x15, %eax
je 0x5d7a
cmpl $0x16, %eax
jne 0x5dee
movl $0x1a, %ebp
movl $0x28, %edi
callq 0x21d0
movq %rax, %r12
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r13, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0x15, %eax
movq %r12, %r14
cmpl $0x2, %eax
jb 0x5d53
jmp 0x5dbd
movq %r14, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3669
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r15), %esi
leaq 0x839d(%rip), %rdi      # 0xe184
xorl %eax, %eax
callq 0x344d
leaq 0x7990(%rip), %rdi      # 0xd785
leaq 0x6a9d(%rip), %rsi      # 0xc899
leaq 0x83c2(%rip), %rcx      # 0xe1c5
movl $0xe4c, %edx            # imm = 0xE4C
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5ee5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0x17, %eax
cmpl $0x2, %eax
ja 0x5e97
movq %rbx, %rdi
callq 0x5ee5
testq %rax, %rax
je 0x5eb4
movq %rax, %r13
movl (%r15), %r15d
leal -0x17(%r15), %eax
cmpl $0x3, %eax
jae 0x5ec6
addl $0x4, %r15d
movl $0x28, %edi
callq 0x21d0
movq %rax, %r12
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r13, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rbx, %rdi
callq 0x3619
movq %rax, %r15
movl (%rax), %eax
addl $-0x17, %eax
movq %r12, %r14
cmpl $0x3, %eax
jb 0x5e36
jmp 0x5e9a
movq %r14, %r12
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3669
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x18(%r15), %esi
leaq 0x833d(%rip), %rdi      # 0xe1fc
xorl %eax, %eax
callq 0x344d
leaq 0x78b8(%rip), %rdi      # 0xd785
leaq 0x69c5(%rip), %rsi      # 0xc899
leaq 0x8363(%rip), %rcx      # 0xe23e
movl $0xe74, %edx            # imm = 0xE74
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3619
cmpl $0x16, (%rax)
jne 0x5f25
movq %rbx, %rdi
callq 0x5f3b
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 0x3669
movq %rbx, %rdi
popq %rbx
jmp 0x5f3b
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3619
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x16, %eax
jg 0x5f77
leal -0x9(%rax), %ecx
cmpl $0x3, %ecx
jae 0x5fa5
movl $0x28, %edi
callq 0x21d0
movl $0x1f, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
jmp 0x5fe0
cmpl $0x23, %eax
jne 0x5fed
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
movq %r14, %rdi
callq 0x6047
testq %rax, %rax
jne 0x5fe7
movl 0x18(%rbx), %esi
leaq 0x8389(%rip), %rdi      # 0xe329
jmp 0x6040
cmpl $0x6, %eax
jne 0x6018
movq %r14, %rdi
callq 0x5aa6
movq %rax, %r15
movq %r14, %rdi
callq 0x3619
cmpl $0x7, (%rax)
jne 0x602d
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 0x6018
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
movq %r14, %rdi
callq 0x50be
movl 0x18(%rbx), %esi
testq %rax, %rax
jne 0x6039
leaq 0x8292(%rip), %rdi      # 0xe2a8
jmp 0x6040
movl 0x18(%rbx), %esi
movq 0x8(%rbx), %rdx
leaq 0x834e(%rip), %rdi      # 0xe374
xorl %eax, %eax
callq 0x344d
movl 0x18(%rbx), %esi
leaq 0x8241(%rip), %rdi      # 0xe278
jmp 0x6040
leaq 0x82a7(%rip), %rdi      # 0xe2e7
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x3619
cmpl $0x23, (%rax)
jne 0x60b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x3619
cmpl $0x6, (%rax)
jne 0x60c1
movq %r14, %rdi
callq 0x3619
cmpl $0x7, (%rax)
jne 0x60eb
movl $0x28, %edi
callq 0x21d0
movq %rax, %r14
movl $0x4, (%rax)
movl $0x28, %edi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x14(%r14)
movl $0x20, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x10(%rax)
jmp 0x6128
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
xorl %eax, %eax
jmp 0x6137
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
movl $0x28, %edi
callq 0x21d0
movl $0x20, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
jmp 0x6130
movl $0x1, %esi
movq %r14, %rdi
callq 0x3669
movq %r14, %rdi
callq 0x592a
movq %rax, %r15
movq %r14, %rdi
callq 0x3619
cmpl $0x7, (%rax)
jne 0x613d
movl $0x28, %edi
callq 0x21d0
movl $0x20, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%rax), %esi
leaq 0x826d(%rip), %rdi      # 0xe3b4
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3992
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 0x61a1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61d0
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 0x61ff
cmpl $0x2, %r14d
je 0x61f6
cmpl $0x1, %r14d
jne 0x624d
movslq %ebp, %r14
shlq $0x2, %r14
jmp 0x6209
movslq %ebp, %r14
shlq $0x3, %r14
jmp 0x6209
movslq %r15d, %rax
movslq %ebp, %r14
imulq %rax, %r14
testq %r14, %r14
je 0x622e
movl $0x1, %edi
movq %r14, %rsi
callq 0x20f0
movq %rax, 0x18(%rbx)
movl %r14d, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x821a(%rip), %rdi      # 0xe44f
leaq 0x665d(%rip), %rsi      # 0xc899
leaq 0x81c8(%rip), %rcx      # 0xe40b
movl $0xf1c, %edx            # imm = 0xF1C
callq 0x20e0
leaq 0x7531(%rip), %rdi      # 0xd785
leaq 0x663e(%rip), %rsi      # 0xc899
leaq 0x81a9(%rip), %rcx      # 0xe40b
movl $0xf19, %edx            # imm = 0xF19
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62b7
movq 0x10(%r14), %rdi
callq 0x626c
movq 0x8(%r14), %r14
jmp 0x62a3
movq %rbx, %rdi
callq 0x2c8a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x62ff
movq %rsi, %rbx
movq 0x10(%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2d26
testb %al, %al
jne 0x6302
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x62de
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
callq 0x62ce
movq %rax, %r12
testq %rax, %rax
jne 0x6358
movq %r13, %rdi
callq 0x614e
movq %rax, %r12
movl $0x1, %edi
movl $0x18, %esi
callq 0x20f0
movq %r12, 0x10(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2be3
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x636e
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6445
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %ebp
movl (%rsi), %esi
cmpl %esi, %ebp
je 0x63ac
testl %ebx, %ebx
jg 0x649b
movq %r15, %rdi
movl $0x40, %edx
movl $0x10, %ecx
callq 0x61a1
movl (%r14), %ebp
xorl %eax, %eax
cmpl $0x3, %ebp
jne 0x63be
movq 0x8(%r14), %rdi
callq 0x20b0
incl %eax
testl %ebx, %ebx
js 0x6464
movl 0x10(%r15), %ecx
cmpl %ebx, %ecx
jle 0x6470
cmpl %eax, 0xc(%r15)
jge 0x63e7
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x61a1
movl (%r14), %ebp
cmpl %ebp, 0x8(%r15)
jne 0x647c
movq %r15, %rdi
movl %ebx, %esi
callq 0x64cd
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x642f
cmpl $0x2, %ecx
je 0x641a
cmpl $0x1, %ecx
jne 0x64ae
movl 0x8(%r14), %ecx
movl %ecx, (%rax)
jmp 0x6424
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2140
leaq 0x8010(%rip), %rdi      # 0xe45c
leaq 0x6446(%rip), %rsi      # 0xc899
leaq 0x8011(%rip), %rcx      # 0xe46b
movl $0xf52, %edx            # imm = 0xF52
callq 0x20e0
movq (%r15), %rsi
leaq 0x8069(%rip), %rdi      # 0xe4d7
jmp 0x64a5
movq (%r15), %rsi
leaq 0x8085(%rip), %rdi      # 0xe4ff
jmp 0x64a5
leaq 0x80aa(%rip), %rdi      # 0xe52d
leaq 0x640f(%rip), %rsi      # 0xc899
leaq 0x7fda(%rip), %rcx      # 0xe46b
movl $0xf77, %edx            # imm = 0xF77
callq 0x20e0
movq (%r15), %rsi
leaq 0x8007(%rip), %rdi      # 0xe4ac
movl %ebx, %edx
xorl %eax, %eax
callq 0x344d
leaq 0x72d0(%rip), %rdi      # 0xd785
leaq 0x63dd(%rip), %rsi      # 0xc899
leaq 0x7fa8(%rip), %rcx      # 0xe46b
movl $0xf8b, %edx            # imm = 0xF8B
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x650c
cmpl %edx, 0x10(%rdi)
jle 0x650c
movl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0x64fb
cmpl $0x2, %eax
je 0x64f3
cmpl $0x1, %eax
jne 0x651d
movl %edx, %eax
shlq $0x2, %rax
jmp 0x6506
movl %edx, %eax
shlq $0x3, %rax
jmp 0x6506
movslq 0xc(%rdi), %rcx
movslq %edx, %rax
imulq %rcx, %rax
addq 0x18(%rdi), %rax
popq %rcx
retq
movq (%rdi), %rsi
leaq 0x875b(%rip), %rdi      # 0xec71
xorl %eax, %eax
callq 0x344d
leaq 0x7261(%rip), %rdi      # 0xd785
leaq 0x636e(%rip), %rsi      # 0xc899
leaq 0x8779(%rip), %rcx      # 0xecab
movl $0x10dd, %edx           # imm = 0x10DD
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x663a
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x6659
movq %r15, %rdi
movl %ebp, %esi
callq 0x64cd
movq %rax, %r14
movl 0x8(%r15), %eax
cmpl $0x3, %eax
je 0x65ad
cmpl $0x2, %eax
je 0x658f
cmpl $0x1, %eax
jne 0x666c
movl 0x8(%rbx), %eax
addl %eax, (%r14)
jmp 0x659e
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, (%rsp)
movq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x20b0
movq %rax, %r13
movq (%rsp), %rax
addl %eax, %r13d
cmpl 0xc(%r15), %r13d
jle 0x661c
testl %ebp, %ebp
jg 0x668b
movq %r14, %rdi
callq 0x3992
movq %rax, %r12
addl $0x4, %r13d
movq %r15, %rdi
movl $0x3, %esi
movl %r13d, %edx
movl $0x1, %ecx
callq 0x61a1
movq %r14, %rdi
movq %r12, %rsi
callq 0x2140
movq %r12, %rdi
callq 0x21a0
movq 0x8(%rbx), %r12
movq (%rsp), %rax
cltq
addq %rax, %r14
movq %r14, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2140
leaq 0x7e1b(%rip), %rdi      # 0xe45c
leaq 0x6251(%rip), %rsi      # 0xc899
leaq 0x7ef4(%rip), %rcx      # 0xe543
movl $0xf92, %edx            # imm = 0xF92
callq 0x20e0
movq (%r15), %rsi
leaq 0x7f21(%rip), %rdi      # 0xe584
movl %ebp, %edx
xorl %eax, %eax
callq 0x344d
leaq 0x7112(%rip), %rdi      # 0xd785
leaq 0x621f(%rip), %rsi      # 0xc899
leaq 0x7ec2(%rip), %rcx      # 0xe543
movl $0xfbf, %edx            # imm = 0xFBF
callq 0x20e0
movq (%r15), %rsi
leaq 0x7f2e(%rip), %rdi      # 0xe5c3
jmp 0x6663
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66e4
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x6703
movq %r14, %rdi
movl %ebx, %esi
callq 0x64cd
movl 0x8(%r14), %ecx
cmpl $0x1, %ecx
je 0x66d8
cmpl $0x2, %ecx
jne 0x670f
movsd (%rax), %xmm0
subsd 0x8(%r15), %xmm0
movsd %xmm0, (%rax)
jmp 0x66de
movl 0x8(%r15), %ecx
subl %ecx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7d71(%rip), %rdi      # 0xe45c
leaq 0x61a7(%rip), %rsi      # 0xc899
leaq 0x7f1f(%rip), %rcx      # 0xe618
movl $0xfc6, %edx            # imm = 0xFC6
callq 0x20e0
movq (%r14), %rsi
leaq 0x7f4c(%rip), %rdi      # 0xe659
jmp 0x671e
cmpl $0x3, %ecx
jne 0x6727
movq (%r14), %rsi
leaq 0x7f7a(%rip), %rdi      # 0xe698
movl %ebx, %edx
xorl %eax, %eax
callq 0x344d
leaq 0x7057(%rip), %rdi      # 0xd785
leaq 0x6164(%rip), %rsi      # 0xc899
leaq 0x7edc(%rip), %rcx      # 0xe618
movl $0xfe1, %edx            # imm = 0xFE1
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6950
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x696f
movq %r14, %rdi
movl %ebx, %esi
callq 0x64cd
movq %rax, %r15
movl 0x8(%r14), %eax
cmpl $0x1, %eax
je 0x6932
cmpl $0x2, %eax
jne 0x697b
movsd 0x8(%r12), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x6921
jnp 0x69ab
movsd (%r15), %xmm0
callq 0x21f0
movsd %xmm0, (%r15)
jmp 0x6944
movl 0x8(%r12), %ecx
testl %ecx, %ecx
je 0x69b7
movl (%r15), %eax
cltd
idivl %ecx
movl %edx, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7b05(%rip), %rdi      # 0xe45c
leaq 0x5f3b(%rip), %rsi      # 0xc899
leaq 0x7f55(%rip), %rcx      # 0xe8ba
movl $0x1036, %edx           # imm = 0x1036
callq 0x20e0
movq (%r14), %rsi
leaq 0x7f82(%rip), %rdi      # 0xe8fb
jmp 0x69c1
cmpl $0x3, %eax
jne 0x698c
movq (%r14), %rsi
leaq 0x7fd8(%rip), %rdi      # 0xe962
jmp 0x69c1
leaq 0x6df2(%rip), %rdi      # 0xd785
leaq 0x5eff(%rip), %rsi      # 0xc899
leaq 0x7f19(%rip), %rcx      # 0xe8ba
movl $0x105c, %edx           # imm = 0x105C
callq 0x20e0
movq (%r14), %rsi
leaq 0x7f85(%rip), %rdi      # 0xe93a
jmp 0x69c1
movq (%r14), %rsi
leaq 0x7f7b(%rip), %rdi      # 0xe93c
movl %ebx, %edx
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64cd
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x6bd8
cmpl $0x2, %ecx
je 0x6bd2
cmpl $0x1, %ecx
jne 0x6be1
movl (%rax), %eax
jmp 0x6bd6
cvttsd2si (%rax), %eax
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x2250
leaq 0x6b9d(%rip), %rdi      # 0xd785
leaq 0x5caa(%rip), %rsi      # 0xc899
leaq 0x80f1(%rip), %rcx      # 0xece7
movl $0x10ec, %edx           # imm = 0x10EC
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64cd
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x6c27
cmpl $0x2, %ecx
je 0x6c21
cmpl $0x1, %ecx
jne 0x6c30
cvtsi2sdl (%rax), %xmm0
jmp 0x6c25
movsd (%rax), %xmm0
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x21c0
leaq 0x6b4e(%rip), %rdi      # 0xd785
leaq 0x5c5b(%rip), %rsi      # 0xc899
leaq 0x80dc(%rip), %rcx      # 0xed21
movl $0x10fb, %edx           # imm = 0x10FB
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64cd
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x6c86
cmpl $0x2, %ecx
je 0x6c7f
cmpl $0x1, %ecx
jne 0x6c8f
movl (%rax), %edi
popq %rbx
jmp 0x4e83
movsd (%rax), %xmm0
popq %rbx
jmp 0x6cae
movq %rax, %rdi
popq %rbx
jmp 0x3992
leaq 0x6aef(%rip), %rdi      # 0xd785
leaq 0x5bfc(%rip), %rsi      # 0xc899
leaq 0x80bd(%rip), %rcx      # 0xed61
movl $0x1113, %edx           # imm = 0x1113
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8fdb(%rip), %rbx      # 0xfc99
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_O3/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 0xf69f(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x6d1d
leal 0x1(%rax), %ecx
movl %ecx, 0xf690(%rip)      # 0x163a0
leaq 0xf489(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rax
jmp 0x6d27
movl $0x18, %edi
callq 0x21d0
movl $0x1, (%rax)
movl %ebx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf666(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x6d56
leal 0x1(%rax), %ecx
movl %ecx, 0xf657(%rip)      # 0x163a0
leaq 0xf450(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rax
jmp 0x6d6a
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_O3/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 0xf61b(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x6da1
leal 0x1(%rax), %ecx
movl %ecx, 0xf60c(%rip)      # 0x163a0
leaq 0xf405(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %r14
jmp 0x6dae
movl $0x18, %edi
callq 0x21d0
movq %rax, %r14
movl $0x3, (%r14)
movq %rbx, %rdi
callq 0x3992
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf5c4(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x6df8
leal 0x1(%rax), %ecx
movl %ecx, 0xf5b5(%rip)      # 0x163a0
leaq 0xf3ae(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rax
jmp 0x6e02
movl $0x18, %edi
callq 0x21d0
movl $0x4, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(neteruhsp::value_t const&)
value_t* create_value( const value_t& v )
{
	value_t* res =alloc_value();
	res->type_ = v.type_;
	switch( v.type_ )
	{
		case VALUE_INT:			res->ivalue_ =v.ivalue_; break;
		case VALUE_DOUBLE:		res->dvalue_ =v.dvalue_; break;
		case VALUE_STRING:		res->svalue_ =create_string(v.svalue_); break;
		case VALUE_VARIABLE:	res->variable_ =v.variable_; res->index_ =v.index_; break;
		default: raise_error( "中身が入ってない値をコピーして作ろうとしました@@ ptr=%p", &v );
	}
	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0xf57b(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x6e41
leal 0x1(%rax), %ecx
movl %ecx, 0xf56c(%rip)      # 0x163a0
leaq 0xf365(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %r14
jmp 0x6e4e
movl $0x18, %edi
callq 0x21d0
movq %rax, %r14
movl (%rbx), %eax
movl %eax, (%r14)
decl %eax
cmpl $0x3, %eax
ja 0x6ea9
leaq 0x5577(%rip), %rcx      # 0xc3d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
jmp 0x6e9e
movq 0x8(%rbx), %rdi
callq 0x3992
movq %rax, 0x8(%r14)
jmp 0x6e9e
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
jmp 0x6e9e
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7ef0(%rip), %rdi      # 0xeda0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x344d