LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xac20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0xb78e
jmp 0xb773
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xb7cb
jmp 0xb77d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xb80c
jmp 0xb81c
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xb7ab
leaq 0x9fda(%rip), %rdi      # 0x15779
movb $0x0, %al
callq 0x4cd0
jmp 0xb83b
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0xb83b
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb7ef
jp 0xb7ef
leaq 0x9f91(%rip), %rdi      # 0x15777
movb $0x0, %al
callq 0x4cd0
jmp 0xb83b
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xb83b
leaq 0x9f83(%rip), %rdi      # 0x15796
movb $0x0, %al
callq 0x4cd0
jmp 0xb83b
leaq 0x814c(%rip), %rdi      # 0x1396f
leaq 0x7227(%rip), %rsi      # 0x12a51
movl $0x12dd, %edx           # imm = 0x12DD
leaq 0x9fa4(%rip), %rcx      # 0x157da
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x77f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xac20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0xb89e
jmp 0xb883
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xb8d9
jmp 0xb88d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xb91f
jmp 0xb92f
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xb8bb
leaq 0x9f61(%rip), %rdi      # 0x15810
movb $0x0, %al
callq 0x4cd0
jmp 0xb94e
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, 0x8(%rax)
jmp 0xb94e
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb8fd
jp 0xb8fd
leaq 0x9e83(%rip), %rdi      # 0x15777
movb $0x0, %al
callq 0x4cd0
jmp 0xb94e
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
callq 0x31f0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0xb94e
leaq 0x9f07(%rip), %rdi      # 0x1582d
movb $0x0, %al
callq 0x4cd0
jmp 0xb94e
leaq 0x8039(%rip), %rdi      # 0x1396f
leaq 0x7114(%rip), %rsi      # 0x12a51
movl $0x12fc, %edx           # imm = 0x12FC
leaq 0x9f28(%rip), %rcx      # 0x15871
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x77f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0xb990
jmp 0xb97c
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0xb9a2
jmp 0xb986
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0xb9cd
jmp 0xb9e5
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0xba04
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0xba04
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x9ecb(%rip), %rdi      # 0x158a7
movb $0x0, %al
callq 0x4cd0
jmp 0xba04
leaq 0x7f83(%rip), %rdi      # 0x1396f
leaq 0x705e(%rip), %rsi      # 0x12a51
movl $0x1308, %edx           # imm = 0x1308
leaq 0x9ed4(%rip), %rcx      # 0x158d3
callq 0x30f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::initialize_value_stack(neteruhsp::value_stack_t*)
void initialize_value_stack( value_stack_t* st )
{
	const auto l =16;// 初期サイズ
	st->stack_ = reinterpret_cast<value_t**>( xmalloc( sizeof(value_t*) *l ) );
	st->top_ = 0;
	st->max_ = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, -0xc(%rbp)
movl $0x80, %edi
callq 0x3800
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x10, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0xbb10
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3900
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
ja 0xbb33
jmp 0xbb52
leaq 0x9e12(%rip), %rdi      # 0x1594c
leaq 0x6f10(%rip), %rsi      # 0x12a51
movl $0x1347, %edx           # imm = 0x1347
leaq 0x9e22(%rip), %rcx      # 0x1596f
callq 0x30f0
jmp 0xbb54
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
jbe 0xbbe1
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xbb8e
jmp 0xbbad
leaq 0x9e0d(%rip), %rdi      # 0x159a2
leaq 0x6eb5(%rip), %rsi      # 0x12a51
movl $0x134b, %edx           # imm = 0x134B
leaq 0x9dc7(%rip), %rcx      # 0x1596f
callq 0x30f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x77f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0xbb54
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0xbc45
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
shll %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x3960
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::query_sysvar(char const*)
int query_sysvar( const char* s )
{
	static const struct
	{
		int				tag_;
		const char*		word_;
	} table[] =
	{
		{ SYSVAR_CNT,		"cnt", },
		{ SYSVAR_STAT,		"stat", },
		{ SYSVAR_REFDVAL,	"refdval", },
		{ SYSVAR_REFSTR,	"refstr", },
		{ SYSVAR_STRSIZE,	"strsize", },
		{ SYSVAR_LOOPLEV,	"looplev", },
		{ -1,				nullptr },
	};

	// 全探索
	for( int i=0; table[i].tag_!=-1; ++i )
	{
		if ( string_equal_igcase( s, table[i].word_ ) )
		{ return table[i].tag_; }
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xfcc2(%rip), %rax      # 0x1ba10
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0xbdaa
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xfca7(%rip), %rax      # 0x1ba10
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4190
testb $0x1, %al
jne 0xbd84
jmp 0xbd9d
movslq -0x14(%rbp), %rcx
leaq 0xfc81(%rip), %rax      # 0x1ba10
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xbdb1
jmp 0xbd9f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbd43
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_execute_environment()
execute_environment_t* create_execute_environment()
{
	auto res = reinterpret_cast<execute_environment_t*>( xmalloc( sizeof( execute_environment_t ) ) );
	res->parser_list_ = create_list();
	res->ast_list_ = create_list();
	res->label_table_ = create_list();
	res->variable_table_ = create_variable_table();
	res->execute_code_ = create_code_container();
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x3800
movq %rax, -0x8(%rbp)
callq 0x3e90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x3e90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3e90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x93b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xbdc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbf0d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x50d0
movq -0x18(%rbp), %rdi
callq 0x5070
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xbeda
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x40b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xbf5e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7da0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xbf34
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x40b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xbfc9
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x3900
movq -0x38(%rbp), %rdi
callq 0x3900
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xbf87
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xbe10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x93c0
movq -0x8(%rbp), %rdi
callq 0x3900
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xba10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x190(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x194(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x198(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x1a0(%rax)
leaq 0x9e77(%rip), %rdi      # 0x15f2c
callq 0x57d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1a8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1b0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
je 0xc312
movq -0x10(%rbp), %rax
cmpl $0x20, (%rax)
jne 0xc360
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9420
cmpq $0x0, %rax
jne 0xc35e
movl $0x1, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rsi
xorl %ecx, %ecx
callq 0x94a0
jmp 0xc3ba
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xc3b8
callq 0x3c70
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x3800
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x57d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x3f70
jmp 0xc3ba
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc3d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xc2f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc3f2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xc2f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: int neteruhsp::(anonymous namespace)::code_get_block<double>(double&, int const*, int)
int code_get_block( T& block, const code_t* codes, int pc )
{
	const auto size = sizeof(block);
	const auto stride = size /sizeof(code_t) + (size %sizeof(code_t) == 0 ? 0 : 1);
	memcpy( &block, reinterpret_cast<const void*>(codes +pc), sizeof(block) );
	return stride;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x8, -0x20(%rbp)
movq $0x2, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,4), %rcx
movq %rcx, (%rax)
movl $0x2, %eax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xc010
movl -0xc(%rbp), %eax
movl %eax, -0x1c0(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, (%rax)
jne 0xd787
movq -0x8(%rbp), %rsi
leaq 0x8536(%rip), %rdi      # 0x15cb6
movb $0x0, %al
callq 0x4cd0
movq -0x8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xc4b0
leaq -0x1c8(%rbp), %rdi
callq 0xc0e0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::query_command(char const*)
int query_command( const char* s )
{
	static const struct
	{
		int				tag_;
		const char*		word_;
	} table[] =
	{
		{ COMMAND_DEVTERM,		"devterm" },
		{ COMMAND_DIM,			"dim", },
		{ COMMAND_DDIM,			"ddim", },
		{ COMMAND_SDIM,			"sdim", },
		{ COMMAND_POKE,			"poke", },
		{ COMMAND_WPOKE,		"wpoke", },
		{ COMMAND_LPOKE,		"lpoke", },
		{ COMMAND_MES,			"mes", },
		{ COMMAND_INPUT,		"input", },
		{ COMMAND_RANDOMIZE,	"randomize", },
#if NHSP_CONFIG_PERFORMANCE_TIMER
		{ COMMAND_BENCH,		"bench", },
#endif
		{ -1,					nullptr },
	};

	// 全探索
	for( int i=0; table[i].tag_!=-1; ++i )
	{
		if ( string_equal_igcase( s, table[i].word_ ) )
		{ return table[i].tag_; }
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xceb2(%rip), %rax      # 0x1ba80
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0xec2a
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xce97(%rip), %rax      # 0x1ba80
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4190
testb $0x1, %al
jne 0xec04
jmp 0xec1d
movslq -0x14(%rbp), %rcx
leaq 0xce71(%rip), %rax      # 0x1ba80
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xec31
jmp 0xec1f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xebc3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0xec97
leaq 0x7676(%rip), %rdi      # 0x16306
movb $0x0, %al
callq 0x4cd0
cmpl $0x2, -0x14(%rbp)
jle 0xecab
leaq 0x7682(%rip), %rdi      # 0x16326
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xecdd
leaq 0x76b3(%rip), %rdi      # 0x16389
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xecf5
leaq 0x76c7(%rip), %rdi      # 0x163b5
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x79c0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0xed2b
leaq 0x76d2(%rip), %rdi      # 0x163f6
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x2c(%rbp), %ecx
movl $0x1, %esi
movl $0x40, %edx
callq 0x9220
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0xed87
leaq 0x7585(%rip), %rdi      # 0x16305
movb $0x0, %al
callq 0x4cd0
cmpl $0x2, -0x14(%rbp)
jle 0xed9b
leaq 0x7591(%rip), %rdi      # 0x16325
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xedcd
leaq 0x75c2(%rip), %rdi      # 0x16388
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xede5
leaq 0x75d6(%rip), %rdi      # 0x163b4
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x79c0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0xee1b
leaq 0x75e1(%rip), %rdi      # 0x163f5
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x2c(%rbp), %ecx
movl $0x2, %esi
movl $0x40, %edx
callq 0x9220
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0xee77
leaq 0x75b8(%rip), %rdi      # 0x16428
movb $0x0, %al
callq 0x4cd0
cmpl $0x3, -0x14(%rbp)
jle 0xee8b
leaq 0x75c4(%rip), %rdi      # 0x16448
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xeebd
leaq 0x75f5(%rip), %rdi      # 0x164ab
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xeed5
leaq 0x7609(%rip), %rdi      # 0x164d7
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x79c0
movl %eax, -0x2c(%rbp)
cmpl $0x2, -0x14(%rbp)
jle 0xef1c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x2, %esi
callq 0xbca0
movq %rax, %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
jmp 0xef26
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xef26
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0xef40
leaq 0x75df(%rip), %rdi      # 0x16518
movb $0x0, %al
callq 0x4cd0
cmpl $0x0, -0x30(%rbp)
jg 0xef54
leaq 0x7604(%rip), %rdi      # 0x16551
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
movl $0x3, %esi
callq 0x9220
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0xefb7
leaq 0x7727(%rip), %rdi      # 0x166d7
movb $0x0, %al
callq 0x4cd0
cmpl $0x3, -0x14(%rbp)
jle 0xefcb
leaq 0x7734(%rip), %rdi      # 0x166f8
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xf002
leaq 0x7766(%rip), %rdi      # 0x1675c
movb $0x0, %al
callq 0x4cd0
jmp 0xf0d3
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xf01f
leaq 0x7776(%rip), %rdi      # 0x16789
movb $0x0, %al
callq 0x4cd0
jmp 0xf0d3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x2, %esi
callq 0xbca0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x79c0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xf086
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xf0a7
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %edx
movl -0x34(%rbp), %ecx
leaq 0x772d(%rip), %rdi      # 0x167cb
movb $0x0, %al
callq 0x4cd0
jmp 0xf0d3
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %eax
movb %al, %dl
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0xf107
leaq 0x7484(%rip), %rdi      # 0x16584
movb $0x0, %al
callq 0x4cd0
cmpl $0x3, -0x14(%rbp)
jle 0xf11b
leaq 0x7491(%rip), %rdi      # 0x165a5
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xf152
leaq 0x74c3(%rip), %rdi      # 0x16609
movb $0x0, %al
callq 0x4cd0
jmp 0xf224
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xf16f
leaq 0x74d3(%rip), %rdi      # 0x16636
movb $0x0, %al
callq 0x4cd0
jmp 0xf224
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x2, %esi
callq 0xbca0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x79c0
movw %ax, -0x42(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xf1d7
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x34(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jge 0xf1f8
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %edx
movl -0x34(%rbp), %ecx
leaq 0x7489(%rip), %rdi      # 0x16678
movb $0x0, %al
callq 0x4cd0
jmp 0xf224
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
movw -0x42(%rbp), %dx
movw %dx, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0xf257
leaq 0x7486(%rip), %rdi      # 0x166d6
movb $0x0, %al
callq 0x4cd0
cmpl $0x3, -0x14(%rbp)
jle 0xf26b
leaq 0x7493(%rip), %rdi      # 0x166f7
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xf2a2
leaq 0x74c5(%rip), %rdi      # 0x1675b
movb $0x0, %al
callq 0x4cd0
jmp 0xf371
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xf2bf
leaq 0x74d5(%rip), %rdi      # 0x16788
movb $0x0, %al
callq 0x4cd0
jmp 0xf371
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x2, %esi
callq 0xbca0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x79c0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xf326
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x34(%rbp), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
jge 0xf347
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %edx
movl -0x34(%rbp), %ecx
leaq 0x748c(%rip), %rdi      # 0x167ca
movb $0x0, %al
callq 0x4cd0
jmp 0xf371
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl -0x44(%rbp), %edx
movl %edx, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xf3a7
leaq 0x7488(%rip), %rdi      # 0x16828
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xf3be
movl -0x14(%rbp), %esi
leaq 0x7490(%rip), %rdi      # 0x16847
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x78a0
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
je 0xf3f3
leaq 0x7494(%rip), %rdi      # 0x16880
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x2e64(%rip), %rdi      # 0x12266
movb $0x0, %al
callq 0x3050
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0xf637
leaq 0x7332(%rip), %rdi      # 0x16962
movb $0x0, %al
callq 0x4cd0
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xf652
xorl %eax, %eax
movl %eax, %edi
callq 0x3130
movl %eax, -0x18(%rbp)
jmp 0xf673
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79c0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x3150
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::query_function(char const*)
int query_function( const char* s )
{
	static const struct
	{
		int				tag_;
		const char*		word_;
	} table[] =
	{
		{ FUNCTION_INT,		"int", },
		{ FUNCTION_DOUBLE,	"double", },
		{ FUNCTION_STR,		"str", },
		{ FUNCTION_PEEK,	"peek", },
		{ FUNCTION_WPEEK,	"wpeek", },
		{ FUNCTION_LPEEK,	"lpeek", },
		{ FUNCTION_RND,		"rnd", },
		{ FUNCTION_ABS,		"abs", },
		{ FUNCTION_ABSF,	"absf", },
		{ FUNCTION_DEG2RAD,	"deg2rad", },
		{ FUNCTION_RAD2DEG,	"rad2deg", },
		{ FUNCTION_SIN,		"sin", },
		{ FUNCTION_COS,		"cos", },
		{ FUNCTION_TAN,		"tan", },
		{ FUNCTION_ATAN,	"atan", },
		{ FUNCTION_EXPF,	"expf", },
		{ FUNCTION_LOGF,	"logf", },
		{ FUNCTION_POWF,	"powf", },
		{ FUNCTION_SQRT,	"sqrt", },
		{ FUNCTION_LIMIT,	"limit", },
		{ FUNCTION_LIMITF,	"limitf", },
		{ FUNCTION_STRLEN,	"strlen", },
		{ -1,				nullptr },
	};

	// 全探索
	for( int i=0; table[i].tag_!=-1; ++i )
	{
		if ( string_equal_igcase( s, table[i].word_ ) )
		{ return table[i].tag_; }
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xc492(%rip), %rax      # 0x1bb90
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0xf75a
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xc477(%rip), %rax      # 0x1bb90
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4190
testb $0x1, %al
jne 0xf734
jmp 0xf74d
movslq -0x14(%rbp), %rcx
leaq 0xc451(%rip), %rax      # 0x1bb90
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xf761
jmp 0xf74f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf6f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xf797
leaq 0x725e(%rip), %rdi      # 0x169ee
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xf7ae
movl -0x14(%rbp), %esi
leaq 0x7266(%rip), %rdi      # 0x16a0d
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0xa5f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xf837
leaq 0x7216(%rip), %rdi      # 0x16a46
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xf84e
movl -0x14(%rbp), %esi
leaq 0x7221(%rip), %rdi      # 0x16a68
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0xa680
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xf8d7
leaq 0x71d4(%rip), %rdi      # 0x16aa4
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xf8ee
movl -0x14(%rbp), %esi
leaq 0x71dc(%rip), %rdi      # 0x16ac3
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xab60
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa820
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)