LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_muldivmod(neteruhsp::parse_context_t&)
ast_node_t* parse_muldivmod( parse_context_t& c )
{
	auto node =parse_term(c);

	for( ; ; )
	{
		bool is_continue = true;
		const auto token = read_token( c );
		switch( token->tag_ )
		{
			case TOKEN_OP_MUL:
			case TOKEN_OP_DIV:
			case TOKEN_OP_MOD:
			{
				auto r = parse_term( c );
				if ( r == nullptr )
				{ raise_error( "*/\\の演算子で、右項の解析が出来ません@@ %d行目", token->appear_line_ ); }

				switch( token->tag_ )
				{
					case TOKEN_OP_MUL:	node = create_ast_node( NODE_MUL, node, r ); break;
					case TOKEN_OP_DIV:	node = create_ast_node( NODE_DIV, node, r ); break;
					case TOKEN_OP_MOD:	node = create_ast_node( NODE_MOD, node, r ); break;
					default: assert( false ); break;
				}
				break;
			}
			default:
				is_continue = false;
				break;
		}
		if ( !is_continue )
		{
			unread_token( c );
			break;
		}
	}
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8e70
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl $-0x17, %eax
subl $0x2, %eax
ja 0x8e44
jmp 0x8d8e
movq -0x8(%rbp), %rdi
callq 0x8e70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8db7
movq -0x20(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xb6ca(%rip), %rdi      # 0x1447a
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x17, %eax
je 0x8ddb
jmp 0x8dc7
movl -0x2c(%rbp), %eax
subl $0x18, %eax
je 0x8df3
jmp 0x8dd1
movl -0x2c(%rbp), %eax
subl $0x19, %eax
je 0x8e0b
jmp 0x8e23
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1b, %edi
callq 0x7ac0
movq %rax, -0x10(%rbp)
jmp 0x8e42
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1c, %edi
callq 0x7ac0
movq %rax, -0x10(%rbp)
jmp 0x8e42
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1d, %edi
callq 0x7ac0
movq %rax, -0x10(%rbp)
jmp 0x8e42
leaq 0xab45(%rip), %rdi      # 0x1396f
leaq 0x9c20(%rip), %rsi      # 0x12a51
movl $0xe74, %edx            # imm = 0xE74
leaq 0xb67f(%rip), %rcx      # 0x144bc
callq 0x30f0
jmp 0x8e48
movb $0x0, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8e5e
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5260
jmp 0x8e63
jmp 0x8d69
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_term(neteruhsp::parse_context_t&)
ast_node_t* parse_term( parse_context_t& c )
{
	const auto token = read_token( c );
	switch( token->tag_ )
	{
		case TOKEN_OP_SUB:		return create_ast_node( NODE_UNARY_MINUS, parse_primitive( c ) );
		default: break;
	}

	unread_token( c );
	return parse_primitive( c );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl $0x16, %eax
jne 0x8eb6
jmp 0x8e96
movq -0x10(%rbp), %rdi
callq 0x8ee0
movq %rax, %rsi
movl $0x1e, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7ac0
movq %rax, -0x8(%rbp)
jmp 0x8ed3
jmp 0x8eb8
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5260
movq -0x10(%rbp), %rdi
callq 0x8ee0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_primitive(neteruhsp::parse_context_t&)
ast_node_t* parse_primitive( parse_context_t& c )
{
	const auto token = read_token( c );
	switch( token->tag_ )
	{
		case TOKEN_LPARENTHESIS:
		{
			const auto node = parse_expression( c );
			const auto next = read_token( c );
			if ( next->tag_ != TOKEN_RPARENTHESIS )
			{
				raise_error( "括弧が閉じられていません@@ %d行目", token->appear_line_ );
			}
			return create_ast_node( NODE_EXPRESSION, node );
		}

		case TOKEN_INTEGER:
		case TOKEN_REAL:
		case TOKEN_STRING:
			return create_ast_node( NODE_PRIMITIVE_VALUE, token );

		case TOKEN_OP_MUL:
		{
			unread_token( c );
			const auto label = parse_label_safe( c );
			if ( label == nullptr )
			{
				raise_error( "ラベルが正しく解析できませんでした@@ %d行目", token->appear_line_ );
			}
			raise_error( "式中にラベル型を使うことはできません@@ %d行目", token->appear_line_ );
			return label;
		}

		case TOKEN_IDENTIFIER:
		{
			unread_token( c );
			const auto expr = parse_identifier_expression( c );
			if ( expr == nullptr )
			{
				raise_error( "関数または変数を正しく解析できませんでした@@ %d行目", token->appear_line_ );
			}
			return expr;
		}
		default: break;
	}

	raise_error( "プリミティブな値を取得できません@@ %d行目[%s]", token->appear_line_, token->content_ );
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x1d, %eax
ja 0x902a
movq -0x40(%rbp), %rax
leaq 0x96a8(%rip), %rcx      # 0x125c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x7620
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x7, (%rax)
je 0x8f5d
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xb5a0(%rip), %rdi      # 0x144f6
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rsi
movl $0xf, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7ac0
movq %rax, -0x8(%rbp)
jmp 0x9051
movq -0x18(%rbp), %rsi
movl $0x1f, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7b30
movq %rax, -0x8(%rbp)
jmp 0x9051
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5260
movq -0x10(%rbp), %rdi
callq 0x7e00
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8fca
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xb563(%rip), %rdi      # 0x14526
movb $0x0, %al
callq 0x4cd0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xb58d(%rip), %rdi      # 0x14565
movb $0x0, %al
callq 0x4cd0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9051
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5260
movq -0x10(%rbp), %rdi
callq 0x9060
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x9020
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xb58e(%rip), %rdi      # 0x145a7
movb $0x0, %al
callq 0x4cd0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9051
jmp 0x902c
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xb5b0(%rip), %rdi      # 0x145f2
movb $0x0, %al
callq 0x4cd0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::parse_identifier_expression(neteruhsp::parse_context_t&)
ast_node_t* parse_identifier_expression( parse_context_t& c )
{
	const auto ident = read_token( c );
	if ( ident->tag_ != TOKEN_IDENTIFIER )
	{
		unread_token( c );
		return nullptr;
	}

	const auto next = read_token( c );
	if ( next->tag_ != TOKEN_LPARENTHESIS )
	{
		unread_token( c );
		return create_ast_node( NODE_IDENTIFIER_EXPR, ident );
	}

	// 引数なしの即閉じ？
	{
		const auto nn = read_token( c );
		if ( nn->tag_ == TOKEN_RPARENTHESIS )
		{
			return create_ast_node( NODE_IDENTIFIER_EXPR, ident, create_ast_node( NODE_ARGUMENTS ) );
		}
		unread_token( c );
	}

	// 引数あり
	const auto idx = parse_arguments( c );
	const auto nn = read_token( c );
	if ( nn->tag_ != TOKEN_RPARENTHESIS )
	{
		raise_error( "関数または配列変数 : 括弧が正しく閉じられていません@@ %d行目", nn->appear_line_ );
	}

	return create_ast_node( NODE_IDENTIFIER_EXPR, ident, idx );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x23, (%rax)
je 0x909d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5260
movq $0x0, -0x8(%rbp)
jmp 0x917e
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
je 0x90dc
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5260
movq -0x18(%rbp), %rsi
movl $0x20, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x7b30
movq %rax, -0x8(%rbp)
jmp 0x917e
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x9122
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x7ac0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
movl $0x20, %edi
callq 0x7b30
movq %rax, -0x8(%rbp)
jmp 0x917e
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5260
movq -0x10(%rbp), %rdi
callq 0x8740
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x7, (%rax)
je 0x9168
movq -0x38(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0xb4d1(%rip), %rdi      # 0x14632
movb $0x0, %al
callq 0x4cd0
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x20, %edi
callq 0x7b30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_variable(char const*)
variable_t* create_variable( const char* name )
{
	const auto res = reinterpret_cast<variable_t*>( xmalloc( sizeof(variable_t) ) );
	res->name_ = create_string( name );
	res->type_ = VALUE_NONE;
	res->granule_size_  = 0;
	res->length_ = 0;
	res->data_ = nullptr;
	res->data_size_ = 0;
	prepare_variable( res, VALUE_INT, 64, 16 );
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x3800
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x57d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x40, %edx
movl $0x10, %ecx
callq 0x9220
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::prepare_variable(neteruhsp::variable_t*, neteruhsp::value_tag, int, int)
void prepare_variable( variable_t* v, value_tag type, int granule_size, int length )
{
	if ( v->data_ != nullptr )
	{
		xfree( v->data_ );
		v->data_ = nullptr;
		v->data_size_ = 0;
	}

	v->type_ = type;
	v->granule_size_ = granule_size;
	v->length_ = length;

	size_t areasize = 0;
	switch( type )
	{
		case VALUE_INT:
			areasize = sizeof(int) *v->length_;
			break;
		case VALUE_DOUBLE:
			areasize = sizeof(double) *v->length_;
			break;
		case VALUE_STRING:
			areasize = sizeof(char) *v->granule_size_ *v->length_;
			break;
		default: assert( false ); break;
	}

	assert( areasize > 0 );
	v->data_ = xmalloc( areasize );
	memset( v->data_, 0, areasize );
	v->data_size_ = static_cast<int>( areasize );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x9264
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3900
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x92ab
jmp 0x9297
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x92bd
jmp 0x92a1
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x92cf
jmp 0x92ed
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x930c
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
jmp 0x930c
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
shlq $0x0, %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
imulq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x930c
leaq 0xa67b(%rip), %rdi      # 0x1396f
leaq 0x9756(%rip), %rsi      # 0x12a51
movl $0xf19, %edx            # imm = 0xF19
leaq 0xb382(%rip), %rcx      # 0x14689
callq 0x30f0
cmpq $0x0, -0x20(%rbp)
jbe 0x9315
jmp 0x9334
leaq 0xb3b1(%rip), %rdi      # 0x146cd
leaq 0x972e(%rip), %rsi      # 0x12a51
movl $0xf1c, %edx            # imm = 0xF1C
leaq 0xb35a(%rip), %rcx      # 0x14689
callq 0x30f0
movq -0x20(%rbp), %rdi
callq 0x3800
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x30d0
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::destroy_variable(neteruhsp::variable_t*)
void destroy_variable( variable_t* v )
{
	xfree( v->name_ );
	xfree( v->data_ );
	v->data_size_ = 0;
	xfree( v );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3900
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3900
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x3900
addq $0x10, %rsp
popq %rbp
retq
nop
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::destroy_variable_table(neteruhsp::list_t*)
void destroy_variable_table( list_t* table )
{
	auto node =table->head_;
	while( node != nullptr )
	{
		const auto var =reinterpret_cast<variable_t*>( node->value_ );
		destroy_variable( var );
		node = node->next_;
	}

	list_free_all( *table );
	destroy_list( table );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9401
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9370
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x93d7
movq -0x8(%rbp), %rdi
callq 0x40b0
movq -0x8(%rbp), %rdi
callq 0x3ed0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::search_variable(neteruhsp::list_t*, char const*)
variable_t* search_variable( list_t* table, const char* name )
{
	auto node =table->head_;
	while( node != nullptr )
	{
		const auto var =reinterpret_cast<variable_t*>( node->value_ );
		if ( string_equal_igcase( var->name_, name ) )
		{ return var; }
		node = node->next_;
	}
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9481
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4190
testb $0x1, %al
jne 0x9469
jmp 0x9473
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9489
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x943b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_set(neteruhsp::list_t*, neteruhsp::value_t const&, char const*, int)
void variable_set( list_t* table, const value_t& v, const char* name, int idx )
{
	auto var =search_variable( table, name );
	if ( var == nullptr )
	{
		var = create_variable( name );
		auto node = create_list_node();
		node->value_ = var;
		list_append( *table, node );
	}

	variable_set( var, v, idx );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9420
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x94fe
movq -0x18(%rbp), %rdi
callq 0x9190
movq %rax, -0x28(%rbp)
callq 0x3c70
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3f70
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x9520
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_data_ptr(neteruhsp::variable_t const&, int)
void* variable_data_ptr( const variable_t& v, int idx )
{
	if ( idx<0 || idx>=v.length_ )
	{
		raise_error( "変数への配列アクセスが範囲外です@@ %s(%d)", v.name_, idx );
	}

	switch( v.type_ )
	{
		case VALUE_INT:
		{
			return reinterpret_cast<int*>( v.data_ ) +idx;
		}
		case VALUE_DOUBLE:
		{
			return reinterpret_cast<double*>( v.data_ ) +idx;
		}
		case VALUE_STRING:
		{
			return reinterpret_cast<char*>( v.data_ ) + v.granule_size_ *idx;
		}
		default:
			assert( false );
			break;
	}
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x9721
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x9739
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
leaq 0xb7bd(%rip), %rdi      # 0x14eef
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x975e
jmp 0x974a
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x9777
jmp 0x9754
movl -0x18(%rbp), %eax
subl $0x3, %eax
je 0x9790
jmp 0x97af
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x97ce
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x97ce
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x97ce
leaq 0xa1b9(%rip), %rdi      # 0x1396f
leaq 0x9294(%rip), %rsi      # 0x12a51
movl $0x10dd, %edx           # imm = 0x10DD
leaq 0xb760(%rip), %rcx      # 0x14f29
callq 0x30f0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_sub(neteruhsp::variable_t*, neteruhsp::value_t const&, int)
void variable_sub( variable_t* var, const value_t& v, int idx )
{
	assert( var != nullptr );
	if ( var->type_ != v.type_ )
	{
		raise_error( "型の異なる変数への減算代入（-=）操作@@ %s(%d)", var->name_, idx );
		return;
	}

	assert( var->type_ == v.type_ );
	auto* data_ptr = variable_data_ptr( *var, idx );
	switch( var->type_ )
	{
	case VALUE_INT:
	{
		reinterpret_cast<int*>( data_ptr )[0] -= v.ivalue_;
		break;
	}
	case VALUE_DOUBLE:
	{
		reinterpret_cast<double*>( data_ptr )[0] -= v.dvalue_;
		break;
	}
	case VALUE_STRING:
	{
		raise_error( "文字列に対する減算代入（-=）操作は定義されてません@@ %s(%d)", var->name_, idx );
		break;
	}
	default:
		assert( false );
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x99dc
jmp 0x99fb
leaq 0xacf7(%rip), %rdi      # 0x146da
leaq 0x9067(%rip), %rsi      # 0x12a51
movl $0xfc6, %edx            # imm = 0xFC6
leaq 0xaea0(%rip), %rcx      # 0x14896
callq 0x30f0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x9a27
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
leaq 0xaebc(%rip), %rdi      # 0x148d7
movb $0x0, %al
callq 0x4cd0
jmp 0x9af3
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x9a38
jmp 0x9a57
leaq 0xad6c(%rip), %rdi      # 0x147ab
leaq 0x900b(%rip), %rsi      # 0x12a51
movl $0xfcd, %edx            # imm = 0xFCD
leaq 0xae44(%rip), %rcx      # 0x14896
callq 0x30f0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9700
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x9a8c
jmp 0x9a78
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x9a9f
jmp 0x9a82
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x9aba
jmp 0x9ad4
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
jmp 0x9af3
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
jmp 0x9af3
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
leaq 0xae4b(%rip), %rdi      # 0x14916
movb $0x0, %al
callq 0x4cd0
jmp 0x9af3
leaq 0x9e94(%rip), %rdi      # 0x1396f
leaq 0x8f6f(%rip), %rsi      # 0x12a51
movl $0xfe1, %edx            # imm = 0xFE1
leaq 0xada8(%rip), %rcx      # 0x14896
callq 0x30f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_calc_int(neteruhsp::variable_t const&, int)
int variable_calc_int( const variable_t& r, int idx )
{
	const auto* const data_ptr = variable_data_ptr( r, idx );
	switch( r.type_ )
	{
		case VALUE_INT:		return *reinterpret_cast<const int*>( data_ptr );
		case VALUE_DOUBLE:	return static_cast<int>(*reinterpret_cast<const double*>( data_ptr ));
		case VALUE_STRING:	return atoi( reinterpret_cast<const char*>( data_ptr ) );
		default:
			assert( false );
			break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9700
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0xa3a4
jmp 0xa390
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xa3af
jmp 0xa39a
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0xa3bc
jmp 0xa3ca
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa3e9
movq -0x20(%rbp), %rax
cvttsd2si (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa3e9
movq -0x20(%rbp), %rdi
callq 0x3230
movl %eax, -0x4(%rbp)
jmp 0xa3e9
leaq 0x959e(%rip), %rdi      # 0x1396f
leaq 0x8679(%rip), %rsi      # 0x12a51
movl $0x10ec, %edx           # imm = 0x10EC
leaq 0xab81(%rip), %rcx      # 0x14f65
callq 0x30f0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_calc_double(neteruhsp::variable_t const&, int)
double variable_calc_double( const variable_t& r, int idx )
{
	const auto* const data_ptr = variable_data_ptr( r, idx );
	switch( r.type_ )
	{
		case VALUE_INT:		return static_cast<double>(*reinterpret_cast<const int*>( data_ptr ));
		case VALUE_DOUBLE:	return *reinterpret_cast<const double*>( data_ptr );
		case VALUE_STRING:	return atof( reinterpret_cast<const char*>( data_ptr ) );
		default:
			assert( false );
			break;
	}
	return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9700
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0xa444
jmp 0xa430
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xa453
jmp 0xa43a
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0xa462
jmp 0xa472
movq -0x20(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa491
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa491
movq -0x20(%rbp), %rdi
callq 0x31c0
movsd %xmm0, -0x8(%rbp)
jmp 0xa491
leaq 0x94f6(%rip), %rdi      # 0x1396f
leaq 0x85d1(%rip), %rsi      # 0x12a51
movl $0x10fb, %edx           # imm = 0x10FB
leaq 0xab13(%rip), %rcx      # 0x14f9f
callq 0x30f0
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_get_string(neteruhsp::variable_t const&, int)
const char* variable_get_string( const variable_t& r, int idx )
{
	if ( r.type_ != VALUE_STRING )
	{ return nullptr; }

	const auto* const data_ptr = variable_data_ptr( r, idx );
	return reinterpret_cast<const char*>( data_ptr );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xa4c3
movq $0x0, -0x8(%rbp)
jmp 0xa4db
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9700
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::variable_calc_string(neteruhsp::variable_t const&, int)
char* variable_calc_string( const variable_t& r, int idx )
{
	const auto* const data_ptr = variable_data_ptr( r, idx );
	switch( r.type_ )
	{
		case VALUE_INT:		return create_string_from( *reinterpret_cast<const int*>( data_ptr ) );
		case VALUE_DOUBLE:	return create_string_from( *reinterpret_cast<const double*>( data_ptr ) );
		case VALUE_STRING:	return create_string( reinterpret_cast<const char*>( data_ptr ) );
		default:
			assert( false );
			break;
	}
	return create_string("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9700
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0xa534
jmp 0xa520
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xa545
jmp 0xa52a
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0xa558
jmp 0xa567
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x7a60
movq %rax, -0x8(%rbp)
jmp 0xa586
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0xa590
movq %rax, -0x8(%rbp)
jmp 0xa586
movq -0x20(%rbp), %rdi
callq 0x57d0
movq %rax, -0x8(%rbp)
jmp 0xa586
leaq 0x9401(%rip), %rdi      # 0x1396f
leaq 0x84dc(%rip), %rsi      # 0x12a51
movl $0x1113, %edx           # imm = 0x1113
leaq 0xaa5e(%rip), %rcx      # 0x14fdf
callq 0x30f0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::create_string_from(double)
char* create_string_from( double v )
{
	const auto len = snprintf( nullptr, 0, "%lf", v );
	auto res = create_string( len );
	sprintf( res, "%lf", v );
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
leaq 0xb988(%rip), %rdx      # 0x15f35
movq %rsi, %rdi
movb $0x1, %al
callq 0x3250
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x3b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
leaq 0xb95e(%rip), %rsi      # 0x15f35
movb $0x1, %al
callq 0x3080
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(int)
value_t* create_value( int v )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_INT;
	res->ivalue_ = v;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0xa630
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(double)
value_t* create_value( double v )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_DOUBLE;
	res->dvalue_ = v;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xa630
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(char const*)
value_t* create_value( const char* v )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_STRING;
	res->svalue_ = create_string( v );
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xa630
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
movq -0x8(%rbp), %rdi
callq 0x57d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::create_value(neteruhsp::variable_t*, int)
value_t* create_value( variable_t* v, int idx )
{
	value_t* res =alloc_value();
	res->type_ = VALUE_VARIABLE;
	res->variable_ = v;
	res->index_ = idx;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0xa630
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xa630
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0xa7f6
movq -0x18(%rbp), %rax
leaq 0x7ead(%rip), %rcx      # 0x1263c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0xa808
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0xa808
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x57d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xa808
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0xa808
movq -0x8(%rbp), %rsi
leaq 0xa81d(%rip), %rdi      # 0x1501e
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xa630
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::free_value(neteruhsp::value_t*)
void free_value( value_t* p )
{
#if NHSP_CONFIG_VALUE_ALLOCATION_CACHE
	if ( s_value_allocation_cache_idx > 0 )
	{
		s_value_allocation_cache[--s_value_allocation_cache_idx] = p;
		return;
	}
#endif
	xfree( p );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x11dad(%rip)     # 0x1c650
jle 0xa8c8
movq -0x8(%rbp), %rdx
movl 0x11da1(%rip), %eax     # 0x1c650
addl $-0x1, %eax
movl %eax, 0x11d98(%rip)     # 0x1c650
movslq %eax, %rcx
leaq 0x11b8e(%rip), %rax     # 0x1c450
movq %rdx, (%rax,%rcx,8)
jmp 0xa8d1
movq -0x8(%rbp), %rdi
callq 0x3900
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa860
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x30d0
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0xaac2
movq -0x18(%rbp), %rax
leaq 0x7be2(%rip), %rcx      # 0x1264c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xaae1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xaae1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31c0
movsd %xmm0, -0x8(%rbp)
jmp 0xaae1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xa400
movsd %xmm0, -0x8(%rbp)
jmp 0xaae1
leaq 0x8ea6(%rip), %rdi      # 0x1396f
leaq 0x7f81(%rip), %rsi      # 0x12a51
movl $0x11a6, %edx           # imm = 0x11A6
leaq 0xa5f4(%rip), %rcx      # 0x150d0
callq 0x30f0
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x3, %eax
je 0xab1e
jmp 0xab14
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0xab2c
jmp 0xab46
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xab48
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xa4a0
movq %rax, -0x10(%rbp)
jmp 0xab48
jmp 0xab48
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0xabee
movq -0x18(%rbp), %rax
leaq 0x7aca(%rip), %rcx      # 0x1265c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x7a60
movq %rax, -0x10(%rbp)
jmp 0xac0d
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0xa590
movq %rax, -0x10(%rbp)
jmp 0xac0d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x57d0
movq %rax, -0x10(%rbp)
jmp 0xac0d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0xa4f0
movq %rax, -0x10(%rbp)
jmp 0xac0d
leaq 0x8d7a(%rip), %rdi      # 0x1396f
leaq 0x7e55(%rip), %rsi      # 0x12a51
movl $0x11c0, %edx           # imm = 0x11C0
leaq 0xa4fd(%rip), %rcx      # 0x15105
callq 0x30f0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xac4c
movq -0x18(%rbp), %rdi
callq 0xa750
movq %rax, -0x8(%rbp)
jmp 0xacda
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0xac6d
jmp 0xac59
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0xac83
jmp 0xac63
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0xac97
jmp 0xacbb
movq -0x18(%rbp), %rdi
callq 0x79c0
movl %eax, %edi
callq 0xa5f0
movq %rax, -0x8(%rbp)
jmp 0xacda
movq -0x18(%rbp), %rdi
callq 0xaa40
callq 0xa680
movq %rax, -0x8(%rbp)
jmp 0xacda
movq -0x18(%rbp), %rdi
callq 0xab60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa820
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xacda
leaq 0x8cad(%rip), %rdi      # 0x1396f
leaq 0x7d88(%rip), %rsi      # 0x12a51
movl $0x11d4, %edx           # imm = 0x11D4
leaq 0xa464(%rip), %rcx      # 0x15139
callq 0x30f0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %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 0xad37
jmp 0xad23
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xad50
jmp 0xad2d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xad60
jmp 0xad70
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
orl 0x8(%rax), %esi
callq 0xa8e0
jmp 0xad8f
leaq 0xa44e(%rip), %rdi      # 0x151a5
movb $0x0, %al
callq 0x4cd0
jmp 0xad8f
leaq 0xa488(%rip), %rdi      # 0x151ef
movb $0x0, %al
callq 0x4cd0
jmp 0xad8f
leaq 0x8bf8(%rip), %rdi      # 0x1396f
leaq 0x7cd3(%rip), %rsi      # 0x12a51
movl $0x11ff, %edx           # imm = 0x11FF
leaq 0xa4a9(%rip), %rcx      # 0x15233
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x77f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
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 0xaf4a
jmp 0xaf33
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xaf72
jmp 0xaf3d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xafa5
jmp 0xafdc
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
xorl %esi, %esi
movl $0x1, %eax
cmpl %edx, %ecx
cmovel %eax, %esi
callq 0xa8e0
jmp 0xaffb
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
xorl %esi, %esi
movl $0x1, %eax
ucomisd %xmm1, %xmm0
setnp %dl
sete %cl
testb %dl, %cl
cmovnel %eax, %esi
callq 0xa8e0
jmp 0xaffb
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3210
movq -0x28(%rbp), %rdi
movl %eax, %ecx
xorl %esi, %esi
movl $0x1, %eax
cmpl $0x0, %ecx
cmovel %eax, %esi
callq 0xa8e0
jmp 0xaffb
leaq 0x898c(%rip), %rdi      # 0x1396f
leaq 0x7a67(%rip), %rsi      # 0x12a51
movl $0x1236, %edx           # imm = 0x1236
leaq 0xa3fd(%rip), %rcx      # 0x153f3
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_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 %rbp
movq %rsp, %rbp
subq $0x20, %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 0xb167
jmp 0xb153
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xb18c
jmp 0xb15d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xb1b7
jmp 0xb1c7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
xorl %esi, %esi
movl $0x1, %eax
cmpl %edx, %ecx
cmovgl %eax, %esi
callq 0xa8e0
jmp 0xb1e6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
xorl %esi, %esi
movl $0x1, %eax
ucomisd %xmm1, %xmm0
cmoval %eax, %esi
callq 0xa8e0
jmp 0xb1e6
leaq 0xa2a0(%rip), %rdi      # 0x1545e
movb $0x0, %al
callq 0x4cd0
jmp 0xb1e6
leaq 0x87a1(%rip), %rdi      # 0x1396f
leaq 0x787c(%rip), %rsi      # 0x12a51
movl $0x1254, %edx           # imm = 0x1254
leaq 0xa2c1(%rip), %rcx      # 0x154a2
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x77f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %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 0xb247
jmp 0xb233
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xb26c
jmp 0xb23d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xb297
jmp 0xb2a7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
xorl %esi, %esi
movl $0x1, %eax
cmpl %edx, %ecx
cmovgel %eax, %esi
callq 0xa8e0
jmp 0xb2c6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
xorl %esi, %esi
movl $0x1, %eax
ucomisd %xmm1, %xmm0
cmovael %eax, %esi
callq 0xa8e0
jmp 0xb2c6
leaq 0xa239(%rip), %rdi      # 0x154d7
movb $0x0, %al
callq 0x4cd0
jmp 0xb2c6
leaq 0x86c1(%rip), %rdi      # 0x1396f
leaq 0x779c(%rip), %rsi      # 0x12a51
movl $0x1265, %edx           # imm = 0x1265
leaq 0xa25b(%rip), %rcx      # 0x1551c
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x77f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %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, -0x2c(%rbp)
subl $0x1, %eax
je 0xb4ea
jmp 0xb4d3
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0xb500
jmp 0xb4dd
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0xb51c
jmp 0xb58e
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0xb5ad
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xb5ad
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
xorl %eax, %eax
movl %eax, %esi
leaq 0xa111(%rip), %rdx      # 0x15648
movq %rsi, %rdi
movb $0x0, %al
callq 0x3250
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x3b30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xa0dc(%rip), %rsi      # 0x15648
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5030
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb5ad
leaq 0x83da(%rip), %rdi      # 0x1396f
leaq 0x74b5(%rip), %rsi      # 0x12a51
movl $0x129c, %edx           # imm = 0x129C
leaq 0xa0a5(%rip), %rcx      # 0x1564d
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_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 %rbp
movq %rsp, %rbp
subq $0x20, %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 0xb607
jmp 0xb5f3
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xb61c
jmp 0xb5fd
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0xb639
jmp 0xb649
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
jmp 0xb668
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xb668
leaq 0xa043(%rip), %rdi      # 0x15683
movb $0x0, %al
callq 0x4cd0
jmp 0xb668
leaq 0x831f(%rip), %rdi      # 0x1396f
leaq 0x73fa(%rip), %rsi      # 0x12a51
movl $0x12ad, %edx           # imm = 0x12AD
leaq 0xa064(%rip), %rcx      # 0x156c7
callq 0x30f0
movq -0x18(%rbp), %rdi
callq 0x77f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)