LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: syusui-s[P]old_rpn_language/./element.h
// Function: findop(Element**, int)
int findop(Element** input,int length){
	int i,output=-1;

	for(i=0;i<length;i++){
		//std::cout << i + " ";
		#if MYDEBUG
		std::cout << input[i]->data_is() << ".type_is() --->" << input[i]->type_is() << std::endl;
		#endif

		if((input[i]->type_is()) == "op"){
			output=i;
			break;
		}
	}
	if(output==-1) throw((std::string)"演算子が見つかりませんでした。");

	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5d24
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5910
movq -0x50(%rbp), %rdi
leaq 0x448d(%rip), %rsi      # 0xa166
callq 0x9340
movb %al, -0x47(%rbp)
jmp 0x5ce3
leaq -0x38(%rbp), %rdi
callq 0x3448
movb -0x47(%rbp), %al
testb $0x1, %al
jne 0x5cf5
jmp 0x5d17
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
jmp 0x5db1
jmp 0x5d19
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5cad
cmpl $-0x1, -0x14(%rbp)
jne 0x5da8
movb $0x1, -0x46(%rbp)
movl $0x20, %edi
callq 0x3130
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x45(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x33c0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x4463(%rip), %rsi      # 0xa1bf
callq 0x9180
jmp 0x5d63
movq -0x68(%rbp), %rdi
movb $0x0, -0x46(%rbp)
leaq 0x8016(%rip), %rsi      # 0xdd88
movq 0x823f(%rip), %rdx      # 0xdfb8
callq 0x3390
jmp 0x5dba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x3280
testb $0x1, -0x46(%rbp)
jne 0x5d9d
jmp 0x5da6
movq -0x68(%rbp), %rdi
callq 0x3190
jmp 0x5db1
movl -0x14(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33b0
nopw (%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: take_elements(Element**, int, int)
Element** take_elements(Element** elements, int pos, int num){
	int i;
	Element **output = new Element*[num];

	for(i=pos;i<pos+num;i++){
		output[i-pos] = elements[i];
	}
	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5e36
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5e01
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: syusui-s[P]old_rpn_language/./element.h
// Function: op_divide(Element*, Element*)
Element* op_divide(Element* op1,Element* op2){
	//long a;
	double b;
	Element *rtn;
	
	b = atof(op1->data_is().c_str()) / atof(op2->data_is().c_str());
	rtn = new Element(ftoa(b));

	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x58e0
movq -0xa8(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
movsd %xmm0, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x58e0
jmp 0x7042
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
movq -0xb8(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0xa0(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x3448
leaq -0x40(%rbp), %rdi
callq 0x3448
movl $0x40, %edi
callq 0x3230
movq %rax, -0xb0(%rbp)
movb $0x1, -0x91(%rbp)
movsd -0x18(%rbp), %xmm0
leaq -0x90(%rbp), %rdi
callq 0x4000
jmp 0x70ae
movq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5800
jmp 0x70c3
movq -0xb0(%rbp), %rax
movb $0x0, -0x91(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3448
movq -0x20(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3448
jmp 0x7149
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x712b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3448
testb $0x1, -0x91(%rbp)
jne 0x7136
jmp 0x7147
movq -0xb0(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x7149
movq -0x68(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: fn_inverse(Element*)
Element* fn_inverse(Element* op){
	//long a;
	double b;
	Element *rtn;
	
	b = atof(op->data_is().c_str());
	rtn = new Element(ftoa(1.0/b));

	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x58e0
movq -0x78(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
movq -0x78(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x3448
movl $0x40, %edi
callq 0x3230
movq %rax, -0x70(%rbp)
movb $0x1, -0x65(%rbp)
movsd -0x10(%rbp), %xmm1
movsd 0x23e2(%rip), %xmm0     # 0xa010
divsd %xmm1, %xmm0
leaq -0x58(%rbp), %rdi
callq 0x4000
jmp 0x7c3d
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5800
jmp 0x7c4c
movq -0x70(%rbp), %rax
movb $0x0, -0x65(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7c91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
testb $0x1, -0x65(%rbp)
jne 0x7c99
jmp 0x7ca7
movq -0x70(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x7ca9
movq -0x60(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: fn_pow(Element*, Element*)
Element* fn_pow(Element* op1,Element* op2){
	double b;
	Element *rtn;
	
	b = std::pow(atof(op1->data_is().c_str()), atof(op2->data_is().c_str()));
	rtn = new Element(ftoa(b));

	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x58e0
movq -0xa8(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
movsd %xmm0, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x58e0
jmp 0x7d12
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
movaps %xmm0, %xmm1
movsd -0xa0(%rbp), %xmm0
callq 0x33a0
movq -0xb8(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
callq 0x3448
leaq -0x40(%rbp), %rdi
callq 0x3448
movl $0x40, %edi
callq 0x3230
movq %rax, -0xb0(%rbp)
movb $0x1, -0x91(%rbp)
movsd -0x18(%rbp), %xmm0
leaq -0x90(%rbp), %rdi
callq 0x4000
jmp 0x7d7f
movq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5800
jmp 0x7d94
movq -0xb0(%rbp), %rax
movb $0x0, -0x91(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3448
movq -0x20(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3448
jmp 0x7e1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7dfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3448
testb $0x1, -0x91(%rbp)
jne 0x7e07
jmp 0x7e18
movq -0xb0(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x7e1a
movq -0x68(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: fn_square(Element*)
Element* fn_square(Element* op1){
	double b;
	Element *rtn;
	
	b = std::pow(atof(op1->data_is().c_str()),2.0);
	rtn = new Element(ftoa(b));

	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x58e0
movq -0x78(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
movsd 0x21af(%rip), %xmm1     # 0xa018
callq 0x33a0
movq -0x78(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x3448
movl $0x40, %edi
callq 0x3230
movq %rax, -0x70(%rbp)
movb $0x1, -0x65(%rbp)
movsd -0x10(%rbp), %xmm0
leaq -0x58(%rbp), %rdi
callq 0x4000
jmp 0x7e9e
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5800
jmp 0x7ead
movq -0x70(%rbp), %rax
movb $0x0, -0x65(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7ef2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
testb $0x1, -0x65(%rbp)
jne 0x7efa
jmp 0x7f08
movq -0x70(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x7f0a
movq -0x60(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: fn_cube(Element*)
Element* fn_cube(Element* op1){
	double b;
	Element *rtn;
	
	b = std::pow(atof(op1->data_is().c_str()),3.0);
	rtn = new Element(ftoa(b));

	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x58e0
movq -0x78(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
movsd 0x20c7(%rip), %xmm1     # 0xa020
callq 0x33a0
movq -0x78(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x3448
movl $0x40, %edi
callq 0x3230
movq %rax, -0x70(%rbp)
movb $0x1, -0x65(%rbp)
movsd -0x10(%rbp), %xmm0
leaq -0x58(%rbp), %rdi
callq 0x4000
jmp 0x7f8e
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5800
jmp 0x7f9d
movq -0x70(%rbp), %rax
movb $0x0, -0x65(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7fe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
testb $0x1, -0x65(%rbp)
jne 0x7fea
jmp 0x7ff8
movq -0x70(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x7ffa
movq -0x60(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: fn_sqrt(Element*)
Element* fn_sqrt(Element* op1){
	double b;
	Element *rtn;
	
	b = std::sqrt(atof(op1->data_is().c_str()));
	rtn = new Element(ftoa(b));

	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x58e0
movq -0x78(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x32f0
callq 0x31c0
movq -0x78(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x3448
movl $0x40, %edi
callq 0x3230
movq %rax, -0x70(%rbp)
movb $0x1, -0x65(%rbp)
movsd -0x10(%rbp), %xmm0
leaq -0x58(%rbp), %rdi
callq 0x4000
jmp 0x8076
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5800
jmp 0x8085
movq -0x70(%rbp), %rax
movb $0x0, -0x65(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x80ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
testb $0x1, -0x65(%rbp)
jne 0x80d2
jmp 0x80e0
movq -0x70(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x80e2
movq -0x60(%rbp), %rdi
callq 0x33b0
nopl (%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: fn_cbrt(Element*)
Element* fn_cbrt(Element* op1){
	double b;
	Element *op2;
	
	//b = cbrtf(atof(op1->data_is().c_str()));
	//rtn = new Element(ftoa(b));
	op2 = new Element("0.333333333"); // あとで修正

	return fn_pow(op1,op2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
callq 0x3230
movq %rax, -0x60(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x33c0
movq -0x58(%rbp), %rdx
leaq 0x20c7(%rip), %rsi      # 0xa1ed
leaq -0x38(%rbp), %rdi
callq 0x9180
jmp 0x8131
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5800
jmp 0x8140
movq -0x60(%rbp), %rax
movb $0x0, -0x4d(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3280
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7cc0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3448
leaq -0x39(%rbp), %rdi
callq 0x3280
testb $0x1, -0x4d(%rbp)
jne 0x81a5
jmp 0x81b3
movq -0x60(%rbp), %rdi
movl $0x40, %esi
callq 0x3240
jmp 0x81b5
movq -0x48(%rbp), %rdi
callq 0x33b0
nop
// File: syusui-s[P]old_rpn_language/./element.h
// Function: del_array(Element**, int, int, int)
Element** del_array(Element** input, int length, int pos, int num){
	// 入力配列 Element** input
	// 入力のサイズ int length <- 配列のサイズを指定
	// 削除開始位置 int pos    <- 開始位置なので、演算子の個数を
	// 削除個数     int num    <- 演算子を含める場合は、呼び出し時に引数に+1する。

	int i,j;
	Element **rtn = new Element*[length-num];

	for(i=0;i<pos;i++) rtn[i] = input[i];
	j = i;

	for(;i<pos+num;i++){
		// delete input[i];
	}

	for(i=pos+num;i<length;i++){
		rtn[j] = input[i];
		j++;
	}

	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x86e4
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x86b9
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x8704
jmp 0x86f9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x86ea
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8741
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x870d
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: syusui-s[P]old_rpn_language/./element.h
// Function: ins_element(Element**, Element*, int, int)
Element** ins_element(Element **inp_arr, Element* inp_elm, int length, int pos){
	int i;
	Element **rtn = new Element*[length+1];
	
	for(i=0;i<pos;i++) rtn[i] = inp_arr[i];
	rtn[i] = inp_elm;
	#if MYDEBUG
	std::cout << "debug:" << inp_elm->data_is() << std::endl;
	#endif
	// ここで、iはrtnに合わせる
	for(i=i+1;i<length+1;i++) rtn[i] = inp_arr[i-1];
	
	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x87c5
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x879a
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8813
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x87de
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: syusui-s[P]old_rpn_language/./interpret.h
// Function: help()
void help(){
	std::cout
		<< " -- Special commands -- \n"	
		<< "\t:h, :help \t show this message\n" 
		<< "\t:q, :quit \t exit " << PROGNAME << "\n"
	<< std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x51ed(%rip), %rdi      # 0xdfc8
leaq 0x14c8(%rip), %rsi      # 0xa2aa
callq 0x3220
movq %rax, %rdi
leaq 0x14d3(%rip), %rsi      # 0xa2c4
callq 0x3220
movq %rax, %rdi
leaq 0x14e4(%rip), %rsi      # 0xa2e4
callq 0x3220
movq %rax, %rdi
leaq 0x14e8(%rip), %rsi      # 0xa2f7
callq 0x3220
movq %rax, %rdi
leaq 0x14a4(%rip), %rsi      # 0xa2c2
callq 0x3220
movq %rax, %rdi
movq 0x5183(%rip), %rsi      # 0xdfb0
callq 0x3260
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: syusui-s[P]old_rpn_language/./interpret.h
// Function: interpret(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void interpret(std::string input){
	if(input[0]==':'){
		if(input==":h" || input==":help" || input==":?") help();
		else if(input==":q" || input==":quit") exit(0);
		else std::cerr << "error: No such a command." << std::endl;
		std::cout << std::endl;
	}else if(delsp(input)==""){
		// do nothing
	}else{
		std::cout << calclate(input) << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x8f2c
movq -0xa0(%rbp), %rdi
leaq 0x148b(%rip), %rsi      # 0xa304
callq 0x9340
testb $0x1, %al
jne 0x8eb2
movq -0xa0(%rbp), %rdi
leaq 0x1477(%rip), %rsi      # 0xa307
callq 0x9340
testb $0x1, %al
jne 0x8eb2
movq -0xa0(%rbp), %rdi
leaq 0x1466(%rip), %rsi      # 0xa30d
callq 0x9340
testb $0x1, %al
jne 0x8eb2
jmp 0x8eb9
callq 0x8dd0
jmp 0x8f14
movq -0xa0(%rbp), %rdi
leaq 0x1449(%rip), %rsi      # 0xa310
callq 0x9340
testb $0x1, %al
jne 0x8ee9
movq -0xa0(%rbp), %rdi
leaq 0x1435(%rip), %rsi      # 0xa313
callq 0x9340
testb $0x1, %al
jne 0x8ee9
jmp 0x8ef0
xorl %edi, %edi
callq 0x32c0
movq 0x50f9(%rip), %rdi      # 0xdff0
leaq 0x141b(%rip), %rsi      # 0xa319
callq 0x3220
movq %rax, %rdi
movq 0x50a3(%rip), %rsi      # 0xdfb0
callq 0x3260
jmp 0x8f14
movq 0x50ad(%rip), %rdi      # 0xdfc8
movq 0x508e(%rip), %rsi      # 0xdfb0
callq 0x3260
jmp 0x9065
movq -0xa0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3100
movq -0xa8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x35c0
jmp 0x8f55
leaq 0x1367(%rip), %rsi      # 0xa2c3
leaq -0x28(%rbp), %rdi
callq 0x9340
movb %al, -0xa9(%rbp)
jmp 0x8f6d
leaq -0x28(%rbp), %rdi
callq 0x3448
leaq -0x48(%rbp), %rdi
callq 0x3448
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x8f8b
jmp 0x8fc1
jmp 0x9063
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8fb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3448
leaq -0x48(%rbp), %rdi
callq 0x3448
jmp 0x906e
movq -0xa0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3100
movq -0xb8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x8a40
jmp 0x8fed
movq 0x4fd4(%rip), %rdi      # 0xdfc8
leaq -0x78(%rbp), %rsi
callq 0x3200
movq %rax, -0xc0(%rbp)
jmp 0x9006
movq -0xc0(%rbp), %rdi
movq 0x4f9c(%rip), %rsi      # 0xdfb0
callq 0x3260
jmp 0x901b
leaq -0x78(%rbp), %rdi
callq 0x3448
leaq -0x98(%rbp), %rdi
callq 0x3448
jmp 0x9063
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x9055
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3448
leaq -0x98(%rbp), %rdi
callq 0x3448
jmp 0x906e
jmp 0x9065
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33b0
nopw (%rax,%rax)
// File: syusui-s[P]old_rpn_language/main.cpp
// Function: main
int main(void){
	std::string input;
	
	////////////////////////////////////
	std::cout << PROGNAME << ", version " << PROGVER << std::endl;
	while(1){
		std::cout << INPUTSTR;
		std::getline(std::cin, input);
		interpret(input);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3330
movq 0x4f29(%rip), %rdi      # 0xdfc8
leaq 0x1251(%rip), %rsi      # 0xa2f7
callq 0x3220
movq %rax, -0x60(%rbp)
jmp 0x90b1
movq -0x60(%rbp), %rdi
leaq 0x1277(%rip), %rsi      # 0xa333
callq 0x3220
movq %rax, -0x68(%rbp)
jmp 0x90c7
movq -0x68(%rbp), %rdi
leaq 0x126c(%rip), %rsi      # 0xa33e
callq 0x3220
movq %rax, -0x70(%rbp)
jmp 0x90dd
movq -0x70(%rbp), %rdi
movq 0x4ec8(%rip), %rsi      # 0xdfb0
callq 0x3260
jmp 0x90ef
jmp 0x90f1
jmp 0x90f3
movq 0x4ece(%rip), %rdi      # 0xdfc8
leaq 0x124e(%rip), %rsi      # 0xa34f
callq 0x3220
jmp 0x9108
movq 0x4ec9(%rip), %rdi      # 0xdfd8
leaq -0x28(%rbp), %rsi
callq 0x3080
jmp 0x911a
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3100
jmp 0x9129
leaq -0x58(%rbp), %rdi
callq 0x8e40
jmp 0x9134
leaq -0x58(%rbp), %rdi
callq 0x3448
jmp 0x90f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x9162
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3448
leaq -0x28(%rbp), %rdi
callq 0x3448
movq -0x30(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
nop
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Features::strictMode()
Features Features::strictMode() {
  Features features;
  features.allowComments_ = false;
  features.strictRoot_ = true;
  features.allowDroppedNullPlaceholders_ = false;
  features.allowNumericKeys_ = false;
  return features;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x4(%rbp), %rdi
callq 0xa370
movb $0x0, -0x4(%rbp)
movb $0x1, -0x3(%rbp)
movb $0x0, -0x2(%rbp)
movb $0x0, -0x1(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::containsNewLine(char const*, char const*)
bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) {
  for (; begin < end; ++begin)
    if (*begin == '\n' || *begin == '\r')
      return true;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa424
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xa40e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0xa414
movb $0x1, -0x1(%rbp)
jmp 0xa428
jmp 0xa416
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa3ec
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value&, bool)
bool Reader::parse(const std::string& document,
                   Value& root,
                   bool collectComments) {
  document_.assign(document.begin(), document.end());
  const char* begin = document_.c_str();
  const char* end = begin + document_.length();
  return parse(begin, end, root, collectComments);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0xa0, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9730
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9e10
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x14420
movq -0x50(%rbp), %rdi
addq $0xa0, %rdi
callq 0x92b0
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0xa0, %rdi
callq 0x9b00
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xa710
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::parse(std::istream&, Json::Value&, bool)
bool Reader::parse(std::istream& is, Value& root, bool collectComments) {
  // std::istream_iterator<char> begin(is);
  // std::istream_iterator<char> end;
  // Those would allow streamed input from a file, if parse() were a
  // template function.

  // Since JSONCPP_STRING is reference-counted, this at least does not
  // create an extra copy.
  JSONCPP_STRING doc;
  std::getline(is, doc, (char)EOF);
  return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x9a50
movq -0x58(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x9df0
jmp 0xa9a7
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x99b0
movq -0x80(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x99b0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x9540
movq -0x78(%rbp), %rdx
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movzbl -0x19(%rbp), %r8d
andl $0x1, %r8d
callq 0xa710
movb %al, -0x61(%rbp)
jmp 0xa9f4
leaq -0x40(%rbp), %rdi
callq 0x9480
movb -0x61(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9480
movq -0x48(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::addError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Reader::Token&, char const*)
bool Reader::addError(const JSONCPP_STRING& message,
                      Token& token,
                      Location extra) {
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = extra;
  errors_.push_back(info);
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x14680
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x50(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9070
jmp 0xb1ae
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x50, %rdi
leaq -0x60(%rbp), %rsi
callq 0x146a0
jmp 0xb1c9
leaq -0x60(%rbp), %rdi
callq 0x14700
xorl %eax, %eax
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x14700
movq -0x68(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::decodeNumber(Json::Reader::Token&)
bool Reader::decodeNumber(Token& token) {
  Value decoded;
  if (!decodeNumber(token, decoded))
    return false;
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %esi, %esi
callq 0x1e5c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0xcdd0
movb %al, -0x51(%rbp)
jmp 0xbd80
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xbdb3
jmp 0xbd89
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xbe3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1f050
jmp 0xbe53
movq -0x68(%rbp), %rdi
callq 0xb200
movq %rax, -0x70(%rbp)
jmp 0xbdc2
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1f1e0
jmp 0xbdd1
movq -0x68(%rbp), %rdi
callq 0xb200
movq %rax, -0x78(%rbp)
jmp 0xbde0
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0x245c0
jmp 0xbe01
movq -0x68(%rbp), %rdi
callq 0xb200
movq %rax, -0x80(%rbp)
jmp 0xbe10
movq -0x80(%rbp), %rdi
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0x245e0
jmp 0xbe31
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1f050
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::decodeString(Json::Reader::Token&)
bool Reader::decodeString(Token& token) {
  JSONCPP_STRING decoded_string;
  if (!decodeString(token, decoded_string))
    return false;
  Value decoded(decoded_string);
  currentValue().swapPayload(decoded);
  currentValue().setOffsetStart(token.start_ - begin_);
  currentValue().setOffsetLimit(token.end_ - begin_);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9a50
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0xc9c0
movb %al, -0x71(%rbp)
jmp 0xbea4
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xbece
jmp 0xbead
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xbfa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbfc0
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1eb70
jmp 0xbedd
movq -0x88(%rbp), %rdi
callq 0xb200
movq %rax, -0x90(%rbp)
jmp 0xbef2
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1f1e0
jmp 0xbf04
movq -0x88(%rbp), %rdi
callq 0xb200
movq %rax, -0x98(%rbp)
jmp 0xbf19
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0x245c0
jmp 0xbf40
movq -0x88(%rbp), %rdi
callq 0xb200
movq %rax, -0xa0(%rbp)
jmp 0xbf55
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0xc0(%rax), %rax
subq %rax, %rsi
callq 0x245e0
jmp 0xbf7c
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1f050
jmp 0xbfa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1f050
jmp 0xbfc0
leaq -0x38(%rbp), %rdi
callq 0x9480
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x9480
movq -0x40(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::readString()
bool Reader::readString() {
  Char c = '\0';
  while (current_ != end_) {
    c = getNextChar();
    if (c == '\\')
      getNextChar();
    else if (c == '"')
      break;
  }
  return c == '"';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x18(%rbp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xc2cb
movq -0x18(%rbp), %rdi
callq 0xc220
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x5c, %eax
jne 0xc2bc
movq -0x18(%rbp), %rdi
callq 0xc220
jmp 0xc2c9
movsbl -0x9(%rbp), %eax
cmpl $0x22, %eax
jne 0xc2c7
jmp 0xc2cb
jmp 0xc2c9
jmp 0xc288
movsbl -0x9(%rbp), %eax
cmpl $0x22, %eax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::match(char const*, int)
bool Reader::match(Location pattern, int patternLength) {
  if (end_ - current_ < patternLength)
    return false;
  int index = patternLength;
  while (index--)
    if (current_[index] != pattern[index])
      return false;
  current_ += patternLength;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0xc8(%rcx), %rax
movq 0xd0(%rcx), %rcx
subq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
jge 0xc647
movb $0x0, -0x1(%rbp)
jmp 0xc6a7
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
je 0xc688
movq -0x28(%rbp), %rax
movq 0xd0(%rax), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xc686
movb $0x0, -0x1(%rbp)
jmp 0xc6a7
jmp 0xc64d
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edx
movq 0xd0(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0xd0(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::readCStyleComment()
bool Reader::readCStyleComment() {
  while ((current_ + 1) < end_) {
    Char c = getNextChar();
    if (c == '*' && *current_ == '/')
      break;
  }
  return getNextChar() == '/';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0xd0(%rcx), %rax
addq $0x1, %rax
cmpq 0xc8(%rcx), %rax
jae 0xc708
movq -0x18(%rbp), %rdi
callq 0xc220
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x2a, %eax
jne 0xc706
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xc706
jmp 0xc708
jmp 0xc6c4
movq -0x18(%rbp), %rdi
callq 0xc220
movsbl %al, %eax
cmpl $0x2f, %eax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::addComment(char const*, char const*, Json::CommentPlacement)
void Reader::addComment(Location begin,
                        Location end,
                        CommentPlacement placement) {
  assert(collectComments_);
  const JSONCPP_STRING& normalized = normalizeEOL(begin, end);
  if (placement == commentAfterOnSameLine) {
    assert(lastValue_ != 0);
    lastValue_->setComment(normalized, placement);
  } else {
    commentsBefore_ += normalized;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x10c(%rax)
je 0xc7ea
jmp 0xc809
leaq 0xaefd4(%rip), %rdi     # 0xbb7c5
leaq 0xaefde(%rip), %rsi     # 0xbb7d6
movl $0x18a, %edx            # imm = 0x18A
leaq 0xaefec(%rip), %rcx     # 0xbb7f0
callq 0x94e0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xc8c0
leaq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0xc889
movq -0x60(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0xc838
jmp 0xc857
leaq 0xaeff5(%rip), %rdi     # 0xbb834
leaq 0xaef90(%rip), %rsi     # 0xbb7d6
movl $0x18d, %edx            # imm = 0x18D
leaq 0xaef9e(%rip), %rcx     # 0xbb7f0
callq 0x94e0
movq -0x60(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x24440
jmp 0xc870
jmp 0xc8a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9480
jmp 0xc8b0
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xe8, %rdi
callq 0x9980
jmp 0xc89f
jmp 0xc8a1
leaq -0x48(%rbp), %rdi
callq 0x9480
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::normalizeEOL[abi:cxx11](char const*, char const*)
JSONCPP_STRING Reader::normalizeEOL(Reader::Location begin,
                                    Reader::Location end) {
  JSONCPP_STRING normalized;
  normalized.reserve(static_cast<size_t>(end - begin));
  Reader::Location current = begin;
  while (current != end) {
    char c = *current++;
    if (c == '\r') {
      if (current != end && *current == '\n')
        // convert dos EOL
        ++current;
      // convert Mac EOL
      normalized += '\n';
    } else {
      normalized += c;
    }
  }
  return normalized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9a50
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
callq 0x9b90
jmp 0xc8fe
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xc994
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %al
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0xd, %eax
jne 0xc97e
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xc96c
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xc96c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xc96c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9480
jmp 0xc9b1
movq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x9490
jmp 0xc97c
jmp 0xc98f
movq -0x48(%rbp), %rdi
movsbl -0x39(%rbp), %esi
callq 0x9490
jmp 0xc98d
jmp 0xc98f
jmp 0xc906
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xc9a7
movq -0x48(%rbp), %rdi
callq 0x9480
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x9d20
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::pushError(Json::Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Reader::pushError(const Value& value, const JSONCPP_STRING& message) {
  ptrdiff_t const length = end_ - begin_;
  if (value.getOffsetStart() > length || value.getOffsetLimit() > length)
    return false;
  Token token;
  token.type_ = tokenError;
  token.start_ = begin_ + value.getOffsetStart();
  token.end_ = end_ + value.getOffsetLimit();
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = 0;
  errors_.push_back(info);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq 0xc8(%rcx), %rax
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24600
cmpq -0x28(%rbp), %rax
jg 0xe465
movq -0x18(%rbp), %rdi
callq 0x24620
cmpq -0x28(%rbp), %rax
jle 0xe46e
movb $0x0, -0x1(%rbp)
jmp 0xe545
movq -0x98(%rbp), %rax
movl $0xd, -0x40(%rbp)
movq 0xc0(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24600
movq -0xa8(%rbp), %rcx
movq %rax, %rdx
movq -0x98(%rbp), %rax
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq 0xc8(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24620
movq %rax, %rcx
movq -0xa0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x14680
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movups -0x40(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x9070
jmp 0xe4fb
movq -0x98(%rbp), %rdi
movq $0x0, -0x48(%rbp)
addq $0x50, %rdi
leaq -0x80(%rbp), %rsi
callq 0x146a0
jmp 0xe519
movb $0x1, -0x1(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x14700
jmp 0xe545
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x14700
jmp 0xe553
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x9d20
nop
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::Reader::pushError(Json::Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value const&)
bool Reader::pushError(const Value& value,
                       const JSONCPP_STRING& message,
                       const Value& extra) {
  ptrdiff_t const length = end_ - begin_;
  if (value.getOffsetStart() > length || value.getOffsetLimit() > length ||
      extra.getOffsetLimit() > length)
    return false;
  Token token;
  token.type_ = tokenError;
  token.start_ = begin_ + value.getOffsetStart();
  token.end_ = begin_ + value.getOffsetLimit();
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = begin_ + extra.getOffsetStart();
  errors_.push_back(info);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq 0xc8(%rcx), %rax
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24600
cmpq -0x30(%rbp), %rax
jg 0xe5c8
movq -0x18(%rbp), %rdi
callq 0x24620
cmpq -0x30(%rbp), %rax
jg 0xe5c8
movq -0x28(%rbp), %rdi
callq 0x24620
cmpq -0x30(%rbp), %rax
jle 0xe5d1
movb $0x0, -0x1(%rbp)
jmp 0xe6eb
movq -0xa8(%rbp), %rax
movl $0xd, -0x48(%rbp)
movq 0xc0(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24600
movq -0xb8(%rbp), %rcx
movq %rax, %rdx
movq -0xa8(%rbp), %rax
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq 0xc0(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24620
movq %rax, %rcx
movq -0xb0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x14680
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9070
jmp 0xe664
movq -0xa8(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rdi
callq 0x24600
movq %rax, -0xc0(%rbp)
jmp 0xe68b
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x58(%rbp)
addq $0x50, %rdi
leaq -0x90(%rbp), %rsi
callq 0x146a0
jmp 0xe6b9
movb $0x1, -0x1(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x14700
jmp 0xe6eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x14700
jmp 0xe6f9
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::OurReader::containsNewLine(char const*, char const*)
bool OurReader::containsNewLine(OurReader::Location begin,
                                OurReader::Location end) {
  for (; begin < end; ++begin)
    if (*begin == '\n' || *begin == '\r')
      return true;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe7b4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xe79e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0xe7a4
movb $0x1, -0x1(%rbp)
jmp 0xe7b8
jmp 0xe7a6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe77c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::OurReader::normalizeEOL[abi:cxx11](char const*, char const*)
JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin,
                                       OurReader::Location end) {
  JSONCPP_STRING normalized;
  normalized.reserve(static_cast<size_t>(end - begin));
  OurReader::Location current = begin;
  while (current != end) {
    char c = *current++;
    if (c == '\r') {
      if (current != end && *current == '\n')
        // convert dos EOL
        ++current;
      // convert Mac EOL
      normalized += '\n';
    } else {
      normalized += c;
    }
  }
  return normalized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9a50
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
callq 0x9b90
jmp 0x1107e
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x11114
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %al
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0xd, %eax
jne 0x110fe
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x110ec
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x110ec
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x110ec
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9480
jmp 0x11131
movq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x9490
jmp 0x110fc
jmp 0x1110f
movq -0x48(%rbp), %rdi
movsbl -0x39(%rbp), %esi
callq 0x9490
jmp 0x1110d
jmp 0x1110f
jmp 0x11086
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x11127
movq -0x48(%rbp), %rdi
callq 0x9480
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x9d20
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.cpp
// Function: Json::parseFromStream(Json::CharReader::Factory const&, std::istream&, Json::Value*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool parseFromStream(CharReader::Factory const& fact,
                     JSONCPP_ISTREAM& sin,
                     Value* root,
                     JSONCPP_STRING* errs) {
  JSONCPP_OSTRINGSTREAM ssin;
  ssin << sin.rdbuf();
  JSONCPP_STRING doc = ssin.str();
  char const* begin = doc.data();
  char const* end = begin + doc.size();
  // Note that we do not actually need a null-terminator.
  CharReaderPtr const reader(fact.newCharReader());
  return reader->parse(begin, end, root, errs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x9a00
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x92f0
movq %rax, -0x1e8(%rbp)
jmp 0x140c3
movq -0x1e8(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x9180
jmp 0x140d8
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x9790
jmp 0x140ed
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x99b0
movq -0x200(%rbp), %rdi
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1f8(%rbp)
callq 0x9540
movq %rax, %rcx
movq -0x1f8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x1d8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x1f0(%rbp)
jmp 0x1414b
movq -0x1f0(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x151b0
movq -0x210(%rbp), %rdi
callq 0x151e0
movq %rax, %rdi
movq -0x1d0(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movb %al, -0x201(%rbp)
jmp 0x1419b
leaq -0x1e0(%rbp), %rdi
callq 0x15200
leaq -0x1c8(%rbp), %rdi
callq 0x9480
leaq -0x198(%rbp), %rdi
callq 0x91d0
movb -0x201(%rbp), %al
andb $0x1, %al
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x14222
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x14216
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x15200
leaq -0x1c8(%rbp), %rdi
callq 0x9480
leaq -0x198(%rbp), %rdi
callq 0x91d0
movq -0x1a0(%rbp), %rdi
callq 0x9d20
nopw (%rax,%rax)