LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(neteruhsp::value_t const&)
value_t* create_value( const value_t& v )
{
	value_t* res =alloc_value();
	res->type_ = v.type_;
	switch( v.type_ )
	{
		case VALUE_INT:			res->ivalue_ =v.ivalue_; break;
		case VALUE_DOUBLE:		res->dvalue_ =v.dvalue_; break;
		case VALUE_STRING:		res->svalue_ =create_string(v.svalue_); break;
		case VALUE_VARIABLE:	res->variable_ =v.variable_; res->index_ =v.index_; break;
		default: raise_error( "中身が入ってない値をコピーして作ろうとしました@@ ptr=%p", &v );
	}
	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x1017b(%rip), %rax     # 0x173a0
cmpq $0x3f, %rax
jg 0x7241
leal 0x1(%rax), %ecx
movl %ecx, 0x1016c(%rip)     # 0x173a0
leaq 0xff65(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %r14
jmp 0x724e
movl $0x18, %edi
callq 0x21d0
movq %rax, %r14
movl (%rbx), %eax
movl %eax, (%r14)
movl (%rbx), %eax
decl %eax
cmpl $0x3, %eax
ja 0x72ab
leaq 0x61b5(%rip), %rcx      # 0xd418
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
jmp 0x72a0
movq 0x8(%rbx), %rdi
callq 0x3a4c
movq %rax, 0x8(%r14)
jmp 0x72a0
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
jmp 0x72a0
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8bf4(%rip), %rdi      # 0xfea6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 0x100d9(%rip), %rax     # 0x173a0
cmpq $0x3f, %rax
jg 0x72e3
leal 0x1(%rax), %ecx
movl %ecx, 0x100ca(%rip)     # 0x173a0
leaq 0xfec3(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rax
jmp 0x72ed
movl $0x18, %edi
callq 0x21d0
movl $0x3, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x73cb
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_O1/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 0x742d
leaq 0x6028(%rip), %rcx      # 0xd428
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 0x7000
movsd 0x8(%rdi), %xmm0
retq
pushq %rax
leaq 0x73c2(%rip), %rdi      # 0xe7f7
leaq 0x649d(%rip), %rsi      # 0xd8d9
leaq 0x8b15(%rip), %rcx      # 0xff58
movl $0x11a6, %edx           # imm = 0x11A6
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x745e
cmpl $0x3, %eax
jne 0x7473
movq 0x8(%rdi), %rax
retq
movq 0x8(%rdi), %rax
cmpl $0x3, 0x8(%rax)
jne 0x7473
movl 0x10(%rdi), %esi
movq %rax, %rdi
jmp 0x68db
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74b9
leaq 0x5fb2(%rip), %rcx      # 0xd438
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%rdi), %edi
jmp 0x523a
movq 0x8(%rdi), %rdi
jmp 0x3a4c
movq 0x8(%rdi), %rax
movl 0x10(%rdi), %esi
movq %rax, %rdi
jmp 0x705c
movsd 0x8(%rdi), %xmm0
jmp 0x70ae
pushq %rax
leaq 0x7336(%rip), %rdi      # 0xe7f7
leaq 0x6411(%rip), %rsi      # 0xd8d9
leaq 0x8abe(%rip), %rcx      # 0xff8d
movl $0x11c0, %edx           # imm = 0x11C0
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74ef
movq %rsi, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x7217
cmpl $0x3, %edi
je 0x7561
cmpl $0x2, %edi
je 0x7536
cmpl $0x1, %edi
jne 0x75e1
movq %rsi, %rdi
callq 0x51df
movl %eax, %ebx
movslq 0xfe8d(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0x75c8
leal 0x1(%rax), %ecx
movl %ecx, 0xfe7a(%rip)      # 0x173a0
leaq 0xfc73(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rax
jmp 0x75d2
movq %rsi, %rdi
callq 0x73f0
movslq 0xfe5b(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0x758f
leal 0x1(%rax), %ecx
movl %ecx, 0xfe4c(%rip)      # 0x173a0
leaq 0xfc45(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rax
jmp 0x75a5
movq %rsi, %rdi
callq 0x7476
movq %rax, %rbx
movslq 0xfe2d(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0x75b2
leal 0x1(%rax), %ecx
movl %ecx, 0xfe1e(%rip)      # 0x173a0
leaq 0xfc17(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rax
jmp 0x75bc
movl $0x18, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x21d0
movsd 0x8(%rsp), %xmm0
movl $0x2, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x75db
movl $0x18, %edi
callq 0x21d0
movl $0x3, (%rax)
movq %rbx, 0x8(%rax)
jmp 0x75db
movl $0x18, %edi
callq 0x21d0
movl $0x1, (%rax)
movl %ebx, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x720f(%rip), %rdi      # 0xe7f7
leaq 0x62ea(%rip), %rsi      # 0xd8d9
leaq 0x89cb(%rip), %rcx      # 0xffc1
movl $0x11d4, %edx           # imm = 0x11D4
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movl (%rbx), %ecx
cmpl $0x1, %ecx
jne 0x7627
movl 0x8(%rax), %ecx
movl $0x1, (%rbx)
orl %ecx, 0x8(%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x507f
cmpl $0x2, %ecx
je 0x763a
cmpl $0x3, %ecx
jne 0x7648
leaq 0x8a3f(%rip), %rdi      # 0x10077
jmp 0x7641
leaq 0x89ec(%rip), %rdi      # 0x1002d
xorl %eax, %eax
callq 0x34a8
leaq 0x71a8(%rip), %rdi      # 0xe7f7
leaq 0x6283(%rip), %rsi      # 0xd8d9
leaq 0x8a5e(%rip), %rcx      # 0x100bb
movl $0x11ff, %edx           # imm = 0x11FF
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x7790
cmpl $0x2, %eax
je 0x7771
cmpl $0x1, %eax
jne 0x77cb
movl 0x8(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x8(%r14), %eax
sete %cl
movl $0x1, (%rbx)
movl %ecx, 0x8(%rbx)
jmp 0x77b9
movsd 0x8(%r14), %xmm0
cmpeqsd 0x8(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movl $0x1, (%rbx)
movl %eax, 0x8(%rbx)
jmp 0x77b9
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 0x507f
leaq 0x7025(%rip), %rdi      # 0xe7f7
leaq 0x6100(%rip), %rsi      # 0xd8d9
leaq 0x8a9b(%rip), %rcx      # 0x1027b
movl $0x1236, %edx           # imm = 0x1236
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movl (%rbx), %ecx
cmpl $0x1, %ecx
je 0x78c5
cmpl $0x2, %ecx
jne 0x78e3
movsd 0x8(%rbx), %xmm0
ucomisd 0x8(%rax), %xmm0
seta %cl
jmp 0x78ce
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 0x507f
cmpl $0x3, %ecx
jne 0x78f6
leaq 0x89f7(%rip), %rdi      # 0x102e6
xorl %eax, %eax
callq 0x34a8
leaq 0x6efa(%rip), %rdi      # 0xe7f7
leaq 0x5fd5(%rip), %rsi      # 0xd8d9
leaq 0x8a1f(%rip), %rcx      # 0x1032a
movl $0x1254, %edx           # imm = 0x1254
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movl (%rbx), %ecx
cmpl $0x1, %ecx
je 0x793b
cmpl $0x2, %ecx
jne 0x7959
movsd 0x8(%rbx), %xmm0
ucomisd 0x8(%rax), %xmm0
setae %cl
jmp 0x7944
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 0x507f
cmpl $0x3, %ecx
jne 0x796c
leaq 0x89fa(%rip), %rdi      # 0x1035f
xorl %eax, %eax
callq 0x34a8
leaq 0x6e84(%rip), %rdi      # 0xe7f7
leaq 0x5f5f(%rip), %rsi      # 0xd8d9
leaq 0x8a23(%rip), %rcx      # 0x103a4
movl $0x1265, %edx           # imm = 0x1265
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x3, %eax
je 0x7ab8
cmpl $0x2, %eax
je 0x7aa6
cmpl $0x1, %eax
jne 0x7b18
movl 0x8(%r14), %eax
addl %eax, 0x8(%rbx)
jmp 0x7b05
movsd 0x8(%r14), %xmm0
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x7b05
movq 0x8(%rbx), %rcx
movq 0x8(%r14), %r8
leaq 0x8a09(%rip), %r15      # 0x104d0
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 0x507f
leaq 0x6cd8(%rip), %rdi      # 0xe7f7
leaq 0x5db3(%rip), %rsi      # 0xd8d9
leaq 0x89a8(%rip), %rcx      # 0x104d5
movl $0x129c, %edx           # imm = 0x129C
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movl (%rbx), %ecx
cmpl $0x1, %ecx
je 0x7b5f
cmpl $0x2, %ecx
jne 0x7b6e
movsd 0x8(%rbx), %xmm0
subsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x7b65
movl 0x8(%rax), %ecx
subl %ecx, 0x8(%rbx)
movq %rax, %rdi
popq %rbx
jmp 0x507f
cmpl $0x3, %ecx
jne 0x7b81
leaq 0x8991(%rip), %rdi      # 0x1050b
xorl %eax, %eax
callq 0x34a8
leaq 0x6c6f(%rip), %rdi      # 0xe7f7
leaq 0x5d4a(%rip), %rsi      # 0xd8d9
leaq 0x89b9(%rip), %rcx      # 0x1054f
movl $0x12ad, %edx           # imm = 0x12AD
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movq %rax, %rdi
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x7c48
cmpl $0x2, %eax
jne 0x7c5e
movsd 0x8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7c38
jnp 0x7c94
movsd 0x8(%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
jmp 0x7c58
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x7c8b
movl 0x8(%rbx), %eax
cltd
idivl %ecx
movl %eax, 0x8(%rbx)
popq %rbx
jmp 0x507f
cmpl $0x3, %eax
jne 0x7c6c
leaq 0x89b4(%rip), %rdi      # 0x1061e
jmp 0x7c9b
leaq 0x6b84(%rip), %rdi      # 0xe7f7
leaq 0x5c5f(%rip), %rsi      # 0xd8d9
leaq 0x89e1(%rip), %rcx      # 0x10662
movl $0x12dd, %edx           # imm = 0x12DD
callq 0x20f0
leaq 0x896f(%rip), %rdi      # 0x10601
jmp 0x7c9b
leaq 0x8964(%rip), %rdi      # 0x105ff
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74d9
movq %rax, %r14
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x7ce2
cmpl $0x2, %eax
jne 0x7d02
movsd 0x8(%r14), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x7cd1
jnp 0x7d38
movsd 0x8(%rbx), %xmm0
callq 0x21f0
movsd %xmm0, 0x8(%rbx)
jmp 0x7cf3
movl 0x8(%r14), %ecx
testl %ecx, %ecx
je 0x7d2f
movl 0x8(%rbx), %eax
cltd
idivl %ecx
movl %edx, 0x8(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x507f
cmpl $0x3, %eax
jne 0x7d10
leaq 0x89a7(%rip), %rdi      # 0x106b5
jmp 0x7d3f
leaq 0x6ae0(%rip), %rdi      # 0xe7f7
leaq 0x5bbb(%rip), %rsi      # 0xd8d9
leaq 0x89d4(%rip), %rcx      # 0x106f9
movl $0x12fc, %edx           # imm = 0x12FC
callq 0x20f0
leaq 0x8962(%rip), %rdi      # 0x10698
jmp 0x7d3f
leaq 0x88c0(%rip), %rdi      # 0x105ff
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d65
cmpl $0x2, %eax
jne 0x7d6a
movsd 0x8(%rdi), %xmm0
xorps 0x5b41(%rip), %xmm0     # 0xd8a0
movlps %xmm0, 0x8(%rdi)
jmp 0x7d68
negl 0x8(%rdi)
popq %rax
retq
cmpl $0x3, %eax
jne 0x7d81
movq 0x8(%rdi), %rsi
leaq 0x89b5(%rip), %rdi      # 0x1072f
xorl %eax, %eax
callq 0x34a8
leaq 0x6a6f(%rip), %rdi      # 0xe7f7
leaq 0x5b4a(%rip), %rsi      # 0xd8d9
leaq 0x89c5(%rip), %rcx      # 0x1075b
movl $0x1308, %edx           # imm = 0x1308
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7e30
movq (%rbx), %rdi
callq 0x21a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ea1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7e7a
movq %rdi, %r14
movslq 0x8(%r14), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0x8(%r14)
movq (%r14), %rcx
movq -0x8(%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x7e82
callq 0x507f
movq (%r14), %rax
movslq 0x8(%r14), %rcx
movq $0x0, (%rax,%rcx,8)
decq %rbx
jne 0x7e48
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x89a1(%rip), %rdi      # 0x1082a
leaq 0x5a49(%rip), %rsi      # 0xd8d9
leaq 0x8960(%rip), %rcx      # 0x107f7
movl $0x134b, %edx           # imm = 0x134B
callq 0x20f0
leaq 0x892c(%rip), %rdi      # 0x107d4
leaq 0x5a2a(%rip), %rsi      # 0xd8d9
leaq 0x8941(%rip), %rcx      # 0x107f7
movl $0x1347, %edx           # imm = 0x1347
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq 0xc(%rdi), %rsi
cmpl %esi, 0x8(%rdi)
jl 0x7ee8
leal (%rsi,%rsi), %eax
movl %eax, 0xc(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x2280
movq %rax, (%rbx)
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x8097
movq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x3634
movq %r14, %rdi
callq 0x21a0
movq 0x8(%r15), %r15
jmp 0x8078
movq (%rbx), %rdi
callq 0x2d06
movq (%rbx), %rdi
callq 0x21a0
movq 0x8(%rbx), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x80c2
movq 0x10(%r14), %rdi
callq 0x544d
movq 0x8(%r14), %r14
jmp 0x80ae
movq 0x8(%rbx), %rdi
callq 0x2d06
movq 0x8(%rbx), %rdi
callq 0x21a0
movq 0x10(%rbx), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x8102
movq 0x10(%r15), %r14
movq (%r14), %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x21a0
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %r15
jmp 0x80db
movq 0x10(%rbx), %rdi
callq 0x2d06
movq 0x10(%rbx), %rdi
callq 0x21a0
movq 0x20(%rbx), %rdi
callq 0x7fd2
movq 0x18(%rbx), %rdi
callq 0x6670
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x21d0
movq %rax, %r14
movl $0x80, %edi
callq 0x21d0
movq %rax, (%r14)
movabsq $0x1000000000, %rax     # imm = 0x1000000000
movq %rax, 0x8(%r14)
movq %r14, (%rbx)
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq %r14, 0x4c(%rbx)
movl %r14d, 0x190(%rbx)
movq %r14, 0x58(%rbx)
movl %r14d, 0x60(%rbx)
movb $0x0, 0x194(%rbx)
movl %r14d, 0x198(%rbx)
movq %r14, 0x1a0(%rbx)
leaq 0x4fb6(%rip), %rdi      # 0xd151
callq 0x3a4c
movq %rax, 0x1a8(%rbx)
movl %r14d, 0x1b0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x83f5
cmpl $0x20, %eax
je 0x8388
cmpl $0xe, %eax
jne 0x843f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r12
movq 0x18(%r14), %r13
movq (%r13), %rbp
testq %rbp, %rbp
je 0x83c4
movq 0x10(%rbp), %r15
movq (%r15), %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2da2
testb %al, %al
je 0x83ba
movq %r15, %r14
jmp 0x83be
movq 0x8(%rbp), %rbp
testb %al, %al
je 0x8398
jmp 0x83c7
xorl %r14d, %r14d
testq %r14, %r14
movq 0x8(%rsp), %r14
jne 0x843f
movl $0x1, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x66f2
jmp 0x843f
movl $0x18, %edi
callq 0x21d0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x10, %edi
callq 0x21d0
movq %rax, %r13
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3a4c
movq %rax, (%r13)
movq %r13, 0x10(%r12)
movq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0x2c58
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x8450
movq %r14, %rdi
callq 0x835a
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x8373
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::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 0x8133
movl %ebp, 0x8(%r14)
movq 0x20(%rbx), %rax
cmpq $0x0, (%rax)
je 0x9061
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8504
movq (%r14), %rdi
callq 0x7def
movq 0x1a8(%r14), %rdi
callq 0x21a0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7ac2(%rip), %rdi      # 0x10b2a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
cmpl $0x1, %edx
jle 0xa322
movl %edx, %ebx
cmpl $0x2, %edx
jne 0xa32b
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xa334
movq %rax, %r15
cmpl $0x0, 0x10(%rax)
jg 0xa33d
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %eax, %eax
jle 0xa346
movq 0x8(%r15), %rdi
movl $0x1, %esi
movl $0x40, %edx
movl %eax, %ecx
callq 0x6565
movq (%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7e30
leaq 0x6e47(%rip), %rdi      # 0x11170
jmp 0xa34d
leaq 0x6e5e(%rip), %rdi      # 0x11190
jmp 0xa34d
leaq 0x6eb8(%rip), %rdi      # 0x111f3
jmp 0xa34d
leaq 0x6edb(%rip), %rdi      # 0x1121f
jmp 0xa34d
leaq 0x6f13(%rip), %rdi      # 0x11260
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
cmpl $0x1, %edx
jle 0xa3c1
movl %edx, %ebx
cmpl $0x2, %edx
jne 0xa3ca
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xa3d3
movq %rax, %r15
cmpl $0x0, 0x10(%rax)
jg 0xa3dc
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %eax, %eax
jle 0xa3e5
movq 0x8(%r15), %rdi
movl $0x2, %esi
movl $0x40, %edx
movl %eax, %ecx
callq 0x6565
movq (%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7e30
leaq 0x6da7(%rip), %rdi      # 0x1116f
jmp 0xa3ec
leaq 0x6dbe(%rip), %rdi      # 0x1118f
jmp 0xa3ec
leaq 0x6e18(%rip), %rdi      # 0x111f2
jmp 0xa3ec
leaq 0x6e3b(%rip), %rdi      # 0x1121e
jmp 0xa3ec
leaq 0x6e73(%rip), %rdi      # 0x1125f
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa4a0
movl %edx, %ebx
cmpl $0x4, %edx
jge 0xa4a9
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xa4b2
movq %rax, %r15
cmpl $0x0, 0x10(%rax)
jg 0xa4bb
movq (%r14), %rdi
movl $0x1, %r12d
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %ebp
cmpl $0x2, %ebx
je 0xa472
movq (%r14), %rdi
movl $0x2, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %r12d
testl %ebp, %ebp
jle 0xa4c4
testl %r12d, %r12d
jle 0xa4cd
movq 0x8(%r15), %rdi
movl $0x3, %esi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x6565
movq (%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7e30
leaq 0x6deb(%rip), %rdi      # 0x11292
jmp 0xa4d4
leaq 0x6e02(%rip), %rdi      # 0x112b2
jmp 0xa4d4
leaq 0x6e5c(%rip), %rdi      # 0x11315
jmp 0xa4d4
leaq 0x6e7f(%rip), %rdi      # 0x11341
jmp 0xa4d4
leaq 0x6eb7(%rip), %rdi      # 0x11382
jmp 0xa4d4
leaq 0x6ee7(%rip), %rdi      # 0x113bb
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edx
jle 0xa58a
movl %edx, %ebx
cmpl $0x3, %edx
jne 0xa593
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xa59c
cmpl $0x0, 0x10(%rax)
jg 0xa5a5
movq 0x8(%rax), %r15
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %ebp
movq (%r14), %rdi
movl $0x2, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %ebp, %ebp
js 0xa573
cmpl %ebp, 0x20(%r15)
jle 0xa573
movq 0x18(%r15), %rcx
movl %ebp, %edx
movb %al, (%rcx,%rdx)
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7e30
movq (%r15), %rsi
movl 0x20(%r15), %edx
leaq 0x70b4(%rip), %rdi      # 0x11635
movl %ebp, %ecx
xorl %eax, %eax
callq 0x34a8
leaq 0x6fb0(%rip), %rdi      # 0x11541
jmp 0xa5ac
leaq 0x6fc8(%rip), %rdi      # 0x11562
jmp 0xa5ac
leaq 0x7023(%rip), %rdi      # 0x115c6
jmp 0xa5ac
leaq 0x7047(%rip), %rdi      # 0x115f3
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edx
jle 0xa671
movl %edx, %ebx
cmpl $0x3, %edx
jne 0xa67a
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xa683
cmpl $0x0, 0x10(%rax)
jg 0xa68c
movq 0x8(%rax), %r12
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %r15d
movq (%r14), %rdi
movl $0x2, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %r15d, %r15d
js 0xa657
leal 0x2(%r15), %ecx
cmpl %ecx, 0x20(%r12)
jl 0xa657
movq 0x18(%r12), %rcx
movl %r15d, %edx
movw %ax, (%rcx,%rdx)
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7e30
movq (%r12), %rsi
movl 0x20(%r12), %edx
leaq 0x6e7b(%rip), %rdi      # 0x114e2
movl %r15d, %ecx
xorl %eax, %eax
callq 0x34a8
leaq 0x6d76(%rip), %rdi      # 0x113ee
jmp 0xa693
leaq 0x6d8e(%rip), %rdi      # 0x1140f
jmp 0xa693
leaq 0x6de9(%rip), %rdi      # 0x11473
jmp 0xa693
leaq 0x6e0d(%rip), %rdi      # 0x114a0
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edx
jle 0xa757
movl %edx, %ebx
cmpl $0x3, %edx
jne 0xa760
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xa769
cmpl $0x0, 0x10(%rax)
jg 0xa772
movq 0x8(%rax), %r12
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %r15d
movq (%r14), %rdi
movl $0x2, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %r15d, %r15d
js 0xa73d
leal 0x4(%r15), %ecx
cmpl %ecx, 0x20(%r12)
jl 0xa73d
movq 0x18(%r12), %rcx
movl %r15d, %edx
movl %eax, (%rcx,%rdx)
movq (%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7e30
movq (%r12), %rsi
movl 0x20(%r12), %edx
leaq 0x6ee7(%rip), %rdi      # 0x11634
movl %r15d, %ecx
xorl %eax, %eax
callq 0x34a8
leaq 0x6de2(%rip), %rdi      # 0x11540
jmp 0xa779
leaq 0x6dfa(%rip), %rdi      # 0x11561
jmp 0xa779
leaq 0x6e55(%rip), %rdi      # 0x115c5
jmp 0xa779
leaq 0x6e79(%rip), %rdi      # 0x115f2
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testl %edx, %edx
jle 0xa7c9
movl %edx, %ebx
cmpl $0x1, %edx
jne 0xa7d2
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %r15
movq %rax, %rdi
callq 0x5109
cmpl $0x3, (%r15)
jne 0xa7e2
movq 0x8(%r15), %rdi
callq 0x2240
movq (%r14), %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7e30
leaq 0x6ec2(%rip), %rdi      # 0x11692
jmp 0xa7e9
leaq 0x6ed8(%rip), %rdi      # 0x116b1
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
leaq 0x6f01(%rip), %rdi      # 0x116ea
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaa38
movl %edx, %ebx
movq %rsi, %r14
testl %edx, %edx
je 0xaa18
movq (%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x51df
jmp 0xaa1f
xorl %edi, %edi
callq 0x2130
movl %eax, %edi
callq 0x2150
movq (%r14), %rdi
movslq %ebx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7e30
leaq 0x6d8d(%rip), %rdi      # 0x117cc
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
testl %edx, %edx
jle 0xab48
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xab56
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %ebx
movq (%r14), %rdi
movl %ebp, %esi
callq 0x7e30
movq (%r14), %r14
movslq 0xc896(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xab26
leal 0x1(%rax), %ecx
movl %ecx, 0xc887(%rip)      # 0x173a0
leaq 0xc680(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xab33
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebx, 0x8(%rsi)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ec0
leaq 0x6d09(%rip), %rdi      # 0x11858
xorl %eax, %eax
callq 0x34a8
leaq 0x6d1a(%rip), %rdi      # 0x11877
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xabf6
movl %edx, %ebx
cmpl $0x1, %edx
jne 0xac04
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xc7f2(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xabca
leal 0x1(%rax), %ecx
movl %ecx, 0xc7e3(%rip)      # 0x173a0
leaq 0xc5dc(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xabd7
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7ec0
leaq 0x6cb3(%rip), %rdi      # 0x118b0
xorl %eax, %eax
callq 0x34a8
leaq 0x6cc7(%rip), %rdi      # 0x118d2
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
testl %edx, %edx
jle 0xac91
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xac9f
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x7476
movq %rax, %rbx
movq (%r14), %rdi
movl %ebp, %esi
callq 0x7e30
movq (%r14), %r14
movslq 0xc74e(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xac6e
leal 0x1(%rax), %ecx
movl %ecx, 0xc73f(%rip)      # 0x173a0
leaq 0xc538(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xac7b
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x3, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ec0
leaq 0x6c76(%rip), %rdi      # 0x1190e
xorl %eax, %eax
callq 0x34a8
leaq 0x6c87(%rip), %rdi      # 0x1192d
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8