LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
cmpl $0x1, %edx
jle 0xa8ff
cmpl $0x2, %edx
jne 0xa908
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
cmpl $0x4, (%rax)
jne 0xa918
cmpl $0x0, 0x10(%rax)
jg 0xa921
movq 0x8(%rax), %r14
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl 0x20(%r14), %edx
testl %eax, %eax
js 0xa92f
leal 0x2(%rax), %ecx
cmpl %ecx, %edx
jl 0xa92f
movq 0x18(%r14), %rcx
movl %eax, %eax
movswl (%rcx,%rax), %ebp
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xbadf(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xa8dd
leal 0x1(%rax), %ecx
movl %ecx, 0xbad0(%rip)      # 0x163a0
leaq 0xb8c9(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xa8ea
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ab5
leaq 0x5f5a(%rip), %rdi      # 0x10860
jmp 0xa928
leaq 0x5f72(%rip), %rdi      # 0x10881
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
leaq 0x5f9d(%rip), %rdi      # 0x108bc
jmp 0xa928
leaq 0x5fc1(%rip), %rdi      # 0x108e9
xorl %eax, %eax
callq 0x344d
movq (%r14), %rsi
leaq 0x5ff2(%rip), %rdi      # 0x1092b
movl %eax, %ecx
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
cmpl $0x1, %edx
jle 0xaa09
cmpl $0x2, %edx
jne 0xaa12
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
cmpl $0x4, (%rax)
jne 0xaa22
cmpl $0x0, 0x10(%rax)
jg 0xaa2b
movq 0x8(%rax), %r14
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl 0x20(%r14), %edx
testl %eax, %eax
js 0xaa39
leal 0x4(%rax), %ecx
cmpl %ecx, %edx
jl 0xaa39
movq 0x18(%r14), %rcx
movl %eax, %eax
movl (%rcx,%rax), %ebp
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xb9d5(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xa9e7
leal 0x1(%rax), %ecx
movl %ecx, 0xb9c6(%rip)      # 0x163a0
leaq 0xb7bf(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xa9f4
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7ab5
leaq 0x5f73(%rip), %rdi      # 0x10983
jmp 0xaa32
leaq 0x5f8b(%rip), %rdi      # 0x109a4
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
leaq 0x5fb6(%rip), %rdi      # 0x109df
jmp 0xaa32
leaq 0x5fda(%rip), %rdi      # 0x10a0c
xorl %eax, %eax
callq 0x344d
movq (%r14), %rsi
leaq 0x600b(%rip), %rdi      # 0x10a4e
movl %eax, %ecx
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaae0
cmpl $0x1, %edx
jne 0xaaee
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %ebx
testl %eax, %eax
jle 0xaaf9
movq (%r14), %rdi
movl $0x1, %esi
callq 0x7a28
callq 0x20a0
movl %eax, %ebp
movq (%r14), %r14
movslq 0xb903(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xaab9
leal 0x1(%rax), %ecx
movl %ecx, 0xb8f4(%rip)      # 0x163a0
leaq 0xb6ed(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xaac6
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 0x7ab5
leaq 0x5fbf(%rip), %rdi      # 0x10aa6
xorl %eax, %eax
callq 0x344d
leaq 0x5fd0(%rip), %rdi      # 0x10ac5
movl %edx, %esi
jmp 0xab02
leaq 0x5ffe(%rip), %rdi      # 0x10afe
movl %ebx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xab97
cmpl $0x1, %edx
jne 0xaba5
movq %rsi, %r14
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %ebx
movq (%r14), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%r14), %r14
movslq 0xb851(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xab6b
leal 0x1(%rax), %ecx
movl %ecx, 0xb842(%rip)      # 0x163a0
leaq 0xb63b(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xab78
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
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7ab5
leaq 0x5f9a(%rip), %rdi      # 0x10b38
xorl %eax, %eax
callq 0x344d
leaq 0x5fab(%rip), %rdi      # 0x10b57
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xac54
cmpl $0x1, %edx
jne 0xac62
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movaps %xmm0, (%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xb7a2(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xac1a
leal 0x1(%rax), %ecx
movl %ecx, 0xb793(%rip)      # 0x163a0
leaq 0xb58c(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xac27
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movapd 0x1c31(%rip), %xmm0     # 0xc860
movapd (%rsp), %xmm1
xorpd %xmm1, %xmm0
maxsd %xmm1, %xmm0
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x7ab5
leaq 0x5f35(%rip), %rdi      # 0x10b90
xorl %eax, %eax
callq 0x344d
leaq 0x5f47(%rip), %rdi      # 0x10bb0
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xad14
cmpl $0x1, %edx
jne 0xad22
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xb6e3(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xacd9
leal 0x1(%rax), %ecx
movl %ecx, 0xb6d4(%rip)      # 0x163a0
leaq 0xb4cd(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xace6
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movsd 0x8(%rsp), %xmm0
mulsd 0x1b7c(%rip), %xmm0     # 0xc870
divsd 0x1b7c(%rip), %xmm0     # 0xc878
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x7ab5
leaq 0x5ecf(%rip), %rdi      # 0x10bea
xorl %eax, %eax
callq 0x344d
leaq 0x5ee4(%rip), %rdi      # 0x10c0d
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xadd4
cmpl $0x1, %edx
jne 0xade2
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xb623(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xad99
leal 0x1(%rax), %ecx
movl %ecx, 0xb614(%rip)      # 0x163a0
leaq 0xb40d(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xada6
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movsd 0x8(%rsp), %xmm0
mulsd 0x1ac4(%rip), %xmm0     # 0xc878
divsd 0x1ab4(%rip), %xmm0     # 0xc870
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x7ab5
leaq 0x5e6f(%rip), %rdi      # 0x10c4a
xorl %eax, %eax
callq 0x344d
leaq 0x5e84(%rip), %rdi      # 0x10c6d
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xae95
cmpl $0x1, %edx
jne 0xaea3
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movsd 0x8(%rsp), %xmm0
callq 0x2090
movq (%rbx), %rbx
movslq 0xb558(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xae64
leal 0x1(%rax), %ecx
movl %ecx, 0xb549(%rip)      # 0x163a0
leaq 0xb342(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xae7d
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 0x7ab5
leaq 0x5e0e(%rip), %rdi      # 0x10caa
xorl %eax, %eax
callq 0x344d
leaq 0x5e1f(%rip), %rdi      # 0x10cc9
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 0xaf56
cmpl $0x1, %edx
jne 0xaf64
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movsd 0x8(%rsp), %xmm0
callq 0x22b0
movq (%rbx), %rbx
movslq 0xb497(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xaf25
leal 0x1(%rax), %ecx
movl %ecx, 0xb488(%rip)      # 0x163a0
leaq 0xb281(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xaf3e
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 0x7ab5
leaq 0x5da5(%rip), %rdi      # 0x10d02
xorl %eax, %eax
callq 0x344d
leaq 0x5db6(%rip), %rdi      # 0x10d21
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xb017
cmpl $0x1, %edx
jne 0xb025
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movsd 0x8(%rsp), %xmm0
callq 0x20d0
movq (%rbx), %rbx
movslq 0xb3d6(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xafe6
leal 0x1(%rax), %ecx
movl %ecx, 0xb3c7(%rip)      # 0x163a0
leaq 0xb1c0(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xafff
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 0x7ab5
leaq 0x5d3d(%rip), %rdi      # 0x10d5b
xorl %eax, %eax
callq 0x344d
leaq 0x5d4f(%rip), %rdi      # 0x10d7b
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edx
jle 0xb104
cmpl $0x2, %edx
jne 0xb112
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
movq %rax, %r14
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r15
movq %r14, %rdi
callq 0x6fee
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x7a28
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2060
movq (%rbx), %rbx
movslq 0xb2eb(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb0d1
leal 0x1(%rax), %ecx
movl %ecx, 0xb2dc(%rip)      # 0x163a0
leaq 0xb0d5(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb0e8
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 $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7ab5
leaq 0x5c4f(%rip), %rdi      # 0x10d5a
xorl %eax, %eax
callq 0x344d
leaq 0x5c61(%rip), %rdi      # 0x10d7a
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xb1c5
cmpl $0x1, %edx
jne 0xb1d3
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movsd 0x8(%rsp), %xmm0
callq 0x22a0
movq (%rbx), %rbx
movslq 0xb228(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb194
leal 0x1(%rax), %ecx
movl %ecx, 0xb219(%rip)      # 0x163a0
leaq 0xb012(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb1ad
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 0x7ab5
leaq 0x5be8(%rip), %rdi      # 0x10db4
xorl %eax, %eax
callq 0x344d
leaq 0x5bfa(%rip), %rdi      # 0x10dd4
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xb286
cmpl $0x1, %edx
jne 0xb294
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movsd 0x8(%rsp), %xmm0
callq 0x2110
movq (%rbx), %rbx
movslq 0xb167(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb255
leal 0x1(%rax), %ecx
movl %ecx, 0xb158(%rip)      # 0x163a0
leaq 0xaf51(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb26e
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 0x7ab5
leaq 0x5b81(%rip), %rdi      # 0x10e0e
xorl %eax, %eax
callq 0x344d
leaq 0x5b93(%rip), %rdi      # 0x10e2e
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 0xb378
movl %edx, %ebp
cmpl $0x3, %edx
jae 0xb386
movq %rsi, %rbx
movl %ebp, %esi
negl %esi
movq (%rbx), %rdi
callq 0x7b11
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
subl %ebp, %esi
callq 0x7b11
movq %rax, %r15
movq %r14, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x6fee
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x7a28
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2290
movq (%rbx), %rbx
movslq 0xb07a(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb342
leal 0x1(%rax), %ecx
movl %ecx, 0xb06b(%rip)      # 0x163a0
leaq 0xae64(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb35b
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 0x7ab5
leaq 0x5ae9(%rip), %rdi      # 0x10e68
xorl %eax, %eax
callq 0x344d
leaq 0x5afb(%rip), %rdi      # 0x10e88
movl %ebp, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
testl %edx, %edx
jle 0xb44d
cmpl $0x1, %edx
jne 0xb45b
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0xb3f1
sqrtsd %xmm0, %xmm0
jmp 0xb3f6
callq 0x2100
movq (%rbx), %rbx
movslq 0xafa0(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb41c
leal 0x1(%rax), %ecx
movl %ecx, 0xaf91(%rip)      # 0x163a0
leaq 0xad8a(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb435
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 0x7ab5
leaq 0x5a6e(%rip), %rdi      # 0x10ec2
xorl %eax, %eax
callq 0x344d
leaq 0x5a80(%rip), %rdi      # 0x10ee2
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %r12
pushq %rbx
cmpl $0x2, %edx
jle 0xb53f
cmpl $0x3, %edx
jne 0xb54d
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7b11
movq %rax, %r14
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
movq %rax, %r15
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r12
movq %r14, %rdi
callq 0x4e28
movl %eax, %ebp
movq %r15, %rdi
callq 0x4e28
movl %eax, %r14d
movq %r12, %rdi
callq 0x4e28
movl %eax, %r15d
movq (%rbx), %rdi
movl $0x3, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xaeb1(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb50b
leal 0x1(%rax), %ecx
movl %ecx, 0xaea2(%rip)      # 0x163a0
leaq 0xac9b(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb518
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
cmpl %ebp, %r14d
cmovgl %r14d, %ebp
cmpl %r15d, %ebp
cmovgel %r15d, %ebp
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7ab5
leaq 0x59d6(%rip), %rdi      # 0x10f1c
xorl %eax, %eax
callq 0x344d
leaq 0x59e9(%rip), %rdi      # 0x10f3d
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, %edx
jle 0xb649
cmpl $0x3, %edx
jne 0xb657
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7b11
movq %rax, %r14
movq (%rbx), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
movq %rax, %r15
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r12
movq %r14, %rdi
callq 0x6fee
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0x6fee
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x6fee
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
movl $0x3, %esi
callq 0x7a28
movq (%rbx), %rbx
movslq 0xadb3(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb609
leal 0x1(%rax), %ecx
movl %ecx, 0xada4(%rip)      # 0x163a0
leaq 0xab9d(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb616
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movsd 0x10(%rsp), %xmm0
maxsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
minsd %xmm0, %xmm1
movl $0x2, (%rsi)
movsd %xmm1, 0x8(%rsi)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7ab5
leaq 0x5928(%rip), %rdi      # 0x10f78
xorl %eax, %eax
callq 0x344d
leaq 0x593c(%rip), %rdi      # 0x10f9a
movl %edx, %esi
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_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 %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xb71b
cmpl $0x1, %edx
jne 0xb724
movq %rsi, %rbx
movq (%rsi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movl (%rax), %ecx
cmpl $0x4, %ecx
jne 0xb69a
movq 0x8(%rax), %rcx
movl 0x8(%rcx), %ecx
cmpl $0x3, %ecx
jne 0xb72d
movq %rax, %rdi
callq 0x704b
testq %rax, %rax
je 0xb73b
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movq %r14, %rdi
callq 0x20b0
movq %rax, %r14
movq (%rbx), %rbx
movslq 0xacc7(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0xb6f5
leal 0x1(%rax), %ecx
movl %ecx, 0xacb8(%rip)      # 0x163a0
leaq 0xaab1(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0xb702
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %r14d, 0x8(%rsi)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7ab5
leaq 0x58b4(%rip), %rdi      # 0x10fd6
jmp 0xb734
leaq 0x58cd(%rip), %rdi      # 0x10ff8
jmp 0xb734
leaq 0x58e6(%rip), %rdi      # 0x1101a
xorl %eax, %eax
callq 0x344d
leaq 0x590c(%rip), %rdi      # 0x1104e
leaq 0x1150(%rip), %rsi      # 0xc899
leaq 0x590d(%rip), %rcx      # 0x1105d
movl $0x4b0, %edx            # imm = 0x4B0
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13d
leaq 0x5952(%rip), %r15      # 0x110c6
leaq 0xf71(%rip), %r12       # 0xc6ec
movzbl %bl, %eax
movl %eax, 0x4(%rsp)
movl %r13d, %ebp
testl %r13d, %r13d
jle 0xb798
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
decl %ebp
jne 0xb78a
movl (%r14), %eax
cmpq $0x2b, %rax
jae 0xb828
movslq (%r12,%rax,4), %rsi
addq %r12, %rsi
leaq 0x46cf(%rip), %rdi      # 0xfe82
xorl %eax, %eax
callq 0x2050
testb %bl, %bl
je 0xb7cf
leaq 0x5a9b(%rip), %rdi      # 0x11260
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xb7ea
movq 0x8(%rax), %rsi
leaq 0x5b88(%rip), %rdi      # 0x1136b
xorl %eax, %eax
callq 0x2050
movl $0xa, %edi
callq 0x2210
movq 0x10(%r14), %rsi
incl %r13d
testq %rsi, %rsi
je 0xb80c
movl %r13d, %edi
movl 0x4(%rsp), %edx
callq 0xb75a
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0xb782
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59ba(%rip), %rdi      # 0x111e9
leaq 0x1063(%rip), %rsi      # 0xc899
leaq 0x59d1(%rip), %rcx      # 0x1120e
movl $0x1889, %edx           # imm = 0x1889
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4436(%rip), %rdi      # 0xfc91
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
movq %r14, %rsi
callq 0x62ce
testq %rax, %rax
je 0xb8a4
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x64cd
movl 0x8(%r14), %ecx
cmpl $0x3, %ecx
je 0xb8c8
cmpl $0x2, %ecx
je 0xb8b4
cmpl $0x1, %ecx
jne 0xb8e8
movl (%rax), %esi
leaq 0x529a(%rip), %rdi      # 0x10b35
xorl %eax, %eax
callq 0x2050
jmp 0xb8d9
leaq 0x442d(%rip), %rdi      # 0xfcd8
xorl %eax, %eax
callq 0x2050
jmp 0xb8d9
movsd (%rax), %xmm0
leaq 0x43da(%rip), %rdi      # 0xfc99
movb $0x1, %al
callq 0x2050
jmp 0xb8d9
leaq 0x45b3(%rip), %rdi      # 0xfe82
movq %rax, %rsi
xorl %eax, %eax
callq 0x2050
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2210
leaq 0x1e96(%rip), %rdi      # 0xd785
leaq 0xfa3(%rip), %rsi       # 0xc899
leaq 0x43a0(%rip), %rcx      # 0xfc9d
movl $0x18ad, %edx           # imm = 0x18AD
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43bc(%rip), %rdi      # 0xfcde
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x8(%rbx)
jle 0xb9c9
leaq 0xd53(%rip), %r14       # 0xc690
leaq 0x4355(%rip), %r15      # 0xfc99
leaq 0x4537(%rip), %r12      # 0xfe82
leaq 0x43ab(%rip), %r13      # 0xfcfd
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7b11
movl (%rax), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0xb9e3
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movl 0x8(%rax), %esi
leaq 0x51bb(%rip), %rdi      # 0x10b35
xorl %eax, %eax
callq 0x2050
jmp 0xb9b8
movq 0x8(%rax), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2050
jmp 0xb9b8
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movl 0x10(%rax), %edx
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
jmp 0xb9b8
movsd 0x8(%rax), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x2050
movl $0xa, %edi
callq 0x2210
incl %ebp
cmpl 0x8(%rbx), %ebp
jl 0xb954
leaq 0x5a2c(%rip), %rdi      # 0x113fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
leaq 0x1d9b(%rip), %rdi      # 0xd785
leaq 0xea8(%rip), %rsi       # 0xc899
leaq 0x4315(%rip), %rcx      # 0xfd0d
movl $0x18c3, %edx           # imm = 0x18C3
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %rax
movq 0x20(%rdi), %rcx
addq 0x8(%rcx), %rax
movq 0x10(%rcx), %rsi
cmpq %rax, %rsi
ja 0xbcd8
movq %rdi, %rbx
cmpq $0xff, %rsi
ja 0xbcaf
movq $0x100, 0x10(%rcx)      # imm = 0x100
movl $0x100, %esi            # imm = 0x100
cmpq %rax, %rsi
ja 0xbcc0
addq %rsi, %rsi
cmpq %rax, %rsi
jbe 0xbcb4
movq %rsi, 0x10(%rcx)
shlq $0x2, %rsi
movq (%rcx), %rdi
callq 0x2280
movq 0x20(%rbx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0xbcda
popq %rbx
retq
leaq 0x4345(%rip), %rdi      # 0x10026
xorl %eax, %eax
callq 0x344d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x632a
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 0x67e7c(%rip), %xmm0    # 0x6e0d0
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 0x67e57(%rip), %xmm3    # 0x6e0e0
movsd 0x67d87(%rip), %xmm4    # 0x6e018
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 0x631c
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 0x631c
incl %eax
addq $0x50, %rcx
decq %rdx
jne 0x6291
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::CImg(unsigned int, unsigned int, unsigned int, unsigned int)
explicit CImg(const unsigned int size_x, const unsigned int size_y=1,
                  const unsigned int size_z=1, const unsigned int size_c=1):
      _is_shared(false) {
      const unsigned long siz = (unsigned long)size_x*size_y*size_z*size_c;
      if (siz) {
        _width = size_x; _height = size_y; _depth = size_z; _spectrum = size_c;
        try { _data = new T[siz]; } catch (...) {
          _width = _height = _depth = _spectrum = 0; _data = 0;
          throw CImgInstanceException(_cimg_instance
                                      "CImg(): Failed to allocate memory (%s) for image (%u,%u,%u,%u).",
                                      cimg_instance,
                                      cimg::strbuffersize(sizeof(T)*size_x*size_y*size_z*size_c),
                                      size_x,size_y,size_z,size_c);
        }
      } else { _width = _height = _depth = _spectrum = 0; _data = 0; }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbp
movb $0x0, 0x10(%rdi)
movl %esi, %ebx
movl %edx, %eax
movl %ecx, %r13d
imulq %rax, %r13
movl %r8d, %r14d
movq %rbx, %rax
imulq %r14, %rax
imulq %r13, %rax
testq %rax, %rax
je 0x86d7
movl %r8d, %r12d
movl %ecx, %r15d
movl %esi, (%rbp)
movl %edx, 0x4(%rbp)
movl %ecx, 0x8(%rbp)
movl %r8d, 0xc(%rbp)
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
callq 0x4040
movq %rax, 0x18(%rbp)
jmp 0x86e6
movq $0x0, 0x18(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x41d0
movq $0x0, 0x18(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movl $0x4008, %edi           # imm = 0x4008
callq 0x4210
movq %rax, 0x8(%rsp)
movl (%rbp), %eax
movl %eax, 0x1c(%rsp)
movl 0x4(%rbp), %eax
movl %eax, 0x18(%rsp)
movl 0x8(%rbp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rbp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rbp), %rax
movq %rax, 0x20(%rsp)
movb 0x10(%rbp), %bpl
imulq %rbx, %r13
imulq %r14, %r13
shlq $0x3, %r13
movq %r13, %rdi
callq 0xbe84
movq %rax, %r10
leaq 0x66106(%rip), %rax     # 0x6e868
leaq 0x674d9(%rip), %r11     # 0x6fc42
testb %bpl, %bpl
cmovneq %rax, %r11
leaq 0x869a8(%rip), %rbx     # 0x8f11f
leaq 0x859fc(%rip), %rsi     # 0x8e17a
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0x14(%rsp), %r8d
movl 0x10(%rsp), %r9d
xorl %eax, %eax
pushq %r12
pushq %r15
pushq 0x38(%rsp)
pushq 0x48(%rsp)
pushq %r10
pushq %rbx
pushq %r11
pushq 0x58(%rsp)
callq 0xbfac
addq $0x40, %rsp
leaq 0x9f47c(%rip), %rsi     # 0xa7c38
movq 0x9f80d(%rip), %rdx     # 0xa7fd0
movq 0x8(%rsp), %rdi
callq 0x4910
movq %rax, %rbx
jmp 0x87df
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x43c0
callq 0x48d0
movq %rbx, %rdi
callq 0x4960
movq %rax, %rdi
callq 0xa02c