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

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

	const auto* const var = v->variable_;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jg 0xf977
leaq 0x72b0(%rip), %rdi      # 0x16c20
movb $0x0, %al
callq 0x4cd0
cmpl $0x2, -0x14(%rbp)
jle 0xf98e
movl -0x14(%rbp), %esi
leaq 0x72ba(%rip), %rdi      # 0x16c41
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xf9c0
leaq 0x72c3(%rip), %rdi      # 0x16c7c
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xf9dd
leaq 0x72d8(%rip), %rdi      # 0x16ca9
movb $0x0, %al
callq 0x4cd0
jmp 0xfa8d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xfa22
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xfa43
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %edx
movl -0x34(%rbp), %ecx
leaq 0x72b1(%rip), %rdi      # 0x16ceb
movb $0x0, %al
callq 0x4cd0
jmp 0xfa8d
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %edi
callq 0xa5f0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jg 0xfac7
leaq 0x703c(%rip), %rdi      # 0x16afc
movb $0x0, %al
callq 0x4cd0
cmpl $0x2, -0x14(%rbp)
jle 0xfade
movl -0x14(%rbp), %esi
leaq 0x7046(%rip), %rdi      # 0x16b1d
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xfb10
leaq 0x704f(%rip), %rdi      # 0x16b58
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xfb2d
leaq 0x7064(%rip), %rdi      # 0x16b85
movb $0x0, %al
callq 0x4cd0
jmp 0xfbe5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xfb72
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x34(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jge 0xfb93
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %edx
movl -0x34(%rbp), %ecx
leaq 0x703d(%rip), %rdi      # 0x16bc7
movb $0x0, %al
callq 0x4cd0
jmp 0xfbe5
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movw $0x0, -0x42(%rbp)
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movw (%rax,%rcx), %ax
movw %ax, -0x42(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movswl -0x42(%rbp), %edi
callq 0xa5f0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jg 0xfc17
leaq 0x700f(%rip), %rdi      # 0x16c1f
movb $0x0, %al
callq 0x4cd0
cmpl $0x2, -0x14(%rbp)
jle 0xfc2e
movl -0x14(%rbp), %esi
leaq 0x7019(%rip), %rdi      # 0x16c40
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0xfc60
leaq 0x7022(%rip), %rdi      # 0x16c7b
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xfc7d
leaq 0x7037(%rip), %rdi      # 0x16ca8
movb $0x0, %al
callq 0x4cd0
jmp 0xfd33
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xfcc2
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x34(%rbp), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
jge 0xfce3
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %edx
movl -0x34(%rbp), %ecx
leaq 0x7010(%rip), %rdi      # 0x16cea
movb $0x0, %al
callq 0x4cd0
jmp 0xfd33
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %edi
callq 0xa5f0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xfd67
leaq 0x6fe2(%rip), %rdi      # 0x16d42
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xfd7e
movl -0x14(%rbp), %esi
leaq 0x6fea(%rip), %rdi      # 0x16d61
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79c0
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0xfdb6
movl -0x24(%rbp), %esi
leaq 0x6feb(%rip), %rdi      # 0x16d9a
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
callq 0x30a0
cltd
idivl -0x24(%rbp)
movl %edx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %edi
callq 0xa5f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_abs(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_abs( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "abs：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "abs：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xfe27
leaq 0x6fb4(%rip), %rdi      # 0x16dd4
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xfe3e
movl -0x14(%rbp), %esi
leaq 0x6fbc(%rip), %rdi      # 0x16df3
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
cmpl $0x0, -0x24(%rbp)
jge 0xfe7f
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xfe85
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %edi
callq 0xa5f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xfed7
leaq 0x6f5c(%rip), %rdi      # 0x16e2c
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xfeee
movl -0x14(%rbp), %esi
leaq 0x6f65(%rip), %rdi      # 0x16e4c
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0xff4e
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0xff58
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xffb7
leaq 0x6ed6(%rip), %rdi      # 0x16e86
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0xffce
movl -0x14(%rbp), %esi
leaq 0x6ee2(%rip), %rdi      # 0x16ea9
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd 0x2a27(%rip), %xmm0     # 0x12a30
mulsd -0x28(%rbp), %xmm0
movsd 0x2a12(%rip), %xmm1     # 0x12a28
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x10077
leaq 0x6e76(%rip), %rdi      # 0x16ee6
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0x1008e
movl -0x14(%rbp), %esi
leaq 0x6e82(%rip), %rdi      # 0x16f09
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd 0x295f(%rip), %xmm0     # 0x12a28
mulsd -0x28(%rbp), %xmm0
movsd 0x295a(%rip), %xmm1     # 0x12a30
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_sin(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_sin( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "sin：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "sin：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x10137
leaq 0x6e16(%rip), %rdi      # 0x16f46
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0x1014e
movl -0x14(%rbp), %esi
leaq 0x6e1e(%rip), %rdi      # 0x16f65
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x28(%rbp), %xmm0
callq 0x3090
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x101e9
leaq 0x6dbe(%rip), %rdi      # 0x16f9e
movb $0x0, %al
callq 0x4cd0
jmp 0x10265
cmpl $0x1, -0x14(%rbp)
jle 0x10202
movl -0x14(%rbp), %esi
leaq 0x6dc4(%rip), %rdi      # 0x16fbd
movb $0x0, %al
callq 0x4cd0
jmp 0x10265
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x28(%rbp), %xmm0
callq 0x3290
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_tan(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_tan( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "tan：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "tan：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x10297
leaq 0x6d67(%rip), %rdi      # 0x16ff7
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0x102ae
movl -0x14(%rbp), %esi
leaq 0x6d70(%rip), %rdi      # 0x17017
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x28(%rbp), %xmm0
callq 0x30e0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_atan(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_atan( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num < 2 )
	{
		raise_error( "atan：引数がたりません" );
	}
	if ( arg_num > 2 )
	{
		raise_error( "atan：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x10347
leaq 0x6cb6(%rip), %rdi      # 0x16ff6
movb $0x0, %al
callq 0x4cd0
cmpl $0x2, -0x14(%rbp)
jle 0x1035e
movl -0x14(%rbp), %esi
leaq 0x6cbf(%rip), %rdi      # 0x17016
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x0, %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x3060
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0xa680
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_expf(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_expf( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "expf：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "expf：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x10427
leaq 0x6c30(%rip), %rdi      # 0x17050
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0x1043e
movl -0x14(%rbp), %esi
leaq 0x6c39(%rip), %rdi      # 0x17070
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x28(%rbp), %xmm0
callq 0x3280
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_logf(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_logf( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "logf：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "logf：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x104d7
leaq 0x6bda(%rip), %rdi      # 0x170aa
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0x104ee
movl -0x14(%rbp), %esi
leaq 0x6be3(%rip), %rdi      # 0x170ca
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x28(%rbp), %xmm0
callq 0x3110
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x10587
leaq 0x6b84(%rip), %rdi      # 0x17104
movb $0x0, %al
callq 0x4cd0
cmpl $0x2, -0x14(%rbp)
jle 0x1059e
movl -0x14(%rbp), %esi
leaq 0x6b8d(%rip), %rdi      # 0x17124
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x0, %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x3270
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0xa680
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_sqrt(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_sqrt( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "sqrt：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "sqrt：引数が多すぎます@@ %d個渡されました", arg_num );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x10667
leaq 0x6afe(%rip), %rdi      # 0x1715e
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0x1067e
movl -0x14(%rbp), %esi
leaq 0x6b07(%rip), %rdi      # 0x1717e
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x28(%rbp), %xmm0
callq 0x3100
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x10717
leaq 0x6aa8(%rip), %rdi      # 0x171b8
movb $0x0, %al
callq 0x4cd0
cmpl $0x3, -0x14(%rbp)
jle 0x1072e
movl -0x14(%rbp), %esi
leaq 0x6ab2(%rip), %rdi      # 0x171d9
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x0, %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x2, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79c0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x79c0
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79c0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movl -0x38(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x107c0
movl -0x34(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jle 0x107ce
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x40(%rbp), %edi
callq 0xa5f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x10827
leaq 0x69f4(%rip), %rdi      # 0x17214
movb $0x0, %al
callq 0x4cd0
cmpl $0x3, -0x14(%rbp)
jle 0x1083e
movl -0x14(%rbp), %esi
leaq 0x69ff(%rip), %rdi      # 0x17236
movb $0x0, %al
callq 0x4cd0
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x0, %esi
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0xbca0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
addl $0x2, %esi
callq 0xbca0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0xaa40
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x108e6
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
ucomisd -0x48(%rbp), %xmm0
jbe 0x108fc
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
callq 0xa680
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::(anonymous namespace)::function_strlen(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*, int)
void function_strlen( execute_environment_t* NHSP_UNUA(e), execute_status_t* s, int arg_num )
{
	if ( arg_num <= 0 )
	{
		raise_error( "strlen：引数がたりません" );
	}
	if ( arg_num > 1 )
	{
		raise_error( "strlen：引数が多すぎます" );
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x10957
leaq 0x6922(%rip), %rdi      # 0x17272
movb $0x0, %al
callq 0x4cd0
cmpl $0x1, -0x14(%rbp)
jle 0x1096b
leaq 0x6930(%rip), %rdi      # 0x17294
movb $0x0, %al
callq 0x4cd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xbca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7990
cmpl $0x3, %eax
je 0x1099c
leaq 0x6921(%rip), %rdi      # 0x172b6
movb $0x0, %al
callq 0x4cd0
movq -0x20(%rbp), %rdi
callq 0xaaf0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x109b2
jmp 0x109d1
leaq 0x6931(%rip), %rdi      # 0x172ea
leaq 0x2091(%rip), %rsi      # 0x12a51
movl $0x4b0, %edx            # imm = 0x4B0
leaq 0x692d(%rip), %rcx      # 0x172f9
callq 0x30f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb10
movq -0x28(%rbp), %rdi
callq 0x30b0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %edi
callq 0xa5f0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x539c(%rip), %rdi      # 0x15f2d
movb $0x0, %al
callq 0x3050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9420
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10c4c
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9700
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x10be9
jmp 0x10bd5
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x10bff
jmp 0x10bdf
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x10c17
jmp 0x10c2b
movq -0x28(%rbp), %rax
movl (%rax), %esi
leaq 0x61db(%rip), %rdi      # 0x16dd1
movb $0x0, %al
callq 0x3050
jmp 0x10c4a
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x5327(%rip), %rdi      # 0x15f35
movb $0x1, %al
callq 0x3050
jmp 0x10c4a
movq -0x28(%rbp), %rsi
leaq 0x54fc(%rip), %rdi      # 0x1611e
movb $0x0, %al
callq 0x3050
jmp 0x10c4a
leaq 0x2d3d(%rip), %rdi      # 0x1396f
leaq 0x1e18(%rip), %rsi      # 0x12a51
movl $0x18ad, %edx           # imm = 0x18AD
leaq 0x52f4(%rip), %rcx      # 0x15f39
callq 0x30f0
jmp 0x10c5a
leaq 0x5321(%rip), %rdi      # 0x15f74
movb $0x0, %al
callq 0x3050
leaq 0x52ca(%rip), %rdi      # 0x15f2b
movb $0x0, %al
callq 0x3050
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
leaq 0x52e5(%rip), %rdi      # 0x15f7a
movb $0x0, %al
callq 0x3050
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x10d8f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbca0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x10d54
movq -0x20(%rbp), %rax
leaq 0x1c73(%rip), %rcx      # 0x12954
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x60d9(%rip), %rdi      # 0x16dd1
movb $0x0, %al
callq 0x3050
jmp 0x10d73
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x5224(%rip), %rdi      # 0x15f35
movb $0x1, %al
callq 0x3050
jmp 0x10d73
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x53f5(%rip), %rdi      # 0x1611e
movb $0x0, %al
callq 0x3050
jmp 0x10d73
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x524e(%rip), %rdi      # 0x15f99
movb $0x0, %al
callq 0x3050
jmp 0x10d73
leaq 0x2c14(%rip), %rdi      # 0x1396f
leaq 0x1cef(%rip), %rsi      # 0x12a51
movl $0x18c3, %edx           # imm = 0x18C3
leaq 0x523b(%rip), %rcx      # 0x15fa9
callq 0x30f0
leaq 0x51b1(%rip), %rdi      # 0x15f2b
movb $0x0, %al
callq 0x3050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10ca3
leaq 0x5191(%rip), %rdi      # 0x15f27
movb $0x0, %al
callq 0x3050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11355
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4190
testb $0x1, %al
jne 0x1133d
jmp 0x11347
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1135d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1130f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: void neteruhsp::(anonymous namespace)::code_write_block<double>(neteruhsp::execute_environment_t*, double)
void code_write_block( execute_environment_t* e, const T block )
{
	const auto size = sizeof(block);
	const auto stride = size /sizeof(code_t) + (size %sizeof(code_t) == 0 ? 0 : 1);
	code_checked_realloc( e, stride );
	memcpy( e->execute_code_->code_ +e->execute_code_->code_size_, &block, size );
	e->execute_code_->code_size_ += stride;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq $0x8, -0x18(%rbp)
movq $0x2, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x11480
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq %rdx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0x11559
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jae 0x114dc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x100, 0x10(%rax)      # imm = 0x100
jmp 0x114de
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0x11505
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
jmp 0x114de
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3960
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, (%rax)
jne 0x11557
leaq 0x4d72(%rip), %rdi      # 0x162c2
movb $0x0, %al
callq 0x4cd0
jmp 0x11559
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movl $0x0, 0x114(%rsp)
movslq 0x114(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x118(%rsp), %rdi
callq 0xb790
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x7a8e
movq 0x118(%rsp), %rdi
movslq 0x114(%rsp), %rsi
callq 0xb7b0
movq %rax, %rsi
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xb7d0
movq 0x18(%rsp), %rdi
callq 0x51f0
movq %rax, %rdi
callq 0x5770
movq %rax, 0x20(%rsp)
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5980
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xf0(%rsp), %rdi
callq 0x56d0
jmp 0x7879
leaq 0xcf(%rsp), %rdi
callq 0x5590
leaq 0xd0(%rsp), %rdi
callq 0x5ae8
leaq 0xe1f28(%rip), %rsi     # 0xe97c2
xorl %eax, %eax
movl %eax, %edx
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5ac0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x98(%rsp), %rdi
movq $-0x1, %rcx
callq 0x5560
jmp 0x78ce
leaq 0xe1eed(%rip), %rsi     # 0xe97c2
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x8(%rsp)
leaq 0xf0(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5ac0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x38(%rsp), %rdi
callq 0x5560
jmp 0x7907
leaq 0xc20ab(%rip), %rdx     # 0xc99b9
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xb850
jmp 0x791f
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0xb800
jmp 0x7938
leaq 0x58(%rsp), %rdi
callq 0x5ae8
leaq 0x38(%rsp), %rdi
callq 0x5ae8
movq 0x118(%rsp), %rdi
movslq 0x114(%rsp), %rsi
callq 0xb7b0
movq %rax, %rdi
movq 0x120(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x7170
jmp 0x7978
leaq 0x78(%rsp), %rdi
callq 0x5ae8
leaq 0x98(%rsp), %rdi
callq 0x5ae8
leaq 0xf0(%rsp), %rdi
callq 0x5ae8
movl 0x114(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x114(%rsp)
jmp 0x77e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xcf(%rsp), %rdi
callq 0x5590
leaq 0xd0(%rsp), %rdi
callq 0x5ae8
jmp 0x7a96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x7a7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x7a72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x7a48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5ae8
leaq 0x38(%rsp), %rdi
callq 0x5ae8
jmp 0x7a72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5ae8
leaq 0x98(%rsp), %rdi
callq 0x5ae8
leaq 0xf0(%rsp), %rdi
callq 0x5ae8
jmp 0x7a96
addq $0x128, %rsp            # imm = 0x128
retq
movq 0xc0(%rsp), %rdi
callq 0x5970
nopw %cs:(%rax,%rax)