LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_peek(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_peek( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 1 )
	{
		raise_error( "peek：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "peek：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	const auto* const var = v->variable_;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edx
jle 0xad8a
movl %edx, %ebx
cmpl $0x2, %edx
jne 0xad93
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xada3
cmpl $0x0, 0x10(%rax)
jg 0xadac
movq 0x8(%rax), %r15
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %eax, %eax
js 0xad73
cmpl %eax, 0x20(%r15)
jle 0xad73
movq 0x18(%r15), %rcx
movl %eax, %eax
movsbl (%rcx,%rax), %ebp
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xc671(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xad4b
leal 0x1(%rax), %ecx
movl %ecx, 0xc662(%rip)      # 0x173a0
leaq 0xc45b(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xad58
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7ec0
movq (%r15), %rsi
movl 0x20(%r15), %edx
leaq 0x6dd4(%rip), %rdi      # 0x11b55
movl %eax, %ecx
xorl %eax, %eax
callq 0x34a8
leaq 0x6cf9(%rip), %rdi      # 0x11a8a
jmp 0xadb3
leaq 0x6d11(%rip), %rdi      # 0x11aab
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
leaq 0x6d3c(%rip), %rdi      # 0x11ae6
jmp 0xadb3
leaq 0x6d60(%rip), %rdi      # 0x11b13
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_wpeek(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_wpeek( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 1 )
	{
		raise_error( "wpeek：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "wpeek：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	const auto* const var = v->variable_;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edx
jle 0xae98
movl %edx, %ebx
cmpl $0x2, %edx
jne 0xaea1
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xaeb1
cmpl $0x0, 0x10(%rax)
jg 0xaeba
movq 0x8(%rax), %r15
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %eax, %eax
js 0xae81
leal 0x2(%rax), %ecx
cmpl %ecx, 0x20(%r15)
jl 0xae81
movq 0x18(%r15), %rcx
movl %eax, %eax
movswl (%rcx,%rax), %ebp
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xc563(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xae59
leal 0x1(%rax), %ecx
movl %ecx, 0xc554(%rip)      # 0x173a0
leaq 0xc34d(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xae66
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7ec0
movq (%r15), %rsi
movl 0x20(%r15), %edx
leaq 0x6ba2(%rip), %rdi      # 0x11a31
movl %eax, %ecx
xorl %eax, %eax
callq 0x34a8
leaq 0x6ac7(%rip), %rdi      # 0x11966
jmp 0xaec1
leaq 0x6adf(%rip), %rdi      # 0x11987
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
leaq 0x6b0a(%rip), %rdi      # 0x119c2
jmp 0xaec1
leaq 0x6b2e(%rip), %rdi      # 0x119ef
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_lpeek(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_lpeek( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 1 )
	{
		raise_error( "lpeek：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "lpeek：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	const auto* const var = v->variable_;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edx
jle 0xafa5
movl %edx, %ebx
cmpl $0x2, %edx
jne 0xafae
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
cmpl $0x4, (%rax)
jne 0xafbe
cmpl $0x0, 0x10(%rax)
jg 0xafc7
movq 0x8(%rax), %r15
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %rdi
callq 0x51df
testl %eax, %eax
js 0xaf8e
leal 0x4(%rax), %ecx
cmpl %ecx, 0x20(%r15)
jl 0xaf8e
movq 0x18(%r15), %rcx
movl %eax, %eax
movl (%rcx,%rax), %ebp
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xc456(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xaf66
leal 0x1(%rax), %ecx
movl %ecx, 0xc447(%rip)      # 0x173a0
leaq 0xc240(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xaf73
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7ec0
movq (%r15), %rsi
movl 0x20(%r15), %edx
leaq 0x6bb8(%rip), %rdi      # 0x11b54
movl %eax, %ecx
xorl %eax, %eax
callq 0x34a8
leaq 0x6add(%rip), %rdi      # 0x11a89
jmp 0xafce
leaq 0x6af5(%rip), %rdi      # 0x11aaa
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
leaq 0x6b20(%rip), %rdi      # 0x11ae5
jmp 0xafce
leaq 0x6b44(%rip), %rdi      # 0x11b12
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_rnd(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_rnd( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "rnd：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "rnd：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %edx, %edx
jle 0xb068
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xb076
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %ebx
testl %eax, %eax
jle 0xb081
movq (%r14), %rdi
movl %ebp, %esi
callq 0x7e30
callq 0x20a0
movl %eax, %ebp
movq (%r14), %r14
movslq 0xc37b(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb041
leal 0x1(%rax), %ecx
movl %ecx, 0xc36c(%rip)      # 0x173a0
leaq 0xc165(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb04e
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl %ebp, %eax
cltd
idivl %ebx
movl $0x1, (%rsi)
movl %edx, 0x8(%rsi)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ec0
leaq 0x6b3d(%rip), %rdi      # 0x11bac
xorl %eax, %eax
callq 0x34a8
leaq 0x6b4e(%rip), %rdi      # 0x11bcb
movl %ebp, %esi
jmp 0xb08a
leaq 0x6b7c(%rip), %rdi      # 0x11c04
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_abs(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_abs( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "abs：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "abs：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %edx, %edx
jle 0xb117
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xb125
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %ebx
movq (%r14), %rdi
movl %ebp, %esi
callq 0x7e30
movq (%r14), %r14
movslq 0xc2ce(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb0ee
leal 0x1(%rax), %ecx
movl %ecx, 0xc2bf(%rip)      # 0x173a0
leaq 0xc0b8(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb0fb
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
movl $0x1, (%rsi)
movl %eax, 0x8(%rsi)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ec0
leaq 0x6b20(%rip), %rdi      # 0x11c3e
xorl %eax, %eax
callq 0x34a8
leaq 0x6b31(%rip), %rdi      # 0x11c5d
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_absf(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_absf( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "absf：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "absf：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
jle 0xb1d7
movl %edx, %ebx
cmpl $0x1, %edx
jne 0xb1e5
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movaps %xmm0, (%rsp)
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xc221(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb19b
leal 0x1(%rax), %ecx
movl %ecx, 0xc212(%rip)      # 0x173a0
leaq 0xc00b(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb1a8
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movapd 0x26f0(%rip), %xmm0     # 0xd8a0
movapd (%rsp), %xmm1
xorpd %xmm1, %xmm0
maxsd %xmm1, %xmm0
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x7ec0
leaq 0x6ab8(%rip), %rdi      # 0x11c96
xorl %eax, %eax
callq 0x34a8
leaq 0x6aca(%rip), %rdi      # 0x11cb6
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_deg2rad(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_deg2rad( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "deg2rad：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "deg2rad：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = ( r * NHSP_MPI / 180.0 );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb295
movl %edx, %ebx
cmpl $0x1, %edx
jne 0xb2a3
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xc163(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb259
leal 0x1(%rax), %ecx
movl %ecx, 0xc154(%rip)      # 0x173a0
leaq 0xbf4d(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb266
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movsd (%rsp), %xmm0
mulsd 0x263d(%rip), %xmm0     # 0xd8b0
divsd 0x263d(%rip), %xmm0     # 0xd8b8
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7ec0
leaq 0x6a54(%rip), %rdi      # 0x11cf0
xorl %eax, %eax
callq 0x34a8
leaq 0x6a69(%rip), %rdi      # 0x11d13
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_rad2deg(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_rad2deg( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "rad2deg：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "rad2deg：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = ( r * 180.0 / NHSP_MPI );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb353
movl %edx, %ebx
cmpl $0x1, %edx
jne 0xb361
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xc0a5(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb317
leal 0x1(%rax), %ecx
movl %ecx, 0xc096(%rip)      # 0x173a0
leaq 0xbe8f(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb324
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movsd (%rsp), %xmm0
mulsd 0x2587(%rip), %xmm0     # 0xd8b8
divsd 0x2577(%rip), %xmm0     # 0xd8b0
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7ec0
leaq 0x69f6(%rip), %rdi      # 0x11d50
xorl %eax, %eax
callq 0x34a8
leaq 0x6a0b(%rip), %rdi      # 0x11d73
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_sin(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_sin( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "sin：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "sin：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = std::sin( r );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb40e
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xb41c
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
movsd (%rsp), %xmm0
callq 0x2090
movq (%rbx), %rbx
movslq 0xbfde(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb3de
leal 0x1(%rax), %ecx
movl %ecx, 0xbfcf(%rip)      # 0x173a0
leaq 0xbdc8(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb3f5
movl $0x18, %edi
movsd %xmm0, (%rsp)
callq 0x21d0
movsd (%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7ec0
leaq 0x699b(%rip), %rdi      # 0x11db0
xorl %eax, %eax
callq 0x34a8
leaq 0x69ac(%rip), %rdi      # 0x11dcf
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_cos(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_cos( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "cos：引数がたりません" );
		return;
	}
	if ( arg_num > 1 )
	{
		raise_error( "cos：引数が多すぎます@@ %d個渡されました", arg_num );
		return;
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = std::cos( r );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xb4cf
cmpl $0x1, %edx
jne 0xb4dd
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7e30
movsd 0x8(%rsp), %xmm0
callq 0x22b0
movq (%rbx), %rbx
movslq 0xbf1e(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb49e
leal 0x1(%rax), %ecx
movl %ecx, 0xbf0f(%rip)      # 0x173a0
leaq 0xbd08(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb4b7
movl $0x18, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x21d0
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x7ec0
leaq 0x6932(%rip), %rdi      # 0x11e08
xorl %eax, %eax
callq 0x34a8
leaq 0x6943(%rip), %rdi      # 0x11e27
movl %edx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_tan(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_tan( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "tan：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "tan：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = std::tan( r );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb58a
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xb598
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
movsd (%rsp), %xmm0
callq 0x20e0
movq (%rbx), %rbx
movslq 0xbe62(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb55a
leal 0x1(%rax), %ecx
movl %ecx, 0xbe53(%rip)      # 0x173a0
leaq 0xbc4c(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb571
movl $0x18, %edi
movsd %xmm0, (%rsp)
callq 0x21d0
movsd (%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7ec0
leaq 0x68d0(%rip), %rdi      # 0x11e61
xorl %eax, %eax
callq 0x34a8
leaq 0x68e2(%rip), %rdi      # 0x11e81
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_atan(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_atan( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 2 )
	{
		raise_error( "atan：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "atan：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto arg_start = -arg_num;
	const auto vy = stack_peek( s->stack_, arg_start + 0 );
	const auto vx = stack_peek( s->stack_, arg_start + 1 );
	const auto y = value_calc_double( *vy );
	const auto x = value_calc_double( *vx );

	stack_pop( s->stack_, arg_num );
	const auto res = std::atan2( y, x );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x1, %edx
jle 0xb67d
movl %edx, %ebp
cmpl $0x2, %edx
jne 0xb68b
movq %rsi, %rbx
movl %ebp, %esi
negl %esi
movq (%rbx), %rdi
callq 0x7f19
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
subl %ebp, %esi
callq 0x7f19
movq %rax, %r15
movq %r14, %rdi
callq 0x73f0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x73f0
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2060
movq (%rbx), %rbx
movslq 0xbd75(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb647
leal 0x1(%rax), %ecx
movl %ecx, 0xbd66(%rip)      # 0x173a0
leaq 0xbb5f(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb660
movl $0x18, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x21d0
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7ec0
leaq 0x67dc(%rip), %rdi      # 0x11e60
xorl %eax, %eax
callq 0x34a8
leaq 0x67ee(%rip), %rdi      # 0x11e80
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_expf(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_expf( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "expf：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "expf：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = std::exp( r );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb738
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xb746
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
movsd (%rsp), %xmm0
callq 0x22a0
movq (%rbx), %rbx
movslq 0xbcb4(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb708
leal 0x1(%rax), %ecx
movl %ecx, 0xbca5(%rip)      # 0x173a0
leaq 0xba9e(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb71f
movl $0x18, %edi
movsd %xmm0, (%rsp)
callq 0x21d0
movsd (%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7ec0
leaq 0x677b(%rip), %rdi      # 0x11eba
xorl %eax, %eax
callq 0x34a8
leaq 0x678d(%rip), %rdi      # 0x11eda
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_logf(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_logf( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "logf：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "logf：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = std::log( r );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb7f3
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xb801
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
movsd (%rsp), %xmm0
callq 0x2110
movq (%rbx), %rbx
movslq 0xbbf9(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb7c3
leal 0x1(%rax), %ecx
movl %ecx, 0xbbea(%rip)      # 0x173a0
leaq 0xb9e3(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb7da
movl $0x18, %edi
movsd %xmm0, (%rsp)
callq 0x21d0
movsd (%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7ec0
leaq 0x671a(%rip), %rdi      # 0x11f14
xorl %eax, %eax
callq 0x34a8
leaq 0x672c(%rip), %rdi      # 0x11f34
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_powf(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_powf( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "powf：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "powf：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto arg_start = -arg_num;
	const auto vx = stack_peek( s->stack_, arg_start + 0 );
	const auto vy = stack_peek( s->stack_, arg_start + 1 );
	const auto x = value_calc_double( *vx );
	const auto y = value_calc_double( *vy );

	stack_pop( s->stack_, arg_num );
	const auto res = std::pow( x, y );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
jle 0xb8e5
movl %edx, %ebp
cmpl $0x3, %edx
jge 0xb8f3
movq %rsi, %rbx
movl %ebp, %esi
negl %esi
movq (%rbx), %rdi
callq 0x7f19
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
subl %ebp, %esi
callq 0x7f19
movq %rax, %r15
movq %r14, %rdi
callq 0x73f0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x73f0
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2290
movq (%rbx), %rbx
movslq 0xbb0d(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb8af
leal 0x1(%rax), %ecx
movl %ecx, 0xbafe(%rip)      # 0x173a0
leaq 0xb8f7(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb8c8
movl $0x18, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x21d0
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7ec0
leaq 0x6682(%rip), %rdi      # 0x11f6e
xorl %eax, %eax
callq 0x34a8
leaq 0x6694(%rip), %rdi      # 0x11f8e
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_sqrt(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_sqrt( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "sqrt：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "sqrt：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

	stack_pop( s->stack_, arg_num );
	const auto res = std::sqrt( r );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb9b4
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xb9c2
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x73f0
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0xb959
sqrtsd %xmm0, %xmm0
jmp 0xb95e
callq 0x2100
movq (%rbx), %rbx
movslq 0xba38(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xb984
leal 0x1(%rax), %ecx
movl %ecx, 0xba29(%rip)      # 0x173a0
leaq 0xb822(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xb99b
movl $0x18, %edi
movsd %xmm0, (%rsp)
callq 0x21d0
movsd (%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7ec0
leaq 0x660d(%rip), %rdi      # 0x11fc8
xorl %eax, %eax
callq 0x34a8
leaq 0x661f(%rip), %rdi      # 0x11fe8
movl %ebp, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_limit(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_limit( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 3 )
	{
		raise_error( "limit：引数がたりません" );
	}
	if ( arg_num > 3 )
	{
		raise_error( "limit：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto arg_start = -arg_num;
	const auto vmi = stack_peek( s->stack_, arg_start + 0 );
	const auto vm = stack_peek( s->stack_, arg_start + 1 );
	const auto vma = stack_peek( s->stack_, arg_start + 2 );
	const auto mi = value_calc_int( *vmi );
	const auto v = value_calc_int( *vm );
	const auto ma = value_calc_int( *vma );

	stack_pop( s->stack_, arg_num );
	auto res = v;
	if ( res < mi )
	{ res = mi; }
	if ( res > ma )
	{ res = ma; }
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edx
jle 0xbab1
movl %edx, %ebx
cmpl $0x3, %edx
jne 0xbabf
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
movq %rax, %r15
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %r12
movq (%r14), %rdi
movl $0x2, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %r13
movq %r15, %rdi
callq 0x51df
movl %eax, %ebp
movq %r12, %rdi
callq 0x51df
movl %eax, %r15d
movq %r13, %rdi
callq 0x51df
movl %eax, %r12d
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xb945(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xba77
leal 0x1(%rax), %ecx
movl %ecx, 0xb936(%rip)      # 0x173a0
leaq 0xb72f(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xba84
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
cmpl %ebp, %r15d
cmovgl %r15d, %ebp
cmpl %r12d, %ebp
cmovgel %r12d, %ebp
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7ec0
leaq 0x656a(%rip), %rdi      # 0x12022
xorl %eax, %eax
callq 0x34a8
leaq 0x657d(%rip), %rdi      # 0x12043
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_limitf(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_limitf( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 3 )
	{
		raise_error( "limitf：引数がたりません" );
	}
	if ( arg_num > 3 )
	{
		raise_error( "limitf：引数が多すぎます@@ %d個渡されました", arg_num );
	}

	const auto arg_start = -arg_num;
	const auto vmi = stack_peek( s->stack_, arg_start + 0 );
	const auto vm = stack_peek( s->stack_, arg_start + 1 );
	const auto vma = stack_peek( s->stack_, arg_start + 2 );
	const auto mi = value_calc_double( *vmi );
	const auto v = value_calc_double( *vm );
	const auto ma = value_calc_double( *vma );

	stack_pop( s->stack_, arg_num );
	auto res = v;
	if ( res < mi )
	{ res = mi; }
	if ( res > ma )
	{ res = ma; }
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x2, %edx
jle 0xbbc3
movl %edx, %ebx
cmpl $0x3, %edx
jne 0xbbd1
movq %rsi, %r14
movl %ebx, %esi
negl %esi
movq (%r14), %rdi
callq 0x7f19
movq %rax, %r15
movq (%r14), %rdi
movl $0x1, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %r12
movq (%r14), %rdi
movl $0x2, %esi
subl %ebx, %esi
callq 0x7f19
movq %rax, %r13
movq %r15, %rdi
callq 0x73f0
movsd %xmm0, 0x18(%rsp)
movq %r12, %rdi
callq 0x73f0
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
callq 0x73f0
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rdi
movl %ebx, %esi
callq 0x7e30
movq (%r14), %rbx
movslq 0xb83c(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xbb80
leal 0x1(%rax), %ecx
movl %ecx, 0xb82d(%rip)      # 0x173a0
leaq 0xb626(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xbb8d
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movsd 0x18(%rsp), %xmm0
maxsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
minsd %xmm0, %xmm1
movl $0x2, (%rsi)
movsd %xmm1, 0x8(%rsi)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7ec0
leaq 0x64b4(%rip), %rdi      # 0x1207e
xorl %eax, %eax
callq 0x34a8
leaq 0x64c8(%rip), %rdi      # 0x120a0
movl %ebx, %esi
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_strlen(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_strlen( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "strlen：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "strlen：引数が多すぎます" );
	}

	const auto m = stack_peek( s->stack_ );
	if ( value_get_primitive_tag( *m ) != VALUE_STRING )
	{
		raise_error( "strlen：引数が文字列型ではありません" );
	}
	const auto* const str = value_get_string( *m );
	assert( str != nullptr );

	stack_pop( s->stack_, arg_num );
	const auto res = static_cast<int>( strlen( str ) );
	stack_push( s->stack_, create_value( res ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %edx, %edx
jle 0xbc91
movl %edx, %ebp
cmpl $0x1, %edx
jne 0xbc9a
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movl (%rax), %ecx
cmpl $0x4, %ecx
jne 0xbc16
movq 0x8(%rax), %rcx
movl 0x8(%rcx), %ecx
cmpl $0x3, %ecx
jne 0xbca3
movq %rax, %rdi
callq 0x744d
testq %rax, %rax
je 0xbcb1
movq %rax, %r14
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7e30
movq %r14, %rdi
callq 0x20b0
movq %rax, %r14
movq (%rbx), %rbx
movslq 0xb74e(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0xbc6e
leal 0x1(%rax), %ecx
movl %ecx, 0xb73f(%rip)      # 0x173a0
leaq 0xb538(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0xbc7b
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %r14d, 0x8(%rsi)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ec0
leaq 0x6444(%rip), %rdi      # 0x120dc
jmp 0xbcaa
leaq 0x645d(%rip), %rdi      # 0x120fe
jmp 0xbcaa
leaq 0x6476(%rip), %rdi      # 0x12120
xorl %eax, %eax
callq 0x34a8
leaq 0x649c(%rip), %rdi      # 0x12154
leaq 0x1c1a(%rip), %rsi      # 0xd8d9
leaq 0x649d(%rip), %rcx      # 0x12163
movl $0x4b0, %edx            # imm = 0x4B0
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::dump_ast(neteruhsp::list_t*, bool)::_::dump(int, neteruhsp::ast_node_t*, bool)
static void dump( int indent, ast_node_t* node, bool is_detail )
		{
			for( int i=0; i<indent; ++i )
			{ printf( "  " ); }
			static const char* nodenames[] =
			{
				"EMPTY",
				"LABEL",
				"BLOCK_STATEMENTS",
				"COMMAND",
				"ARGUMENTS",
				"ASSIGN",
				"ADD_ASSIGN",
				"SUB_ASSIGN",
				"MUL_ASSIGN",
				"DIV_ASSIGN",
				"MOD_ASSIGN",
				"BOR_ASSIGN",
				"BAND_ASSIGN",
				"BXOR_ASSIGN",
				"VARIABLE",
				"EXPRESSION",
				"BOR",
				"BAND",
				"BXOR",
				"EQ",
				"NEQ",
				"GT",
				"GTOE",
				"LT",
				"LTOE",
				"ADD",
				"SUB",
				"MUL",
				"DIV",
				"MOD",
				"UNARY_MINUS",
				"PRIMITIVE_VALUE",
				"IDENTIFIER_EXPR",
				"END",
				"RETURN",
				"GOTO",
				"GOSUB",
				"REPEAT",
				"LOOP",
				"CONTINUE",
				"BREAK",
				"IF",
				"IF_DISPATCHER",
			};
			static_assert( sizeof(nodenames) /sizeof(*nodenames) == MAX_NODE, "nodenames size is not match with MAX_NODE" );
			assert( node->tag_>=0 && node->tag_<MAX_NODE );
			printf( "%s", nodenames[node->tag_] );
			if ( is_detail )
			{ printf( " :%p", node ); }
			if ( node->token_ )
			{ printf( "[%s]", node->token_->content_ ); }
			printf( "\n" );
			if ( node->left_ )
			{ dump( indent +1, node->left_, is_detail ); }
			if ( node->right_ )
			{ dump( indent +1, node->right_, is_detail ); }
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
leaq 0x64e2(%rip), %r12      # 0x121cc
leaq 0x1a3f(%rip), %r13      # 0xd730
movzbl %bl, %eax
movl %eax, 0x4(%rsp)
movl %r15d, %ebp
testl %r15d, %r15d
jle 0xbd0e
movq %r12, %rdi
xorl %eax, %eax
callq 0x2050
decl %ebp
jne 0xbd00
movl (%r14), %eax
cmpq $0x2b, %rax
jae 0xbda1
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
leaq 0x525e(%rip), %rdi      # 0x10f88
xorl %eax, %eax
callq 0x2050
testb %bl, %bl
je 0xbd46
leaq 0x662a(%rip), %rdi      # 0x12366
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xbd61
movq 0x8(%rax), %rsi
leaq 0x6717(%rip), %rdi      # 0x12471
xorl %eax, %eax
callq 0x2050
movl $0xa, %edi
callq 0x2210
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xbd81
leal 0x1(%r15), %edi
movl 0x4(%rsp), %edx
callq 0xbcd0
movq 0x18(%r14), %r14
testq %r14, %r14
je 0xbd92
incl %r15d
jmp 0xbcf8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6547(%rip), %rdi      # 0x122ef
leaq 0x1b2a(%rip), %rsi      # 0xd8d9
leaq 0x655e(%rip), %rcx      # 0x12314
movl $0x1889, %edx           # imm = 0x1889
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::dump_variable(neteruhsp::list_t*, char const*, int)
void dump_variable( list_t* var_table, const char* name, int idx )
{
	printf( "%s[%d]=", name, idx );
	if ( auto v = search_variable( var_table, name ) )
	{
		auto p = variable_data_ptr( *v, idx );
		switch( v->type_ )
		{
			case VALUE_INT:		printf("%d", reinterpret_cast<int*>(p)[0]); break;
			case VALUE_DOUBLE:	printf("%lf", reinterpret_cast<double*>(p)[0]); break;
			case VALUE_STRING:	printf("%s", reinterpret_cast<char*>(p)); break;
			default: assert( false ); break;
		}
	}
	else
	{
		printf( "<nil>" );
	}
	printf( "\n" );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4fbf(%rip), %rdi      # 0x10d97
xorl %eax, %eax
callq 0x2050
movq (%r15), %r12
testq %r12, %r12
je 0xbe11
movq 0x10(%r12), %r13
movq (%r13), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2da2
testb %al, %al
je 0xbe06
movq %r13, %r15
jmp 0xbe0b
movq 0x8(%r12), %r12
testb %al, %al
je 0xbde2
jmp 0xbe14
xorl %r15d, %r15d
testq %r15, %r15
je 0xbe48
movq %r15, %rdi
movl %ebx, %esi
callq 0x68db
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0xbe6c
cmpl $0x2, %ecx
je 0xbe58
cmpl $0x1, %ecx
jne 0xbe90
movl (%rax), %esi
leaq 0x5dfc(%rip), %rdi      # 0x11c3b
xorl %eax, %eax
callq 0x2050
jmp 0xbe7d
leaq 0x4f8f(%rip), %rdi      # 0x10dde
xorl %eax, %eax
callq 0x2050
jmp 0xbe7d
movsd (%rax), %xmm0
leaq 0x4f3c(%rip), %rdi      # 0x10d9f
movb $0x1, %al
callq 0x2050
jmp 0xbe7d
leaq 0x5115(%rip), %rdi      # 0x10f88
movq %rax, %rsi
xorl %eax, %eax
callq 0x2050
movl $0xa, %edi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2210
leaq 0x2960(%rip), %rdi      # 0xe7f7
leaq 0x1a3b(%rip), %rsi      # 0xd8d9
leaq 0x4efe(%rip), %rcx      # 0x10da3
movl $0x18ad, %edx           # imm = 0x18AD
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::dump_stack(neteruhsp::value_stack_t*)
void dump_stack( value_stack_t* stack )
{
	printf( "====stack[%p] top[%d] max[%d]\n", stack, stack->top_, stack->max_ );
	for( int i=0; i<stack->top_; ++i )
	{
		const auto v = stack_peek( stack, i );
		switch( v->type_ )
		{
			case VALUE_INT:			printf("%d", v->ivalue_); break;
			case VALUE_DOUBLE:		printf("%lf", v->dvalue_); break;
			case VALUE_STRING:		printf("%s", v->svalue_); break;
			case VALUE_VARIABLE:	printf("var[%s] idx[%d]", v->variable_->name_, v->index_); break;
			default: assert( false ); break;
		}
		printf( "\n" );
	}
	printf( "----\n" );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
leaq 0x4f1a(%rip), %rdi      # 0x10de4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x8(%rbx)
jle 0xbf71
leaq 0x17ef(%rip), %r14      # 0xd6d4
leaq 0x4eb3(%rip), %r15      # 0x10d9f
leaq 0x5095(%rip), %r12      # 0x10f88
leaq 0x4f09(%rip), %r13      # 0x10e03
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7f19
movl (%rax), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0xbf8b
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movl 0x8(%rax), %esi
leaq 0x5d19(%rip), %rdi      # 0x11c3b
xorl %eax, %eax
callq 0x2050
jmp 0xbf60
movq 0x8(%rax), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2050
jmp 0xbf60
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movl 0x10(%rax), %edx
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
jmp 0xbf60
movsd 0x8(%rax), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x2050
movl $0xa, %edi
callq 0x2210
incl %ebp
cmpl 0x8(%rbx), %ebp
jl 0xbefc
leaq 0x658a(%rip), %rdi      # 0x12502
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
leaq 0x2865(%rip), %rdi      # 0xe7f7
leaq 0x1940(%rip), %rsi      # 0xd8d9
leaq 0x4e73(%rip), %rcx      # 0x10e13
movl $0x18c3, %edx           # imm = 0x18C3
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::search_label(neteruhsp::execute_environment_t*, char const*)
label_node_t* search_label( execute_environment_t* e, const char* name )
{
	auto node = e->label_table_->head_;
	while( node != nullptr )
	{
		const auto label = reinterpret_cast<label_node_t*>( node->value_ );
		if ( string_equal_igcase( label->name_, name ) )
		{ return label; }

		node = node->next_;
	}
	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %r15
testq %r15, %r15
je 0xc268
movq 0x10(%r15), %r12
movq (%r12), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2da2
testb %al, %al
je 0xc25e
movq %r12, %r14
jmp 0xc262
movq 0x8(%r15), %r15
testb %al, %al
je 0xc23b
jmp 0xc26b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::code_checked_realloc(neteruhsp::execute_environment_t*, unsigned long)
void code_checked_realloc( execute_environment_t* e, size_t size )
{
	const auto required = e->execute_code_->code_size_ +size;
	if ( e->execute_code_->code_buffer_size_ <= required )
	{
		static const size_t default_size = 256;
		if ( e->execute_code_->code_buffer_size_ < default_size )
		{
			e->execute_code_->code_buffer_size_ = default_size;
		}

		while( e->execute_code_->code_buffer_size_ <= required )
		{
			e->execute_code_->code_buffer_size_ *= 2;
		}

		const auto area_size = e->execute_code_->code_buffer_size_ *sizeof(code_t);
		e->execute_code_->code_ = reinterpret_cast<code_t*>( xrealloc( e->execute_code_->code_, area_size ) );
		if ( e->execute_code_->code_ == nullptr )
		{
			raise_error( "仮想マシン用のコードバッファが確保できません" );
		}
	}
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rcx
addq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rax
cmpq %rsi, %rax
ja 0xc2cf
movq %rdi, %rbx
cmpq $0xff, %rax
ja 0xc29f
movq $0x100, 0x10(%rcx)      # imm = 0x100
movq 0x10(%rcx), %rax
cmpq %rsi, %rax
ja 0xc2b4
addq %rax, %rax
cmpq %rsi, %rax
jbe 0xc2a8
movq %rax, 0x10(%rcx)
shlq $0x2, %rax
movq (%rcx), %rdi
movq %rax, %rsi
callq 0x2280
movq 0x20(%rbx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0xc2d1
popq %rbx
retq
leaq 0x4e54(%rip), %rdi      # 0x1112c
xorl %eax, %eax
callq 0x34a8
// File: /workspace/github_cpp_makefile_star2_O1/manikandan5[P]Image-Matching-Stitching-Warping/./Homography.h
// Function: getInliners(cimg_library::CImg<double>&, std::vector<std::pair<SiftDescriptor, SiftDescriptor>, std::allocator<std::pair<SiftDescriptor, SiftDescriptor>>> const&)
int getInliners(CImg<double>& projection,const SiftDescriptorMap& mapping)
{
	int count = 0;
	
	//point in Second Image = [projection]* point in first 	
	for(int i = 0;i<mapping.size();++i)
	{
		double zz = projection(0,6) * mapping[i].first.col + projection(0,7) * mapping[i].first.row + 1;
		double xx = (projection(0,0) * mapping[i].first.col + projection(0,1) * mapping[i].first.row + projection(0,2))/zz;
		double yy = (projection(0,3) * mapping[i].first.col + projection(0,4) * mapping[i].first.row + projection(0,5))/zz;
		
		//cout<<i+1<<" x-x'= "<<xx-mapping[i].second.col<<" y-y' = "<<yy-mapping[i].second.row<<endl; 		

		if(abs(xx-mapping[i].second.col) <5.0 && abs(yy-mapping[i].second.row)<5.0)
			count++;
	}
	return count;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
je 0x631b
sarq $0x4, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
movq 0x18(%rdi), %rsi
movl (%rdi), %eax
leal (%rax,%rax), %r8d
leal (%r8,%r8,2), %r9d
leal (,%rax,8), %r10d
subl %eax, %r10d
cmpq $0x1, %rdx
adcq $0x0, %rdx
leal (%rax,%rax,4), %edi
movapd 0x6ae8b(%rip), %xmm0    # 0x710d0
movlpd (%rsi,%r8,8), %xmm0     # xmm0 = mem[0],xmm0[1]
leal (,%rax,4), %r8d
movsd (%rsi), %xmm1
movhpd (%rsi,%r9,8), %xmm1     # xmm1 = xmm1[0],mem[0]
leal (%rax,%rax,2), %r9d
movsd (%rsi,%rax,8), %xmm2
movhpd (%rsi,%r10,8), %xmm2    # xmm2 = xmm2[0],mem[0]
addq $0x2c, %rcx
xorl %eax, %eax
movapd 0x6ae66(%rip), %xmm3    # 0x710e0
movsd 0x6ad9e(%rip), %xmm4    # 0x71020
xorps %xmm5, %xmm5
cvtss2sd -0x28(%rcx), %xmm5
xorps %xmm6, %xmm6
cvtss2sd -0x2c(%rcx), %xmm6
movaps %xmm6, %xmm7
movlhps %xmm6, %xmm7            # xmm7 = xmm7[0],xmm6[0]
mulpd %xmm2, %xmm7
movaps %xmm5, %xmm8
movlhps %xmm5, %xmm8            # xmm8 = xmm8[0],xmm5[0]
mulpd %xmm1, %xmm8
addpd %xmm7, %xmm8
addpd %xmm0, %xmm8
movapd %xmm8, %xmm7
unpckhpd %xmm8, %xmm7            # xmm7 = xmm7[1],xmm8[1]
divsd %xmm7, %xmm8
xorps %xmm9, %xmm9
cvtss2sd (%rcx), %xmm9
subsd %xmm9, %xmm8
andpd %xmm3, %xmm8
ucomisd %xmm8, %xmm4
jbe 0x630d
mulsd (%rsi,%r8,8), %xmm6
mulsd (%rsi,%r9,8), %xmm5
addsd %xmm6, %xmm5
addsd (%rsi,%rdi,8), %xmm5
divsd %xmm7, %xmm5
xorps %xmm6, %xmm6
cvtss2sd -0x4(%rcx), %xmm6
subsd %xmm6, %xmm5
andpd %xmm3, %xmm5
ucomisd %xmm5, %xmm4
jbe 0x630d
incl %eax
addq $0x50, %rcx
decq %rdx
jne 0x6282
retq
xorl %eax, %eax
retq