LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/RuiDGPires[P]CrimLang/src/semantic_analiser.cpp
// Function: sc_Tracker::cas(crl::Node*)
void _sc_Tracker::cas(crl::Node *node){
	Context::Item item;
	item.type = Context::Item::Type::CAS;
	item.subtype = ((crl::Leaf *)node->get_child(0))->token.str;
	item.name = ((crl::Leaf *)node->get_child(1))->token.str;

	i32 i;
	for (i = 2; node->get_child(i)->type == crl::Node::Type::ARG; i++){
		crl::Node *arg = node->get_child(i);
		std::string var_type = ((crl::Leaf *) arg->get_child(0))->token.str;

		item.args.push_back(std::pair<std::string, bool>(var_type, arg->annotation == "mut"));
	}

	node->argc = i - 2;
	this->add(item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb0(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x90(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movb %cl, 0x10(%rax)
andl $0x0, 0x14(%rax)
movb %cl, 0x18(%rax)
andq $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movl $0x2, -0x38(%rax)
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x18(%rax)
leaq -0xa0(%rbp), %rdi
addq $0x58, %rax
movq %rax, %rsi
callq 0x3160
movq (%r14), %rax
pushq $0x1
popq %rsi
movq %r14, %rdi
callq *0x18(%rax)
leaq -0xc0(%rbp), %rdi
addq $0x58, %rax
movq %rax, %rsi
callq 0x3160
movq %rbx, -0x30(%rbp)
xorl %r13d, %r13d
leaq -0xe8(%rbp), %r12
leaq -0x58(%rbp), %rbx
leal 0x2(%r13), %r15d
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
callq *0x18(%rax)
cmpl $0x12, 0x8(%rax)
jne 0xf7ac
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
callq *0x18(%rax)
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
xorl %esi, %esi
callq *0x18(%rax)
addq $0x58, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0x32f0
addq $0x30, %r15
movq %r15, %rdi
leaq 0x5cdf(%rip), %rsi      # 0x15450
callq 0x410a
movl %eax, %r15d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32f0
movb %r15b, -0x38(%rbp)
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x12f22
movq %rbx, %rdi
callq 0x3110
movq %r12, %rdi
callq 0x3110
incl %r13d
jmp 0xf724
movl %r13d, 0x50(%r14)
leaq -0x158(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x4444
leaq -0x158(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xf562
leaq -0x158(%rbp), %rdi
callq 0x44c8
leaq -0xc8(%rbp), %rdi
callq 0x44c8
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x158(%rbp), %rdi
callq 0x44c8
jmp 0xf838
jmp 0xf835
jmp 0xf835
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3110
jmp 0xf823
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x3110
jmp 0xf838
jmp 0xf835
jmp 0xf835
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x44c8
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
callq 0xf4f8
movq 0x18(%r15), %rbx
subq 0x10(%r15), %rbx
sarq $0x3, %rbx
xorl %r12d, %r12d
leaq -0x58(%rbp), %r13
cmpq %r12, %rbx
je 0xfd28
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x18(%rax)
movq %rax, %r14
movq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0x32f0
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x10c62
movq %r13, %rdi
callq 0x3110
incq %r12
jmp 0xfcec
movq -0x30(%rbp), %rdi
callq 0xf538
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r12
subq 0x10(%rsi), %r12
sarq $0x3, %r12
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x128d9
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *0x18(%rax)
movl 0x8(%rax), %ecx
cmpl $0x2, %ecx
je 0x128c9
cmpl $0x3, %ecx
je 0x128bc
cmpl $0x11, %ecx
jne 0x128e6
movq %r14, %rdi
movq %rax, %rsi
callq 0xf678
jmp 0x128d4
movq %r14, %rdi
movq %rax, %rsi
callq 0xf84c
jmp 0x128d4
movq %r14, %rdi
movq %rax, %rsi
callq 0xfd54
incq %r15
jmp 0x1288c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %rbx
leaq 0x3419(%rip), %rsi      # 0x15d11
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x3be4
movb $0x1, %r15b
pushq $-0x1
popq %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
movl %edx, %esi
callq 0x4e88
xorl %r15d, %r15d
leaq 0xb46d(%rip), %rsi      # 0x1dd90
leaq -0xd9f2(%rip), %rdx     # 0x4f38
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x3110
testb %r15b, %r15b
jne 0x12948
jmp 0x12950
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xd8, %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 0x12868
movq 0x8(%rbx), %rbx
leaq 0x33ba(%rip), %rsi      # 0x15d49
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3be4
leaq -0xf0(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %rbx, %rsi
callq 0x4172
leaq -0x40(%rbp), %rdi
callq 0x3110
cmpl $0x1, -0xf0(%rbp)
jne 0x129f2
leaq -0xc8(%rbp), %rdi
leaq 0x2cc4(%rip), %rsi      # 0x15693
callq 0x410a
testb %al, %al
je 0x12a40
leaq -0xf0(%rbp), %rdi
callq 0x44c8
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %rbx
leaq 0x334a(%rip), %rsi      # 0x15d4e
leaq -0x80(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3be4
movb $0x1, %r15b
pushq $-0x1
popq %rdx
leaq -0x80(%rbp), %rcx
movq %rbx, %rdi
movl %edx, %esi
callq 0x4e88
xorl %r15d, %r15d
leaq 0xb361(%rip), %rsi      # 0x1dd90
leaq -0xdafe(%rip), %rdx     # 0x4f38
movq %rbx, %rdi
callq 0x33f0
jmp 0x12a8c
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %rbx
leaq 0x32fc(%rip), %rsi      # 0x15d4e
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3be4
movb $0x1, %r15b
pushq $-0x1
popq %rdx
leaq -0x60(%rbp), %rcx
movq %rbx, %rdi
movl %edx, %esi
callq 0x4e88
xorl %r15d, %r15d
leaq 0xb313(%rip), %rsi      # 0x1dd90
leaq -0xdb4c(%rip), %rdx     # 0x4f38
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x12a9e
jmp 0x12aaa
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x3110
testb %r15b, %r15b
jne 0x12aad
jmp 0x12ab5
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
leaq -0xf0(%rbp), %rdi
callq 0x44c8
jmp 0x12ad4
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x12ad4
movq %rax, %r14
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
andl $0x0, 0x20(%rdi)
leaq 0x1f0f(%rip), %rsi      # 0x154e4
callq 0x3450
andq $0x0, 0x24(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x290(%rbp), %r15
movq %r15, %rdi
callq 0x3280
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3200
leaq -0x88(%rbp), %rdi
callq 0x146ee
leaq -0x290(%rbp), %r14
leaq -0x21(%rbp), %r15
leaq -0x88(%rbp), %r12
movq -0x290(%rbp), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, -0x278(%rbp,%rax) # imm = 0xFFFFEFFF
movq %r14, %rdi
movq %r15, %rsi
callq 0x32d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movsbl -0x21(%rbp), %esi
jne 0x1462c
movq %r12, %rdi
callq 0x13d24
jmp 0x145ef
leaq -0x88(%rbp), %rdi
callq 0x13d24
leaq -0x88(%rbp), %rdi
callq 0x13cfe
leaq -0x290(%rbp), %rdi
callq 0x3070
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xc200
leaq -0x88(%rbp), %rdi
callq 0x14724
leaq -0x290(%rbp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14689
movq %rax, %rbx
jmp 0x1469f
jmp 0x14690
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x14724
leaq -0x290(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x1050, %rsp           # imm = 0x1050
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
xorl %r12d, %r12d
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
xorl %esi, %esi
callq 0x21450
testl %r15d, %r15d
cmovgl %r15d, %r12d
subl $0x1, %r12d
jb 0x255db
movq %r14, %rdi
callq 0x21340
movw $0x2020, 0x50(%rsp,%rax) # imm = 0x2020
movb $0x0, 0x52(%rsp,%rax)
jmp 0x255bf
movq %rbx, %rdi
callq 0x25bf6
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x62142
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x37a5e
movq 0x8(%rbx), %r15
leaq 0x9dd9d(%rip), %rdi     # 0xc33a3
leaq 0x50(%rsp), %r14
movq %r14, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x21080
movl 0x1c(%rbx), %edx
leaq 0x9dd90(%rip), %rdi     # 0xc33b1
movq %r14, %rsi
xorl %eax, %eax
callq 0x21080
testq %r15, %r15
je 0x25647
movl 0x8(%r15), %edx
leaq 0x9dd89(%rip), %rdi     # 0xc33c4
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 0x9dbd8(%rip), %rdi     # 0xc3249
leaq 0x50(%rsp), %r14
movq %r14, %rsi
movb $0x6, %al
callq 0x21080
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
leaq 0x9db98(%rip), %rdi     # 0xc3230
movq %r14, %rsi
movb $0x3, %al
callq 0x21080
pushq $0xa
popq %rdi
callq 0x21cd0
movq %rbx, %rdi
callq 0x62dfa
addq $0x1050, %rsp           # imm = 0x1050
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x62dfa
movq %rbx, %rdi
callq 0x22080
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/strcompare.cc
// Function: main
int main()
{
    string str = "Hello";
    string phrase = "Hello World";
    string slang  = "Hiya";

    if (str < phrase) cout << "str is smaller" << endl;
    if (slang > str) cout << "slang is greater" << endl;
    if (slang > phrase) cout << "slang is greater" << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
leaq 0xde8(%rip), %rsi       # 0x2004
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1050
leaq 0xdda(%rip), %rsi       # 0x200a
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1050
leaq 0xdd2(%rip), %rsi       # 0x2016
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1050
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1329
testb %al, %al
je 0x127d
movq 0x2d6f(%rip), %rdi      # 0x3fd8
leaq 0xdab(%rip), %rsi       # 0x201b
callq 0x10a0
movq %rax, %rdi
callq 0x1080
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x133f
testb %al, %al
je 0x12a9
movq 0x2d43(%rip), %rdi      # 0x3fd8
leaq 0xd8e(%rip), %rsi       # 0x202a
callq 0x10a0
movq %rax, %rdi
callq 0x1080
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x133f
testb %al, %al
je 0x12d5
movq 0x2d17(%rip), %rdi      # 0x3fd8
leaq 0xd62(%rip), %rsi       # 0x202a
callq 0x10a0
movq %rax, %rdi
callq 0x1080
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq -0x50(%rbp), %rdi
callq 0x1070
leaq -0x70(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x130f
movq %rax, %rbx
jmp 0x1318
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq -0x50(%rbp), %rdi
callq 0x1070
leaq -0x70(%rbp), %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, (%rdi)
andq $0x0, 0x20(%rdi)
movsd %xmm0, 0x10(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x28(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
incl 0x20(%rdi)
leaq -0x28(%rbp), %rdi
movl $0x47, (%rdi)
cvttsd2si %xmm0, %rsi
callq 0x2346
movl %eax, %eax
movq %rax, -0x20(%rbp)
cvtsi2sd %rax, %xmm0
movsd 0x10(%rbx), %xmm1
divsd 0x1c69(%rip), %xmm1     # 0x3008
cvtsi2sdq 0x28(%rbx), %xmm2
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x1402
leaq 0x30(%rbx), %r14
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x243c
testq %rax, %rax
je 0x13e9
leaq -0x20(%rbp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x282e
movl (%rax), %r15d
incl %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x282e
movl %r15d, (%rax)
jmp 0x1402
leaq -0x24(%rbp), %rdx
movl $0x1, (%rdx)
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x24dc
incl 0x24(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xd8, %rsp
leaq -0xa0(%rbp), %rax
movq %rax, -0x30(%rax)
pushq $0x1
popq %rcx
movq %rcx, -0x28(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, -0x20(%rax)
movl $0x3f800000, %edx       # imm = 0x3F800000
movl %edx, -0x10(%rax)
movupd %xmm0, -0x8(%rax)
andq $0x0, -0x60(%rax)
andq $0x0, -0x40(%rax)
movabsq $0x4024000000000000, %rsi # imm = 0x4024000000000000
movq %rsi, -0x50(%rax)
movabsq $0x100000000, %rdi      # imm = 0x100000000
movq %rdi, -0x38(%rax)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rax)
movq %rcx, -0x28(%rax)
movupd %xmm0, -0x20(%rax)
movl %edx, -0x10(%rax)
movupd %xmm0, -0x8(%rax)
andq $0x0, -0x60(%rax)
andq $0x0, -0x40(%rax)
movq %rsi, -0x50(%rax)
movq %rdi, -0x38(%rax)
leaq -0x98(%rbp), %r15
leaq -0x100(%rbp), %r12
xorl %ebx, %ebx
cmpl $0x2710, %ebx           # imm = 0x2710
je 0x2292
callq 0x1040
cltd
movl $0xfa, %ecx
idivl %ecx
movl %edx, %r13d
callq 0x1040
cltd
pushq $0x39
popq %rcx
idivl %ecx
leal (%rdx,%r13), %r14d
addl $0x16, %r14d
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x30(%rbp)
cmpl $-0x31, %r13d
pushq $-0x32
popq %rax
cmovll %eax, %r13d
addl $0x32, %r13d
subl $0x1, %r13d
jb 0x226d
movq %r12, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x1360
jmp 0x2258
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
subl $0x1, %r14d
jb 0x228e
movq %r15, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x1360
jmp 0x2279
incl %ebx
jmp 0x2215
leaq -0x100(%rbp), %rdi
leaq -0x98(%rbp), %rsi
xorl %edx, %edx
callq 0x140e
movsd %xmm0, -0x30(%rbp)
movq 0x2d25(%rip), %rdi      # 0x4fd8
movsd -0x30(%rbp), %xmm0
callq 0x1170
movq %rax, %rdi
callq 0x1080
movsd -0x30(%rbp), %xmm0
xorl %edi, %edi
callq 0x192a
movsd 0xd37(%rip), %xmm1      # 0x3010
subsd %xmm0, %xmm1
movq 0x2cf4(%rip), %rdi      # 0x4fd8
movapd %xmm1, %xmm0
callq 0x1170
leaq -0x68(%rbp), %rdi
callq 0x238c
leaq -0xd0(%rbp), %rdi
callq 0x238c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2318
jmp 0x2318
movq %rax, %r15
leaq -0x68(%rbp), %rdi
callq 0x238c
leaq -0xd0(%rbp), %rdi
callq 0x238c
movq %r15, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O2/ashlall[P]StreamStats/Test/./../SourceCode/ChiSquare/ChiSquareCategorical.h
// Function: HashTable::hash(unsigned int)
uint32_t hash(uint32_t a)
	{	
		a = (a+0x479ab41d) + (a<<8); //http://burtleburtle.net/bob/hash/integer.html
		a = (a^0xe4aa10ce) ^ (a>>5);
		a = (a+0x9942f0a6) - (a<<14);
		a = (a^0x5aedd67d) ^ (a>>3);
		a = (a+0x17bea992) + (a<<7);
		return a;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
shll $0x8, %eax
addl %esi, %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
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1070
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r12d, %r12d
movq 0x2d9c(%rip), %r14      # 0x3fe0
leaq -0x48(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x127c
cmpq $0x140, %r12            # imm = 0x140
je 0x127c
leaq (%rbx,%r12), %rdi
addq $0x20, %r12
movq %r15, %rsi
callq 0x10a0
jmp 0x1248
xorl %r13d, %r13d
movq 0x2d4a(%rip), %r14      # 0x3fd0
cmpq %r13, %r12
je 0x12b0
leaq (%rbx,%r13), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1030
addq $0x20, %r13
jmp 0x1286
movl $0x140, %esi            # imm = 0x140
movq %rbx, %rdi
callq 0x1080
leaq -0x48(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12d9
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x10, %rax
je 0x2604
movb (%r14,%rax), %cl
xorb (%rdx,%rax), %cl
movb %cl, -0x40(%rbp,%rax)
incq %rax
jmp 0x25ee
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x26bb
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
cmpq $0x10, %rax
je 0x2654
movb (%r14,%rax), %cl
xorb -0x50(%rbp,%rax), %cl
movq %rax, %rdx
xorq $0x8, %rdx
movb %cl, -0x60(%rbp,%rdx)
incq %rax
jmp 0x2636
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2669
movb -0x40(%rbp,%rax), %cl
xorb %cl, -0x60(%rbp,%rax)
incq %rax
jmp 0x2656
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x26bb
xorl %eax, %eax
cmpq $0x10, %rax
je 0x268e
movb (%r14,%rax), %cl
xorb %cl, -0x40(%rbp,%rax)
incq %rax
jmp 0x267b
testq %rbx, %rbx
je 0x269a
movq -0x40(%rbp), %rax
movq %rax, (%rbx)
movq 0x10(%rbp), %rcx
testq %rcx, %rcx
je 0x26aa
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_O2/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 $0x18, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r8
movq %rdi, %r15
subq $0x8, %rsp
leaq -0x40(%rbp), %r9
movq %rdx, %rsi
movq %r12, %rdx
movq %r8, -0x38(%rbp)
pushq $0x0
callq 0x25cc
popq %rcx
popq %rdx
leaq -0x2e(%rbp), %rax
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x20(%rbp), %rcx
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %r9
pushq $0x0
pushq %rax
callq 0x297a
popq %rcx
popq %rdx
xorl %eax, %eax
cmpq $0x6, %rax
je 0x2b9d
movb -0x2e(%rbp,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x2b87
movq -0x38(%rbp), %rax
movzwl (%rax), %eax
movw %ax, 0x6(%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r13
andw $0x0, -0x2a(%rbp)
leaq -0x30(%rbp), %rax
andq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
movq %rdx, -0x38(%rbp)
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x297a
cmpq $0x6, %r15
je 0x2c1d
movb -0x30(%rbp,%r15), %al
xorb (%rbx,%r15), %al
movb %al, (%r14,%r15)
incq %r15
jmp 0x2c05
leaq -0x40(%rbp), %r15
movq %r15, (%rsp)
leaq -0x2a(%rbp), %r8
movq %r13, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rcx
xorl %r9d, %r9d
callq 0x25cc
movq (%r15), %rax
cmpq 0x6(%rbx), %rax
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26bb
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2cd3
movb (%r14,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
jmp 0x2cc1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/uicc.h
// Function: bcdToAscii(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static inline string bcdToAscii(string data) {
    string ret="";

    for (size_t i=0; i<data.size(); i++) {
        char c= (data[i] & 0xF) + '0';

        if ( c >= '0' && c <= '9' )
            ret+=c;

        c= (data[i]>>4 & 0xF) + '0';

        if ( c >= '0' && c <= '9' )
            ret+=c;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xfcc7(%rip), %rsi      # 0x13392
leaq -0x19(%rbp), %rdx
callq 0x20f0
xorl %r15d, %r15d
cmpq 0x8(%r14), %r15
jae 0x371c
movq (%r14), %rax
movb (%rax,%r15), %al
movl %eax, %ecx
andb $0xf, %cl
orb $0x30, %cl
cmpb $0x39, %cl
ja 0x3703
movzbl %cl, %esi
movq %rbx, %rdi
callq 0x21f0
movq (%r14), %rax
movb (%rax,%r15), %al
shrb $0x4, %al
orb $0x30, %al
cmpb $0x39, %al
ja 0x3717
movzbl %al, %esi
movq %rbx, %rdi
callq 0x21f0
incq %r15
jmp 0x36d7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/uicc.h
// Function: makeBcd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, int)
static inline string makeBcd(string data, bool swap=true, int outputLength=0) {
    string tmp=data;
    string output;

    if (data.size()%2 == 1 )
        tmp+='f';

    if (swap)
        for(size_t i=0; i< tmp.size(); i+=2)
            output+=(char)( (mkDigit(tmp[i+1])<<4) + (mkDigit(tmp[i])) );
    else
        for(size_t i=0; i< tmp.size(); i+=2)
            output+=(char)( (mkDigit(tmp[i])<<4) + (mkDigit(tmp[i+1])) );

    for (int i=tmp.size()/2; i<outputLength; i++)
        output+='\xff';

    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2330
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
testb $0x1, 0x8(%r12)
je 0x4e6a
leaq -0x48(%rbp), %rdi
pushq $0x66
popq %rsi
callq 0x21f0
xorl %r12d, %r12d
testb %r15b, %r15b
je 0x4eb4
movq -0x40(%rbp), %r13
cmpq %r13, %r12
jae 0x4ef6
movq -0x48(%rbp), %rax
movzbl 0x1(%rax,%r12), %edi
callq 0x8359
movl %eax, %r15d
movq -0x48(%rbp), %rax
movzbl (%rax,%r12), %edi
callq 0x8359
shlb $0x4, %r15b
orb %al, %r15b
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x21f0
addq $0x2, %r12
jmp 0x4e72
movq -0x40(%rbp), %r13
cmpq %r13, %r12
jae 0x4ef6
movq -0x48(%rbp), %rax
movzbl (%rax,%r12), %edi
callq 0x8359
movl %eax, %r15d
movq -0x48(%rbp), %rax
movzbl 0x1(%rax,%r12), %edi
callq 0x8359
shlb $0x4, %r15b
orb %al, %r15b
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x21f0
addq $0x2, %r12
jmp 0x4eb4
shrq %r13
pushq $-0x1
popq %r15
cmpl %r14d, %r13d
jge 0x4f12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x21f0
incl %r13d
jmp 0x4efd
leaq -0x48(%rbp), %rdi
callq 0x2120
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f33
jmp 0x4f33
jmp 0x4f33
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
leaq -0x48(%rbp), %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xa0, %rsp
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
leaq 0xe8(%rdi), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x2330
leaq -0xb0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x714c
movl %eax, %r14d
leaq -0xb0(%rbp), %rdi
callq 0x2120
cmpl $0x10, %r14d
jne 0x7078
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x88(%rbx), %rsi
leaq -0x90(%rbp), %rdi
callq 0x2330
leaq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x714c
movl %eax, %r14d
leaq -0x90(%rbp), %rdi
callq 0x2120
cmpl $0x10, %r14d
jne 0x70ae
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x2cad
addq $0x68, %rbx
leaq 0xbf37(%rip), %r14      # 0x12f5a
leaq -0xb8(%rbp), %r15
xorl %r12d, %r12d
cmpq $0x10, %r12
je 0x7056
movzbl -0x70(%rbp,%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2080
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2440
incq %r12
jmp 0x702d
leaq -0x40(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x11f51(%rip), %r14     # 0x18fd0
movq (%r14), %rbx
callq 0x2040
movl (%rax), %edi
callq 0x20c0
leaq 0xbd7b(%rip), %rsi      # 0x12e10
leaq 0xbe17(%rip), %rdx      # 0x12eb3
leaq 0xa27b(%rip), %rcx      # 0x1131e
movq %rbx, %rdi
movl $0x12f, %r8d            # imm = 0x12F
jmp 0x70e2
movq 0x11f1b(%rip), %r14     # 0x18fd0
movq (%r14), %rbx
callq 0x2040
movl (%rax), %edi
callq 0x20c0
leaq 0xbdef(%rip), %rsi      # 0x12eba
leaq 0xbde1(%rip), %rdx      # 0x12eb3
leaq 0xa245(%rip), %rcx      # 0x1131e
movq %rbx, %rdi
movl $0x131, %r8d            # imm = 0x131
movq %rax, %r9
xorl %eax, %eax
callq 0x2360
movq 0x11eb5(%rip), %rax     # 0x18fa8
movq (%rax), %rdi
callq 0x22c0
movq (%r14), %rdi
callq 0x22c0
pushq $0x1
popq %rdi
callq 0x22e0
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2120
jmp 0x7132
jmp 0x712f
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x7136
movq %rax, %rbx
jmp 0x713b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc22e(%rip), %rsi      # 0x13392
movq %r14, %rdi
callq 0x2450
movq 0x8(%r15), %rax
pushq $-0x1
popq %rbx
testb $0x1, %al
jne 0x71fc
xorl %r12d, %r12d
cmpq %rax, %r12
jae 0x71f7
movq (%r15), %rdx
movb (%rdx,%r12), %al
cmpb $0x30, %al
jl 0x71fc
movb $-0x30, %cl
cmpb $0x3a, %al
jb 0x71ab
cmpb $0x61, %al
jb 0x71a0
movb $-0x57, %cl
cmpb $0x67, %al
jb 0x71ab
jmp 0x71fc
leal -0x41(%rax), %esi
movb $-0x37, %cl
cmpb $0x5, %sil
ja 0x71fc
movb 0x1(%rdx,%r12), %dl
cmpb $0x30, %dl
jl 0x71fc
movb $-0x30, %sil
cmpb $0x3a, %dl
jb 0x71d8
cmpb $0x61, %dl
jb 0x71cc
movb $-0x57, %sil
cmpb $0x67, %dl
jb 0x71d8
jmp 0x71fc
leal -0x41(%rdx), %edi
movb $-0x37, %sil
cmpb $0x5, %dil
ja 0x71fc
addb %cl, %al
addb %sil, %dl
shlb $0x4, %al
orb %dl, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x21f0
addq $0x2, %r12
movq 0x8(%r15), %rax
jmp 0x717e
shrq %rax
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/uicc.h
// Function: dump_hex(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 void dump_hex(string name, string data) {
    printf("%s: 0x", name.c_str());

    for (size_t i=0; i<data.size(); i++)
        printf("%02hhx", data[i]);

    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0xc33b(%rip), %rdi      # 0x13db8
xorl %eax, %eax
callq 0x2050
leaq 0xb4cf(%rip), %r14      # 0x12f5a
xorl %r15d, %r15d
cmpq 0x8(%rbx), %r15
jae 0x7aab
movq (%rbx), %rax
movsbl (%rax,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
jmp 0x7a8e
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/aes.h
// Function: KeyAdd(unsigned char (*) [4], unsigned char (*) [4][4], int)
static inline void KeyAdd (uint8_t state[4][4], uint8_t roundKeys[11][4][4], int round) {
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++)
      state[i][j] ^= roundKeys[round][i][j];

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
shlq $0x4, %rax
addq %rsi, %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x8059
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x804c
movb (%rax,%rdx), %sil
xorb %sil, (%rdi,%rdx)
incq %rdx
jmp 0x8039
incq %rcx
addq $0x4, %rdi
addq $0x4, %rax
jmp 0x8031
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FFY00[P]uicc/include/uicc.h
// Function: mkDigit(unsigned char)
static inline unsigned char mkDigit(unsigned char in) {
    unsigned char v=tolower(in);

    if ( v >= '0'&& v <= '9' )
        return v-'0';

    if ( v >= 'a'&& v <= 'f' )
        return v-'a'+10;

    printf("Invalid hexa value: %x \n", (int)in);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x2380
movzbl %al, %ecx
leal -0x30(%rcx), %edx
cmpl $0x9, %edx
ja 0x8378
leal -0x30(%rax), %r14d
jmp 0x8399
addl $-0x61, %ecx
cmpl $0x5, %ecx
ja 0x8386
leal -0x57(%rax), %r14d
jmp 0x8399
leaq 0xb969(%rip), %rdi      # 0x13cf6
xorl %r14d, %r14d
movl %ebx, %esi
xorl %eax, %eax
callq 0x2050
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x50(%rbp), %r14
pushq $0x1
popq %rax
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2260
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x36b4
leaq -0x50(%rbp), %rdi
callq 0x2120
leaq -0x30(%rbp), %r14
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
leaq -0x30(%rbp), %rdi
callq 0x2120
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x85d7
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rax
addq $-0xe, %rax
leaq -0x50(%rbp), %r14
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2260
movq (%r14), %rax
movsbq (%rax), %rcx
leaq -0x30(%rbp), %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x2260
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x36b4
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x50(%rbp), %rdi
callq 0x2120
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0x8b02
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x9bb1(%rip), %rsi      # 0x13392
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x20f0
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xf1f8
leaq -0x40(%rbp), %rdi
callq 0x2120
movq 0x8(%r14), %rcx
movl %ecx, %eax
shrl %eax
testb $0x1, %cl
jne 0x9820
movq (%rbx), %rdi
movb $0x1, %r15b
movsbl %al, %esi
callq 0x21f0
jmp 0x9830
incb %al
movq (%rbx), %rdi
movb $0x9, %r15b
movsbl %al, %esi
callq 0x21f0
movq (%r14), %rax
movb (%rax), %al
shlb $0x4, %al
orb %r15b, %al
movq (%rbx), %rdi
movsbl %al, %esi
callq 0x21f0
leaq -0x60(%rbp), %rdi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x2260
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x4e20
movq (%rbx), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2470
leaq -0x40(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x98a7
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x98b6
jmp 0x98bf
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x98c2
jmp 0x98bf
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a5a
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movl %r8d, %r14d
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq -0x80(%rbp), %rdi
movq %rdx, %rsi
callq 0x2330
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x4e20
leaq -0x40(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2300
movq %r12, %rdi
callq 0x2120
leaq -0x80(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x2330
leal -0x2(%r14), %eax
xorl %ecx, %ecx
cmpl $0x3, %r14d
cmovgel %eax, %ecx
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x4e20
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x2470
leaq -0x40(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x99a0
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x99af
jmp 0x99b6
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x2120
jmp 0x99b9
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x990a(%rip), %rsi      # 0x13392
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20f0
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xf1f8
leaq -0x50(%rbp), %rdi
callq 0x2120
cmpl $0xf, %r14d
pushq $0xe
popq %r13
cmovgel %r14d, %r13d
addl $-0xe, %r13d
pushq $-0x1
popq %r12
subl $0x1, %r13d
jb 0x9ad1
movq (%rbx), %rdi
movl %r12d, %esi
callq 0x21f0
jmp 0x9abe
leaq -0x90(%rbp), %rdi
movq %r15, %rsi
callq 0x2330
leaq -0x50(%rbp), %rdi
leaq -0x90(%rbp), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x4e20
movsbl -0x48(%rbp), %esi
movq (%rbx), %rdi
callq 0x21f0
leaq -0x50(%rbp), %rdi
callq 0x2120
leaq -0x90(%rbp), %rdi
callq 0x2120
movq (%rbx), %rdi
pushq $-0x7f
popq %rsi
callq 0x21f0
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0x2330
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x4e20
movq (%rbx), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2470
leaq -0x50(%rbp), %rdi
callq 0x2120
leaq -0x70(%rbp), %rdi
callq 0x2120
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x5, %r12
pushq $-0x1
popq %r15
cmpl %r14d, %r12d
jge 0x9b81
movq (%rbx), %rdi
movl %r15d, %esi
callq 0x21f0
incl %r12d
jmp 0x9b6c
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2120
jmp 0x9ba4
movq %rax, %r14
leaq -0x70(%rbp), %rdi
jmp 0x9bd1
jmp 0x9bdc
jmp 0x9bdc
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2120
jmp 0x9bbf
movq %rax, %r14
leaq -0x90(%rbp), %rdi
jmp 0x9bd1
jmp 0x9bdc
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x2120
jmp 0x9bdf
jmp 0x9bdc
jmp 0x9bdc
movq %rax, %r14
movq %rbx, %rdi
callq 0x8a5a
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2330
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd5aa
leaq -0x30(%rbp), %rdi
callq 0x2120
cmpq $0x3, 0x30(%rbx)
jae 0xa14a
pushq $-0x1
popq %rax
jmp 0xa152
movq 0x28(%rbx), %rax
movsbl 0x3(%rax), %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2400
nop