LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq 0xf4db(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x6ee1
leal 0x1(%rax), %ecx
movl %ecx, 0xf4cc(%rip)      # 0x163a0
leaq 0xf2c5(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rax
jmp 0x6eeb
movl $0x18, %edi
callq 0x21d0
movl $0x3, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::value_move(neteruhsp::value_t*, neteruhsp::value_t*)
void value_move( value_t* to, value_t* from )
{
	clear_value( to );
	// ここも結構遅い、アーキテクチャ確定してれば早くできるが…
	memcpy( to, from, sizeof(*to) );
	memset( from, 0, sizeof(*from) );
	from->type_ = VALUE_NONE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x3, (%rdi)
jne 0x6fc9
movq 0x8(%r14), %rdi
callq 0x21a0
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movups (%rbx), %xmm0
movups %xmm0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x702b
leaq 0x53ea(%rip), %rcx      # 0xc3e8
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 0x6c00
movsd 0x8(%rdi), %xmm0
retq
pushq %rax
leaq 0x6752(%rip), %rdi      # 0xd785
leaq 0x585f(%rip), %rsi      # 0xc899
leaq 0x7e11(%rip), %rcx      # 0xee52
movl $0x11a6, %edx           # imm = 0x11A6
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x705c
cmpl $0x3, %eax
jne 0x7071
movq 0x8(%rdi), %rax
retq
movq 0x8(%rdi), %rax
cmpl $0x3, 0x8(%rax)
jne 0x7071
movl 0x10(%rdi), %esi
movq %rax, %rdi
jmp 0x64cd
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70b7
leaq 0x5374(%rip), %rcx      # 0xc3f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rdi), %edi
jmp 0x4e83
movq 0x8(%rdi), %rdi
jmp 0x3992
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %esi
movq %rax, %rdi
jmp 0x6c5c
movsd 0x8(%rdi), %xmm0
jmp 0x6cae
pushq %rax
leaq 0x66c6(%rip), %rdi      # 0xd785
leaq 0x57d3(%rip), %rsi      # 0xc899
leaq 0x7dba(%rip), %rcx      # 0xee87
movl $0x11c0, %edx           # imm = 0x11C0
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
cmpl %edi, (%rsi)
jne 0x70ed
movq %rsi, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x6e17
cmpl $0x3, %edi
je 0x715f
cmpl $0x2, %edi
je 0x7134
cmpl $0x1, %edi
jne 0x71df
movq %rsi, %rdi
callq 0x4e28
movl %eax, %ebx
movslq 0xf28f(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x71c6
leal 0x1(%rax), %ecx
movl %ecx, 0xf27c(%rip)      # 0x163a0
leaq 0xf075(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rax
jmp 0x71d0
movq %rsi, %rdi
callq 0x6fee
movslq 0xf25d(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x718d
leal 0x1(%rax), %ecx
movl %ecx, 0xf24e(%rip)      # 0x163a0
leaq 0xf047(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rax
jmp 0x71a3
movq %rsi, %rdi
callq 0x7074
movq %rax, %rbx
movslq 0xf22f(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x71b0
leal 0x1(%rax), %ecx
movl %ecx, 0xf220(%rip)      # 0x163a0
leaq 0xf019(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rax
jmp 0x71ba
movl $0x18, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x21d0
movsd 0x8(%rsp), %xmm0
movl $0x2, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x71d9
movl $0x18, %edi
callq 0x21d0
movl $0x3, (%rax)
movq %rbx, 0x8(%rax)
jmp 0x71d9
movl $0x18, %edi
callq 0x21d0
movl $0x1, (%rax)
movl %ebx, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x659f(%rip), %rdi      # 0xd785
leaq 0x56ac(%rip), %rsi      # 0xc899
leaq 0x7cc7(%rip), %rcx      # 0xeebb
movl $0x11d4, %edx           # imm = 0x11D4
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x70d7
movl (%rbx), %ecx
cmpl $0x1, %ecx
jne 0x7225
movl 0x8(%rax), %ecx
movl $0x1, (%rbx)
orl %ecx, 0x8(%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x4cd8
cmpl $0x2, %ecx
je 0x7238
cmpl $0x3, %ecx
jne 0x7246
leaq 0x7d3b(%rip), %rdi      # 0xef71
jmp 0x723f
leaq 0x7ce8(%rip), %rdi      # 0xef27
xorl %eax, %eax
callq 0x344d
leaq 0x6538(%rip), %rdi      # 0xd785
leaq 0x5645(%rip), %rsi      # 0xc899
leaq 0x7d5a(%rip), %rcx      # 0xefb5
movl $0x11ff, %edx           # imm = 0x11FF
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x70d7
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x738e
cmpl $0x2, %eax
je 0x736f
cmpl $0x1, %eax
jne 0x73c9
movl 0x8(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x8(%r14), %eax
sete %cl
movl $0x1, (%rbx)
movl %ecx, 0x8(%rbx)
jmp 0x73b7
movsd 0x8(%r14), %xmm0
cmpeqsd 0x8(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movl $0x1, (%rbx)
movl %eax, 0x8(%rbx)
jmp 0x73b7
movq 0x8(%rbx), %r15
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x2220
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
movq %r15, %rdi
callq 0x21a0
movl $0x1, (%rbx)
movl %ebp, 0x8(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4cd8
leaq 0x63b5(%rip), %rdi      # 0xd785
leaq 0x54c2(%rip), %rsi      # 0xc899
leaq 0x7d97(%rip), %rcx      # 0xf175
movl $0x1236, %edx           # imm = 0x1236
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x70d7
movl (%rbx), %ecx
cmpl $0x1, %ecx
je 0x74c3
cmpl $0x2, %ecx
jne 0x74e1
movsd 0x8(%rbx), %xmm0
ucomisd 0x8(%rax), %xmm0
seta %cl
jmp 0x74cc
movl 0x8(%rbx), %ecx
cmpl 0x8(%rax), %ecx
setg %cl
movzbl %cl, %ecx
movl $0x1, (%rbx)
movl %ecx, 0x8(%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x4cd8
cmpl $0x3, %ecx
jne 0x74f4
leaq 0x7cf3(%rip), %rdi      # 0xf1e0
xorl %eax, %eax
callq 0x344d
leaq 0x628a(%rip), %rdi      # 0xd785
leaq 0x5397(%rip), %rsi      # 0xc899
leaq 0x7d1b(%rip), %rcx      # 0xf224
movl $0x1254, %edx           # imm = 0x1254
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x70d7
movl (%rbx), %ecx
cmpl $0x1, %ecx
je 0x7539
cmpl $0x2, %ecx
jne 0x7557
movsd 0x8(%rbx), %xmm0
ucomisd 0x8(%rax), %xmm0
setae %cl
jmp 0x7542
movl 0x8(%rbx), %ecx
cmpl 0x8(%rax), %ecx
setge %cl
movzbl %cl, %ecx
movl $0x1, (%rbx)
movl %ecx, 0x8(%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x4cd8
cmpl $0x3, %ecx
jne 0x756a
leaq 0x7cf6(%rip), %rdi      # 0xf259
xorl %eax, %eax
callq 0x344d
leaq 0x6214(%rip), %rdi      # 0xd785
leaq 0x5321(%rip), %rsi      # 0xc899
leaq 0x7d1f(%rip), %rcx      # 0xf29e
movl $0x1265, %edx           # imm = 0x1265
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70d7
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x76b6
cmpl $0x2, %eax
je 0x76a4
cmpl $0x1, %eax
jne 0x7716
movl 0x8(%r14), %eax
addl %eax, 0x8(%rbx)
jmp 0x7703
movsd 0x8(%r14), %xmm0
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x7703
movq 0x8(%rbx), %rcx
movq 0x8(%r14), %r8
leaq 0x7d05(%rip), %r15      # 0xf3ca
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2270
movslq %eax, %rdi
incq %rdi
callq 0x21d0
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 0x4cd8
leaq 0x6068(%rip), %rdi      # 0xd785
leaq 0x5175(%rip), %rsi      # 0xc899
leaq 0x7ca4(%rip), %rcx      # 0xf3cf
movl $0x129c, %edx           # imm = 0x129C
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70d7
movl (%rbx), %ecx
cmpl $0x1, %ecx
je 0x775d
cmpl $0x2, %ecx
jne 0x776c
movsd 0x8(%rbx), %xmm0
subsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x7763
movl 0x8(%rax), %ecx
subl %ecx, 0x8(%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x4cd8
cmpl $0x3, %ecx
jne 0x777f
leaq 0x7c8d(%rip), %rdi      # 0xf405
xorl %eax, %eax
callq 0x344d
leaq 0x5fff(%rip), %rdi      # 0xd785
leaq 0x510c(%rip), %rsi      # 0xc899
leaq 0x7cb5(%rip), %rcx      # 0xf449
movl $0x12ad, %edx           # imm = 0x12AD
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70d7
movq %rax, %rdi
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x7846
cmpl $0x2, %eax
jne 0x785c
movsd 0x8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7836
jnp 0x7892
movsd 0x8(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
jmp 0x7856
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x7889
movl 0x8(%rbx), %eax
cltd
idivl %ecx
movl %eax, 0x8(%rbx)
popq %rbx
jmp 0x4cd8
cmpl $0x3, %eax
jne 0x786a
leaq 0x7cb0(%rip), %rdi      # 0xf518
jmp 0x7899
leaq 0x5f14(%rip), %rdi      # 0xd785
leaq 0x5021(%rip), %rsi      # 0xc899
leaq 0x7cdd(%rip), %rcx      # 0xf55c
movl $0x12dd, %edx           # imm = 0x12DD
callq 0x20e0
leaq 0x7c6b(%rip), %rdi      # 0xf4fb
jmp 0x7899
leaq 0x7c60(%rip), %rdi      # 0xf4f9
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70d7
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x78e0
cmpl $0x2, %eax
jne 0x7900
movsd 0x8(%r14), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x78cf
jnp 0x7936
movsd 0x8(%rbx), %xmm0
callq 0x21f0
movsd %xmm0, 0x8(%rbx)
jmp 0x78f1
movl 0x8(%r14), %ecx
testl %ecx, %ecx
je 0x792d
movl 0x8(%rbx), %eax
cltd
idivl %ecx
movl %edx, 0x8(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4cd8
cmpl $0x3, %eax
jne 0x790e
leaq 0x7ca3(%rip), %rdi      # 0xf5af
jmp 0x793d
leaq 0x5e70(%rip), %rdi      # 0xd785
leaq 0x4f7d(%rip), %rsi      # 0xc899
leaq 0x7cd0(%rip), %rcx      # 0xf5f3
movl $0x12fc, %edx           # imm = 0x12FC
callq 0x20e0
leaq 0x7c5e(%rip), %rdi      # 0xf592
jmp 0x793d
leaq 0x7bbc(%rip), %rdi      # 0xf4f9
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7963
cmpl $0x2, %eax
jne 0x7968
movsd 0x8(%rdi), %xmm0
xorps 0x4f03(%rip), %xmm0     # 0xc860
movlps %xmm0, 0x8(%rdi)
jmp 0x7966
negl 0x8(%rdi)
popq %rax
retq
cmpl $0x3, %eax
jne 0x797f
movq 0x8(%rdi), %rsi
leaq 0x7cb1(%rip), %rdi      # 0xf629
xorl %eax, %eax
callq 0x344d
leaq 0x5dff(%rip), %rdi      # 0xd785
leaq 0x4f0c(%rip), %rsi      # 0xc899
leaq 0x7cc1(%rip), %rcx      # 0xf655
movl $0x1308, %edx           # imm = 0x1308
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7a28
movq (%rbx), %rdi
callq 0x21a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7a96
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7a6f
movq %rdi, %r14
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
movq (%r14), %rcx
cltq
movq -0x8(%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x7a77
callq 0x4cd8
movq (%r14), %rcx
movslq 0x8(%r14), %rax
movq $0x0, (%rcx,%rax,8)
decq %rbx
jne 0x7a40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7ca6(%rip), %rdi      # 0xf724
leaq 0x4e14(%rip), %rsi      # 0xc899
leaq 0x7c65(%rip), %rcx      # 0xf6f1
movl $0x134b, %edx           # imm = 0x134B
callq 0x20e0
leaq 0x7c31(%rip), %rdi      # 0xf6ce
leaq 0x4df5(%rip), %rsi      # 0xc899
leaq 0x7c46(%rip), %rcx      # 0xf6f1
movl $0x1347, %edx           # imm = 0x1347
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
movq (%rdi), %r15
testq %r15, %r15
je 0x7c7b
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x35d0
movq %r14, %rdi
callq 0x21a0
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x7c5b
movq (%rbx), %rdi
callq 0x2c8a
movq (%rbx), %rdi
callq 0x21a0
movq 0x8(%rbx), %rdi
movq (%rdi), %r14
testq %r14, %r14
je 0x7caa
movq 0x10(%r14), %rdi
callq 0x5089
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x7c94
movq 0x8(%rbx), %rdi
callq 0x2c8a
movq 0x8(%rbx), %rdi
callq 0x21a0
movq 0x10(%rbx), %rdi
movq (%rdi), %r15
testq %r15, %r15
je 0x7ced
movq 0x10(%r15), %r14
movq (%r14), %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x21a0
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x7cc4
movq 0x10(%rbx), %rdi
callq 0x2c8a
movq 0x10(%rbx), %rdi
callq 0x21a0
movq 0x20(%rbx), %rdi
callq 0x7bbd
movq 0x18(%rbx), %rdi
callq 0x6299
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x7fa5
cmpl $0x20, %eax
je 0x7f67
cmpl $0xe, %eax
jne 0x7fe6
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r12
movq 0x18(%r14), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x62ce
testq %rax, %rax
jne 0x7fe6
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x630b
jmp 0x7fe6
movl $0x1, %edi
movl $0x18, %esi
callq 0x20f0
movq %rax, %r12
movl $0x10, %edi
callq 0x21d0
movq %rax, %r13
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3992
movq %rax, (%r13)
movq %r13, 0x10(%r12)
movq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0x2be3
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x7ff7
movq %r14, %rdi
callq 0x7f3e
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x7f56
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7d1a
movl %ebp, 0x8(%r14)
movq 0x20(%rbx), %rax
cmpq $0x0, (%rax)
je 0x8b2b
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80aa
movq (%r14), %rdi
callq 0x79ed
movq 0x1a8(%r14), %rdi
callq 0x21a0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6ef2(%rip), %rdi      # 0xfa24
movq %rbx, %rsi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9dff
cmpl $0x2, %edx
jne 0x9e08
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
cmpl $0x4, (%rax)
jne 0x9e11
movq %rax, %r14
cmpl $0x0, 0x10(%rax)
jg 0x9e1a
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
testl %eax, %eax
jle 0x9e23
movq 0x8(%r14), %rdi
movl $0x1, %esi
movl $0x40, %edx
movl %eax, %ecx
callq 0x61a1
movq (%rbx), %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a28
leaq 0x6264(%rip), %rdi      # 0x1006a
jmp 0x9e2a
leaq 0x627b(%rip), %rdi      # 0x1008a
jmp 0x9e2a
leaq 0x62d5(%rip), %rdi      # 0x100ed
jmp 0x9e2a
leaq 0x62f8(%rip), %rdi      # 0x10119
jmp 0x9e2a
leaq 0x6330(%rip), %rdi      # 0x1015a
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9e9f
cmpl $0x2, %edx
jne 0x9ea8
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
cmpl $0x4, (%rax)
jne 0x9eb1
movq %rax, %r14
cmpl $0x0, 0x10(%rax)
jg 0x9eba
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
testl %eax, %eax
jle 0x9ec3
movq 0x8(%r14), %rdi
movl $0x2, %esi
movl $0x40, %edx
movl %eax, %ecx
callq 0x61a1
movq (%rbx), %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a28
leaq 0x61c3(%rip), %rdi      # 0x10069
jmp 0x9eca
leaq 0x61da(%rip), %rdi      # 0x10089
jmp 0x9eca
leaq 0x6234(%rip), %rdi      # 0x100ec
jmp 0x9eca
leaq 0x6257(%rip), %rdi      # 0x10118
jmp 0x9eca
leaq 0x628f(%rip), %rdi      # 0x10159
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9f83
movl %edx, %ebx
cmpl $0x4, %edx
jae 0x9f8c
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7b11
cmpl $0x4, (%rax)
jne 0x9f95
movq %rax, %r15
cmpl $0x0, 0x10(%rax)
jg 0x9f9e
movq (%r14), %rdi
movl $0x1, %r12d
movl $0x1, %esi
subl %ebx, %esi
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %ebp
cmpl $0x2, %ebx
jne 0x9f3c
testl %ebp, %ebp
jg 0x9f5e
jmp 0x9fa7
movq (%r14), %rdi
movl $0x2, %esi
subl %ebx, %esi
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
testl %ebp, %ebp
jle 0x9fa7
movl %eax, %r12d
testl %eax, %eax
jle 0x9fb0
movq 0x8(%r15), %rdi
movl $0x3, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x61a1
movq (%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a28
leaq 0x6202(%rip), %rdi      # 0x1018c
jmp 0x9fb7
leaq 0x6219(%rip), %rdi      # 0x101ac
jmp 0x9fb7
leaq 0x6273(%rip), %rdi      # 0x1020f
jmp 0x9fb7
leaq 0x6296(%rip), %rdi      # 0x1023b
jmp 0x9fb7
leaq 0x62ce(%rip), %rdi      # 0x1027c
jmp 0x9fb7
leaq 0x62fe(%rip), %rdi      # 0x102b5
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa03d
cmpl $0x3, %edx
jne 0xa046
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7b11
cmpl $0x4, (%rax)
jne 0xa04f
cmpl $0x0, 0x10(%rax)
jg 0xa058
movq 0x8(%rax), %r14
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %ebp
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl 0x20(%r14), %edx
testl %ebp, %ebp
js 0xa066
cmpl %ebp, %edx
jle 0xa066
movq 0x18(%r14), %rcx
movl %ebp, %edx
movb %al, (%rcx,%rdx)
movq (%rbx), %rdi
movl $0x3, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7a28
leaq 0x63f7(%rip), %rdi      # 0x1043b
jmp 0xa05f
leaq 0x640f(%rip), %rdi      # 0x1045c
jmp 0xa05f
leaq 0x646a(%rip), %rdi      # 0x104c0
jmp 0xa05f
leaq 0x648e(%rip), %rdi      # 0x104ed
xorl %eax, %eax
callq 0x344d
movq (%r14), %rsi
leaq 0x64bf(%rip), %rdi      # 0x1052f
movl %ebp, %ecx
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa10a
cmpl $0x3, %edx
jne 0xa113
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7b11
cmpl $0x4, (%rax)
jne 0xa11c
cmpl $0x0, 0x10(%rax)
jg 0xa125
movq 0x8(%rax), %r15
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %r14d
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl 0x20(%r15), %edx
testl %r14d, %r14d
js 0xa133
leal 0x2(%r14), %ecx
cmpl %ecx, %edx
jl 0xa133
movq 0x18(%r15), %rcx
movl %r14d, %edx
movw %ax, (%rcx,%rdx)
movq (%rbx), %rdi
movl $0x3, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7a28
leaq 0x61d7(%rip), %rdi      # 0x102e8
jmp 0xa12c
leaq 0x61ef(%rip), %rdi      # 0x10309
jmp 0xa12c
leaq 0x624a(%rip), %rdi      # 0x1036d
jmp 0xa12c
leaq 0x626e(%rip), %rdi      # 0x1039a
xorl %eax, %eax
callq 0x344d
movq (%r15), %rsi
leaq 0x629f(%rip), %rdi      # 0x103dc
movl %r14d, %ecx
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa1d7
cmpl $0x3, %edx
jne 0xa1e0
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7b11
cmpl $0x4, (%rax)
jne 0xa1e9
cmpl $0x0, 0x10(%rax)
jg 0xa1f2
movq 0x8(%rax), %r15
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %r14d
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl 0x20(%r15), %edx
testl %r14d, %r14d
js 0xa200
leal 0x4(%r14), %ecx
cmpl %ecx, %edx
jl 0xa200
movq 0x18(%r15), %rcx
movl %r14d, %edx
movl %eax, (%rcx,%rdx)
movq (%rbx), %rdi
movl $0x3, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7a28
leaq 0x625c(%rip), %rdi      # 0x1043a
jmp 0xa1f9
leaq 0x6274(%rip), %rdi      # 0x1045b
jmp 0xa1f9
leaq 0x62cf(%rip), %rdi      # 0x104bf
jmp 0xa1f9
leaq 0x62f3(%rip), %rdi      # 0x104ec
xorl %eax, %eax
callq 0x344d
movq (%r15), %rsi
leaq 0x6324(%rip), %rdi      # 0x1052e
movl %r14d, %ecx
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa25f
cmpl $0x1, %edx
jne 0xa268
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r14
movq %rax, %rdi
callq 0x4d52
cmpl $0x3, (%r14)
jne 0xa278
movq 0x8(%r14), %rdi
callq 0x2240
movq (%rbx), %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a28
leaq 0x6326(%rip), %rdi      # 0x1058c
jmp 0xa27f
leaq 0x633c(%rip), %rdi      # 0x105ab
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
leaq 0x6365(%rip), %rdi      # 0x105e4
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa4a6
movl %edx, %ebx
movq %rsi, %r14
testl %edx, %edx
je 0xa486
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
jmp 0xa48d
xorl %edi, %edi
callq 0x2130
movl %eax, %edi
callq 0x2150
movq (%r14), %rdi
movslq %ebx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a28
leaq 0x6219(%rip), %rdi      # 0x106c6
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xa5be
cmpl $0x1, %edx
jne 0xa5cc
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %ebx
movq (%r14), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%r14), %r14
movslq 0xbe23(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xa599
leal 0x1(%rax), %ecx
movl %ecx, 0xbe14(%rip)      # 0x163a0
leaq 0xbc0d(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xa5a6
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebx, 0x8(%rsi)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7ab5
leaq 0x618d(%rip), %rdi      # 0x10752
xorl %eax, %eax
callq 0x344d
leaq 0x619e(%rip), %rdi      # 0x10771
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa66e
cmpl $0x1, %edx
jne 0xa67c
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xbd79(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xa643
leal 0x1(%rax), %ecx
movl %ecx, 0xbd6a(%rip)      # 0x163a0
leaq 0xbb63(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xa650
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x7ab5
leaq 0x6135(%rip), %rdi      # 0x107aa
xorl %eax, %eax
callq 0x344d
leaq 0x6149(%rip), %rdi      # 0x107cc
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa711
cmpl $0x1, %edx
jne 0xa71f
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x7074
movq %rax, %rbx
movq (%r14), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%r14), %r14
movslq 0xbcd1(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xa6eb
leal 0x1(%rax), %ecx
movl %ecx, 0xbcc2(%rip)      # 0x163a0
leaq 0xbabb(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xa6f8
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x3, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7ab5
leaq 0x60f0(%rip), %rdi      # 0x10808
xorl %eax, %eax
callq 0x344d
leaq 0x6101(%rip), %rdi      # 0x10827
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7f4
cmpl $0x2, %edx
jne 0xa7fd
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
cmpl $0x4, (%rax)
jne 0xa80d
cmpl $0x0, 0x10(%rax)
jg 0xa816
movq 0x8(%rax), %r14
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl 0x20(%r14), %edx
testl %eax, %eax
js 0xa824
cmpl %eax, %edx
jle 0xa824
movq 0x18(%r14), %rcx
movl %eax, %eax
movsbl (%rcx,%rax), %ebp
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xbbea(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xa7d2
leal 0x1(%rax), %ecx
movl %ecx, 0xbbdb(%rip)      # 0x163a0
leaq 0xb9d4(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xa7df
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ab5
leaq 0x6189(%rip), %rdi      # 0x10984
jmp 0xa81d
leaq 0x61a1(%rip), %rdi      # 0x109a5
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
leaq 0x61cc(%rip), %rdi      # 0x109e0
jmp 0xa81d
leaq 0x61f0(%rip), %rdi      # 0x10a0d
xorl %eax, %eax
callq 0x344d
movq (%r14), %rsi
leaq 0x6221(%rip), %rdi      # 0x10a4f
movl %eax, %ecx
xorl %eax, %eax
callq 0x344d