LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/table.cpp
// Function: tabInsert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _TabEntry const&)
void tabInsert(
    const std::string &id, 
    const TabEntry &entry)
{
    // TODO: 
    // local variable name can't be same with the name
    // of the function where the local variable is defined in.
    // (What a stupid rule!)
    std::unordered_map<std::string, TabEntry> &symbolTable =
        (entry.scope == GLOBAL) ? symbolTableG : symbolTableL;
    if (symbolTable.find(id) != symbolTable.end()) {
        error(entry.scope == GLOBAL ? ERR_DUPLICATE_GLOBAL_IDENTIFIER :
                ERR_DUPLICATE_LOCAL_IDENTIFIER);
        return;
    }
    symbolTable[id] = entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rsi)
leaq 0xf6f9(%rip), %rax      # 0x2a1e0
leaq 0xf72a(%rip), %r15      # 0x2a218
cmoveq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b630
testq %rax, %rax
je 0x1ab50
xorl %eax, %eax
cmpl $0x0, (%rbx)
leaq 0x28c9(%rip), %rcx      # 0x1d3d7
leaq 0x291b(%rip), %rsi      # 0x1d430
cmoveq %rcx, %rsi
setne %al
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq (%rsi,%rax,8), %rdx
addq $0x58, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x14454
movq %rbx, %rdi
callq 0xdcc8
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x1ab67
callq 0x32a0
jmp 0x1ab67
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b73c
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x1ab83
callq 0x32a0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/table.cpp
// Function: string2label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string string2label(const std::string &str)
{
    std::map<std::string, std::string>::iterator it;
    if ((it = strings_table.find(str)) != strings_table.end()) {
        return (*it).second;
    }
    std::stringstream ss;
    ss << "$STRING_" << strings_count;
    std::string label = ss.str();
    strings_table[str] = label;
    strings_count++;
    return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf6cc(%rip), %rdi      # 0x2a2a8
callq 0x1ba9e
leaq 0xf6c8(%rip), %rcx      # 0x2a2b0
cmpq %rcx, %rax
je 0x1ac0c
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe4c0
jmp 0x1ac8f
leaq -0x1a0(%rbp), %rdi
callq 0x31f0
leaq -0x190(%rbp), %r15
leaq 0x2893(%rip), %rsi      # 0x1d4b9
movl $0x8, %edx
movq %r15, %rdi
callq 0x3340
movl 0xf69f(%rip), %esi      # 0x2a2d8
movq %r15, %rdi
callq 0x3470
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x3420
leaq 0xf651(%rip), %rdi      # 0x2a2a8
movq %r14, %rsi
callq 0x1adea
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3160
incl 0xf668(%rip)            # 0x2a2d8
movq 0x8329(%rip), %rsi      # 0x22fa0
leaq -0x1a0(%rbp), %rdi
callq 0x3210
leaq -0x120(%rbp), %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x1acb9
callq 0x32a0
jmp 0x1acb9
movq %rax, %r14
movq 0x82e0(%rip), %rsi      # 0x22fa0
leaq -0x1a0(%rbp), %rdi
callq 0x3210
leaq -0x120(%rbp), %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/compareSpec.cc
// Function: main
int main()
{
	int *p1 = new int(45);
	int *p2 = new int(42);

	// because we're comparing pointer values, the result of
    // this call may vary each time the program is run
	cout << compare(*p1, *p2) << endl;
	cout << compare(p1, p2) << endl;

	cout << strcmp("hi", "mom") << endl;
	cout << compare("hi", "mom") << endl;

	const char *cp1 = "hi", *cp2= "mom";
	cout << compare(cp1, cp2) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x4, %edi
callq 0x1070
movq %rax, %r14
movl $0x2d, (%rax)
movl $0x4, %edi
callq 0x1070
movq %rax, %r15
movl $0x2a, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1410
movq 0x2d41(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movl %eax, %esi
callq 0x10b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq 0xd55(%rip), %rsi       # 0x2027
movl $0xa, %edx
movq %rbx, %rdi
callq 0x1080
leaq 0xd38(%rip), %rsi       # 0x201e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1080
xorl %esi, %esi
cmpq %r14, %r15
setb %sil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmoval %eax, %esi
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x10b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq 0xcac(%rip), %r15       # 0x2020
leaq 0xca8(%rip), %r14       # 0x2023
movq %r15, %rdi
movq %r14, %rsi
callq 0x146e
movq %rbx, %rdi
movl %eax, %esi
callq 0x10b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq -0x30(%rbp), %rdi
movq %r15, (%rdi)
leaq -0x28(%rbp), %rsi
movq %r14, (%rsi)
callq 0x11fc
movq %rbx, %rdi
movl %eax, %esi
callq 0x10b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/DiskUtils.cpp
// Function: DiskUtils::MakeDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DiskUtils::MakeDir( std::string _path )
{
	// if it's already there, we're done
	if( DiskUtils::IsValidDir( _path )) return;

	// okay. try to create it
#if defined (_WIN32) || defined( __MINGW32__ )
	_mkdir( _path.c_str() );
#else
	mkdir( _path.c_str(), 0755 );
#endif

	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2c9a
movq (%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0x20e0
testl %eax, %eax
jne 0x2486
movl $0xf000, %eax           # imm = 0xF000
andl 0x40(%rsp), %eax
movb $0x1, %bpl
cmpl $0x4000, %eax           # imm = 0x4000
je 0x2488
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x249f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
testb %bpl, %bpl
jne 0x24b1
movq (%rbx), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x2080
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::ConfigurePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void VoiceFile::ConfigurePath( std::string _path )
{
	this->vrDir.assign( _path );
	this->vrVoiceDir.assign( _path );
	vrVoiceDir += "/VOICE/";

	vrMSFFile.assign( vrVoiceDir );
	vrMSFFile += "MSGLISTS.MSF";

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rdi
callq 0x2090
leaq 0x30(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2090
leaq 0x1ef7(%rip), %rsi      # 0x510f
movq %r15, %rdi
callq 0x2250
addq $0x50, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2090
leaq 0x1ee1(%rip), %rsi      # 0x5117
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetFolderName[abi:cxx11](int)
std::string VoiceFile::GetFolderName( int folderIndex )
{
	if( !this->ValidFolder( folderIndex )) return "";

	long folderOffset = this->GetOffsetToFolder( folderIndex );
	
	char * folderName = (char * ) (this->buffer + folderOffset  + 4);

	return folderName;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x4, %edx
ja 0x3bb8
cmpb $0x0, (%rsi)
je 0x3bb8
imull $0xcc0, %edx, %eax      # imm = 0xCC0
movq 0x8(%rsi), %rcx
leaq (%rcx,%rax), %r15
addq $0x20, %r15
leaq 0x24(%rcx,%rax), %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2070
leaq (%rax,%r15), %rdx
addq $0x4, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x3bcc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x15e6(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d2a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetPathForFolder[abi:cxx11](int)
std::string VoiceFile::GetPathForFolder( int folderIndex )
{
	if( !this->ValidFolder( folderIndex )) return "";

	std::string folderPath( this->vrVoiceDir );
	folderPath.append( this->GetFolderName( folderIndex ));
	folderPath.append( "/" );

	return folderPath;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x4, %edx
ja 0x3c5d
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x3c5d
movl %edx, %ebp
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c9a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3b70
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2060
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c4c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
leaq 0x14c2(%rip), %rsi      # 0x5115
movq %rbx, %rdi
callq 0x2250
jmp 0x3c76
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1541(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d2a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ca6
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ca9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
jmp 0x3ca9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3cbc
movq (%r15), %rsi
incq %rsi
callq 0x2110
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetFileCountForFolder(int)
int VoiceFile::GetFileCountForFolder( int folderIndex )
{
	if( !this->ValidFolder( folderIndex )) return 0;

	long offs = this->GetOffsetToFolder( folderIndex );

	int count = 0;

	offs += kFolderHeaderSz;

	// check for items until we find a null item
	for( count = 0 ; (count < kFolderNItems) && (this->buffer[offs] != '\0') ; count++, offs+= kFolderItemSz);

	return count;
}

// Assembly:
xorl %eax, %eax
cmpl $0x4, %esi
ja 0x3cf4
cmpb $0x0, (%rdi)
je 0x3cf4
imull $0xcc0, %esi, %ecx      # imm = 0xCC0
addl $0x60, %ecx
addq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
je 0x3cf4
incl %eax
addq $0x20, %rcx
cmpl $0x63, %eax
jne 0x3cdf
movl $0x63, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetFileInFolder[abi:cxx11](int, int)
std::string VoiceFile::GetFileInFolder( int fileIndex, int folderIndex )
{
	if( !this->valid || !this->ValidFile( fileIndex, folderIndex )) return "";

	// get the offset to the item
	long offs = this->GetOffsetToFolder( folderIndex );
	offs += this->GetOffsetToFile( fileIndex );
	
	sFldItm *fi = (sFldItm *)&this->buffer[ offs ];
	char fn[9];


	for( int i=0 ; i<8 ; i++ ) {
		fn[i] = fi->file[i];
	}
	fn[8] = '\0';

	std::string filename( fn );
	filename.append( ".MP3" );

	return filename;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x3dbf
cmpl $0x5, %ecx
setae %al
testl %edx, %edx
sets %dil
orb %al, %dil
jne 0x3dbf
imull $0xcc0, %ecx, %eax      # imm = 0xCC0
leal 0x60(%rax), %r8d
addq 0x8(%rsi), %r8
xorl %edi, %edi
cmpb $0x0, (%r8)
je 0x3d46
incl %edi
addq $0x20, %r8
cmpl $0x63, %edi
jne 0x3d30
movl $0x63, %edi
cmpl %edx, %edi
jle 0x3dbf
orl $0x20, %eax
xorl %edi, %edi
cmpl $0x5, %ecx
cmovael %edi, %eax
movl %edx, %ecx
shll $0x5, %ecx
addl $0x40, %ecx
cmpl $0x63, %edx
cmovael %edi, %ecx
movq 0x8(%rsi), %rdx
addq %rax, %rcx
leaq (%rdx,%rcx), %rax
addq $0x10, %rax
movb (%rax,%rdi), %cl
movb %cl, 0x7(%rsp,%rdi)
incq %rdi
cmpq $0x8, %rdi
jne 0x3d72
leaq 0x7(%rsp), %r14
movb $0x0, 0x8(%r14)
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq %r14, %rdi
callq 0x2070
leaq (%rsp,%rax), %rdx
addq $0x7, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d2a
leaq 0x141b(%rip), %rsi      # 0x51d0
movq %rbx, %rdi
callq 0x2250
jmp 0x3dd8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13df(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d2a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3dfb
movq (%r15), %rsi
incq %rsi
callq 0x2110
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::PrintableDateForFileInFolder[abi:cxx11](int, int)
std::string VoiceFile::PrintableDateForFileInFolder( int fileIndex, int folderIndex )
{
	if( !this->valid || !this->ValidFile( fileIndex, folderIndex )) return "";

	long offs = this->GetOffsetToFolder( folderIndex );
	offs += this->GetOffsetToFile( fileIndex );

	sFldItm *fi = (sFldItm *)&this->buffer[ offs ];

	char b[128];

	snprintf( b, 127, "%d-%02d-%02d  %02d:%02d:%02d",
		fi->Year + 1980, fi->Month, fi->Day,
		fi->Hour, fi->Minute, fi->Second );

	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x3eee
cmpl $0x5, %ecx
setae %al
testl %edx, %edx
sets %dil
orb %al, %dil
jne 0x3eee
imull $0xcc0, %ecx, %eax      # imm = 0xCC0
leal 0x60(%rax), %r8d
addq 0x8(%rsi), %r8
xorl %edi, %edi
cmpb $0x0, (%r8)
je 0x3e57
incl %edi
addq $0x20, %r8
cmpl $0x63, %edi
jne 0x3e41
movl $0x63, %edi
cmpl %edx, %edi
jle 0x3eee
orl $0x20, %eax
xorl %edi, %edi
cmpl $0x5, %ecx
cmovael %edi, %eax
movl %edx, %r10d
shll $0x5, %r10d
addl $0x40, %r10d
cmpl $0x63, %edx
cmovael %edi, %r10d
addq 0x8(%rsi), %rax
movzbl 0x18(%r10,%rax), %ecx
addl $0x7bc, %ecx            # imm = 0x7BC
movzbl 0x19(%r10,%rax), %r8d
movzbl 0x1a(%r10,%rax), %r9d
movzbl 0x1b(%r10,%rax), %r11d
movzbl 0x1c(%r10,%rax), %r15d
movzbl 0x1d(%r10,%rax), %r10d
subq $0x8, %rsp
leaq 0x1320(%rip), %rdx      # 0x51d5
leaq 0x8(%rsp), %r14
movl $0x7f, %esi
movq %r14, %rdi
xorl %eax, %eax
pushq %r10
pushq %r15
pushq %r11
callq 0x21e0
addq $0x20, %rsp
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2070
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x3f02
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12b0(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d2a
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::SortableDateForFileInFolder[abi:cxx11](int, int)
std::string VoiceFile::SortableDateForFileInFolder( int fileIndex, int folderIndex )
{
	if( !this->valid || !this->ValidFile( fileIndex, folderIndex )) return "";

	long offs = this->GetOffsetToFolder( folderIndex );
	offs += this->GetOffsetToFile( fileIndex );

	sFldItm *fi = (sFldItm *)&this->buffer[ offs ];

	char b[128];

	snprintf( b, 127, "%d_%02d_%02d_%02d%02d%02d",
		fi->Year + 1980, fi->Month, fi->Day,
		fi->Hour, fi->Minute, fi->Second );

	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x4002
cmpl $0x5, %ecx
setae %al
testl %edx, %edx
sets %dil
orb %al, %dil
jne 0x4002
imull $0xcc0, %ecx, %eax      # imm = 0xCC0
leal 0x60(%rax), %r8d
addq 0x8(%rsi), %r8
xorl %edi, %edi
cmpb $0x0, (%r8)
je 0x3f6b
incl %edi
addq $0x20, %r8
cmpl $0x63, %edi
jne 0x3f55
movl $0x63, %edi
cmpl %edx, %edi
jle 0x4002
orl $0x20, %eax
xorl %edi, %edi
cmpl $0x5, %ecx
cmovael %edi, %eax
movl %edx, %r10d
shll $0x5, %r10d
addl $0x40, %r10d
cmpl $0x63, %edx
cmovael %edi, %r10d
addq 0x8(%rsi), %rax
movzbl 0x18(%r10,%rax), %ecx
addl $0x7bc, %ecx            # imm = 0x7BC
movzbl 0x19(%r10,%rax), %r8d
movzbl 0x1a(%r10,%rax), %r9d
movzbl 0x1b(%r10,%rax), %r11d
movzbl 0x1c(%r10,%rax), %r15d
movzbl 0x1d(%r10,%rax), %r10d
subq $0x8, %rsp
leaq 0x1229(%rip), %rdx      # 0x51f2
leaq 0x8(%rsp), %r14
movl $0x7f, %esi
movq %r14, %rdi
xorl %eax, %eax
pushq %r10
pushq %r15
pushq %r11
callq 0x21e0
addq $0x20, %rsp
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2070
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x4016
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x119c(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d2a
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BleuLlama[P]msf-tools/msf-autosave.cpp
// Function: usage(char*)
void usage( char * av0 )
{
	std::cout << "Usage:  " << av0 << " <LOCAL PATH TO SAVE TO>" << std::endl;
	std::cout << std::endl;
	std::cout << "note: define VOICERECORDER env var to set root path." << std::endl;
	std::cout << "  eg:" << std::endl;
	std::cout << "      export VOICERECORDER=/Volumes/IC_RECORDER" << std::endl;
	std::cout << "      export VOICERECORDER=/v/" << std::endl;
	std::cout << "      export VOICERECORDER=v:\\" << std::endl;

	std::cout << std::endl;
	std::cout << "Version 1.0  yorgle@gmail.com  Scott Lawrence" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x3f0a(%rip), %rbx      # 0x7fd0
leaq 0x114b(%rip), %rsi      # 0x5218
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2130
testq %r14, %r14
je 0x40fb
movq %r14, %rdi
callq 0x2070
movq 0x3ee2(%rip), %rdi      # 0x7fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2130
jmp 0x4112
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2210
leaq 0x1108(%rip), %rsi      # 0x5221
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10bf(%rip), %rsi      # 0x523a
movl $0x34, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x10b9(%rip), %rsi      # 0x526f
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x1084(%rip), %rsi      # 0x5275
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x1079(%rip), %rsi      # 0x52a5
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x105d(%rip), %rsi      # 0x52c4
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
leaq 0x101a(%rip), %rsi      # 0x52e3
movl $0x2d, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: GetProperty(gaps::R3MeshPropertySet*, char const*)
R3MeshProperty
GetProperty(R3MeshPropertySet *properties, const char *name)
{
  // Initialize property
  R3MeshProperty property(properties->Mesh());

  // Find property in properties
  R3MeshProperty *existing_property = properties->Property(name);
  if (existing_property) return R3MeshProperty(*existing_property);

  // Read property from file
  R3MeshProperty new_property(properties->Mesh());
  if (new_property.Read(name)) return new_property;

  // Property not found
  RNFail("Unable to get property %s\n", name); 
  exit(-1); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x450, %rsp            # imm = 0x450
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x11f30
movq %r15, %rdi
movq %r14, %rsi
callq 0x105fa
testl %eax, %eax
js 0xe83d
movq 0x8(%r15), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rsi
jmp 0xe83f
xorl %esi, %esi
testq %rsi, %rsi
je 0xe84e
movq %rbx, %rdi
callq 0x12038
jmp 0xe86c
movq (%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x11f30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1469c
testl %eax, %eax
je 0xe886
leaq 0x8(%rsp), %rdi
callq 0x120ec
movq %rbx, %rax
addq $0x450, %rsp            # imm = 0x450
popq %rbx
popq %r14
popq %r15
retq
leaq 0x497b3(%rip), %rdi     # 0x58040
movq %r14, %rsi
xorl %eax, %eax
callq 0x5761a
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xc470
movq %rax, %r14
movq %rbx, %rdi
callq 0x120ec
jmp 0xe8b1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x120ec
movq %r14, %rdi
callq 0xc650
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: ParseArgs(int, char**)
int ParseArgs(int argc, char **argv)
{
  // Parse arguments
  for (int i = 0; i < argc; i++) {
    if (!strcmp(argv[i], "-v")) print_verbose = 1; 
    else if (!strcmp(argv[i], "-debug")) print_debug = 1; 
    else if (!strcmp(argv[i], "-parameters_in_absolute_units")) parameters_in_relative_units = 0; 
    else if (!strcmp(argv[i], "-parameters_in_relative_units")) parameters_in_relative_units = 1; 
  }

  // Return OK status 
  return 1;
}

// Assembly:
testl %edi, %edi
jle 0xe96d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r13d
xorl %r12d, %r12d
leaq 0x49775(%rip), %r14     # 0x5805b
leaq 0x49771(%rip), %r15     # 0x5805e
movq (%rbx,%r12,8), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0xc500
testl %eax, %eax
je 0xe93e
movq %rbp, %rdi
movq %r15, %rsi
callq 0xc500
testl %eax, %eax
je 0xe947
movq %rbp, %rdi
leaq 0x4974c(%rip), %rsi     # 0x58065
callq 0xc500
testl %eax, %eax
je 0xe950
movq %rbp, %rdi
leaq 0x49757(%rip), %rsi     # 0x58083
callq 0xc500
testl %eax, %eax
jne 0xe957
movb $0x0, 0x6f184(%rip)     # 0x7dac0
jmp 0xe957
movb $0x1, 0x6f173(%rip)     # 0x7dab8
jmp 0xe957
movb $0x1, 0x6f16e(%rip)     # 0x7dabc
jmp 0xe957
movb $0x1, 0x6f169(%rip)     # 0x7dac0
incq %r12
cmpq %r12, %r13
jne 0xe8ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: IsNumber(char const*)
static int
IsNumber(const char *s)
{
  if (!strcmp(s, "keep") || !strcmp(s, "Keep")) return 1;
  if (*s == '\0') return 0;
  if (*s == '+') s++;
  if (*s == '\0') return 0;
  if (*s == '-') s++;
  if (*s == '\0') return 0;
  while (*s) {
    if (!isdigit(*s) && (*s != '.') && (*s != 'E')) return 0;
    s++;
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x47fcf(%rip), %rsi     # 0x583c4
callq 0xc500
movl $0x1, %ebx
testl %eax, %eax
je 0x1046f
leaq 0x47fe1(%rip), %rsi     # 0x583eb
movq %r14, %rdi
callq 0xc500
testl %eax, %eax
je 0x1046f
movzbl (%r14), %eax
testl %eax, %eax
je 0x10469
cmpl $0x2b, %eax
jne 0x10426
incq %r14
movzbl (%r14), %eax
testl %eax, %eax
je 0x10469
cmpl $0x2d, %eax
jne 0x10436
incq %r14
cmpb $0x0, (%r14)
je 0x1046d
movb (%r14), %al
testb %al, %al
je 0x1046f
incq %r14
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x1045d
cmpb $0x45, %al
je 0x1045d
movzbl %al, %eax
cmpl $0x2e, %eax
jne 0x1046d
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x10446
jmp 0x1046f
movl %eax, %ebx
jmp 0x1046f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Scale(gaps::R3Mesh*)
static RNScalar
Scale(R3Mesh *mesh)
{
  // Check if absolute scale
  if (!parameters_in_relative_units) return 1.0;

  // Compute smallest sigma
  static RNScalar scale = 1;
  static R3Mesh *last_mesh = NULL;
  if (mesh != last_mesh) {
    RNLength length = sqrt(mesh->Area());
    if (length > 0) scale = 1.0 / length;
    last_mesh = mesh;
  }

  // Return scale
  return scale;
}

// Assembly:
cmpb $0x0, 0x6d640(%rip)     # 0x7dac0
je 0x1048b
movsd 0x47bae(%rip), %xmm0    # 0x58038
retq
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, 0x6d632(%rip)     # 0x7dac8
je 0x104da
movq %rbx, %rdi
callq 0x1608c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x104b0
sqrtsd %xmm0, %xmm0
jmp 0x104b9
callq 0xc2c0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x104d3
movsd 0x47b71(%rip), %xmm1    # 0x58038
divsd %xmm0, %xmm1
movsd %xmm1, 0x6cedd(%rip)    # 0x7d3b0
movq %rbx, 0x6d5ee(%rip)     # 0x7dac8
movsd 0x6cece(%rip), %xmm0    # 0x7d3b0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::execute()
void GoogleTTS::execute() {
    if (_cmds.size() == 1) {
        std::system(_cmds[0].c_str());
    } else {
        for(string cmd : _cmds) {
            std::system(cmd.c_str());
        }
        this->unite();
    }
    _mpv += _speed + _play;
    std::system(_mpv.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x1a0(%rdi), %r15
movq 0x1a8(%rdi), %r12
movq %r12, %rax
subq %r15, %rax
cmpq $0x20, %rax
je 0x4af9
cmpq %r12, %r15
je 0x4ae6
leaq -0x38(%rbp), %r13
leaq -0x48(%rbp), %r14
movq %r13, -0x48(%rbp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5caa
movq -0x48(%rbp), %rdi
callq 0x2140
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4add
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
addq $0x20, %r15
cmpq %r12, %r15
jne 0x4aa9
movq 0x160(%rbx), %rdi
callq 0x2140
leaq 0x180(%rbx), %r15
movq (%r15), %rdi
callq 0x2140
leaq 0x120(%rbx), %rsi
leaq 0x140(%rbx), %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x5a64
addq $0x100, %rbx            # imm = 0x100
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2080
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b4a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
movq (%rbx), %rdi
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x4b7f
jmp 0x4b8b
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4b8b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void GoogleTTS::replace(string& text) {
    size_t start_pos = 0;
    while ((start_pos = text.find(" ", start_pos)) != string::npos) {
       text.replace(start_pos, 1, "%20");
       start_pos += 3; // Handles case where 'to' is a substring of 'from'
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x285c(%rip), %rsi      # 0x7405
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2250
cmpq $-0x1, %rax
je 0x4c08
movq %rax, %r14
leaq 0x289f(%rip), %r15      # 0x7467
leaq 0x2836(%rip), %r12      # 0x7405
movl $0x1, %edx
movl $0x3, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x21a0
addq $0x3, %r14
movl $0x1, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2250
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x4bcf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::languages()
void GoogleTTS::languages() {
    std::cout << "Supported languages:" << std::endl;
    int counter = 0;
    for(std::pair<string, string> l : lang_codes) {
        std::cout << l.first  << "\t:\t"<< l.second << std::endl;
    }    
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x50fe(%rip), %rbx      # 0x9fd8
leaq 0x26f7(%rip), %rsi      # 0x75d8
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x526c(%rip), %r14      # 0xa188
leaq 0x5255(%rip), %r15      # 0xa178
cmpq %r15, %r14
je 0x4fea
movq 0x50a5(%rip), %r12      # 0x9fd8
leaq 0x26b3(%rip), %r13      # 0x75ed
leaq 0x20(%r14), %rsi
leaq -0x68(%rbp), %rdi
callq 0x5ac8
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r12, %rdi
callq 0x21b0
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21b0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4fbd
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4fd6
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
cmpq %r15, %rax
jne 0x4f3a
movq 0x4fe7(%rip), %rbx      # 0x9fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x5b34
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/main.cpp
// Function: h264_decoder_feed(ymn::h264_decoder&, unsigned char const*, unsigned long)
static void h264_decoder_feed(ymn::h264_decoder& decoder, const uint8_t* data, std::size_t count)
{
//{
//    const uint8_t *p = data;
//    fprintf(stdout, " 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", p[0], p[1], p[2], p[3], p[4], p[5], p[6]);
//}

    if (h264_ofile.is_open())
        h264_ofile.write(reinterpret_cast<const char*>(data), count);

    decoder.feed(data, count);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1ec4c(%rip), %rdi     # 0x222a8
callq 0x2080
testb %al, %al
je 0x3677
leaq 0x1ebcc(%rip), %rdi     # 0x22238
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2200
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x8068
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/./flatbuffer.hpp
// Function: ymn::flatbuffer<unsigned char>::move()
void move()
    {
        std::size_t x;

        if (m_counters.m_bookmark_idx >= 0) {
            x = m_counters.m_bookmark_idx;
            m_counters.m_bookmark_idx = 0;
        }
        else
            x = m_counters.m_read_idx;

        if (x > 0) {
            std::size_t available_elements = m_counters.m_write_idx - x;
            std::size_t offset = m_counters.m_read_idx - x;

            std::memmove(m_buffer, &m_buffer[x], available_elements * sizeof(T));

            m_counters.m_read_idx = offset;
            m_counters.m_write_idx = available_elements;
            m_counters.m_write_avail = m_capacity - available_elements;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rsi
testq %rsi, %rsi
js 0x379d
movq $0x0, 0x60(%rbx)
jmp 0x37a1
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x37d8
movq 0x40(%rbx), %r15
movq 0x50(%rbx), %r14
subq %rsi, %r14
subq %rsi, %r15
movq 0x80(%rbx), %rdi
addq %rdi, %rsi
movq %r14, %rdx
callq 0x2270
movq %r15, 0x40(%rbx)
movq %r14, 0x50(%rbx)
movq (%rbx), %rax
subq %r14, %rax
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/mpeg2ts_parser.cpp
// Function: ymn::mpeg2ts_parser::synchronize(unsigned long)
int mpeg2ts_parser::synchronize(const std::size_t tspacket_size)
{
    int offset;
    std::size_t i, j;
    const uint8_t *p;

    offset = MPEG2TS_PARSER_NO_SYNC_INDICATOR;
    p = m_flatbuffer.read_ptr();

    for (i = 0;
        ((i < tspacket_size) && (MPEG2TS_PARSER_NO_SYNC_INDICATOR == offset));
        ++i) {
        if (p[i] != MPEG2TS_PARSER_SYNC_BYTE) continue;
        offset = static_cast<int>(i);
        for (j = 1; j <= MPEG2TS_PARSER_FORWARD_SCAN; ++j) {
            if (p[j * tspacket_size + offset] != MPEG2TS_PARSER_SYNC_BYTE) {
                offset = MPEG2TS_PARSER_NO_SYNC_INDICATOR;
                break;
            }
        }
    }

    return offset;
}

// Assembly:
testq %rsi, %rsi
je 0x3834
movq 0x80(%rdi), %rcx
movq 0xc0(%rdi), %rax
leaq (%rax,%rcx), %rdx
addq %rsi, %rcx
addq %rax, %rcx
xorl %edi, %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x47, (%rdx,%rdi)
jne 0x3826
movslq %edi, %r8
addq %rcx, %r8
movl $0xa, %r9d
cmpb $0x47, (%r8)
jne 0x3826
addq %rsi, %r8
decq %r9
jne 0x3816
movl %edi, %eax
incq %rdi
cmpq %rsi, %rdi
jae 0x3833
cmpl $-0x1, %eax
je 0x37ff
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/mpeg2ts_parser.cpp
// Function: ymn::mpeg2ts_parser::waiting_for_sync()
mpeg2ts_parser_status_e mpeg2ts_parser::waiting_for_sync()
{
    mpeg2ts_parser_status_e status = mpeg2ts_parser_status_e::NOT_SYNCHRONIZED;

    for (std::size_t n = 0; n < mpeg2ts_parser_packet_sizes_elements; ++n) {
        int offset;
        std::size_t packet_size = mpeg2ts_parser_packet_sizes[n];

        if (m_flatbuffer.read_available() < (packet_size * (MPEG2TS_PARSER_FORWARD_SCAN + 1))) {
            status = mpeg2ts_parser_status_e::NEED_BYTES;
            break;
        }

        offset = synchronize(packet_size);
        if (MPEG2TS_PARSER_NO_SYNC_INDICATOR != offset) {
            m_flatbuffer.consume(offset);
            m_state_function = &mpeg2ts_parser::synchronized;
            m_tspacket_size = packet_size;
            status = mpeg2ts_parser_status_e::SYNC_GAINED;
            break;
        }
    }

    if (mpeg2ts_parser_status_e::NOT_SYNCHRONIZED == status)
        m_flatbuffer.consume(MPEG2TS_PARSER_PACKET_SIZE);

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rdi), %r12
movl $0x4, %eax
xorl %r13d, %r13d
leaq 0x15cf3(%rip), %r15     # 0x19560
movq (%r13,%r15), %r14
leaq (%r14,%r14,4), %rdx
leaq (%r14,%rdx,2), %rdx
movb $0x1, %bpl
cmpq %rdx, %r12
jae 0x3886
xorl %eax, %eax
jmp 0x38ee
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37e0
cmpl $-0x1, %eax
je 0x38e8
cltq
cmpq %rax, %r12
cmovbq %r12, %rax
movq 0x10(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x80(%rbx)
subq %rax, %r12
movq %r12, 0x88(%rbx)
leaq 0x74(%rip), %rax        # 0x393c
movq %rax, 0x108(%rbx)
movq $0x0, 0x110(%rbx)
movq %r14, 0x118(%rbx)
movl $0x1, %eax
jmp 0x38ee
xorl %ebp, %ebp
movl 0xc(%rsp), %eax
testb %bpl, %bpl
jne 0x3904
leaq 0x8(%r13), %rdx
cmpq $0x10, %r13
movq %rdx, %r13
jne 0x386d
cmpl $0x4, %eax
jne 0x392d
movq 0x88(%rbx), %rdx
movl $0xbc, %ecx
cmpq %rcx, %rdx
cmovbq %rdx, %rcx
addq %rcx, 0x80(%rbx)
subq %rcx, %rdx
movq %rdx, 0x88(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/mpeg2ts_parser.cpp
// Function: ymn::mpeg2ts_parser::transport_rate::calculate(unsigned char const*)
bool mpeg2ts_parser::transport_rate::calculate(const uint8_t* tsp)
{
    bool status = false;

    if (0 == m_transport_rate) {
        mpeg2ts_pid pid = mpeg2ts_parser_get_pid(tsp);

        if (MPEG2TS_PID_INVALID == m_pcr_pid) {
           if (mpeg2ts_parser_has_pcr(tsp)) { /* 1st pcr */
              m_pcr1 = mpeg2ts_parser_get_pcr(tsp);
              m_pcr_pid = pid;
           }
        }
        else {
           m_no_of_packets++;
           if (pid == m_pcr_pid) {
              if (mpeg2ts_parser_has_pcr(tsp)) { /* 2nd pcr */
                 m_pcr2 = mpeg2ts_parser_get_pcr(tsp);
                 if (m_pcr2 > m_pcr1) {
                     m_transport_rate = m_no_of_packets * 27000000 /
                         (m_pcr2 - m_pcr1);
                     status = true;
                 }
                 else {
                     m_pcr1 = m_pcr2;
                     m_no_of_packets = 0;
                 }
              }
           }
        }
    }
    else
        status = true;

    return status;
}

// Assembly:
movb $0x1, %cl
cmpq $0x0, 0x20(%rdi)
jne 0x3b15
movzbl 0x1(%rsi), %eax
movzbl 0x2(%rsi), %edx
andl $0x1f, %eax
shll $0x8, %eax
orl %edx, %eax
movl (%rdi), %r8d
cmpl $0x2000, %r8d           # imm = 0x2000
jne 0x3a66
testb $0x20, 0x3(%rsi)
je 0x3b13
cmpb $0x0, 0x4(%rsi)
je 0x3b13
testb $0x10, 0x5(%rsi)
je 0x3b13
movzbl 0x6(%rsi), %ecx
shll $0x18, %ecx
movzbl 0x7(%rsi), %edx
shll $0x10, %edx
movslq %ecx, %rcx
orq %rdx, %rcx
movzbl 0x8(%rsi), %edx
shll $0x8, %edx
orq %rcx, %rdx
movzbl 0x9(%rsi), %ecx
orq %rdx, %rcx
shlq $0x8, %rcx
movzbl 0xa(%rsi), %edx
addq %rdx, %rcx
shrq $0x7, %rcx
imulq $0x12c, %rcx, %rcx      # imm = 0x12C
movzbl 0xb(%rsi), %esi
andl $0x1, %edx
shll $0x8, %edx
orq %rsi, %rdx
addq %rdx, %rcx
incq %rcx
movq %rcx, 0x8(%rdi)
movl %eax, (%rdi)
jmp 0x3b13
movq 0x18(%rdi), %rdx
incq %rdx
movq %rdx, 0x18(%rdi)
cmpl %r8d, %eax
jne 0x3b13
testb $0x20, 0x3(%rsi)
je 0x3b13
cmpb $0x0, 0x4(%rsi)
je 0x3b13
testb $0x10, 0x5(%rsi)
je 0x3b13
movzbl 0x6(%rsi), %eax
shll $0x18, %eax
movzbl 0x7(%rsi), %r8d
shll $0x10, %r8d
cltq
orq %r8, %rax
movzbl 0x8(%rsi), %r8d
shll $0x8, %r8d
orq %rax, %r8
movzbl 0x9(%rsi), %eax
orq %r8, %rax
shlq $0x8, %rax
movzbl 0xa(%rsi), %r8d
addq %r8, %rax
shrq $0x7, %rax
imulq $0x12c, %rax, %rax      # imm = 0x12C
movzbl 0xb(%rsi), %esi
andl $0x1, %r8d
shll $0x8, %r8d
orq %rsi, %r8
addq %r8, %rax
incq %rax
movq %rax, 0x10(%rdi)
movq %rax, %rsi
subq 0x8(%rdi), %rsi
jbe 0x3b07
imulq $0x19bfcc0, %rdx, %rax  # imm = 0x19BFCC0
xorl %edx, %edx
divq %rsi
movq %rax, 0x20(%rdi)
jmp 0x3b15
movq %rax, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
xorl %ecx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::get_structure(ymn::h264_parser_structure_e, int)
const h264_structure* h264_parser::get_structure(h264_parser_structure_e structure, int id)
{
    const h264_structure* retval = nullptr;

    switch (structure) {
        case h264_parser_structure_e::AUD:
            retval = &m_aud;
            break;

        case h264_parser_structure_e::SPS:
            if (id == H264_PARSER_STRUCTURE_ID_RECENT)
                id = m_recent_sps;
            if ((id >= 0) && (id < H264_PARSER_MAX_NUMBER_OF_SPS))
                retval = &m_sps_table[id];
            break;

        case h264_parser_structure_e::PPS:
            if (id == H264_PARSER_STRUCTURE_ID_RECENT)
                id = m_recent_pps;
            if ((id >= 0) && (id < H264_PARSER_MAX_NUMBER_OF_PPS))
                retval = &m_pps_table[id];
            break;

        case h264_parser_structure_e::SEI:
            retval = &m_sei;
            break;

        case h264_parser_structure_e::SLICE_HEADER:
            retval = &m_slice_header;
            break;

        case h264_parser_structure_e::SLICE_DATA:
            retval = &m_slice_data;
            break;

        default:
            return nullptr;
    }

    return retval && retval->is_valid() ? retval : nullptr;
}

// Assembly:
cmpl $0x5, %esi
ja 0x3bb6
movl %esi, %eax
leaq 0x15a4e(%rip), %rcx     # 0x19578
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x118, %rdi            # imm = 0x118
jmp 0x3ba6
addq $0x87960, %rdi          # imm = 0x87960
jmp 0x3ba6
cmpl $-0x1, %edx
jne 0x3b50
movl 0x87930(%rdi), %edx
cmpl $0xff, %edx
ja 0x3b9b
movl %edx, %eax
imulq $0x718, %rax, %rax      # imm = 0x718
addq %rax, %rdi
addq $0x16130, %rdi          # imm = 0x16130
jmp 0x3ba6
addq $0x87938, %rdi          # imm = 0x87938
jmp 0x3ba6
cmpl $-0x1, %edx
jne 0x3b81
movl 0x16128(%rdi), %edx
cmpl $0x1f, %edx
ja 0x3b9b
movl %edx, %eax
imulq $0xb00, %rax, %rax      # imm = 0xB00
addq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
jmp 0x3ba6
xorl %edi, %edi
jmp 0x3ba6
addq $0x882e0, %rdi          # imm = 0x882E0
testq %rdi, %rdi
je 0x3bb6
xorl %eax, %eax
cmpb $0x0, 0x8(%rdi)
cmovneq %rdi, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::find_nal_unit()
int h264_parser::find_nal_unit()
{
    std::size_t i, limit, available;
    const uint8_t* s;
    const uint8_t* p;

    s = m_flatbuffer.get_bookmark();
    if (NULL == s) {
        if (find_next_start_code()) {
            m_flatbuffer.set_bookmark();
            s = m_flatbuffer.get_bookmark();
        }
        else
            return 0; /* have not found start of a nal unit */
    }

    available = m_flatbuffer.read_available();
    if (available < 3)
        return 0; /* not enough room to find end of a nal unit */

    limit = available - 3;

    p = m_flatbuffer.read_ptr();
    i = 0;
    while ((i <= limit) && ((p[i] != 0x00) || (p[i + 1] != 0x00) || (p[i + 2] > 0x01)))
        i++;

    m_flatbuffer.consume(i);

    if (i > limit)
        return -1; /* have not found end of a nal unit */

    return &p[i] - s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa0(%rdi), %rcx
movq 0xc0(%rdi), %rax
addq %rcx, %rax
xorl %r14d, %r14d
testq %rcx, %rcx
cmovsq %r14, %rax
testq %rax, %rax
jne 0x3c98
movq %rbx, %rdi
callq 0x3bba
testb %al, %al
je 0x3d13
movq 0x80(%rbx), %rcx
movq %rcx, 0xa0(%rbx)
movq 0xc0(%rbx), %rdx
addq %rcx, %rdx
xorl %eax, %eax
testq %rcx, %rcx
cmovnsq %rdx, %rax
movq 0x88(%rbx), %rdx
cmpq $0x3, %rdx
jb 0x3d13
leaq -0x3(%rdx), %r10
movq 0x80(%rbx), %rcx
movq 0xc0(%rbx), %rsi
leaq -0x2(%rdx), %r8
leaq (%rcx,%rsi), %r11
addq $0x2, %r11
xorl %r9d, %r9d
xorl %edi, %edi
cmpb $0x0, -0x2(%r11,%rdi)
jne 0x3cdf
cmpb $0x0, -0x1(%r11,%rdi)
jne 0x3cdf
cmpb $0x2, (%r11,%rdi)
jb 0x3d1e
cmpq %r10, %rdi
leaq 0x1(%rdi), %r14
setae %r9b
movq %r14, %rdi
cmpq %r14, %r8
jne 0x3cc8
cmpq %r8, %rdx
cmovbq %rdx, %r8
addq %r8, %rcx
movq %rcx, 0x80(%rbx)
subq %r8, %rdx
movq %rdx, 0x88(%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq %rdi, %rdx
movq %rdi, %r8
cmovbq %rdx, %r8
leaq (%r8,%rcx), %r10
movq %r10, 0x80(%rbx)
subq %r8, %rdx
movq %rdx, 0x88(%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb $0x1, %r9b
jne 0x3d13
addl %esi, %ecx
subl %eax, %ecx
addl %ecx, %edi
movl %edi, %r14d
jmp 0x3d13
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::parse_scaling_list_4x4(ymn::istream<0>&, ymn::h264::scaling_list_nxn<16ul> (&) [6], int)
void h264_parser::parse_scaling_list_4x4(istream_be& s, h264::scaling_list_4x4 (&lists)[SL_4x4_NUM], int list)
{
    do {
        h264::scaling_list_4x4& sl = lists[list];

        if (!s.read_bits(1, sl.scaling_list_present_flag)) {
            s.mark_corrupted();
            break;
        }

        if (sl.scaling_list_present_flag)
            parse_scaling_list(s, sl.scaling_list, h264::scaling_list_default_4x4[list / 3]);

        if (s.status() != ISTREAM_STATUS_OK)
            break;

        sl.set_valid(true);
    } while (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movslq %ecx, %r13
movq %r13, %r12
shlq $0x5, %r12
leaq (%rdx,%r12), %r15
addq $0xc, %r15
movq %rsi, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x70a0
testb %al, %al
je 0x3e25
addq %r12, %rbx
cmpl $0x0, (%r15)
je 0x3e40
leaq 0x10(%rbx), %r12
imulq $0x55555556, %r13, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
cltq
shlq $0x4, %rax
leaq 0x1609c(%rip), %rcx     # 0x19e60
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
movb $0x8, %bpl
xorl %r13d, %r13d
leaq 0x16127(%rip), %r15     # 0x19f00
movb $0x8, %al
testb %al, %al
je 0x3df9
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x7600
testb %al, %al
je 0x3e3b
movb 0xc(%rsp), %al
addb %bpl, %al
jmp 0x3dfb
xorl %eax, %eax
testq %r13, %r13
jne 0x3e04
testb %al, %al
je 0x3e2c
testb %al, %al
movzbl %al, %ecx
movzbl %bpl, %ebp
cmovnel %ecx, %ebp
movzbl (%r13,%r15), %ecx
movb %bpl, (%r12,%rcx)
incq %r13
cmpq $0x10, %r13
jne 0x3ddb
jmp 0x3e40
orb $0x4, 0x20(%r14)
jmp 0x3e4b
movq 0x10(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%r12)
jmp 0x3e40
orb $0x4, 0x20(%r14)
cmpl $0x0, 0x20(%r14)
jne 0x3e4b
movb $0x1, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::parse_scaling_list_8x8(ymn::istream<0>&, ymn::h264::scaling_list_nxn<64ul> (&) [6], int)
void h264_parser::parse_scaling_list_8x8(istream_be& s, h264::scaling_list_8x8 (&lists)[SL_8x8_NUM], int list)
{
    do {
        h264::scaling_list_8x8& sl = lists[list];

        if (!s.read_bits(1, sl.scaling_list_present_flag)) {
            s.mark_corrupted();
            break;
        }

        if (sl.scaling_list_present_flag)
            parse_scaling_list(s, sl.scaling_list, h264::scaling_list_default_8x8[list % 2]);

        if (s.status() != ISTREAM_STATUS_OK)
            break;

        sl.set_valid(true);
    } while (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movslq %ecx, %rax
leaq (%rax,%rax,4), %r12
shlq $0x4, %r12
leaq (%rdx,%r12), %r15
addq $0xc, %r15
movq %rsi, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x70a0
testb %al, %al
je 0x3f27
addq %r12, %rbx
cmpl $0x0, (%r15)
je 0x3f60
leaq 0x10(%rbx), %r12
movl %ebp, %eax
shrl $0x1f, %eax
addl %ebp, %eax
andl $-0x2, %eax
subl %eax, %ebp
movslq %ebp, %rax
shlq $0x6, %rax
leaq 0x15fba(%rip), %rcx     # 0x19e80
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
movb $0x8, %bpl
xorl %r13d, %r13d
leaq 0x16035(%rip), %r15     # 0x19f10
movb $0x8, %al
testb %al, %al
je 0x3efb
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x7600
testb %al, %al
je 0x3f5b
movb 0xc(%rsp), %al
addb %bpl, %al
jmp 0x3efd
xorl %eax, %eax
testq %r13, %r13
jne 0x3f06
testb %al, %al
je 0x3f2e
testb %al, %al
movzbl %al, %ecx
movzbl %bpl, %ebp
cmovnel %ecx, %ebp
movzbl (%r13,%r15), %ecx
movb %bpl, (%r12,%rcx)
incq %r13
cmpq $0x40, %r13
jne 0x3edd
jmp 0x3f60
orb $0x4, 0x20(%r14)
jmp 0x3f6b
movq 0x10(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movups %xmm3, 0x30(%r12)
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
jmp 0x3f60
orb $0x4, 0x20(%r14)
cmpl $0x0, 0x20(%r14)
jne 0x3f6b
movb $0x1, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq