LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_eq(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_eq( 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_ ? 1 : 0 ); break;
		case VALUE_DOUBLE:	value_set( v, v->dvalue_==t->dvalue_ ? 1 : 0 ); break;
		case VALUE_STRING:	value_set( v, strcmp(v->svalue_, t->svalue_)==0 ? 1: 0 ); 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 $0x3, %eax
je 0x65e3
cmpl $0x2, %eax
je 0x65cd
cmpl $0x1, %eax
jne 0x660f
movl 0x8(%rbx), %eax
cmpl 0x8(%r14), %eax
jmp 0x65f2
movsd 0x8(%r14), %xmm0
cmpeqsd 0x8(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x65f5
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x2220
testl %eax, %eax
sete %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x622a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4738
leaq 0x616f(%rip), %rdi      # 0xc785
leaq 0x527c(%rip), %rsi      # 0xb899
leaq 0x7b51(%rip), %rcx      # 0xe175
movl $0x1236, %edx           # imm = 0x1236
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_gt(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_gt( 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_ ? 1 : 0 ); break;
		case VALUE_DOUBLE:	value_set( v, v->dvalue_>t->dvalue_ ? 1 : 0 ); 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
je 0x66e7
cmpl $0x2, %eax
jne 0x670b
movsd 0x8(%rbx), %xmm0
ucomisd 0x8(%r14), %xmm0
seta %al
jmp 0x66f1
movl 0x8(%rbx), %eax
cmpl 0x8(%r14), %eax
setg %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x622a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4738
cmpl $0x3, %eax
jne 0x671e
leaq 0x7ac9(%rip), %rdi      # 0xe1e0
xorl %eax, %eax
callq 0x326e
leaq 0x6060(%rip), %rdi      # 0xc785
leaq 0x516d(%rip), %rsi      # 0xb899
leaq 0x7af1(%rip), %rcx      # 0xe224
movl $0x1254, %edx           # imm = 0x1254
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_gtoe(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_gtoe( 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_ ? 1 : 0 ); break;
		case VALUE_DOUBLE:	value_set( v, v->dvalue_>=t->dvalue_ ? 1 : 0 ); 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
je 0x676a
cmpl $0x2, %eax
jne 0x678e
movsd 0x8(%rbx), %xmm0
ucomisd 0x8(%r14), %xmm0
setae %al
jmp 0x6774
movl 0x8(%rbx), %eax
cmpl 0x8(%r14), %eax
setge %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x622a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4738
cmpl $0x3, %eax
jne 0x67a1
leaq 0x7abf(%rip), %rdi      # 0xe259
xorl %eax, %eax
callq 0x326e
leaq 0x5fdd(%rip), %rdi      # 0xc785
leaq 0x50ea(%rip), %rsi      # 0xb899
leaq 0x7ae8(%rip), %rcx      # 0xe29e
movl $0x1265, %edx           # imm = 0x1265
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_add(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_add( value_t* v, const value_t& r )
{
	value_t* t = value_convert_type( v->type_, r );
	switch( v->type_ )
	{
		case VALUE_INT:		v->ivalue_ += t->ivalue_; break;
		case VALUE_DOUBLE:	v->dvalue_ += t->dvalue_; break;
		case VALUE_STRING:
		{
			const auto required = snprintf( nullptr, 0, "%s%s", v->svalue_, t->svalue_ );
			auto s = create_string( required );
			sprintf( s, "%s%s", v->svalue_, t->svalue_ );
			destroy_string( v->svalue_ );
			v->svalue_ = s;
			break;
		}
		default: assert( false ); break;
	}
	destroy_value( t );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x63d5
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x6907
cmpl $0x2, %eax
je 0x68f5
cmpl $0x1, %eax
jne 0x6964
movl 0x8(%r14), %eax
addl %eax, 0x8(%rbx)
jmp 0x6951
movsd 0x8(%r14), %xmm0
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x6951
movq 0x8(%rbx), %rcx
movq 0x8(%r14), %r8
leaq 0x7ab4(%rip), %r15      # 0xe3ca
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2270
movslq %eax, %rdi
callq 0x2948
movq %rax, %r12
movq 0x8(%rbx), %rdx
movq 0x8(%r14), %rcx
movq %rax, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2080
movq 0x8(%rbx), %rdi
callq 0x21a0
movq %r12, 0x8(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4738
leaq 0x5e1a(%rip), %rdi      # 0xc785
leaq 0x4f27(%rip), %rsi      # 0xb899
leaq 0x7a56(%rip), %rcx      # 0xe3cf
movl $0x129c, %edx           # imm = 0x129C
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_sub(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_sub( value_t* v, const value_t& r )
{
	value_t* t = value_convert_type( v->type_, r );
	switch( v->type_ )
	{
		case VALUE_INT:		v->ivalue_ -= t->ivalue_; break;
		case VALUE_DOUBLE:	v->dvalue_ -= t->dvalue_; break;
		case VALUE_STRING:
		{
			raise_error( "文字列同士の-演算子は挙動が定義されていません" );
			break;
		}
		default: assert( false ); break;
	}
	destroy_value( t );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x63d5
movl (%rbx), %ecx
cmpl $0x1, %ecx
je 0x69ab
cmpl $0x2, %ecx
jne 0x69ba
movsd 0x8(%rbx), %xmm0
subsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x69b1
movl 0x8(%rax), %ecx
subl %ecx, 0x8(%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x4738
cmpl $0x3, %ecx
jne 0x69cd
leaq 0x7a3f(%rip), %rdi      # 0xe405
xorl %eax, %eax
callq 0x326e
leaq 0x5db1(%rip), %rdi      # 0xc785
leaq 0x4ebe(%rip), %rsi      # 0xb899
leaq 0x7a67(%rip), %rcx      # 0xe449
movl $0x12ad, %edx           # imm = 0x12AD
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_div(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_div( value_t* v, const value_t& r )
{
	value_t* t = value_convert_type( v->type_, r );
	switch( v->type_ )
	{
		case VALUE_INT:
			if ( t->ivalue_ == 0 )
			{
				raise_error( "0除算が行われました" );
				break;
			}
			v->ivalue_ /= t->ivalue_;
			break;
		case VALUE_DOUBLE:
			if ( t->dvalue_ == 0.0 )
			{
				raise_error( "0.0除算が行われました" );
				break;
			}
			v->dvalue_ /= t->dvalue_;
			break;
		case VALUE_STRING:
		{
			raise_error( "文字列同士の/演算子は挙動が定義されていません" );
			break;
		}
		default: assert( false ); break;
	}
	destroy_value( t );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x63d5
movq %rax, %rdi
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x6a94
cmpl $0x2, %eax
jne 0x6aaa
movsd 0x8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6a84
jnp 0x6ae0
movsd 0x8(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
jmp 0x6aa4
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x6ad7
movl 0x8(%rbx), %eax
cltd
idivl %ecx
movl %eax, 0x8(%rbx)
popq %rbx
jmp 0x4738
cmpl $0x3, %eax
jne 0x6ab8
leaq 0x7a62(%rip), %rdi      # 0xe518
jmp 0x6ae7
leaq 0x5cc6(%rip), %rdi      # 0xc785
leaq 0x4dd3(%rip), %rsi      # 0xb899
leaq 0x7a8f(%rip), %rcx      # 0xe55c
movl $0x12dd, %edx           # imm = 0x12DD
callq 0x20e0
leaq 0x7a1d(%rip), %rdi      # 0xe4fb
jmp 0x6ae7
leaq 0x7a12(%rip), %rdi      # 0xe4f9
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_mod(neteruhsp::value_t*, neteruhsp::value_t const&)
void value_mod( value_t* v, const value_t& r )
{
	value_t* t = value_convert_type( v->type_, r );
	switch( v->type_ )
	{
		case VALUE_INT:
			if ( t->ivalue_ == 0 )
			{
				raise_error( "0剰余が行われました" );
				break;
			}
			v->ivalue_ %= t->ivalue_;
			break;
		case VALUE_DOUBLE:
			if ( t->dvalue_ == 0.0 )
			{
				raise_error( "0.0除算が行われました" );
				break;
			}
			v->dvalue_ = std::fmod(v->dvalue_, t->dvalue_);
			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
je 0x6b2e
cmpl $0x2, %eax
jne 0x6b4e
movsd 0x8(%r14), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x6b1d
jnp 0x6b84
movsd 0x8(%rbx), %xmm0
callq 0x21f0
movsd %xmm0, 0x8(%rbx)
jmp 0x6b3f
movl 0x8(%r14), %ecx
testl %ecx, %ecx
je 0x6b7b
movl 0x8(%rbx), %eax
cltd
idivl %ecx
movl %edx, 0x8(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4738
cmpl $0x3, %eax
jne 0x6b5c
leaq 0x7a55(%rip), %rdi      # 0xe5af
jmp 0x6b8b
leaq 0x5c22(%rip), %rdi      # 0xc785
leaq 0x4d2f(%rip), %rsi      # 0xb899
leaq 0x7a82(%rip), %rcx      # 0xe5f3
movl $0x12fc, %edx           # imm = 0x12FC
callq 0x20e0
leaq 0x7a10(%rip), %rdi      # 0xe592
jmp 0x6b8b
leaq 0x796e(%rip), %rdi      # 0xe4f9
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_unary_minus(neteruhsp::value_t*)
void value_unary_minus( value_t* v )
{
	switch( v->type_ )
	{
		case VALUE_INT:		v->ivalue_ = -v->ivalue_; break;
		case VALUE_DOUBLE:	v->dvalue_ = -v->dvalue_; break;
		case VALUE_STRING:	raise_error( "文字列に負値は存在しません[%s]", v->svalue_ ); break;
		default: assert( false ); break;
	}
}

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x6bb1
cmpl $0x2, %eax
jne 0x6bb6
movsd 0x8(%rdi), %xmm0
xorps 0x4cb5(%rip), %xmm0     # 0xb860
movlps %xmm0, 0x8(%rdi)
jmp 0x6bb4
negl 0x8(%rdi)
popq %rax
retq
cmpl $0x3, %eax
jne 0x6bcd
movq 0x8(%rdi), %rsi
leaq 0x7a63(%rip), %rdi      # 0xe629
xorl %eax, %eax
callq 0x326e
leaq 0x5bb1(%rip), %rdi      # 0xc785
leaq 0x4cbe(%rip), %rsi      # 0xb899
leaq 0x7a73(%rip), %rcx      # 0xe655
movl $0x1308, %edx           # imm = 0x1308
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::uninitialize_value_stack(neteruhsp::value_stack_t*)
void uninitialize_value_stack( value_stack_t* st )
{
	stack_pop( st, st->top_ );
	xfree( st->stack_ );
	st->stack_ = nullptr;
	st->top_ = 0;
	st->max_ = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x8(%rdi), %rsi
callq 0x6c55
movq (%rbx), %rdi
callq 0x21a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::stack_pop(neteruhsp::value_stack_t*, unsigned long)
void stack_pop( value_stack_t* st, size_t n )
{
	assert( n <= static_cast<size_t>(st->top_) );
	while( n-- > 0 )
	{
		--st->top_;
		assert( st->stack_[ st->top_ ] != nullptr );
		destroy_value( st->stack_[ st->top_ ] );
		st->stack_[ st->top_ ] = nullptr;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x8(%rdi), %rax
cmpq %rsi, %rax
jb 0x6cbe
movq %rsi, %rbx
movq %rdi, %r14
subq $0x1, %rbx
jb 0x6c97
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
movq (%r14), %rcx
cltq
movq -0x8(%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x6c9f
callq 0x4738
movq (%r14), %rcx
movslq 0x8(%r14), %rax
andq $0x0, (%rcx,%rax,8)
jmp 0x6c68
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7a7e(%rip), %rdi      # 0xe724
leaq 0x4bec(%rip), %rsi      # 0xb899
leaq 0x7a3d(%rip), %rcx      # 0xe6f1
movl $0x134b, %edx           # imm = 0x134B
callq 0x20e0
leaq 0x7a09(%rip), %rdi      # 0xe6ce
leaq 0x4bcd(%rip), %rsi      # 0xb899
leaq 0x7a1e(%rip), %rcx      # 0xe6f1
movl $0x1347, %edx           # imm = 0x1347
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::stack_push(neteruhsp::value_stack_t*, neteruhsp::value_t*)
void stack_push( value_stack_t* st, value_t* v )
{
	if ( st->top_+1 > st->max_ )
	{
		st->max_ = st->max_ *2;// 貪欲
		st->stack_ = reinterpret_cast<value_t**>( xrealloc( st->stack_, sizeof(value_t*) *st->max_ ) );
	}

	st->stack_[st->top_] =v;
	++st->top_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movslq 0xc(%rdi), %rsi
movq (%rdi), %rax
cmpl %esi, %ecx
jl 0x6d0d
leal (%rsi,%rsi), %ecx
movl %ecx, 0xc(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x2280
movq %rax, (%rbx)
movl 0x8(%rbx), %ecx
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
incl %ecx
movl %ecx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_execute_environment()
execute_environment_t* create_execute_environment()
{
	auto res = reinterpret_cast<execute_environment_t*>( xmalloc( sizeof( execute_environment_t ) ) );
	res->parser_list_ = create_list();
	res->ast_list_ = create_list();
	res->label_table_ = create_list();
	res->variable_table_ = create_variable_table();
	res->execute_code_ = create_code_container();
	return res;
}

// Assembly:
pushq %rbx
pushq $0x28
popq %rdi
callq 0x21d0
movq %rax, %rbx
callq 0x2aa2
movq %rax, (%rbx)
callq 0x2aa2
movq %rax, 0x8(%rbx)
callq 0x2aa2
movq %rax, 0x10(%rbx)
callq 0x2aa2
movq %rax, 0x18(%rbx)
callq 0x6db8
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::destroy_execute_environment(neteruhsp::execute_environment_t*)
void destroy_execute_environment( execute_environment_t* e )
{
	{
		auto node =e->parser_list_->head_;
		while( node != nullptr )
		{
			const auto parser = reinterpret_cast<parse_context_t*>( node->value_ );
			uninitialize_parse_context( parser );
			destroy_parse_context( parser );
			node = node->next_;
		}
		list_free_all( *e->parser_list_ );
		destroy_list( e->parser_list_ );
	}
	{
		auto node =e->ast_list_->head_;
		while( node != nullptr )
		{
			const auto ast = reinterpret_cast<list_t*>( node->value_ );
			destroy_ast( ast );
			node = node->next_;
		}
		list_free_all( *e->ast_list_ );
		destroy_list( e->ast_list_ );
	}
	{
		auto node = e->label_table_->head_;
		while( node != nullptr )
		{
			const auto label_node =reinterpret_cast<label_node_t*>( node->value_ );
			xfree( label_node->name_ );
			xfree( label_node );
			node->value_ = nullptr;
			node = node->next_;
		}
		list_free_all( *e->label_table_ );
		destroy_list( e->label_table_ );
	}
	{
		destroy_code_container( e->execute_code_ );
	}
	destroy_variable_table( e->variable_table_ );
	xfree( e );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x6e42
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x33d0
movq %r14, %rdi
callq 0x21a0
addq $0x8, %r15
jmp 0x6e20
movq (%rbx), %rdi
callq 0x2b90
movq (%rbx), %rdi
callq 0x21a0
movq 0x8(%rbx), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x6e6d
movq 0x10(%r14), %rdi
callq 0x4a53
addq $0x8, %r14
jmp 0x6e56
movq 0x8(%rbx), %rdi
callq 0x2b90
movq 0x8(%rbx), %rdi
callq 0x21a0
movq 0x10(%rbx), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x6eaa
movq 0x10(%r15), %r14
movq (%r14), %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x21a0
andq $0x0, 0x10(%r15)
addq $0x8, %r15
jmp 0x6e83
movq 0x10(%rbx), %rdi
callq 0x2b90
movq 0x10(%rbx), %rdi
callq 0x21a0
movq 0x20(%rbx), %rdi
callq 0x6dc3
movq 0x18(%rbx), %rdi
callq 0x568f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::initialize_execute_status(neteruhsp::execute_status_t*)
void initialize_execute_status( execute_status_t* s )
{
	s->stack_ = create_value_stack();
	s->pc_ = 0;
	s->current_call_frame_ = 0;
	s->call_frame_[0].caller_poisition_ = 0;
	s->current_loop_frame_ = 0;
	s->loop_frame_[0].start_position_ = 0;
	s->loop_frame_[0].counter_ = 0;
	s->loop_frame_[0].max_ = 0;
	s->loop_frame_[0].cnt_ = 0;
	s->is_end_ = false;
	s->stat_ =0;
	s->refdval_ = 0.0;
	s->refstr_ = create_string( "" );
	s->strsize_ = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x6bec
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
andq $0x0, 0x4c(%rbx)
andl $0x0, 0x190(%rbx)
andq $0x0, 0x58(%rbx)
andl $0x0, 0x60(%rbx)
movb $0x0, 0x194(%rbx)
andl $0x0, 0x198(%rbx)
andq $0x0, 0x1a0(%rbx)
leaq 0x41f2(%rip), %rdi      # 0xb110
callq 0x36e9
movq %rax, 0x1a8(%rbx)
andl $0x0, 0x1b0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::load_script(neteruhsp::execute_environment_t*, char const*, neteruhsp::load_arg_t const*)::_::walk(neteruhsp::execute_environment_t*, neteruhsp::ast_node_t*)
static void walk( execute_environment_t* e, ast_node_t* node )
			{
				if ( node->tag_==NODE_VARIABLE || node->tag_==NODE_IDENTIFIER_EXPR/*変数配列の可能性あり*/ )
				{
					auto var_name = node->token_->content_;
					if ( search_variable( e->variable_table_, var_name ) == nullptr )
					{
						// 適当な変数として初期化しておく
						value_t v;
						v.type_ = VALUE_INT;
						v.ivalue_ = 0;
						variable_set( e->variable_table_, v, var_name, 0 );
					}
				}
				else if ( node->tag_ == NODE_LABEL )
				{
					auto label_node = create_list_node();
					label_node_t* label =reinterpret_cast<label_node_t*>( xmalloc( sizeof(label_node_t) ) );
					label->name_ = create_string( node->token_->content_ );
					label_node->value_ = label;
					list_append( *e->label_table_, label_node );
				}
				if ( node->left_ != nullptr )
				{ walk( e, node->left_ ); }
				if ( node->right_ != nullptr )
				{ walk( e, node->right_ ); }
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %r15
movq %rsp, %r12
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x7106
cmpl $0x20, %eax
je 0x70cc
cmpl $0xe, %eax
jne 0x713a
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r13
movq 0x18(%r14), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x56c7
testq %rax, %rax
jne 0x713a
movl $0x1, (%rsp)
andl $0x0, 0x8(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x570b
jmp 0x713a
callq 0x29e2
movq %rax, %r13
movq %r15, %rdi
callq 0x21d0
movq %rax, %rbp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x36e9
movq %rax, (%rbp)
movq %rbp, 0x10(%r13)
movq 0x10(%r14), %rdi
movq %r13, %rsi
callq 0x2b03
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x714b
movq %r14, %rdi
callq 0x70a0
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x70bb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::execute(neteruhsp::execute_environment_t*, int)
void execute( execute_environment_t* e, int initial_pc )
{
	execute_status_t s;
	initialize_execute_status( &s );
	s.pc_ = initial_pc;

	if ( e->execute_code_->code_ == nullptr )
	{
		raise_error( "実行できるノードがありません@@ [%p]", e );
	}

	execute_inner( e, &s );

	uninitialize_execute_status( &s );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6edb
movl %ebp, 0x8(%r14)
movq 0x20(%rbx), %rax
cmpq $0x0, (%rax)
je 0x7b28
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71e1
movq %r14, %rdi
callq 0x6f33
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6ef5(%rip), %rdi      # 0xea24
movq %rbx, %rsi
xorl %eax, %eax
callq 0x326e
nop
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_dim(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_dim( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 2 )
	{
		raise_error( "dim：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "dim：引数が多すぎます、配列変数は1次元までしかサポートしていません" );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "dim：対象が変数ではありません" );
	}
	if ( v->index_ > 0 )
	{
		raise_error( "dim：対象の変数が配列として指定されています" );
	}

	const auto n = stack_peek( s->stack_, arg_start +1 );
	const auto num = value_calc_int( *n );
	if ( num <= 0 )
	{
		raise_error( "dim：0個以下の要素は確保できません" );
	}

	prepare_variable( v->variable_, VALUE_INT, 64, num );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edx
jle 0x891e
cmpl $0x2, %edx
jne 0x8927
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x8930
movq %rax, %r14
cmpl $0x0, 0x10(%rax)
jg 0x8939
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
testl %eax, %eax
jle 0x8942
movq 0x8(%r14), %rdi
pushq $0x1
popq %rsi
pushq $0x40
popq %rdx
movl %eax, %ecx
callq 0x55a9
movq (%rbx), %rdi
pushq $0x2
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c55
leaq 0x6745(%rip), %rdi      # 0xf06a
jmp 0x8949
leaq 0x675c(%rip), %rdi      # 0xf08a
jmp 0x8949
leaq 0x67b6(%rip), %rdi      # 0xf0ed
jmp 0x8949
leaq 0x67d9(%rip), %rdi      # 0xf119
jmp 0x8949
leaq 0x6811(%rip), %rdi      # 0xf15a
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_ddim(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_ddim( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 2 )
	{
		raise_error( "ddim：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "ddim：引数が多すぎます、配列変数は1次元までしかサポートしていません" );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "ddim：対象が変数ではありません" );
	}
	if ( v->index_ > 0 )
	{
		raise_error( "ddim：対象の変数が配列として指定されています" );
	}

	const auto n = stack_peek( s->stack_, arg_start +1 );
	const auto num = value_calc_int( *n );
	if ( num <= 0 )
	{
		raise_error( "ddim：0個以下の要素は確保できません" );
	}

	prepare_variable( v->variable_, VALUE_DOUBLE, 64, num );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edx
jle 0x89b4
cmpl $0x2, %edx
jne 0x89bd
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x89c6
movq %rax, %r14
cmpl $0x0, 0x10(%rax)
jg 0x89cf
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
testl %eax, %eax
jle 0x89d8
movq 0x8(%r14), %rdi
pushq $0x2
popq %rsi
pushq $0x40
popq %rdx
movl %eax, %ecx
callq 0x55a9
movq (%rbx), %rdi
pushq $0x2
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c55
leaq 0x66ae(%rip), %rdi      # 0xf069
jmp 0x89df
leaq 0x66c5(%rip), %rdi      # 0xf089
jmp 0x89df
leaq 0x671f(%rip), %rdi      # 0xf0ec
jmp 0x89df
leaq 0x6742(%rip), %rdi      # 0xf118
jmp 0x89df
leaq 0x677a(%rip), %rdi      # 0xf159
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_sdim(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_sdim( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 2 )
	{
		raise_error( "sdim：引数がたりません" );
	}
	if ( arg_num > 3 )
	{
		raise_error( "sdim：引数が多すぎます、配列変数は1次元までしかサポートしていません" );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "sdim：対象が変数ではありません" );
	}
	if ( v->index_ > 0 )
	{
		raise_error( "sdim：対象の変数が配列として指定されています" );
	}

	const auto g = stack_peek( s->stack_, arg_start +1 );
	const auto granule = value_calc_int( *g );

	const auto num = ( arg_num>2 ? value_calc_int( *stack_peek( s->stack_, arg_start +2 ) ) : 1 );
	if ( granule <= 0 )
	{
		raise_error( "sdim：0以下のサイズの文字列は作れません" );
	}
	if ( num <= 0 )
	{
		raise_error( "sdim：0個以下の要素は確保できません" );
	}

	prepare_variable( v->variable_, VALUE_STRING, granule, num );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1, %edx
jle 0x8a90
movl %edx, %ebx
cmpl $0x4, %edx
jae 0x8a99
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x8aa2
movq %rax, %r15
cmpl $0x0, 0x10(%rax)
jg 0x8aab
movq (%r14), %rdi
pushq $0x1
popq %r12
movl %r12d, %esi
subl %ebx, %esi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %ebp
cmpl $0x2, %ebx
jne 0x8a4d
testl %ebp, %ebp
jg 0x8a6d
jmp 0x8ab4
movq (%r14), %rdi
pushq $0x2
popq %rsi
subl %ebx, %esi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
testl %ebp, %ebp
jle 0x8ab4
movl %eax, %r12d
testl %eax, %eax
jle 0x8abd
movq 0x8(%r15), %rdi
pushq $0x3
popq %rsi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x55a9
movq (%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6c55
leaq 0x66f5(%rip), %rdi      # 0xf18c
jmp 0x8ac4
leaq 0x670c(%rip), %rdi      # 0xf1ac
jmp 0x8ac4
leaq 0x6766(%rip), %rdi      # 0xf20f
jmp 0x8ac4
leaq 0x6789(%rip), %rdi      # 0xf23b
jmp 0x8ac4
leaq 0x67c1(%rip), %rdi      # 0xf27c
jmp 0x8ac4
leaq 0x67f1(%rip), %rdi      # 0xf2b5
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_poke(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_poke( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 3 )
	{
		raise_error( "poke：引数がたりません" );
	}
	if ( arg_num > 3 )
	{
		raise_error( "poke：引数が多すぎます、配列変数は1次元までしかサポートしていません" );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "poke：対象が変数ではありません" );
		return;
	}
	if ( v->index_ > 0 )
	{
		raise_error( "poke：対象の変数が配列として指定されています" );
		return;
	}

	auto* const var = v->variable_;

	const auto i = stack_peek( s->stack_, arg_start +1 );
	const auto byte_idx = value_calc_int( *i );

	const auto wp = stack_peek( s->stack_, arg_start +2 );
	const auto w = value_calc_int( *wp );

	if ( byte_idx<0 || var->data_size_<( byte_idx + 1 ) )
	{
		raise_error( "poke：対象の変数の範囲外を書き込もうとしています@@ %s(size=%d, idx=%d)", var->name_, var->data_size_, byte_idx );
		return;
	}

	auto* const dp = reinterpret_cast<char*>( var->data_ );
	dp[byte_idx] = static_cast<char>( w );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %edx
jle 0x8b42
cmpl $0x3, %edx
jne 0x8b4b
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x3
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x8b54
cmpl $0x0, 0x10(%rax)
jg 0x8b5d
movq 0x8(%rax), %r14
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %ebp
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl 0x20(%r14), %edx
testl %ebp, %ebp
js 0x8b6b
cmpl %ebp, %edx
jle 0x8b6b
movq 0x18(%r14), %rcx
movl %ebp, %edx
movb %al, (%rcx,%rdx)
movq (%rbx), %rdi
pushq $0x3
popq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6c55
leaq 0x68f2(%rip), %rdi      # 0xf43b
jmp 0x8b64
leaq 0x690a(%rip), %rdi      # 0xf45c
jmp 0x8b64
leaq 0x6965(%rip), %rdi      # 0xf4c0
jmp 0x8b64
leaq 0x6989(%rip), %rdi      # 0xf4ed
xorl %eax, %eax
callq 0x326e
movq (%r14), %rsi
leaq 0x69ba(%rip), %rdi      # 0xf52f
movl %ebp, %ecx
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_wpoke(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_wpoke( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 3 )
	{
		raise_error( "wpoke：引数がたりません" );
	}
	if ( arg_num > 3 )
	{
		raise_error( "wpoke：引数が多すぎます、配列変数は1次元までしかサポートしていません" );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "wpoke：対象が変数ではありません" );
		return;
	}
	if ( v->index_ > 0 )
	{
		raise_error( "wpoke：対象の変数が配列として指定されています" );
		return;
	}

	auto* const var = v->variable_;

	const auto i = stack_peek( s->stack_, arg_start +1 );
	const auto byte_idx = value_calc_int( *i );

	const auto wp = stack_peek( s->stack_, arg_start +2 );
	const std::int16_t w = static_cast<std::int16_t>( value_calc_int( *wp ) );

	if ( byte_idx<0 || var->data_size_<( byte_idx + 2 ) )
	{
		raise_error( "wpoke：対象の変数の範囲外を書き込もうとしています@@ %s(size=%d, idx=%d)", var->name_, var->data_size_, byte_idx );
		return;
	}

	auto* const dp = reinterpret_cast<char*>( var->data_ );
	memcpy( dp + byte_idx, &w, 2 );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x2, %edx
jle 0x8bff
cmpl $0x3, %edx
jne 0x8c08
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x3
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x8c11
cmpl $0x0, 0x10(%rax)
jg 0x8c1a
movq 0x8(%rax), %r15
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %r14d
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl 0x20(%r15), %edx
testl %r14d, %r14d
js 0x8c28
leal 0x2(%r14), %ecx
cmpl %ecx, %edx
jl 0x8c28
movq 0x18(%r15), %rcx
movl %r14d, %edx
movw %ax, (%rcx,%rdx)
movq (%rbx), %rdi
pushq $0x3
popq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6c55
leaq 0x66e2(%rip), %rdi      # 0xf2e8
jmp 0x8c21
leaq 0x66fa(%rip), %rdi      # 0xf309
jmp 0x8c21
leaq 0x6755(%rip), %rdi      # 0xf36d
jmp 0x8c21
leaq 0x6779(%rip), %rdi      # 0xf39a
xorl %eax, %eax
callq 0x326e
movq (%r15), %rsi
leaq 0x67aa(%rip), %rdi      # 0xf3dc
movl %r14d, %ecx
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_lpoke(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_lpoke( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 3 )
	{
		raise_error( "lpoke：引数がたりません" );
	}
	if ( arg_num > 3 )
	{
		raise_error( "lpoke：引数が多すぎます、配列変数は1次元までしかサポートしていません" );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "lpoke：対象が変数ではありません" );
		return;
	}
	if ( v->index_ > 0 )
	{
		raise_error( "lpoke：対象の変数が配列として指定されています" );
		return;
	}

	auto* const var = v->variable_;

	const auto i = stack_peek( s->stack_, arg_start +1 );
	const auto byte_idx = value_calc_int( *i );

	const auto wp = stack_peek( s->stack_, arg_start +2 );
	const std::int32_t w = static_cast<std::int32_t>( value_calc_int( *wp ) );

	if ( byte_idx<0 || var->data_size_<( byte_idx + 4 ) )
	{
		raise_error( "lpoke：対象の変数の範囲外を書き込もうとしています@@ %s(size=%d, idx=%d)", var->name_, var->data_size_, byte_idx );
		return;
	}

	auto* const dp = reinterpret_cast<char*>( var->data_ );
	memcpy( dp + byte_idx, &w, 4 );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x2, %edx
jle 0x8cbc
cmpl $0x3, %edx
jne 0x8cc5
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x3
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x8cce
cmpl $0x0, 0x10(%rax)
jg 0x8cd7
movq 0x8(%rax), %r15
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %r14d
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl 0x20(%r15), %edx
testl %r14d, %r14d
js 0x8ce5
leal 0x4(%r14), %ecx
cmpl %ecx, %edx
jl 0x8ce5
movq 0x18(%r15), %rcx
movl %r14d, %edx
movl %eax, (%rcx,%rdx)
movq (%rbx), %rdi
pushq $0x3
popq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6c55
leaq 0x6777(%rip), %rdi      # 0xf43a
jmp 0x8cde
leaq 0x678f(%rip), %rdi      # 0xf45b
jmp 0x8cde
leaq 0x67ea(%rip), %rdi      # 0xf4bf
jmp 0x8cde
leaq 0x680e(%rip), %rdi      # 0xf4ec
xorl %eax, %eax
callq 0x326e
movq (%r15), %rsi
leaq 0x683f(%rip), %rdi      # 0xf52e
movl %r14d, %ecx
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_mes(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_mes( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "mes：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "mes：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto m = stack_peek( s->stack_ );
	value_isolate( *m );
	if ( m->type_ != VALUE_STRING )
	{
		raise_error( "mes：引数が文字列型ではありません" );
	}

	printf( "%s\n", m->svalue_ );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x8d40
cmpl $0x1, %edx
jne 0x8d49
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r14
movq %rax, %rdi
callq 0x47ad
cmpl $0x3, (%r14)
jne 0x8d59
movq 0x8(%r14), %rdi
callq 0x2240
movq (%rbx), %rdi
pushq $0x1
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c55
leaq 0x6845(%rip), %rdi      # 0xf58c
jmp 0x8d60
leaq 0x685b(%rip), %rdi      # 0xf5ab
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
leaq 0x6884(%rip), %rdi      # 0xf5e4
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::command_randomize(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void command_randomize( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num > 1 )
	{
		raise_error( "randomize：引数が多すぎます" );
	}

	unsigned int seed = 0;
	if ( arg_num == 0 )
	{
		seed = static_cast<unsigned int>(time(nullptr));
	}
	else
	{
		const auto m = stack_peek( s->stack_ );
		seed = static_cast<unsigned int>( value_calc_int( *m ) );
	}
	srand( seed );

	stack_pop( s->stack_, arg_num );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edx
jge 0x8f42
movl %edx, %ebx
movq %rsi, %r14
testl %edx, %edx
je 0x8f22
movq (%r14), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
jmp 0x8f29
xorl %edi, %edi
callq 0x2130
movl %eax, %edi
callq 0x2150
movq (%r14), %rdi
movslq %ebx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c55
leaq 0x677d(%rip), %rdi      # 0xf6c6
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_int(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_int( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "int：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "int：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto m = stack_peek( s->stack_ );
	const auto r = value_calc_int( *m );

	stack_pop( s->stack_, arg_num );
	stack_push( s->stack_, create_value( r ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x9003
cmpl $0x1, %edx
jne 0x9011
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %ebp
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movq (%rbx), %rbx
movl %ebp, %edi
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6cdd
leaq 0x6748(%rip), %rdi      # 0xf752
xorl %eax, %eax
callq 0x326e
leaq 0x6759(%rip), %rdi      # 0xf771
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_double(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_double( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "double：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "double：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto m = stack_peek( s->stack_ );
	const auto r = value_calc_double( *m );

	stack_pop( s->stack_, arg_num );
	stack_push( s->stack_, create_value( r ) );
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0x9074
cmpl $0x1, %edx
jne 0x9082
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movq (%rbx), %rbx
movsd 0x8(%rsp), %xmm0
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x672f(%rip), %rdi      # 0xf7aa
xorl %eax, %eax
callq 0x326e
leaq 0x6743(%rip), %rdi      # 0xf7cc
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_str(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_str( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "str：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "str：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto m = stack_peek( s->stack_ );
	const auto r = value_calc_string( *m );

	stack_pop( s->stack_, arg_num );
	stack_push( s->stack_, create_value_move( r ) );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x90e0
cmpl $0x1, %edx
jne 0x90ee
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x6372
movq %rax, %r14
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movq (%rbx), %rbx
movq %r14, %rdi
callq 0x6206
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6cdd
leaq 0x6721(%rip), %rdi      # 0xf808
xorl %eax, %eax
callq 0x326e
leaq 0x6732(%rip), %rdi      # 0xf827
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_peek(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_peek( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 1 )
	{
		raise_error( "peek：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "peek：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "peek：対象が変数ではありません" );
	}
	if ( v->index_ > 0 )
	{
		raise_error( "peek：対象の変数が配列として指定されています" );
		return;
	}

	const auto* const var = v->variable_;

	const auto n = stack_peek( s->stack_, arg_start +1 );
	const auto byte_idx = value_calc_int( *n );

	if ( byte_idx<0 || var->data_size_<( byte_idx + 1 ) )
	{
		raise_error( "peek：対象の変数の範囲外を読もうとしています@@ %s(size=%d, idx=%d)", var->name_, var->data_size_, byte_idx );
		return;
	}

	const auto* const dp = reinterpret_cast<const char*>( var->data_ );
	const int res = dp[byte_idx];

	stack_pop( s->stack_, arg_num );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edx
jle 0x9176
cmpl $0x2, %edx
jne 0x917f
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x918f
cmpl $0x0, 0x10(%rax)
jg 0x9198
movq 0x8(%rax), %r14
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl 0x20(%r14), %edx
testl %eax, %eax
js 0x91a6
cmpl %eax, %edx
jle 0x91a6
movq 0x18(%r14), %rcx
movl %eax, %eax
movsbl (%rcx,%rax), %ebp
movq (%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x6c55
movq (%rbx), %rbx
movl %ebp, %edi
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6cdd
leaq 0x6807(%rip), %rdi      # 0xf984
jmp 0x919f
leaq 0x681f(%rip), %rdi      # 0xf9a5
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
leaq 0x684a(%rip), %rdi      # 0xf9e0
jmp 0x919f
leaq 0x686e(%rip), %rdi      # 0xfa0d
xorl %eax, %eax
callq 0x326e
movq (%r14), %rsi
leaq 0x689f(%rip), %rdi      # 0xfa4f
movl %eax, %ecx
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_wpeek(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_wpeek( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 1 )
	{
		raise_error( "wpeek：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "wpeek：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "wpeek：対象が変数ではありません" );
	}
	if ( v->index_ > 0 )
	{
		raise_error( "wpeek：対象の変数が配列として指定されています" );
		return;
	}

	const auto* const var = v->variable_;

	const auto n = stack_peek( s->stack_, arg_start +1 );
	const auto byte_idx = value_calc_int( *n );

	if ( byte_idx<0 || var->data_size_<( byte_idx + 2 ) )
	{
		raise_error( "wpeek：対象の変数の範囲外を読もうとしています@@ %s(size=%d, idx=%d)", var->name_, var->data_size_, byte_idx );
		return;
	}

	const auto* const dp = reinterpret_cast<const char*>( var->data_ );
	std::int16_t res =0;
	memcpy(&res, dp + byte_idx, 2);

	stack_pop( s->stack_, arg_num );
	stack_push( s->stack_, create_value( static_cast<int>( res ) ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edx
jle 0x9234
cmpl $0x2, %edx
jne 0x923d
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x924d
cmpl $0x0, 0x10(%rax)
jg 0x9256
movq 0x8(%rax), %r14
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl 0x20(%r14), %edx
testl %eax, %eax
js 0x9264
leal 0x2(%rax), %ecx
cmpl %ecx, %edx
jl 0x9264
movq 0x18(%r14), %rcx
movl %eax, %eax
movswl (%rcx,%rax), %ebp
movq (%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x6c55
movq (%rbx), %rbx
movl %ebp, %edi
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6cdd
leaq 0x6625(%rip), %rdi      # 0xf860
jmp 0x925d
leaq 0x663d(%rip), %rdi      # 0xf881
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
leaq 0x6668(%rip), %rdi      # 0xf8bc
jmp 0x925d
leaq 0x668c(%rip), %rdi      # 0xf8e9
xorl %eax, %eax
callq 0x326e
movq (%r14), %rsi
leaq 0x66bd(%rip), %rdi      # 0xf92b
movl %eax, %ecx
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_lpeek(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_lpeek( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 1 )
	{
		raise_error( "lpeek：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "lpeek：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto arg_start = -arg_num;
	const auto v = stack_peek( s->stack_, arg_start );
	if ( v->type_ != VALUE_VARIABLE )
	{
		raise_error( "lpeek：対象が変数ではありません" );
	}
	if ( v->index_ > 0 )
	{
		raise_error( "lpeek：対象の変数が配列として指定されています" );
		return;
	}

	const auto* const var = v->variable_;

	const auto n = stack_peek( s->stack_, arg_start +1 );
	const auto byte_idx = value_calc_int( *n );

	if ( byte_idx<0 || var->data_size_<( byte_idx + 4 ) )
	{
		raise_error( "lpeek：対象の変数の範囲外を読もうとしています@@ %s(size=%d, idx=%d)", var->name_, var->data_size_, byte_idx );
		return;
	}

	const auto* const dp = reinterpret_cast<const char*>( var->data_ );
	std::int32_t res =0;
	memcpy(&res, dp + byte_idx, 4);

	stack_pop( s->stack_, arg_num );
	stack_push( s->stack_, create_value( static_cast<int>( res ) ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edx
jle 0x92f1
cmpl $0x2, %edx
jne 0x92fa
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x930a
cmpl $0x0, 0x10(%rax)
jg 0x9313
movq 0x8(%rax), %r14
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl 0x20(%r14), %edx
testl %eax, %eax
js 0x9321
leal 0x4(%rax), %ecx
cmpl %ecx, %edx
jl 0x9321
movq 0x18(%r14), %rcx
movl %eax, %eax
movl (%rcx,%rax), %ebp
movq (%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x6c55
movq (%rbx), %rbx
movl %ebp, %edi
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6cdd
leaq 0x668b(%rip), %rdi      # 0xf983
jmp 0x931a
leaq 0x66a3(%rip), %rdi      # 0xf9a4
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
leaq 0x66ce(%rip), %rdi      # 0xf9df
jmp 0x931a
leaq 0x66f2(%rip), %rdi      # 0xfa0c
xorl %eax, %eax
callq 0x326e
movq (%r14), %rsi
leaq 0x6723(%rip), %rdi      # 0xfa4e
movl %eax, %ecx
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_rnd(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_rnd( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "rnd：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "rnd：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto m = stack_peek( s->stack_ );
	const auto r = value_calc_int( *m );
	if ( r < 1 )
	{
		raise_error( "rnd：引数は1以上である必要があります@@ %d", r );
	}

	stack_pop( s->stack_, arg_num );
	const auto res = rand() %(r);
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x938a
cmpl $0x1, %edx
jne 0x9398
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %ebp
testl %eax, %eax
jle 0x93a3
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
callq 0x20a0
cltd
idivl %ebp
movl %edx, %edi
movq (%rbx), %rbx
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6cdd
leaq 0x6715(%rip), %rdi      # 0xfaa6
xorl %eax, %eax
callq 0x326e
leaq 0x6726(%rip), %rdi      # 0xfac5
movl %edx, %esi
jmp 0x93ac
leaq 0x6754(%rip), %rdi      # 0xfafe
movl %ebp, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_abs(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_abs( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "abs：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "abs：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto m = stack_peek( s->stack_ );
	const auto r = value_calc_int( *m );

	stack_pop( s->stack_, arg_num );
	const auto res = ( r<0 ? -r : r );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x9402
cmpl $0x1, %edx
jne 0x9410
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %ebp
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movl %ebp, %edi
negl %edi
cmovsl %ebp, %edi
movq (%rbx), %rbx
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6cdd
leaq 0x672f(%rip), %rdi      # 0xfb38
xorl %eax, %eax
callq 0x326e
leaq 0x6740(%rip), %rdi      # 0xfb57
movl %edx, %esi
xorl %eax, %eax
callq 0x326e