LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/RuiDGPires[P]CrimLang/src/semantic_analiser.cpp
// Function: sc_Tracker::block(crl::Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void _sc_Tracker::block(crl::Node *node, std::string annotation){
	this->enter();
	size_t size = node->children.size();
	for (size_t i = 0; i < size; i++){
		this->statement(node->get_child(i), annotation);
	}
	this->leave();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
callq 0x13b84
movq 0x18(%r15), %rax
subq 0x10(%r15), %rax
je 0x1486e
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x18(%rax)
movq %rax, %rbx
leaq -0x50(%rbp), %r13
movq %r13, -0x60(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0x4d4a
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x15e16
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x14865
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3230
incq %r12
cmpq %r12, -0x38(%rbp)
jne 0x14810
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %r14
movq (%r14), %rax
movq %rax, 0x8(%rcx)
movq %r14, %rdi
callq 0x4420
movl $0x38, %esi
movq %r14, %rdi
callq 0x3230
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x148b9
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/RuiDGPires[P]CrimLang/src/semantic_analiser.cpp
// Function: sc_Tracker::program(crl::Node*)
void _sc_Tracker::program(crl::Node *node){
	size_t size = node->children.size();

	for (size_t i = 0; i < size; i++){
		crl::Node *child = node->get_child(i);
		ASSERT(child->type == crl::Node::Type::VAR_DECLARATION || child->type == crl::Node::Type::FUNC_DECLARATION || child->type == crl::Node::Type::CAS, "Program must only have declarations or cas instructions");
		if (child->type == crl::Node::Type::FUNC_DECLARATION)
			this->func_declaration(child);
		else if (child->type == crl::Node::Type::VAR_DECLARATION)
			this->var_declaration(child);
		else if (child->type == crl::Node::Type::CAS)
			this->cas(child);
		else
			ASSERT(false, "???");
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x18(%rsi), %r12
subq 0x10(%rsi), %r12
je 0x18541
movq %rsi, %rbx
movq %rdi, %r14
sarq $0x3, %r12
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r15d, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *0x18(%rax)
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x1852e
cmpl $0x3, %ecx
je 0x18521
cmpl $0x11, %ecx
jne 0x1854e
movq %r14, %rdi
movq %rax, %rsi
callq 0x13dee
jmp 0x18539
movq %r14, %rdi
movq %rax, %rsi
callq 0x140c2
jmp 0x18539
movq %r14, %rdi
movq %rax, %rsi
callq 0x148c2
incq %r15
cmpq %r15, %r12
jne 0x184f6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x3120
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x37a6(%rip), %rsi      # 0x1bd11
leaq 0x37d6(%rip), %rdx      # 0x1bd48
leaq -0x40(%rbp), %rdi
callq 0x433a
movb $0x1, %r15b
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r15d, %r15d
leaq 0xa7da(%rip), %rsi      # 0x22d78
leaq -0x12fbf(%rip), %rdx    # 0x55e6
movq %rbx, %rdi
callq 0x33d0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x185cd
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x185cd
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x185da
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/RuiDGPires[P]CrimLang/src/semantic_analiser.cpp
// Function: sc_Tracker::check()
void _sc_Tracker::check(){
	this->ast = this->ast->get_child(0); // Enter the program	
	this->program(this->ast);
	Context::Item item = this->context->seek("main");
	ASSERT(item.type == Context::Item::Type::FUNC, "Main function is not defined");
	ASSERT(item.subtype == "u32", "Main function is not defined");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x18(%rax)
movq %rax, (%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x184c8
movq 0x8(%rbx), %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3726(%rip), %rsi      # 0x1bd49
leaq 0x3723(%rip), %rdx      # 0x1bd4d
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x433a
leaq -0xf0(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x442e
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1865d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
cmpl $0x1, -0xf0(%rbp)
jne 0x18699
leaq -0xc8(%rbp), %rdi
leaq 0x301f(%rip), %rsi      # 0x1b693
callq 0x30a0
testl %eax, %eax
jne 0x186fa
leaq -0xf0(%rbp), %rdi
callq 0x4816
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x3120
movq %rax, %rbx
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3698(%rip), %rsi      # 0x1bd4e
leaq 0x36ad(%rip), %rdx      # 0x1bd6a
leaq -0x80(%rbp), %rdi
callq 0x433a
movb $0x1, %r15b
leaq -0x80(%rbp), %rcx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r15d, %r15d
leaq 0xa68f(%rip), %rsi      # 0x22d78
leaq -0x1310a(%rip), %rdx    # 0x55e6
movq %rbx, %rdi
callq 0x33d0
jmp 0x18759
movl $0x50, %edi
callq 0x3120
movq %rax, %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3637(%rip), %rsi      # 0x1bd4e
leaq 0x364c(%rip), %rdx      # 0x1bd6a
leaq -0x60(%rbp), %rdi
callq 0x433a
movb $0x1, %r15b
leaq -0x60(%rbp), %rcx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r15d, %r15d
leaq 0xa62e(%rip), %rsi      # 0x22d78
leaq -0x1316b(%rip), %rdx    # 0x55e6
movq %rbx, %rdi
callq 0x33d0
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x1878d
movq -0x50(%rbp), %rsi
jmp 0x1877d
jmp 0x18787
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x1878d
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x1878d
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1879a
movq %rbx, %rdi
callq 0x31a0
leaq -0xf0(%rbp), %rdi
callq 0x4816
jmp 0x187c0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x187c0
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/RuiDGPires[P]CrimLang/src/token.cpp
// Function: crl::Token::Token()
crl::Token::Token(){
	this->type = crl::Token::Type::NONE;
	this->str = "";
	this->line = 0;
	this->column = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x0, 0x20(%rdi)
leaq 0x2272(%rip), %rcx      # 0x1b4e4
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x3340
movq $0x0, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x192a7
movq (%r15), %rsi
incq %rsi
callq 0x3230
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/RuiDGPires[P]CrimLang/src/tokenizer.cpp
// Function: crl::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<crl::Token> crl::tokenize(std::string filename){
	std::ifstream file;
	file.open(filename);

	Tracker tracker;	
	char c;
	while (file >> std::noskipws >> c){
		tracker.take(c);
	}
	// TODO : Is this needed?
	tracker.take(c);

	tracker.dump_eof();
	file.close();

	return tracker.get_result();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x298(%rbp), %r15
movq %r15, %rdi
callq 0x3270
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x3200
leaq -0x90(%rbp), %rdi
callq 0x19244
leaq -0x48(%rbp), %r14
movl $0x1, -0x18(%r14)
movl $0x0, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
movq %rax, -0x14(%r14)
movb $0x0, -0xc(%r14)
leaq -0x29(%rbp), %r12
leaq -0x90(%rbp), %r13
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, -0x280(%rbp,%rax) # imm = 0xFFFFEFFF
movq %r15, %rdi
movq %r12, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movsbl -0x29(%rbp), %esi
jne 0x1a5fd
movq %r13, %rdi
callq 0x19b3c
jmp 0x1a5c0
leaq -0x90(%rbp), %rdi
callq 0x19b3c
leaq -0x90(%rbp), %rdi
movl $0x3a, 0x20(%rdi)
movq 0x8(%rdi), %rdx
movl $0x1, %ecx
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x3420
leaq -0x90(%rbp), %rdi
callq 0x19a9e
leaq -0x298(%rbp), %rdi
callq 0x3070
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf6da
movq %r14, %rdi
callq 0xf780
leaq -0x90(%rbp), %rdi
callq 0x192b0
leaq -0x298(%rbp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a684
movq %rax, %rbx
jmp 0x1a6a2
jmp 0x1a68b
movq %rax, %rbx
movq %r14, %rdi
callq 0xf780
leaq -0x90(%rbp), %rdi
callq 0x192b0
leaq -0x298(%rbp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/scninfo/scninfo.cpp
// Function: PrintElement(gaps::R3SceneElement*, int, int)
static int
PrintElement(R3SceneElement *element, int index, int level)
{
  // Construct indent
  char indent[4096] = { '\0' };
  for (int i = 0; i < level; i++) {
    strcat(indent, "  ");
  }

  // Print element stuff
  R3Box bbox = element->BBox();
  R3Point centroid = element->Centroid();
  R3Material *material = element->Material();
  printf("%sElement %d\n", indent, index);
  printf("%s  # Shapes = %d\n", indent, element->NShapes());
  if (material) printf("%s  Material = %d\n", indent, material->SceneIndex());
  printf("%s  BBox = ( %g %g %g ) ( %g %g %g )\n", indent, bbox[0][0], bbox[0][1], bbox[0][2], bbox[1][0], bbox[1][1], bbox[1][2]);
  printf("%s  Centroid = %g %g %g\n", indent, centroid[0], centroid[1], centroid[2]);
  printf("\n");

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1058, %rsp           # imm = 0x1058
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x21450
testl %r14d, %r14d
jle 0x265ea
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x21350
movw $0x2020, 0x50(%rsp,%rax) # imm = 0x2020
movb $0x0, 0x52(%rsp,%rax)
decl %r14d
jne 0x265d1
movsd 0x30(%rbx), %xmm0
ucomisd 0xb4a21(%rip), %xmm0    # 0xdb018
jne 0x26603
jp 0x26603
movq %rbx, %rdi
callq 0x3c714
leaq 0x28(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x6c090
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3c0cc
movq 0x8(%rbx), %r15
leaq 0xb4d74(%rip), %rdi     # 0xdb39b
leaq 0x50(%rsp), %r14
movq %r14, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x21080
movl 0x1c(%rbx), %edx
leaq 0xb4d67(%rip), %rdi     # 0xdb3a9
movq %r14, %rsi
xorl %eax, %eax
callq 0x21080
testq %r15, %r15
je 0x26668
movl 0x8(%r15), %edx
leaq 0xb4d60(%rip), %rdi     # 0xdb3bc
leaq 0x50(%rsp), %rsi
xorl %eax, %eax
callq 0x21080
leaq 0x18(%rsp), %rbx
movsd 0x8(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movsd 0x18(%rbx), %xmm2
movsd 0x20(%rbx), %xmm3
movsd 0x28(%rbx), %xmm4
movsd 0x30(%rbx), %xmm5
leaq 0xb4baf(%rip), %rdi     # 0xdb241
leaq 0x50(%rsp), %r14
movq %r14, %rsi
movb $0x6, %al
callq 0x21080
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
leaq 0xb4b6f(%rip), %rdi     # 0xdb228
movq %r14, %rsi
movb $0x3, %al
callq 0x21080
movl $0xa, %edi
callq 0x21cb0
movq %rbx, %rdi
callq 0x6cee8
addq $0x1058, %rsp           # imm = 0x1058
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6cee8
movq %rbx, %rdi
callq 0x22070
// File: /workspace/github_cpp_makefile_star2_O1/ashlall[P]StreamStats/Test/./../SourceCode/ChiSquare/ChiSquareCategorical.cpp
// Function: ChiSquareCategorical::ChiSquareCategorical(double)
ChiSquareCategorical::ChiSquareCategorical(double p)
{
	chi_squared=0;
	stream_size=0;
	percent =p;
	range=pow(2,32);
	num_cat=0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x60(%rdi), %rax
movq %rax, 0x30(%rdi)
movq $0x1, 0x38(%rdi)
xorps %xmm1, %xmm1
movups %xmm1, 0x40(%rdi)
movl $0x3f800000, 0x50(%rdi) # imm = 0x3F800000
movups %xmm1, 0x58(%rdi)
movq $0x0, (%rdi)
movups %xmm1, 0x20(%rdi)
movsd %xmm0, 0x10(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ashlall[P]StreamStats/Test/./../SourceCode/ChiSquare/ChiSquareCategorical.cpp
// Function: ChiSquareCategorical::insert(double)
void ChiSquareCategorical::insert(double c)
{
	stream_size++;
	HashTable HashA(71);
	long hash_value= HashA.hash(c);
	if(hash_value<((percent/100)*range))
	{	
		if(map.count(hash_value)<1)
		{	
			map.emplace(hash_value,1);
			num_cat++;
		}
		else
		{
			long cat_count=map.at(hash_value);
			cat_count++;
			map.at(hash_value)=cat_count;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
incl 0x20(%rdi)
cvttsd2si %xmm0, %rax
movl %eax, %ecx
shll $0x8, %ecx
addl %ecx, %eax
addl $0x479ab41d, %eax       # imm = 0x479AB41D
movl %eax, %ecx
shrl $0x5, %ecx
xorl %eax, %ecx
xorl $0xe4aa10ce, %ecx       # imm = 0xE4AA10CE
movl %ecx, %eax
shll $0xe, %eax
negl %eax
addl %ecx, %eax
addl $0x9942f0a6, %eax       # imm = 0x9942F0A6
movl %eax, %ecx
shrl $0x3, %ecx
xorl %eax, %ecx
xorl $0x5aedd67d, %ecx       # imm = 0x5AEDD67D
movl %ecx, %eax
shll $0x7, %eax
addl %ecx, %eax
addl $0x17bea992, %eax       # imm = 0x17BEA992
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x10(%rdi), %xmm1
divsd 0x1c08(%rip), %xmm1     # 0x3008
cvtsi2sdq 0x28(%rdi), %xmm2
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x1466
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x268a
testq %rax, %rax
je 0x144d
leaq -0x20(%rbp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29de
movl (%rax), %r15d
incl %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29de
movl %r15d, (%rax)
jmp 0x1466
leaq -0x24(%rbp), %rdx
movl $0x1, (%rdx)
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x2716
incl 0x24(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ashlall[P]StreamStats/Test/Chi_Square_Categorical_test.cpp
// Function: categorical_test5()
void categorical_test5()
{
		
	ChiSquareCategorical c1(10);
	ChiSquareCategorical c2(10);
	int num_cat=10000;
	int df=0;
	for(int i=0;i<num_cat;i++)
	{
		int v1= (int)(rand() % 250+50);
		int max_dif= 28;
		int v2= v1-max_dif+rand()%(2*max_dif+1);
	
		for(int j=0;j<v1;j++)
			c1.insert(i);
				
		for(int k=0;k<v2;k++)
			c2.insert(i);
	}
	
	
	double chi=c1.calculate_statistic(c2,df);
	cout<<chi<<endl;
	cout<<1-pochisq(chi,df--);
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq -0xa8(%rbp), %rax
movq %rax, -0x30(%rax)
movl $0x1, %ecx
movq %rcx, -0x28(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, -0x20(%rax)
movl $0x3f800000, %edx       # imm = 0x3F800000
movl %edx, -0x10(%rax)
movupd %xmm0, -0x8(%rax)
xorl %ebx, %ebx
movq %rbx, -0x60(%rax)
movupd %xmm0, -0x40(%rax)
movabsq $0x4024000000000000, %rsi # imm = 0x4024000000000000
movq %rsi, -0x50(%rax)
movabsq $0x100000000, %rdi      # imm = 0x100000000
movq %rdi, -0x38(%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rax)
movq %rcx, -0x28(%rax)
movupd %xmm0, -0x20(%rax)
movl %edx, -0x10(%rax)
movupd %xmm0, -0x8(%rax)
movq %rbx, -0x60(%rax)
movupd %xmm0, -0x40(%rax)
movq %rsi, -0x50(%rax)
movq %rdi, -0x38(%rax)
leaq -0x108(%rbp), %r15
leaq -0xa0(%rbp), %r12
callq 0x1050
movslq %eax, %r14
imulq $0x10624dd3, %r14, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
sarl $0x4, %eax
addl %ecx, %eax
imull $0xfa, %eax, %eax
subl %eax, %r14d
callq 0x1050
movl %eax, -0x2c(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x38(%rbp)
cmpl $-0x31, %r14d
jl 0x2506
leal 0x32(%r14), %r13d
movq %r15, %rdi
movsd -0x38(%rbp), %xmm0
callq 0x1392
decl %r13d
jne 0x24f4
movslq -0x2c(%rbp), %rax
imulq $-0x7047dc11, %rax, %rcx # imm = 0x8FB823EF
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x39, %ecx, %ecx
subl %ecx, %eax
addl %eax, %r14d
addl $0x16, %r14d
testl %r14d, %r14d
jle 0x2544
movq %r12, %rdi
movsd -0x38(%rbp), %xmm0
callq 0x1392
decl %r14d
jne 0x2532
incl %ebx
cmpl $0x2710, %ebx           # imm = 0x2710
jne 0x24ae
leaq -0x108(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
xorl %edx, %edx
callq 0x1472
movq 0x2a6a(%rip), %rdi      # 0x4fd8
callq 0x1190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1110
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq 0x2a34(%rip), %rdi      # 0x4fd8
xorpd %xmm0, %xmm0
callq 0x1190
leaq -0x70(%rbp), %rdi
callq 0x2606
leaq -0xd8(%rbp), %rdi
callq 0x2606
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25d8
jmp 0x25d8
movq %rax, %r15
leaq -0x70(%rbp), %rdi
callq 0x2606
leaq -0xd8(%rbp), %rdi
callq 0x2606
movq %r15, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_26.cc
// Function: main
int main(int argc, char const *argv[])
{
	allocator<string> alloc;
	string* const p = alloc.allocate(SIZE);

	string s;
	auto q = p;

	while (cin >> s && q != p + SIZE) {
		alloc.construct(q++, s);
	}

	for (auto r = p; r != q; ++r) {
		cout << *r << endl;
		alloc.destroy(r);
	}

	alloc.deallocate(p, SIZE);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x140, %edi            # imm = 0x140
callq 0x1090
movq %rax, %r14
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r13d, %r13d
movq 0x2d65(%rip), %r15      # 0x3fe0
leaq -0x50(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x10c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12ce
cmpq $0x140, %r13            # imm = 0x140
je 0x12ce
leaq (%r14,%r13), %rdi
leaq 0x20(%r13), %rbx
leaq (%r14,%r13), %rax
addq $0x10, %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx,%r13)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
callq 0x139e
movq %rbx, %r13
jmp 0x127f
testq %r13, %r13
je 0x133f
addq $0x10, %r14
xorl %r15d, %r15d
movq 0x2cef(%rip), %rbx      # 0x3fd0
movq -0x10(%r14,%r15), %rsi
movq -0x8(%r14,%r15), %rdx
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq (%r14,%r15), %rax
movq -0x10(%r14,%r15), %rdi
cmpq %rdi, %rax
je 0x1336
movq (%rax), %rsi
incq %rsi
callq 0x10a0
addq $0x20, %r15
cmpq %r15, %r13
jne 0x12e1
movl $0x140, %esi            # imm = 0x140
movq -0x30(%rbp), %rdi
callq 0x10a0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1366
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x10a0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1379
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1395
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x10a0
movq %rbx, %rdi
callq 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/milenage.h
// Function: milenage_f1(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char*, unsigned char*)
bool milenage_f1(const u8 *opc, const u8 *k, const u8 *_rand,
                 const u8 *sqn, const u8 *amf, u8 *mac_a, u8 *mac_s) {
  u8 tmp1[16], tmp2[16], tmp3[16];
  int i;

  /* tmp1 = TEMP = E_K(RAND XOR OP_C) */
  for (i = 0; i < 16; i++)
    tmp1[i] = _rand[i] ^ opc[i];

  aes_128_encrypt_block(k, tmp1, tmp1);
  /* tmp2 = IN1 = SQN || AMF || SQN || AMF */
  memcpy(tmp2, sqn, 6);
  memcpy(tmp2 + 6, amf, 2);
  memcpy(tmp2 + 8, tmp2, 8);

  /* OUT1 = E_K(TEMP XOR rot(IN1 XOR OP_C, r1) XOR c1) XOR OP_C */

  /* rotate (tmp2 XOR OP_C) by r1 (= 0x40 = 8 bytes) */
  for (i = 0; i < 16; i++)
    tmp3[(i + 8) % 16] = tmp2[i] ^ opc[i];

  /* XOR with TEMP = E_K(RAND XOR OP_C) */
  for (i = 0; i < 16; i++)
    tmp3[i] ^= tmp1[i];

  /* XOR with c1 (= ..00, i.e., NOP) */
  /* f1 || f1* = E_K(tmp3) XOR OP_c */
  aes_128_encrypt_block(k, tmp3, tmp1);

  for (i = 0; i < 16; i++)
    tmp1[i] ^= opc[i];

  if (mac_a)
    memcpy(mac_a, tmp1, 8); /* f1 */

  if (mac_s)
    memcpy(mac_s, tmp1 + 8, 8); /* f1* */

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
movb (%r14,%rax), %cl
xorb (%rdx,%rax), %cl
movb %cl, -0x40(%rbp,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x3f7e
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x4043
movzwl 0x4(%r13), %eax
movw %ax, -0x4c(%rbp)
movl (%r13), %eax
movl %eax, -0x50(%rbp)
movzwl (%r12), %eax
movw %ax, -0x4a(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movb (%r14,%rax), %cl
xorb -0x50(%rbp,%rax), %cl
movq %rax, %rdx
xorq $0x8, %rdx
movb %cl, -0x60(%rbp,%rdx)
incq %rax
cmpq $0x10, %rax
jne 0x3fc4
xorl %eax, %eax
movb -0x40(%rbp,%rax), %cl
xorb %cl, -0x60(%rbp,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x3fe2
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x4043
xorl %eax, %eax
movb (%r14,%rax), %cl
xorb %cl, -0x40(%rbp,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x4005
testq %rbx, %rbx
je 0x4022
movq -0x40(%rbp), %rax
movq %rax, (%rbx)
movq 0x10(%rbp), %rcx
testq %rcx, %rcx
je 0x4032
movq -0x38(%rbp), %rax
movq %rax, (%rcx)
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/milenage.h
// Function: milenage_generate(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char*, unsigned char*, unsigned char*, unsigned char*)
bool milenage_generate(const u8 *opc, const u8 *amf, const u8 *k,
                       const u8 *sqn, const u8 *_rand, u8 *autn, u8 *ik,
                       u8 *ck, u8 *res) {
  int i;
  u8 mac_a[8], ak[6];

  if (!milenage_f1(opc, k, _rand, sqn, amf, mac_a, NULL) ||
      !milenage_f2345(opc, k, _rand, res, ck, ik, ak, NULL))
    return false;

  /* AUTN = (SQN ^ AK) || AMF || MAC */
  for (i = 0; i < 6; i++)
    autn[i] = sqn[i] ^ ak[i];

  memcpy(autn + 6, amf, 2);
  memcpy(autn + 8, mac_a, 8);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %rax
movq %r8, -0x38(%rbp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r8
movq %rdi, %r15
subq $0x8, %rsp
xorl %r12d, %r12d
leaq -0x48(%rbp), %r9
movq %rdx, %rsi
movq %rax, %rdx
movq %r8, -0x40(%rbp)
pushq %r12
callq 0x3f5c
addq $0x10, %rsp
leaq -0x2e(%rbp), %rax
movq %r15, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %r9
pushq %r12
pushq %rax
callq 0x43b2
addq $0x10, %rsp
movb -0x2e(%rbp,%r12), %al
xorb (%r14,%r12), %al
movb %al, (%rbx,%r12)
incq %r12
cmpq $0x6, %r12
jne 0x45bb
movq -0x40(%rbp), %rax
movzwl (%rax), %eax
movw %ax, 0x6(%rbx)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rbx)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/milenage.h
// Function: milenage_auts(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char*)
bool milenage_auts(const u8 *opc, const u8 *k, const u8 *_rand, const u8 *auts,
                   u8 *sqn) {
  u8 amf[2] = { 0x00, 0x00 }; /* TS 33.102 v7.0.0, 6.3.3 */
  u8 ak[6], mac_s[8];
  int i;

  if (!milenage_f2345(opc, k, _rand, NULL, NULL, NULL, NULL, ak))
    return false;

  for (i = 0; i < 6; i++)
    sqn[i] = auts[i] ^ ak[i];

  if (!milenage_f1(opc, k, _rand, sqn, amf, NULL, mac_s) ||
      memcmp(mac_s, auts + 6, 8) != 0)
    return false;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movw $0x0, -0x2a(%rbp)
leaq -0x30(%rbp), %rax
xorl %r15d, %r15d
movq %rdx, -0x38(%rbp)
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq $0x0
callq 0x43b2
addq $0x10, %rsp
movb -0x30(%rbp,%r15), %al
xorb (%rbx,%r15), %al
movb %al, (%r14,%r15)
incq %r15
cmpq $0x6, %r15
jne 0x4637
subq $0x8, %rsp
leaq -0x40(%rbp), %r15
leaq -0x2a(%rbp), %r8
movq %r13, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rcx
xorl %r9d, %r9d
pushq %r15
callq 0x3f5c
addq $0x10, %rsp
movq (%r15), %rax
cmpq 0x6(%rbx), %rax
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/milenage.h
// Function: milenage_opc_gen(unsigned char const*, unsigned char const*, unsigned char*)
void milenage_opc_gen(const u8 *k, const u8 *op, u8 *opc) {
  int i;
  /* Encrypt OP using K */
  aes_128_encrypt_block(k, op, opc);

  /* XOR the resulting Ek(OP) with OP */
  for (i = 0; i < 16; i++)
    opc[i] = opc[i] ^ op[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4043
xorl %eax, %eax
movb (%r14,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x46fb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/src/program_uicc.c
// Function: setOPc(uicc_vals&)
void setOPc(struct uicc_vals &values) {
    string key;
    Assert(makeBin(values.key, key) == 16, "can't read a correct key: 16 hexa figures\n");
    string op;
    Assert(makeBin(values.op, op) == 16, "can't read a correct op: 16 hexa figures\n");
    uint8_t opc[16];
    milenage_opc_gen((const uint8_t *)key.c_str(),
                     (const uint8_t *)op.c_str(),
                     opc);

    for (int i=0 ; i<16; i++) {
        char tmp[8];
        sprintf(tmp,"%02hhx",opc[i]);
        values.opc+= tmp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0xb0(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0xe8(%rdi), %rsi
movq 0xf0(%rdi), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %rdi
callq 0x1372a
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x924f
movl %eax, %r14d
movq -0xc0(%rbp), %rdi
cmpq %r15, %rdi
je 0x90e2
callq 0x2220
cmpl $0x10, %r14d
jne 0x91ec
leaq -0x90(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x88(%rbx), %rsi
movq 0x90(%rbx), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x1372a
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x924f
movl %eax, %r14d
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x9147
callq 0x2220
cmpl $0x10, %r14d
jne 0x91f1
movq -0x48(%rbp), %rdi
movq -0xa0(%rbp), %r14
leaq -0x60(%rbp), %rdx
movq %r14, %rsi
callq 0x4043
xorl %eax, %eax
movb (%r14,%rax), %cl
xorb %cl, -0x60(%rbp,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x916a
addq $0x68, %rbx
leaq 0xedf4(%rip), %r14      # 0x17f7a
leaq -0xc8(%rbp), %r15
xorl %r12d, %r12d
movzbl -0x60(%rbp,%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2090
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2450
incq %r12
cmpq $0x10, %r12
jne 0x9190
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
je 0x91c8
callq 0x2220
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x91da
callq 0x2220
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x384e
callq 0x38b2
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x9224
callq 0x2220
jmp 0x9224
jmp 0x9221
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r15, %rdi
jne 0x9230
jmp 0x9235
movq %rax, %rbx
jmp 0x9235
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
je 0x9235
callq 0x2220
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9247
callq 0x2220
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/src/program_uicc.c
// Function: makeBin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
static inline int makeBin(string in, string &out) {
    out="";

    if ( in.size() %2 == 1)
        return -1;

    for (size_t i=0; i<in.size(); i++) {
        uint8_t tmp=255;

        if (in[i] >= '0' && in[i]<= '9')
            tmp=in[i]-'0';

        if (in[i] >= 'a' && in[i]<= 'f')
            tmp=in[i]-'a'+10;

        if (in[i] >= 'A' && in[i]<= 'F')
            tmp=in[i]-'A'+10;

        if (tmp == 255)
            return -1;

        i++;

        if (in[i] >= '0' && in[i] <= '9') {
            out+=(unsigned char) ((in[i]-'0') | tmp <<4);
            continue;
        }

        if (in[i] >= 'a' && in[i] <= 'f') {
            out+=(unsigned char) ((in[i]-'a'+10) | tmp <<4);
            continue;
        }

        if (in[i] >= 'A' && in[i] <= 'F') {
            out+=(unsigned char) ((in[i]-'A'+10) | tmp <<4);
            continue;
        }

        return -1;
    }

    return in.size()/2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
leaq 0xf144(%rip), %rcx      # 0x183b2
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x23d0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb $0x1, 0x8(%rbx)
jne 0x933d
cmpq $0x0, 0x8(%rbx)
setne %r12b
je 0x9336
xorl %r13d, %r13d
movq (%rbx), %rcx
movb (%rcx,%r13), %al
leal -0x30(%rax), %edx
cmpb $0xa, %dl
movzbl %dl, %edx
movl $0xff, %esi
cmovael %esi, %edx
leal -0x61(%rax), %esi
leal -0x57(%rax), %edi
cmpb $0x6, %sil
movzbl %dil, %esi
cmovael %edx, %esi
leal -0x41(%rax), %edx
addb $-0x37, %al
cmpb $0x6, %dl
movzbl %al, %eax
cmovael %esi, %eax
cmpb $-0x1, %al
je 0x9317
movb 0x1(%rcx,%r13), %cl
incq %r13
leal -0x30(%rcx), %esi
movb $-0x30, %dl
cmpb $0xa, %sil
jb 0x9301
leal -0x61(%rcx), %esi
movb $-0x57, %dl
cmpb $0x6, %sil
jb 0x9301
leal -0x41(%rcx), %esi
movb $-0x37, %dl
cmpb $0x5, %sil
ja 0x9317
addb %dl, %cl
shlb $0x4, %al
orb %cl, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x2200
movb $0x1, %al
jmp 0x9319
xorl %eax, %eax
testb %al, %al
je 0x9330
incq %r13
cmpq 0x8(%rbx), %r13
setb %r12b
jb 0x929d
jmp 0x9336
testb $0x1, %r12b
jne 0x933d
movq 0x8(%rbx), %r14
shrq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: UICC::open[abi:cxx11](char*)
string open(char *portname) {
        Assert( (fd=::open(portname, O_RDWR | O_NOCTTY | O_SYNC)) >=0,
                "Failed to open %s", portname);
        struct termios tty;
        Assert (tcgetattr(fd, &tty) >= 0, "");
        tty.c_cflag &= ~( CSIZE );
        tty.c_cflag |= CLOCAL | CREAD | CS8 | PARENB | CSTOPB | HUPCL ;
        /* setup for non-canonical mode */
        tty.c_iflag &= ~(IGNBRK | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
        tty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
        tty.c_oflag &= ~OPOST;
        /* fetch bytes as they become available */
        tty.c_cc[VMIN] = 0;
        tty.c_cc[VTIME] = 1;
        cfsetispeed(&tty, (speed_t)B9600);
        cfsetospeed(&tty, (speed_t)B9600);
        Assert (tcsetattr(fd, TCSANOW, &tty) == 0,"");
        // reset the UICC
        int iFlags;
        iFlags = 0 ;
        // turn off DTR
        ioctl(fd, TIOCMSET, &iFlags);
        struct timespec t= {0,1000*1000*100};
        nanosleep(&t,NULL);
        iFlags = 0xFFFF;
        // turn on DTR
        //iFlags = TIOCM_CTS  ;
        //ioctl(fd, TIOCMSET, &iFlags);
        return this->read();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
movl $0x101102, %esi         # imm = 0x101102
xorl %eax, %eax
callq 0x21c0
movl %eax, 0x4(%r14)
testl %eax, %eax
js 0xa901
leaq -0x6c(%rbp), %rsi
movl %eax, %edi
callq 0x22a0
testl %eax, %eax
js 0xa909
leaq -0x6c(%rbp), %r15
orl $0xdf0, 0x8(%r15)       # imm = 0xDF0
andl $0xfffffa16, (%r15)     # imm = 0xFFFFFA16
andl $0xffff7fb4, 0xc(%r15)  # imm = 0xFFFF7FB4
andb $-0x2, 0x4(%r15)
movw $0x1, 0x16(%r15)
movq %r15, %rdi
movl $0xd, %esi
callq 0x2160
movq %r15, %rdi
movl $0xd, %esi
callq 0x2290
movl 0x4(%r14), %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2330
testl %eax, %eax
jne 0xa90e
leaq -0x1c(%rbp), %r15
movl $0x0, (%r15)
movl 0x4(%r14), %edi
movl $0x5418, %esi           # imm = 0x5418
movq %r15, %rdx
xorl %eax, %eax
callq 0x2350
movups 0xa752(%rip), %xmm0     # 0x15020
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x20c0
movl $0xffff, (%r15)         # imm = 0xFFFF
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %r14, %rsi
callq 0xde7c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x24fc
callq 0x256a
callq 0x25ce
nop
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: UICC::decodeIMSI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string decodeIMSI(string raw) {
        //int l=raw.c_str()[0];
        string imsi=bcdToAscii(raw.substr(1)); // First byte is length
        //IMSI length bytes, then parity is second byte
        return imsi.substr(1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rsi
movq %rdi, %rbx
leaq -0x40(%rbp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq $-0x1, %rcx
callq 0x2270
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpq $0x0, 0x8(%r14)
je 0xa9a3
xorl %r12d, %r12d
leaq -0x60(%rbp), %r14
movq -0x40(%rbp), %rax
movb (%rax,%r12), %al
andb $0xf, %al
orb $0x30, %al
cmpb $0x39, %al
ja 0xa97e
movzbl %al, %esi
movq %r14, %rdi
callq 0x2200
movq -0x40(%rbp), %rax
movb (%rax,%r12), %al
shrb $0x4, %al
orb $0x30, %al
cmpb $0x39, %al
ja 0xa99a
movzbl %al, %esi
movq %r14, %rdi
callq 0x2200
incq %r12
cmpq -0x38(%rbp), %r12
jb 0xa963
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa9b5
callq 0x2220
leaq -0x60(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x2270
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xa9db
callq 0x2220
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
jne 0xaa17
jmp 0xaa1c
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xaa0a
callq 0x2220
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa1c
callq 0x2220
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: UICC::decodeISDN(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string decodeISDN(string raw) {
        // ISDN is in last 14 bytes
        string isdn=raw.substr(raw.size()-14);
        char isdnLength=isdn[0];
        //char TON=isdn[1]; // should be 0x81
        // two last bytes should be FF (capability , extensions)
        return bcdToAscii(isdn.substr(2,isdnLength));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rax
addq $-0xe, %rax
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x2270
movq (%r14), %rax
movsbq (%rax), %rcx
leaq -0x38(%rbp), %rdi
movl $0x2, %edx
movq %r14, %rsi
callq 0x2270
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
cmpq $0x0, -0x30(%rbp)
je 0xb0c8
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movb (%rax,%r14), %al
andb $0xf, %al
orb $0x30, %al
cmpb $0x39, %al
ja 0xb0a3
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2200
movq -0x38(%rbp), %rax
movb (%rax,%r14), %al
shrb $0x4, %al
orb $0x30, %al
cmpb $0x39, %al
ja 0xb0bf
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2200
incq %r14
cmpq -0x30(%rbp), %r14
jb 0xb088
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb0da
callq 0x2220
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb0ec
callq 0x2220
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xb121
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb10f
callq 0x2220
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb121
callq 0x2220
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb133
callq 0x2220
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: UICC::encodeIMSI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> encodeIMSI(string imsi) {
        vector<string> encoded;
        encoded.push_back("");

        if (imsi.size() %2 ==1 ) {
            encoded[0]+=(char)(imsi.size()/2 + 1);
            encoded[0]+=(char)(9 | (imsi[0]-'0')<<4);
        } else {
            encoded[0]+=(char)(imsi.size()/2);
            encoded[0]+=(char)(1 | (imsi[0]-'0')<<4);
        }

        encoded[0]+=makeBcd(imsi.substr(1));
        return encoded;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc140(%rip), %rdx      # 0x183b2
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x137c4
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1385e
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xc298
callq 0x2220
movq 0x8(%r14), %rcx
movl %ecx, %eax
shrl %eax
testb $0x1, %cl
jne 0xc2b5
movq (%rbx), %rdi
movb $0x1, %r12b
movsbl %al, %esi
callq 0x2200
jmp 0xc2c5
incb %al
movq (%rbx), %rdi
movb $0x9, %r12b
movsbl %al, %esi
callq 0x2200
movq (%r14), %rax
movb (%rax), %al
shlb $0x4, %al
orb %r12b, %al
movq (%rbx), %rdi
movsbl %al, %esi
callq 0x2200
leaq -0x60(%rbp), %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x2270
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x6c5a
movq (%rbx), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x20d0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xc325
callq 0x2220
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc337
callq 0x2220
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xc35d
callq 0x2220
jmp 0xc35d
movq %rax, %r14
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xc37a
jmp 0xc386
jmp 0xc383
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xc386
callq 0x2220
jmp 0xc386
jmp 0xc383
movq %rax, %r14
movq %rbx, %rdi
callq 0xafd4
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: UICC::encodeMccMnc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string encodeMccMnc(string Mcc, string Mnc, int len=0) {
        string out;
        out=makeBcd(Mcc);
        out+=makeBcd(Mnc, true, len>2?len-2:0);
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r14d
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq -0x80(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %rdi
callq 0x1372a
leaq -0x50(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x6c5a
leaq -0x50(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2320
movq (%r12), %rdi
leaq -0x40(%rbp), %r12
cmpq %r12, %rdi
je 0xc41d
callq 0x2220
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0xc42e
callq 0x2220
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x1372a
leal -0x2(%r14), %eax
xorl %ecx, %ecx
cmpl $0x3, %r14d
cmovgel %eax, %ecx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x1, %edx
callq 0x6c5a
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xc486
callq 0x2220
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0xc494
callq 0x2220
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xc4bc
callq 0x2220
jmp 0xc4bc
movq %rax, %r14
movq -0x70(%rbp), %rdi
jmp 0xc4ce
jmp 0xc4da
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %r13, %rdi
je 0xc4dd
callq 0x2220
jmp 0xc4dd
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xc4eb
callq 0x2220
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: UICC::encodeISDN(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
vector<string> encodeISDN(string isdn, int recordLenght) {
        vector<string> encoded;
        encoded.push_back("");

        for (int i=0; i < recordLenght-14 ; i++)
            encoded[0]+='\xff';

        encoded[0]+=makeBcd(isdn).size();
        encoded[0]+='\x81'; //add TON field
        encoded[0]+=makeBcd(isdn);

        for (int i=encoded.size(); i<recordLenght; i++)
            encoded[0]+='\xff';

        return encoded;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xbdc8(%rip), %rdx      # 0x183b2
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x137c4
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1385e
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xc610
callq 0x2220
cmpl $0xf, %r14d
jl 0xc62c
leal -0xe(%r14), %r13d
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2200
decl %r13d
jne 0xc61a
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x1372a
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x6c5a
movsbl -0x40(%rbp), %esi
movq (%rbx), %rdi
callq 0x2200
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xc67b
callq 0x2220
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xc68c
callq 0x2220
movq (%rbx), %rdi
movl $0xffffff81, %esi       # imm = 0xFFFFFF81
callq 0x2200
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x1372a
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x6c5a
movq (%rbx), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x20d0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xc6e6
callq 0x2220
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xc6f4
callq 0x2220
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x5, %rax
subl %eax, %r14d
jle 0xc716
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2200
decl %r14d
jne 0xc704
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xc73e
callq 0x2220
jmp 0xc73e
movq %rax, %r14
movq -0x68(%rbp), %rdi
jmp 0xc765
jmp 0xc785
jmp 0xc785
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xc75e
callq 0x2220
jmp 0xc75e
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
jne 0xc77a
jmp 0xc788
jmp 0xc785
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xc788
callq 0x2220
jmp 0xc788
jmp 0xc785
jmp 0xc785
movq %rax, %r14
movq %rbx, %rdi
callq 0xafd4
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: USIM::fileRecordSize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int fileRecordSize(string filename) {
        openFile(filename);

        if (fileDesc.size() <= 2)
            return -1;

        return fileDesc[3];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1372a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11440
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xce90
callq 0x2220
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x3, 0x30(%rbx)
jb 0xcea4
movq 0x28(%rbx), %rax
movsbl 0x3(%rax), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xcec0
callq 0x2220
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/FFY00[P]uicc/include/uicc.h
// Function: UICC::verifyChv(char, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool verifyChv(char cla, char chv, string pwd) {
        string order;
        order+=cla;
        order+=string(u8"\x20\x00",2);
        order+=chv;
        order+=(char)8;
        order+=pwd;

        for (int i=pwd.size(); i<8 ; i++)
            order+='\xff';

        string answer (u8"\x90\x00",2);
        return send_check(order, answer);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movl %edx, %r12d
movq %rdi, %r14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x68(%rbp), %rdi
callq 0x2200
leaq -0x38(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movw $0x20, (%rbx)
movq $0x2, -0x8(%rbx)
movb $0x0, 0x2(%rbx)
leaq -0x68(%rbp), %rdi
movl $0x2, %edx
movq %rbx, %rsi
callq 0x20d0
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x13521
callq 0x2220
movsbl %r12b, %esi
leaq -0x68(%rbp), %rdi
callq 0x2200
leaq -0x68(%rbp), %rdi
movl $0x8, %esi
callq 0x2200
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq -0x68(%rbp), %rdi
callq 0x20d0
movl 0x8(%r15), %r12d
cmpl $0x7, %r12d
jg 0x13570
addl $-0x8, %r12d
leaq -0x68(%rbp), %r15
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2200
incl %r12d
jne 0x1355e
movq %rbx, -0x48(%rbp)
movw $0x90, -0x38(%rbp)
movq $0x2, -0x40(%rbp)
movb $0x0, -0x36(%rbp)
leaq -0x98(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x1372a
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x1372a
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %r14, %rdi
callq 0xe8a6
movl %eax, %r14d
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x135f2
callq 0x2220
movq -0xa8(%rbp), %rdi
cmpq %r15, %rdi
je 0x13603
callq 0x2220
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x13611
callq 0x2220
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x1361f
callq 0x2220
movl %r14d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x1364d
callq 0x2220
jmp 0x1364d
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %r15, %rdi
je 0x13665
callq 0x2220
jmp 0x13665
jmp 0x13662
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1367a
callq 0x2220
jmp 0x1367a
jmp 0x13677
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x13688
callq 0x2220
movq %r14, %rdi
callq 0x2400