LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
callq 0x4fd8
testq %rax, %rax
je 0x4f3a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3416
movl (%rax), %r15d
leal -0x1a(%r15), %ecx
cmpl $0x9, %ecx
jae 0x4f42
addl $-0x15, %r15d
movq %rbx, %rdi
callq 0x5071
movl %r15d, %edi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x48d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%rax), %esi
leaq 0x804f(%rip), %rdi      # 0xcf9b
xorl %eax, %eax
callq 0x326e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5071
pushq $0x4
popq %rbp
movl %ebp, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x48d0
movq %rax, %r14
movq %rax, %r15
movq %rbx, %rdi
callq 0x3416
cmpl $0x8, (%rax)
jne 0x4fbf
movq %rbx, %rdi
callq 0x5071
movl %ebp, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x48d0
movq %rax, 0x18(%r15)
jmp 0x4f95
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x345a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3416
cmpl $0x23, (%rax)
jne 0x501f
movq %rax, %rbx
movq %r14, %rdi
callq 0x3416
cmpl $0x6, (%rax)
jne 0x5032
movq %r14, %rdi
callq 0x5071
movq %rax, %r15
movq %r14, %rdi
callq 0x3416
movl (%rax), %ecx
cmpl $0x7, %ecx
jne 0x504f
pushq $0xe
popq %rdi
movq %rbx, %rsi
movq %r15, %rdx
jmp 0x5045
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x345a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x345a
pushq $0xe
popq %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x48fc
cmpl $0x8, %ecx
jne 0x5060
movl 0x18(%rax), %esi
leaq 0x7f62(%rip), %rdi      # 0xcfc0
jmp 0x506a
movl 0x18(%rax), %esi
leaq 0x8359(%rip), %rdi      # 0xd3c3
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x5103
movq %rax, %r14
movq %rbx, %rdi
callq 0x3416
movq %rax, %r15
movl (%rax), %eax
addl $-0xc, %eax
cmpl $0x2, %eax
ja 0x50be
movq %rbx, %rdi
callq 0x5103
testq %rax, %rax
je 0x50d2
movl (%r15), %edi
leal -0xc(%rdi), %ecx
cmpl $0x3, %ecx
jae 0x50e4
addl $0x4, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x48d0
jmp 0x507e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x345a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%r15), %esi
leaq 0x7f37(%rip), %rdi      # 0xd014
xorl %eax, %eax
callq 0x326e
leaq 0x769a(%rip), %rdi      # 0xc785
leaq 0x67a7(%rip), %rsi      # 0xb899
leaq 0x7f5d(%rip), %rcx      # 0xd056
movl $0xdd2, %edx            # imm = 0xDD2
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x51c3
movq %rax, %r14
movl $0x4018000, %ebp        # imm = 0x4018000
pushq $0x13
popq %r12
pushq $0x14
popq %r13
movq %rbx, %rdi
callq 0x3416
movq %rax, %r15
movl (%rax), %eax
cmpl $0x1a, %eax
ja 0x5175
btl %eax, %ebp
jae 0x5175
movq %rbx, %rdi
callq 0x51c3
testq %rax, %rax
je 0x5192
movl (%r15), %ecx
movl %r12d, %edi
cmpl $0xf, %ecx
je 0x5165
movl %r12d, %edi
cmpl $0x1a, %ecx
je 0x5165
cmpl $0x10, %ecx
jne 0x51a4
movl %r13d, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x48d0
movq %rax, %r14
jmp 0x5126
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x345a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r15), %esi
leaq 0x7ef0(%rip), %rdi      # 0xd08d
xorl %eax, %eax
callq 0x326e
leaq 0x75da(%rip), %rdi      # 0xc785
leaq 0x66e7(%rip), %rsi      # 0xb899
leaq 0x7f18(%rip), %rcx      # 0xd0d1
movl $0xdfc, %edx            # imm = 0xDFC
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x5255
movq %rax, %r14
movq %rbx, %rdi
callq 0x3416
movq %rax, %r15
movl (%rax), %eax
addl $-0x11, %eax
cmpl $0x3, %eax
ja 0x5210
movq %rbx, %rdi
callq 0x5255
testq %rax, %rax
je 0x5224
movl (%r15), %edi
leal -0x11(%rdi), %ecx
cmpl $0x4, %ecx
jae 0x5236
addl $0x4, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x48d0
jmp 0x51d0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x345a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%r15), %esi
leaq 0x7ed8(%rip), %rdi      # 0xd107
xorl %eax, %eax
callq 0x326e
leaq 0x7548(%rip), %rdi      # 0xc785
leaq 0x6655(%rip), %rsi      # 0xb899
leaq 0x7f04(%rip), %rcx      # 0xd14f
movl $0xe26, %edx            # imm = 0xE26
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52fb
movq %rax, %r14
pushq $0x19
popq %rbp
pushq $0x1a
popq %r12
movq %rbx, %rdi
callq 0x3416
movq %rax, %r15
movl (%rax), %eax
addl $-0x15, %eax
cmpl $0x1, %eax
ja 0x52b3
movq %rbx, %rdi
callq 0x52fb
testq %rax, %rax
je 0x52ca
movl (%r15), %ecx
movl %ebp, %edi
cmpl $0x15, %ecx
je 0x52a3
cmpl $0x16, %ecx
jne 0x52dc
movl %r12d, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x48d0
movq %rax, %r14
jmp 0x526f
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x345a
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r15), %esi
leaq 0x7eaf(%rip), %rdi      # 0xd184
xorl %eax, %eax
callq 0x326e
leaq 0x74a2(%rip), %rdi      # 0xc785
leaq 0x65af(%rip), %rsi      # 0xb899
leaq 0x7ed4(%rip), %rcx      # 0xd1c5
movl $0xe4c, %edx            # imm = 0xE4C
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x538d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3416
movq %rax, %r15
movl (%rax), %eax
addl $-0x17, %eax
cmpl $0x2, %eax
ja 0x5348
movq %rbx, %rdi
callq 0x538d
testq %rax, %rax
je 0x535c
movl (%r15), %edi
leal -0x17(%rdi), %ecx
cmpl $0x3, %ecx
jae 0x536e
addl $0x4, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x48d0
jmp 0x5308
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x345a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x18(%r15), %esi
leaq 0x7e95(%rip), %rdi      # 0xd1fc
xorl %eax, %eax
callq 0x326e
leaq 0x7410(%rip), %rdi      # 0xc785
leaq 0x651d(%rip), %rsi      # 0xb899
leaq 0x7ebb(%rip), %rcx      # 0xd23e
movl $0xe74, %edx            # imm = 0xE74
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3416
cmpl $0x16, (%rax)
jne 0x53b1
movq %rbx, %rdi
callq 0x53c5
pushq $0x1e
popq %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
jmp 0x48d0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x345a
movq %rbx, %rdi
popq %rbx
jmp 0x53c5
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3416
movq %rax, %rbx
movl (%rax), %eax
leal -0x9(%rax), %ecx
cmpl $0x3, %ecx
jae 0x53f1
pushq $0x1f
popq %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x48fc
cmpl $0x6, %eax
je 0x5419
cmpl $0x23, %eax
jne 0x5443
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x345a
movq %r14, %rdi
callq 0x54a7
testq %rax, %rax
je 0x5478
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x5071
movq %rax, %r15
movq %r14, %rdi
callq 0x3416
cmpl $0x7, (%rax)
jne 0x546c
pushq $0xf
popq %rdi
movq %r15, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x48d0
cmpl $0x17, %eax
jne 0x5484
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x345a
movq %r14, %rdi
callq 0x4a8b
movl 0x18(%rbx), %esi
testq %rax, %rax
jne 0x5499
leaq 0x7e3e(%rip), %rdi      # 0xd2a8
jmp 0x54a0
movl 0x18(%rbx), %esi
leaq 0x7e02(%rip), %rdi      # 0xd278
jmp 0x54a0
movl 0x18(%rbx), %esi
leaq 0x7ea7(%rip), %rdi      # 0xd329
jmp 0x54a0
movl 0x18(%rbx), %esi
movq 0x8(%rbx), %rdx
leaq 0x7ee2(%rip), %rdi      # 0xd374
xorl %eax, %eax
callq 0x326e
leaq 0x7e47(%rip), %rdi      # 0xd2e7
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3416
cmpl $0x23, (%rax)
jne 0x54ed
movq %rax, %rbx
movq %r14, %rdi
callq 0x3416
cmpl $0x6, (%rax)
jne 0x5500
movq %r14, %rdi
callq 0x3416
cmpl $0x7, (%rax)
jne 0x5515
pushq $0x4
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x48d0
pushq $0x20
popq %rdi
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x5541
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x345a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x345a
pushq $0x20
popq %rdi
movq %rbx, %rsi
xorl %edx, %edx
jmp 0x5541
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x345a
movq %r14, %rdi
callq 0x4f74
movq %rax, %r15
movq %r14, %rdi
callq 0x3416
cmpl $0x7, (%rax)
jne 0x554b
pushq $0x20
popq %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x48fc
movl 0x18(%rax), %esi
leaq 0x7e5f(%rip), %rdi      # 0xd3b4
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x36e9
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
andl $0x0, 0x10(%r14)
andq $0x0, 0x18(%r14)
andl $0x0, 0x20(%r14)
pushq $0x1
popq %rsi
pushq $0x40
popq %rdx
pushq $0x10
popq %rcx
movq %r14, %rdi
callq 0x55a9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55d2
callq 0x21a0
andq $0x0, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movl %r14d, 0x8(%rbx)
movl %r15d, 0xc(%rbx)
movl %ebp, 0x10(%rbx)
cmpl $0x3, %r14d
je 0x5601
cmpl $0x2, %r14d
je 0x55f8
cmpl $0x1, %r14d
jne 0x564d
movslq %ebp, %r14
shlq $0x2, %r14
jmp 0x560b
movslq %ebp, %r14
shlq $0x3, %r14
jmp 0x560b
movslq %r15d, %rax
movslq %ebp, %r14
imulq %rax, %r14
testq %r14, %r14
je 0x562e
pushq $0x1
popq %rdi
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 0x7e1a(%rip), %rdi      # 0xd44f
leaq 0x625d(%rip), %rsi      # 0xb899
leaq 0x7dc8(%rip), %rcx      # 0xd40b
movl $0xf1c, %edx            # imm = 0xF1C
callq 0x20e0
leaq 0x7131(%rip), %rdi      # 0xc785
leaq 0x623e(%rip), %rsi      # 0xb899
leaq 0x7da9(%rip), %rcx      # 0xd40b
movl $0xf19, %edx            # imm = 0xF19
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rbx, %rdi
popq %rbx
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%r14), %r14
testq %r14, %r14
je 0x56b0
movq 0x10(%r14), %rdi
callq 0x566c
addq $0x8, %r14
jmp 0x5699
movq %rbx, %rdi
callq 0x2b90
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %rbp
movq (%r14), %r14
testq %r14, %r14
je 0x56fa
movq 0x10(%r14), %r15
movq (%r15), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2c0b
addq $0x8, %r14
testb %al, %al
je 0x56d7
jmp 0x56fd
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x56c7
movq %rax, %r12
testq %rax, %rax
jne 0x574e
movq %r13, %rdi
callq 0x555c
movq %rax, %r12
callq 0x29e2
movq %r12, 0x10(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2b03
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5764
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5837
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %ebp
movl (%rsi), %esi
cmpl %esi, %ebp
je 0x579e
testl %ebx, %ebx
jg 0x588d
pushq $0x40
popq %rdx
pushq $0x10
popq %rcx
movq %r15, %rdi
callq 0x55a9
movl (%r14), %ebp
xorl %eax, %eax
cmpl $0x3, %ebp
jne 0x57b0
movq 0x8(%r14), %rdi
callq 0x20b0
incl %eax
testl %ebx, %ebx
js 0x5856
movl 0x10(%r15), %ecx
cmpl %ebx, %ecx
jle 0x5862
cmpl %eax, 0xc(%r15)
jge 0x57d9
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x55a9
movl (%r14), %ebp
cmpl %ebp, 0x8(%r15)
jne 0x586e
movq %r15, %rdi
movl %ebx, %esi
callq 0x58bf
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x5821
cmpl $0x2, %ecx
je 0x580c
cmpl $0x1, %ecx
jne 0x58a0
movl 0x8(%r14), %ecx
movl %ecx, (%rax)
jmp 0x5816
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 0x7c1e(%rip), %rdi      # 0xd45c
leaq 0x6054(%rip), %rsi      # 0xb899
leaq 0x7c1f(%rip), %rcx      # 0xd46b
movl $0xf52, %edx            # imm = 0xF52
callq 0x20e0
movq (%r15), %rsi
leaq 0x7c77(%rip), %rdi      # 0xd4d7
jmp 0x5897
movq (%r15), %rsi
leaq 0x7c93(%rip), %rdi      # 0xd4ff
jmp 0x5897
leaq 0x7cb8(%rip), %rdi      # 0xd52d
leaq 0x601d(%rip), %rsi      # 0xb899
leaq 0x7be8(%rip), %rcx      # 0xd46b
movl $0xf77, %edx            # imm = 0xF77
callq 0x20e0
movq (%r15), %rsi
leaq 0x7c15(%rip), %rdi      # 0xd4ac
movl %ebx, %edx
xorl %eax, %eax
callq 0x326e
leaq 0x6ede(%rip), %rdi      # 0xc785
leaq 0x5feb(%rip), %rsi      # 0xb899
leaq 0x7bb6(%rip), %rcx      # 0xd46b
movl $0xf8b, %edx            # imm = 0xF8B
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x58fe
cmpl %edx, 0x10(%rdi)
jle 0x58fe
movl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0x58ed
cmpl $0x2, %eax
je 0x58e5
cmpl $0x1, %eax
jne 0x590f
movl %edx, %eax
shlq $0x2, %rax
jmp 0x58f8
movl %edx, %eax
shlq $0x3, %rax
jmp 0x58f8
movslq 0xc(%rdi), %rcx
movslq %edx, %rax
imulq %rcx, %rax
addq 0x18(%rdi), %rax
popq %rcx
retq
movq (%rdi), %rsi
leaq 0x8369(%rip), %rdi      # 0xdc71
xorl %eax, %eax
callq 0x326e
leaq 0x6e6f(%rip), %rdi      # 0xc785
leaq 0x5f7c(%rip), %rsi      # 0xb899
leaq 0x8387(%rip), %rcx      # 0xdcab
movl $0x10dd, %edx           # imm = 0x10DD
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5a28
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x5a47
movq %r15, %rdi
movl %ebp, %esi
callq 0x58bf
movq %rax, %r14
movl 0x8(%r15), %eax
cmpl $0x3, %eax
je 0x599f
cmpl $0x2, %eax
je 0x5981
cmpl $0x1, %eax
jne 0x5a5a
movl 0x8(%rbx), %eax
addl %eax, (%r14)
jmp 0x5990
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 0x5a0a
testl %ebp, %ebp
jg 0x5a79
movq %r14, %rdi
callq 0x36e9
movq %rax, %r12
addl $0x4, %r13d
pushq $0x3
popq %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
movl %r13d, %edx
callq 0x55a9
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 0x7a2d(%rip), %rdi      # 0xd45c
leaq 0x5e63(%rip), %rsi      # 0xb899
leaq 0x7b06(%rip), %rcx      # 0xd543
movl $0xf92, %edx            # imm = 0xF92
callq 0x20e0
movq (%r15), %rsi
leaq 0x7b33(%rip), %rdi      # 0xd584
movl %ebp, %edx
xorl %eax, %eax
callq 0x326e
leaq 0x6d24(%rip), %rdi      # 0xc785
leaq 0x5e31(%rip), %rsi      # 0xb899
leaq 0x7ad4(%rip), %rcx      # 0xd543
movl $0xfbf, %edx            # imm = 0xFBF
callq 0x20e0
movq (%r15), %rsi
leaq 0x7b40(%rip), %rdi      # 0xd5c3
jmp 0x5a51
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5ad2
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x5af1
movq %r14, %rdi
movl %ebx, %esi
callq 0x58bf
movl 0x8(%r14), %ecx
cmpl $0x1, %ecx
je 0x5ac6
cmpl $0x2, %ecx
jne 0x5afd
movsd (%rax), %xmm0
subsd 0x8(%r15), %xmm0
movsd %xmm0, (%rax)
jmp 0x5acc
movl 0x8(%r15), %ecx
subl %ecx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7983(%rip), %rdi      # 0xd45c
leaq 0x5db9(%rip), %rsi      # 0xb899
leaq 0x7b31(%rip), %rcx      # 0xd618
movl $0xfc6, %edx            # imm = 0xFC6
callq 0x20e0
movq (%r14), %rsi
leaq 0x7b5e(%rip), %rdi      # 0xd659
jmp 0x5b0c
cmpl $0x3, %ecx
jne 0x5b15
movq (%r14), %rsi
leaq 0x7b8c(%rip), %rdi      # 0xd698
movl %ebx, %edx
xorl %eax, %eax
callq 0x326e
leaq 0x6c69(%rip), %rdi      # 0xc785
leaq 0x5d76(%rip), %rsi      # 0xb899
leaq 0x7aee(%rip), %rcx      # 0xd618
movl $0xfe1, %edx            # imm = 0xFE1
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d3e
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl (%rsi), %eax
jne 0x5d5d
movq %r14, %rdi
movl %ebx, %esi
callq 0x58bf
movq %rax, %r15
movl 0x8(%r14), %eax
cmpl $0x1, %eax
je 0x5d20
cmpl $0x2, %eax
jne 0x5d69
movsd 0x8(%r12), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x5d0f
jnp 0x5d99
movsd (%r15), %xmm0
callq 0x21f0
movsd %xmm0, (%r15)
jmp 0x5d32
movl 0x8(%r12), %ecx
testl %ecx, %ecx
je 0x5da5
movl (%r15), %eax
cltd
idivl %ecx
movl %edx, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7717(%rip), %rdi      # 0xd45c
leaq 0x5b4d(%rip), %rsi      # 0xb899
leaq 0x7b67(%rip), %rcx      # 0xd8ba
movl $0x1036, %edx           # imm = 0x1036
callq 0x20e0
movq (%r14), %rsi
leaq 0x7b94(%rip), %rdi      # 0xd8fb
jmp 0x5daf
cmpl $0x3, %eax
jne 0x5d7a
movq (%r14), %rsi
leaq 0x7bea(%rip), %rdi      # 0xd962
jmp 0x5daf
leaq 0x6a04(%rip), %rdi      # 0xc785
leaq 0x5b11(%rip), %rsi      # 0xb899
leaq 0x7b2b(%rip), %rcx      # 0xd8ba
movl $0x105c, %edx           # imm = 0x105C
callq 0x20e0
movq (%r14), %rsi
leaq 0x7b97(%rip), %rdi      # 0xd93a
jmp 0x5daf
movq (%r14), %rsi
leaq 0x7b8d(%rip), %rdi      # 0xd93c
movl %ebx, %edx
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x58bf
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x5fc6
cmpl $0x2, %ecx
je 0x5fc0
cmpl $0x1, %ecx
jne 0x5fcf
movl (%rax), %eax
jmp 0x5fc4
cvttsd2si (%rax), %eax
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x2250
leaq 0x67af(%rip), %rdi      # 0xc785
leaq 0x58bc(%rip), %rsi      # 0xb899
leaq 0x7d03(%rip), %rcx      # 0xdce7
movl $0x10ec, %edx           # imm = 0x10EC
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x58bf
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x6015
cmpl $0x2, %ecx
je 0x600f
cmpl $0x1, %ecx
jne 0x601e
cvtsi2sdl (%rax), %xmm0
jmp 0x6013
movsd (%rax), %xmm0
popq %rbx
retq
movq %rax, %rdi
popq %rbx
jmp 0x21c0
leaq 0x6760(%rip), %rdi      # 0xc785
leaq 0x586d(%rip), %rsi      # 0xb899
leaq 0x7cee(%rip), %rcx      # 0xdd21
movl $0x10fb, %edx           # imm = 0x10FB
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x58bf
movl 0x8(%rbx), %ecx
cmpl $0x3, %ecx
je 0x6074
cmpl $0x2, %ecx
je 0x606d
cmpl $0x1, %ecx
jne 0x607d
movl (%rax), %edi
popq %rbx
jmp 0x488f
movsd (%rax), %xmm0
popq %rbx
jmp 0x609c
movq %rax, %rdi
popq %rbx
jmp 0x36e9
leaq 0x6701(%rip), %rdi      # 0xc785
leaq 0x580e(%rip), %rsi      # 0xb899
leaq 0x7ccf(%rip), %rcx      # 0xdd61
movl $0x1113, %edx           # imm = 0x1113
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8bed(%rip), %rbx      # 0xec99
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movb $0x1, %al
callq 0x2270
movslq %eax, %rdi
callq 0x2948
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_O2/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
callq 0x60f5
movl $0x1, (%rax)
movl %ebx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movsd %xmm0, (%rsp)
callq 0x60f5
movl $0x2, (%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x60f5
movq %rax, %r14
movl $0x3, (%rax)
movq %rbx, %rdi
callq 0x36e9
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x60f5
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_O2/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, %r14
callq 0x60f5
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
decl %eax
cmpl $0x3, %eax
ja 0x61f5
leaq 0x522b(%rip), %rcx      # 0xb3d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
jmp 0x61ea
movq 0x8(%r14), %rdi
callq 0x36e9
movq %rax, 0x8(%rbx)
jmp 0x61ea
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
jmp 0x61ea
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7ba4(%rip), %rdi      # 0xdda0
movq %r14, %rsi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value_move(char*)
value_t* create_value_move( char* v )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_STRING;
	res->svalue_ = v;
	return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x60f5
movl $0x3, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_calc_double(neteruhsp::value_t const&)
double value_calc_double( const value_t& r )
{
	switch( r.type_ )
	{
		case VALUE_INT:			return static_cast<double>( r.ivalue_ );
		case VALUE_DOUBLE:		return r.dvalue_;
		case VALUE_STRING:		return atof( r.svalue_ );
		case VALUE_VARIABLE:	return variable_calc_double( *r.variable_, r.index_ ); break;
		default: assert( false ); break;
	}
	return 0.0;
}

// Assembly:
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x632f
leaq 0x50e6(%rip), %rcx      # 0xb3e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdl 0x8(%rdi), %xmm0
retq
movq 0x8(%rdi), %rdi
jmp 0x21c0
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %esi
movq %rax, %rdi
jmp 0x5fee
movsd 0x8(%rdi), %xmm0
retq
pushq %rax
leaq 0x644e(%rip), %rdi      # 0xc785
leaq 0x555b(%rip), %rsi      # 0xb899
leaq 0x7b0d(%rip), %rcx      # 0xde52
movl $0x11a6, %edx           # imm = 0x11A6
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_get_string(neteruhsp::value_t const&)
const char* value_get_string( const value_t& r )
{
	const char* s =nullptr;
	switch( r.type_ )
	{
	case VALUE_STRING:		s = r.svalue_; break;
	case VALUE_VARIABLE:	s = variable_get_string( *r.variable_, r.index_ ); break;
	default: break;
	}
	return s;
}

// Assembly:
movl (%rdi), %eax
cmpl $0x4, %eax
je 0x6360
cmpl $0x3, %eax
jne 0x636f
movq 0x8(%rdi), %rax
retq
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %esi
movq %rax, %rdi
jmp 0x603d
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_calc_string(neteruhsp::value_t const&)
char* value_calc_string( const value_t& r )
{
	char* s =nullptr;
	switch( r.type_ )
	{
		case VALUE_INT:			s = create_string_from( r.ivalue_ ); break;
		case VALUE_DOUBLE:		s = create_string_from( r.dvalue_ ); break;
		case VALUE_STRING:		s = create_string( r.svalue_ ); break;
		case VALUE_VARIABLE:	s = variable_calc_string( *r.variable_, r.index_ ); break;
		default: assert( false ); break;
	}
	return s;
}

// Assembly:
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x63b5
leaq 0x5076(%rip), %rcx      # 0xb3f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rdi), %edi
jmp 0x488f
movq 0x8(%rdi), %rdi
jmp 0x36e9
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %esi
movq %rax, %rdi
jmp 0x604a
movsd 0x8(%rdi), %xmm0
jmp 0x609c
pushq %rax
leaq 0x63c8(%rip), %rdi      # 0xc785
leaq 0x54d5(%rip), %rsi      # 0xb899
leaq 0x7abc(%rip), %rcx      # 0xde87
movl $0x11c0, %edx           # imm = 0x11C0
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_convert_type(neteruhsp::value_tag, neteruhsp::value_t const&)
value_t* value_convert_type( value_tag to, const value_t& r )
{
	if ( to == r.type_ )
	{ return create_value( r ); }

	switch( to )
	{
		case VALUE_INT:		return create_value( value_calc_int( r ) );
		case VALUE_DOUBLE:	return create_value( value_calc_double( r ) );
		case VALUE_STRING:
		{
			auto s = value_calc_string( r );
			auto res = create_value_move( s );
			return res;
		}
		default: assert( false ); break;
	}
	return nullptr;
}

// Assembly:
pushq %rax
cmpl %edi, (%rsi)
jne 0x63e3
movq %rsi, %rdi
popq %rax
jmp 0x618b
cmpl $0x3, %edi
je 0x6410
cmpl $0x2, %edi
je 0x6402
cmpl $0x1, %edi
jne 0x6421
movq %rsi, %rdi
callq 0x4834
movl %eax, %edi
popq %rax
jmp 0x60e2
movq %rsi, %rdi
callq 0x62f2
popq %rax
jmp 0x611f
movq %rsi, %rdi
callq 0x6372
movq %rax, %rdi
popq %rax
jmp 0x6206
leaq 0x635d(%rip), %rdi      # 0xc785
leaq 0x546a(%rip), %rsi      # 0xb899
leaq 0x7a85(%rip), %rcx      # 0xdebb
movl $0x11d4, %edx           # imm = 0x11D4
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_bor(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_bor( value_t* v, const value_t& r )
{
	value_t* t = value_convert_type( v->type_, r );
	switch( v->type_ )
	{
		case VALUE_INT:		value_set( v, v->ivalue_ | t->ivalue_ ); break;
		case VALUE_DOUBLE:
		{
			raise_error( "浮動小数点同士の|演算子は挙動が定義されていません" );
			break;
		}
		case VALUE_STRING:
		{
			raise_error( "文字列同士の|演算子は挙動が定義されていません" );
			break;
		}
		default: assert( false ); break;
	}
	destroy_value( t );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x63d5
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x6476
movl 0x8(%r14), %esi
orl 0x8(%rbx), %esi
movq %rbx, %rdi
callq 0x622a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4738
cmpl $0x2, %eax
je 0x6489
cmpl $0x3, %eax
jne 0x6497
leaq 0x7aea(%rip), %rdi      # 0xdf71
jmp 0x6490
leaq 0x7a97(%rip), %rdi      # 0xdf27
xorl %eax, %eax
callq 0x326e
leaq 0x62e7(%rip), %rdi      # 0xc785
leaq 0x53f4(%rip), %rsi      # 0xb899
leaq 0x7b09(%rip), %rcx      # 0xdfb5
movl $0x11ff, %edx           # imm = 0x11FF
callq 0x20e0