LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9480
cmpl $0x1, %edx
jne 0x948e
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movaps %xmm0, (%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movapd 0x2405(%rip), %xmm0     # 0xb860
movapd (%rsp), %xmm1
xorpd %xmm1, %xmm0
maxsd %xmm1, %xmm0
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x6709(%rip), %rdi      # 0xfb90
xorl %eax, %eax
callq 0x326e
leaq 0x671b(%rip), %rdi      # 0xfbb0
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9501
cmpl $0x1, %edx
jne 0x950f
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
mulsd 0x238f(%rip), %xmm0     # 0xb870
divsd 0x238f(%rip), %xmm0     # 0xb878
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x66e2(%rip), %rdi      # 0xfbea
xorl %eax, %eax
callq 0x326e
leaq 0x66f7(%rip), %rdi      # 0xfc0d
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9582
cmpl $0x1, %edx
jne 0x9590
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
mulsd 0x2316(%rip), %xmm0     # 0xb878
divsd 0x2306(%rip), %xmm0     # 0xb870
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x66c1(%rip), %rdi      # 0xfc4a
xorl %eax, %eax
callq 0x326e
leaq 0x66d6(%rip), %rdi      # 0xfc6d
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x95f8
cmpl $0x1, %edx
jne 0x9606
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
callq 0x2090
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x66ab(%rip), %rdi      # 0xfcaa
xorl %eax, %eax
callq 0x326e
leaq 0x66bc(%rip), %rdi      # 0xfcc9
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x966e
cmpl $0x1, %edx
jne 0x967c
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
callq 0x22b0
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x668d(%rip), %rdi      # 0xfd02
xorl %eax, %eax
callq 0x326e
leaq 0x669e(%rip), %rdi      # 0xfd21
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x96e4
cmpl $0x1, %edx
jne 0x96f2
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
callq 0x20d0
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x6670(%rip), %rdi      # 0xfd5b
xorl %eax, %eax
callq 0x326e
leaq 0x6682(%rip), %rdi      # 0xfd7b
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9786
cmpl $0x2, %edx
jne 0x9794
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
movq %rax, %r14
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r15
movq %r14, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x62f2
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x2060
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6cdd
leaq 0x65cd(%rip), %rdi      # 0xfd5a
xorl %eax, %eax
callq 0x326e
leaq 0x65df(%rip), %rdi      # 0xfd7a
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x97fc
cmpl $0x1, %edx
jne 0x980a
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
callq 0x22a0
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x65b1(%rip), %rdi      # 0xfdb4
xorl %eax, %eax
callq 0x326e
leaq 0x65c3(%rip), %rdi      # 0xfdd4
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9872
cmpl $0x1, %edx
jne 0x9880
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movsd 0x8(%rsp), %xmm0
callq 0x2110
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x6595(%rip), %rdi      # 0xfe0e
xorl %eax, %eax
callq 0x326e
leaq 0x65a7(%rip), %rdi      # 0xfe2e
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9923
movl %edx, %ebp
cmpl $0x3, %edx
jae 0x9931
movq %rsi, %rbx
movl %ebp, %esi
negl %esi
movq (%rbx), %rdi
callq 0x6d39
movq %rax, %r14
movq (%rbx), %rdi
pushq $0x1
popq %rsi
subl %ebp, %esi
callq 0x6d39
movq %rax, %r15
movq %r14, %rdi
callq 0x62f2
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
movl %ebp, %esi
callq 0x6c55
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2290
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6cdd
leaq 0x653e(%rip), %rdi      # 0xfe68
xorl %eax, %eax
callq 0x326e
leaq 0x6550(%rip), %rdi      # 0xfe88
movl %ebp, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x99ad
cmpl $0x1, %edx
jne 0x99bb
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm1, %xmm0
jb 0x9990
sqrtsd %xmm0, %xmm0
jmp 0x9995
callq 0x2100
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
jmp 0x6cdd
leaq 0x650e(%rip), %rdi      # 0xfec2
xorl %eax, %eax
callq 0x326e
leaq 0x6520(%rip), %rdi      # 0xfee2
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9a68
cmpl $0x3, %edx
jne 0x9a76
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x3
popq %rsi
callq 0x6d39
movq %rax, %r14
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
movq %rax, %r15
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r12
movq %r14, %rdi
callq 0x4834
movl %eax, %ebp
movq %r15, %rdi
callq 0x4834
movl %eax, %r14d
movq %r12, %rdi
callq 0x4834
movl %eax, %r15d
movq (%rbx), %rdi
pushq $0x3
popq %rsi
callq 0x6c55
cmpl %ebp, %r14d
cmovgl %r14d, %ebp
cmpl %r15d, %ebp
cmovgel %r15d, %ebp
movq (%rbx), %rbx
movl %ebp, %edi
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6cdd
leaq 0x64ad(%rip), %rdi      # 0xff1c
xorl %eax, %eax
callq 0x326e
leaq 0x64c0(%rip), %rdi      # 0xff3d
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9b37
cmpl $0x3, %edx
jne 0x9b45
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x3
popq %rsi
callq 0x6d39
movq %rax, %r14
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x6d39
movq %rax, %r15
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r12
movq %r14, %rdi
callq 0x62f2
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0x62f2
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x62f2
movsd %xmm0, (%rsp)
movq (%rbx), %rdi
pushq $0x3
popq %rsi
callq 0x6c55
movsd 0x10(%rsp), %xmm1
maxsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
minsd %xmm1, %xmm0
movq (%rbx), %rbx
callq 0x611f
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6cdd
leaq 0x643a(%rip), %rdi      # 0xff78
xorl %eax, %eax
callq 0x326e
leaq 0x644e(%rip), %rdi      # 0xff9a
movl %edx, %esi
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9bc2
cmpl $0x1, %edx
jne 0x9bcb
movq %rsi, %rbx
movq (%rsi), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movl (%rax), %ecx
cmpl $0x4, %ecx
jne 0x9b7e
movq 0x8(%rax), %rcx
movl 0x8(%rcx), %ecx
cmpl $0x3, %ecx
jne 0x9bd4
movq %rax, %rdi
callq 0x634f
testq %rax, %rax
je 0x9be2
movq %rax, %r14
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movq %r14, %rdi
callq 0x20b0
movq (%rbx), %rbx
movl %eax, %edi
callq 0x60e2
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6cdd
leaq 0x640d(%rip), %rdi      # 0xffd6
jmp 0x9bdb
leaq 0x6426(%rip), %rdi      # 0xfff8
jmp 0x9bdb
leaq 0x643f(%rip), %rdi      # 0x1001a
xorl %eax, %eax
callq 0x326e
leaq 0x6465(%rip), %rdi      # 0x1004e
leaq 0x1ca9(%rip), %rsi      # 0xb899
leaq 0x6466(%rip), %rcx      # 0x1005d
movl $0x4b0, %edx            # imm = 0x4B0
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %ebp
leaq 0x1ad1(%rip), %r13      # 0xb6ec
movzbl %bl, %eax
movl %eax, 0x4(%rsp)
leaq 0x649d(%rip), %r15      # 0x100c6
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
subl $0x1, %r12d
jb 0x9c47
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
jmp 0x9c35
movl (%r14), %eax
cmpq $0x2b, %rax
jae 0x9cd4
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
leaq 0x521f(%rip), %rdi      # 0xee82
xorl %eax, %eax
callq 0x2050
testb %bl, %bl
je 0x9c7f
leaq 0x65eb(%rip), %rdi      # 0x10260
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x9c9a
movq 0x8(%rax), %rsi
leaq 0x66d8(%rip), %rdi      # 0x1036b
xorl %eax, %eax
callq 0x2050
pushq $0xa
popq %rdi
callq 0x2210
movq 0x10(%r14), %rsi
incl %ebp
testq %rsi, %rsi
je 0x9cb8
movl %ebp, %edi
movl 0x4(%rsp), %edx
callq 0x9c02
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x9c29
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x650e(%rip), %rdi      # 0x101e9
leaq 0x1bb7(%rip), %rsi      # 0xb899
leaq 0x6525(%rip), %rcx      # 0x1020e
movl $0x1889, %edx           # imm = 0x1889
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f8a(%rip), %rdi      # 0xec91
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
movq %r14, %rsi
callq 0x56c7
testq %rax, %rax
je 0x9d50
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x58bf
movl 0x8(%r14), %ecx
cmpl $0x3, %ecx
je 0x9d74
cmpl $0x2, %ecx
je 0x9d60
cmpl $0x1, %ecx
jne 0x9d92
movl (%rax), %esi
leaq 0x5dee(%rip), %rdi      # 0xfb35
xorl %eax, %eax
callq 0x2050
jmp 0x9d85
leaq 0x4f81(%rip), %rdi      # 0xecd8
xorl %eax, %eax
callq 0x2050
jmp 0x9d85
movsd (%rax), %xmm0
leaq 0x4f2e(%rip), %rdi      # 0xec99
movb $0x1, %al
callq 0x2050
jmp 0x9d85
leaq 0x5107(%rip), %rdi      # 0xee82
movq %rax, %rsi
xorl %eax, %eax
callq 0x2050
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2210
leaq 0x29ec(%rip), %rdi      # 0xc785
leaq 0x1af9(%rip), %rsi      # 0xb899
leaq 0x4ef6(%rip), %rcx      # 0xec9d
movl $0x18ad, %edx           # imm = 0x18AD
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f12(%rip), %rdi      # 0xecde
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
leaq 0x18b3(%rip), %r15      # 0xb690
pushq $0xa
popq %rbp
leaq 0x509b(%rip), %r12      # 0xee82
leaq 0x4f0f(%rip), %r13      # 0xecfd
xorl %r14d, %r14d
cmpl 0x8(%rbx), %r14d
jge 0x9e6c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x6d39
movl (%rax), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x9e86
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movl 0x8(%rax), %esi
leaq 0x5d17(%rip), %rdi      # 0xfb35
xorl %eax, %eax
callq 0x2050
jmp 0x9e60
movq 0x8(%rax), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2050
jmp 0x9e60
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movl 0x10(%rax), %edx
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
jmp 0x9e60
movsd 0x8(%rax), %xmm0
leaq 0x4e40(%rip), %rdi      # 0xec99
movb $0x1, %al
callq 0x2050
movl %ebp, %edi
callq 0x2210
incl %r14d
jmp 0x9df1
leaq 0x6589(%rip), %rdi      # 0x103fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240
leaq 0x28f8(%rip), %rdi      # 0xc785
leaq 0x1a05(%rip), %rsi      # 0xb899
leaq 0x4e72(%rip), %rcx      # 0xed0d
movl $0x18c3, %edx           # imm = 0x18C3
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r15
pushq $-0x1
popq %rbp
movq (%r15), %r15
testq %r15, %r15
je 0xa14b
movq 0x10(%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2c0b
addq $0x8, %r15
testb %al, %al
je 0xa128
jmp 0xa14e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa1df
movq %rdi, %rbx
movl $0x100, %edx            # imm = 0x100
cmpq $0xff, %rax
ja 0xa1b7
movq %rdx, 0x10(%rcx)
movq %rdx, %rax
cmpq %rsi, %rax
ja 0xa1c4
addq %rax, %rax
movq %rax, %rdx
jmp 0xa1b0
shlq $0x2, %rax
movq (%rcx), %rdi
movq %rax, %rsi
callq 0x2280
movq 0x20(%rbx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0xa1e1
popq %rbx
retq
leaq 0x4e3e(%rip), %rdi      # 0xf026
xorl %eax, %eax
callq 0x326e
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
movq (%rsi), %r8
movq 0x8(%rsi), %rax
subq %r8, %rax
movabsq $0x50, %rcx
cqto
idivq %rcx
movq 0x18(%rdi), %rdx
movl (%rdi), %esi
imull $0x6, %esi, %edi
imull $0x7, %esi, %r9d
leal (%rsi,%rsi), %r10d
leal (%rsi,%rsi,4), %r11d
leal (,%rsi,4), %ebx
leal (%rsi,%rsi,2), %r14d
addq $0x2c, %r8
xorl %ecx, %ecx
movapd 0x4edd7(%rip), %xmm0    # 0x540d0
movapd 0x4eddf(%rip), %xmm1    # 0x540e0
movsd 0x4ed0f(%rip), %xmm2    # 0x54018
subq $0x1, %rax
jb 0x53b0
cvtss2sd -0x28(%r8), %xmm3
cvtss2sd -0x2c(%r8), %xmm4
movsd (%rdx,%rsi,8), %xmm5
movhpd (%rdx,%r9,8), %xmm5     # xmm5 = xmm5[0],mem[0]
movaps %xmm4, %xmm6
movlhps %xmm4, %xmm6            # xmm6 = xmm6[0],xmm4[0]
mulpd %xmm5, %xmm6
movsd (%rdx), %xmm5
movhpd (%rdx,%rdi,8), %xmm5    # xmm5 = xmm5[0],mem[0]
movaps %xmm3, %xmm7
movlhps %xmm3, %xmm7            # xmm7 = xmm7[0],xmm3[0]
mulpd %xmm5, %xmm7
addpd %xmm6, %xmm7
movapd %xmm0, %xmm6
movlpd (%rdx,%r10,8), %xmm6    # xmm6 = mem[0],xmm6[1]
addpd %xmm7, %xmm6
movapd %xmm6, %xmm5
unpckhpd %xmm6, %xmm5            # xmm5 = xmm5[1],xmm6[1]
divsd %xmm5, %xmm6
cvtss2sd (%r8), %xmm7
subsd %xmm7, %xmm6
andpd %xmm1, %xmm6
ucomisd %xmm6, %xmm2
jbe 0x53a7
mulsd (%rdx,%rbx,8), %xmm4
mulsd (%rdx,%r14,8), %xmm3
addsd %xmm4, %xmm3
addsd (%rdx,%r11,8), %xmm3
divsd %xmm5, %xmm3
cvtss2sd -0x4(%r8), %xmm4
subsd %xmm4, %xmm3
andpd %xmm1, %xmm3
ucomisd %xmm3, %xmm2
jbe 0x53a7
incl %ecx
addq $0x50, %r8
jmp 0x5309
movl %ecx, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./Homography.h
// Function: warpingApplication(Image const&, std::vector<Image, std::allocator<Image>> const&)
void warpingApplication(const Image& queryImage,const vector<Image>& images)
{
	for(int i = 0;i<images.size();++i)
	{
		string name = string(basename(images[i].getName().c_str()));
		string ext = name.substr(name.find("."));
		string newName = name.substr(0, name.find("."))+ "-warped"+ext;
		getProjection(images[i],queryImage,newName);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbp
movq %rdi, (%rsp)
xorl %r14d, %r14d
leaq 0x18(%rsp), %r13
leaq 0x98(%rsp), %r12
xorl %edi, %edi
movq (%rbp), %rsi
movq 0x8(%rbp), %rax
subq %rsi, %rax
cqto
pushq $0x70
popq %rcx
idivq %rcx
cmpq %rdi, %rax
jbe 0x5736
movq %rdi, 0x8(%rsp)
movq %r14, 0x10(%rsp)
addq %r14, %rsi
movq %r13, %rdi
callq 0x4700
movq 0x18(%rsp), %rdi
callq 0x4770
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
leaq 0x58(%rsp), %rdx
callq 0x41c0
movq %r13, %rdi
callq 0x4aa8
movq %r14, %rdi
movq %r13, %rbx
leaq 0x70226(%rip), %r13     # 0x7589f
movq %r13, %rsi
xorl %edx, %edx
callq 0x4a80
movq %rbx, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
pushq $-0x1
popq %rcx
callq 0x4560
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4a80
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4560
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x503d4(%rip), %rdx     # 0x55a9a
callq 0x7546
movq 0x10(%rsp), %r14
movq %r15, %r13
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x7527
movq %r12, %rdi
callq 0x4aa8
leaq 0x38(%rsp), %rdi
callq 0x4aa8
movq (%rbp), %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %r15, %rdx
callq 0x53b6
movq %r15, %rdi
callq 0x4aa8
movq %r13, %rdi
callq 0x4aa8
leaq 0x78(%rsp), %rdi
callq 0x4aa8
movq 0x8(%rsp), %rdi
incq %rdi
addq $0x70, %r14
jmp 0x5614
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x5794
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x577b
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x4aa8
jmp 0x5776
movq %rax, %rbx
jmp 0x5780
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4aa8
leaq 0x18(%rsp), %rdi
callq 0x4aa8
jmp 0x578f
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4aa8
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6d1b
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 0x6d27
andq $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
andq $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 0x9afd
movq %rax, %r10
leaq 0x4da48(%rip), %rax     # 0x547e8
leaq 0x4ee1b(%rip), %r11     # 0x55bc2
testb %bpl, %bpl
cmovneq %rax, %r11
leaq 0x6e2ea(%rip), %rbx     # 0x7509f
leaq 0x6d33e(%rip), %rsi     # 0x740fa
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 0x9bf8
addq $0x40, %rsp
leaq 0x88e4e(%rip), %rsi     # 0x8fc48
movq 0x891d7(%rip), %rdx     # 0x8ffd8
movq 0x8(%rsp), %rdi
callq 0x4910
movq %rax, %rbx
jmp 0x6e1d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x4390
callq 0x48d0
movq %rbx, %rdi
callq 0x4950
movq %rax, %rdi
callq 0x7f6f
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./SiftHelpers.h
// Function: Image::Image(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Image(string Name)
	{
		name = Name;
		CImg<double> imageData(name.c_str());
		input_image = imageData;
		CImg<double> gray = imageData.get_RGBtoHSI().get_channel(2);
		descriptors = Sift::compute_sift(gray);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x38(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x39(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
callq 0x4260
movq (%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2b868
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x2ad88
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2b87c
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
pushq $0x2
popq %rdx
callq 0x2b8d2
movq %rsp, %rdi
callq 0x6c96
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x2bb3c
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x2b8e2
leaq 0x60(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x83ec
movq %rbx, %rdi
callq 0x7f7a
movq %rsp, %rdi
callq 0x17c20
leaq 0x40(%rsp), %rdi
callq 0x6c96
leaq 0x20(%rsp), %rdi
callq 0x6c96
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq %rsp, %rdi
callq 0x17c20
jmp 0x79cb
movq %rax, %r12
leaq 0x40(%rsp), %rdi
jmp 0x79d8
movq %rax, %r12
movq %rsp, %rdi
callq 0x6c96
jmp 0x79e4
jmp 0x79e1
movq %rax, %r12
leaq 0x20(%rsp), %rdi
callq 0x6c96
jmp 0x79f5
jmp 0x79f2
movq %rax, %r12
leaq 0x58(%rbx), %rdi
callq 0x7f7a
movq %r15, %rdi
callq 0x6c96
movq %r14, %rdi
callq 0x7f7a
movq %rbx, %rdi
callq 0x4aa8
movq %r12, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::move_to(cimg_library::CImg<double>&)
CImg<T>& move_to(CImg<T>& img) {
      if (_is_shared || img._is_shared) img.assign(*this);
      else swap(img);
      assign();
      return img;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%rdi)
jne 0x9368
cmpb $0x1, 0x10(%rbx)
jne 0x9375
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ad88
jmp 0x9380
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ada2
movq %r14, %rdi
callq 0x94f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::CImg<double>::assign(double const*, unsigned int, unsigned int, unsigned int, unsigned int, bool)
CImg<T>& assign(const T *const values, const unsigned int size_x, const unsigned int size_y,
                    const unsigned int size_z, const unsigned int size_c, const bool is_shared) {
      const unsigned long siz = (unsigned long)size_x*size_y*size_z*size_c;
      if (!values || !siz) return assign();
      if (!is_shared) { if (_is_shared) assign(); assign(values,size_x,size_y,size_z,size_c); }
      else {
        if (!_is_shared) {
          if (values+siz<_data || values>=_data+size()) assign();
          else cimg::warn(_cimg_instance
                          "assign(): Shared image instance has overlapping memory.",
                          cimg_instance);
        }
        _width = size_x; _height = size_y; _depth = size_z; _spectrum = size_c; _is_shared = true;
        _data = const_cast<T*>(values);
      }
      return *this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
movl %edx, %eax
movl %ecx, %ecx
imulq %rax, %rcx
movl %r8d, %edx
movl %r9d, %eax
imulq %rdx, %rax
imulq %rcx, %rax
testq %rsi, %rsi
setne %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
je 0x948b
movl %r9d, %ebp
movl %r8d, %r14d
movq %rsi, %r15
movb 0x10(%rbx), %cl
cmpb $0x0, 0x40(%rsp)
je 0x94a1
testb %cl, %cl
jne 0x94ce
leaq (%r15,%rax,8), %rax
movq 0x18(%rbx), %r9
cmpq %r9, %rax
jb 0x94c6
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movq %rdx, %rax
imulq %rsi, %rax
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movq %rcx, %rdi
imulq %r8, %rdi
imulq %rax, %rdi
leaq (%r9,%rdi,8), %rax
cmpq %r15, %rax
jbe 0x94c6
leaq 0x6bc31(%rip), %r10     # 0x7509f
leaq 0x4c74d(%rip), %r11     # 0x55bc2
leaq 0x4c6e0(%rip), %rdi     # 0x55b5c
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x97a7
popq %rax
popq %rcx
jmp 0x94ce
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x94f6
testb %cl, %cl
je 0x94ad
movq %rbx, %rdi
callq 0x94f6
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r12d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x9522
jmp 0x94e4
movq %rbx, %rdi
callq 0x94f6
movl %r13d, (%rbx)
movl %r12d, 0x4(%rbx)
movl %r14d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movb $0x1, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::warn(char const*, ...)
inline void warn(const char *const format, ...) {
      if (cimg::exception_mode()>=1) {
        char message[16384] = { 0 };
        std::va_list ap;
        va_start(ap,format);
        cimg_vsnprintf(message,sizeof(message),format,ap);
        va_end(ap);
#ifdef cimg_strict_warnings
        throw CImgWarningException(message);
#else
        std::fprintf(cimg::output(),"\n%s[CImg] *** Warning ***%s%s",cimg::t_red,cimg::t_normal,message);
#endif
      }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x40d8, %rsp           # imm = 0x40D8
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x9808
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x9eac
cmpl $0x0, (%rax)
je 0x9883
leaq 0xd0(%rsp), %rbx
movl $0x4000, %edx           # imm = 0x4000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4280
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x40f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
movl $0x4000, %esi           # imm = 0x4000
movq %rbx, %rdi
movq %r14, %rdx
callq 0x42f0
xorl %edi, %edi
callq 0x9eb5
leaq 0x6b815(%rip), %rsi     # 0x75081
leaq 0x4af75(%rip), %rcx     # 0x547e8
movq %rax, %rdi
movq %rcx, %rdx
movq %rbx, %r8
xorl %eax, %eax
callq 0x4750
addq $0x40d8, %rsp           # imm = 0x40D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::strbuffersize(unsigned long)
inline const char *strbuffersize(const unsigned long size) {
      static char res[256] = { 0 };
      cimg::mutex(5);
      if (size<1024LU) cimg_snprintf(res,sizeof(res),"%lu byte%s",size,size>1?"s":"");
      else if (size<1024*1024LU) { const float nsize = size/1024.0f; cimg_snprintf(res,sizeof(res),"%.1f Kio",nsize); }
      else if (size<1024*1024*1024LU) {
        const float nsize = size/(1024*1024.0f); cimg_snprintf(res,sizeof(res),"%.1f Mio",nsize);
      } else { const float nsize = size/(1024*1024*1024.0f); cimg_snprintf(res,sizeof(res),"%.1f Gio",nsize); }
      cimg::mutex(5,0);
      return res;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x5
popq %rdi
pushq $0x1
popq %rsi
callq 0xa419
cmpq $0x3ff, %rbx            # imm = 0x3FF
ja 0x9b4d
cmpq $0x2, %rbx
leaq 0x6cd68(%rip), %rax     # 0x76888
leaq 0x4acc1(%rip), %r8      # 0x547e8
cmovaeq %rax, %r8
leaq 0x8927e(%rip), %rdi     # 0x92db0
leaq 0x6b50c(%rip), %rdx     # 0x75045
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4890
jmp 0x9be5
cmpq $0xfffff, %rbx          # imm = 0xFFFFF
ja 0x9b77
cvtsi2ss %rbx, %xmm0
mulss 0x4a6c9(%rip), %xmm0    # 0x5422c
cvtss2sd %xmm0, %xmm0
leaq 0x89242(%rip), %rdi     # 0x92db0
leaq 0x6b4db(%rip), %rdx     # 0x75050
jmp 0x9bd9
testq %rbx, %rbx
js 0x9b83
cvtsi2ss %rbx, %xmm0
jmp 0x9b9a
movq %rbx, %rax
shrq %rax
movl %ebx, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cmpq $0x3fffffff, %rbx       # imm = 0x3FFFFFFF
ja 0x9bbf
mulss 0x4a67d(%rip), %xmm0    # 0x54228
cvtss2sd %xmm0, %xmm0
leaq 0x891fa(%rip), %rdi     # 0x92db0
leaq 0x6b49c(%rip), %rdx     # 0x75059
jmp 0x9bd9
mulss 0x4a65d(%rip), %xmm0    # 0x54224
cvtss2sd %xmm0, %xmm0
leaq 0x891de(%rip), %rdi     # 0x92db0
leaq 0x6b489(%rip), %rdx     # 0x75062
movl $0x100, %esi            # imm = 0x100
movb $0x1, %al
callq 0x4890
pushq $0x5
popq %rdi
xorl %esi, %esi
callq 0xa419
leaq 0x891ba(%rip), %rax     # 0x92db0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::output(_IO_FILE*)
inline std::FILE* output(std::FILE *file) {
      cimg::mutex(1);
      static std::FILE *res = stderr;
      if (file) res = file;
      cimg::mutex(1,0);
      return res;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
movl %edi, %esi
callq 0xa419
movb 0x86bdf(%rip), %al      # 0x90aa8
testb %al, %al
je 0x9eec
testq %rbx, %rbx
je 0x9ed9
movq %rbx, 0x86bc7(%rip)     # 0x90aa0
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0xa419
movq 0x86bb6(%rip), %rax     # 0x90aa0
popq %rbx
retq
leaq 0x86bb5(%rip), %rdi     # 0x90aa8
callq 0x49a0
testl %eax, %eax
je 0x9ecd
movq 0x860c5(%rip), %rax     # 0x8ffc8
movq (%rax), %rax
movq %rax, 0x86b93(%rip)     # 0x90aa0
leaq 0x86b94(%rip), %rdi     # 0x90aa8
callq 0x4320
jmp 0x9ecd
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::_exception_mode(unsigned int, bool)
inline unsigned int& _exception_mode(const unsigned int value, const bool is_set) {
      static unsigned int mode = cimg_verbosity;
      cimg::mutex(0);
      if (is_set) mode = value;
      cimg::mutex(0,0);
      return mode;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0xa419
testl %ebp, %ebp
je 0xa402
movl %ebx, 0x8615e(%rip)     # 0x90560
xorl %edi, %edi
xorl %esi, %esi
callq 0xa419
leaq 0x8614e(%rip), %rax     # 0x90560
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manikandan5[P]Image-Matching-Stitching-Warping/./CImg.h
// Function: cimg_library::cimg::mutex(unsigned int, int)
inline int mutex(const unsigned int n, const int lock_mode) {
      switch (lock_mode) {
      case 0 : cimg::Mutex_attr().unlock(n); return 0;
      case 1 : cimg::Mutex_attr().lock(n); return 0;
      default : return cimg::Mutex_attr().trylock(n);
      }
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0xa457
movl %ebp, %ecx
imulq $0x28, %rcx, %rdi
addq %rax, %rdi
cmpl $0x1, %ebx
je 0xa43e
testl %ebx, %ebx
jne 0xa44c
callq 0x43c0
jmp 0xa443
callq 0x47a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4080