LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf841(%rip), %rax      # 0x2a1e0
leaq 0xf872(%rip), %r15      # 0x2a218
cmoveq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b4f0
testq %rax, %rax
je 0x1aa08
xorl %eax, %eax
cmpl $0x0, (%rbx)
leaq 0x29a9(%rip), %rcx      # 0x1d36f
leaq 0x29fb(%rip), %rsi      # 0x1d3c8
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 0x14396
movq %rbx, %rdi
callq 0xdccb
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x1aa1f
callq 0x32a0
jmp 0x1aa1f
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b5fc
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 0x1aa3b
callq 0x32a0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf814(%rip), %rdi      # 0x2a2a8
callq 0x1b956
leaq 0xf810(%rip), %rcx      # 0x2a2b0
cmpq %rcx, %rax
je 0x1aac4
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe4fc
jmp 0x1ab47
leaq -0x1a0(%rbp), %rdi
callq 0x31f0
leaq -0x190(%rbp), %r15
leaq 0x2973(%rip), %rsi      # 0x1d451
movl $0x8, %edx
movq %r15, %rdi
callq 0x3340
movl 0xf7e7(%rip), %esi      # 0x2a2d8
movq %r15, %rdi
callq 0x3470
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x3420
leaq 0xf799(%rip), %rdi      # 0x2a2a8
movq %r14, %rsi
callq 0x1acb0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3160
incl 0xf7b0(%rip)            # 0x2a2d8
movq 0x8471(%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 0x1ab71
callq 0x32a0
jmp 0x1ab71
movq %rax, %r14
movq 0x8428(%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_O3/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 0x3db4
cmpl $0x5, %ecx
setae %al
testl %edx, %edx
sets %dil
orb %al, %dil
jne 0x3db4
imull $0xcc0, %ecx, %ecx      # imm = 0xCC0
leal 0x60(%rcx), %edi
movq 0x8(%rsi), %rax
addq %rax, %rdi
xorl %esi, %esi
cmpb $0x0, (%rdi)
je 0x3d47
incl %esi
addq $0x20, %rdi
cmpl $0x63, %esi
jne 0x3d32
movl $0x63, %esi
cmpl %edx, %esi
jle 0x3db4
movl %ecx, %esi
movl %edx, %edi
shll $0x5, %edi
addl $0x40, %edi
xorl %ecx, %ecx
cmpl $0x63, %edx
cmovael %ecx, %edi
addq %rsi, %rax
addq %rdi, %rax
addq $0x30, %rax
movb (%rax,%rcx), %dl
movb %dl, 0x7(%rsp,%rcx)
incq %rcx
cmpq $0x8, %rcx
jne 0x3d67
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 0x2d24
leaq 0x1426(%rip), %rsi      # 0x51d0
movq %rbx, %rdi
callq 0x2250
jmp 0x3dcd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13ea(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d24
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3df0
movq (%r15), %rsi
incq %rsi
callq 0x2110
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ed6
cmpl $0x5, %ecx
setae %al
testl %edx, %edx
sets %dil
orb %al, %dil
jne 0x3ed6
imull $0xcc0, %ecx, %ecx      # imm = 0xCC0
leal 0x60(%rcx), %edi
movq 0x8(%rsi), %rax
addq %rax, %rdi
xorl %esi, %esi
cmpb $0x0, (%rdi)
je 0x3e4c
incl %esi
addq $0x20, %rdi
cmpl $0x63, %esi
jne 0x3e37
movl $0x63, %esi
cmpl %edx, %esi
jle 0x3ed6
movl %ecx, %ecx
movl %edx, %esi
shll $0x5, %esi
addl $0x40, %esi
xorl %edi, %edi
cmpl $0x63, %edx
cmovael %edi, %esi
addq %rcx, %rax
movzbl 0x38(%rsi,%rax), %ecx
addl $0x7bc, %ecx            # imm = 0x7BC
movzbl 0x39(%rsi,%rax), %r8d
movzbl 0x3a(%rsi,%rax), %r9d
movzbl 0x3b(%rsi,%rax), %r10d
movzbl 0x3c(%rsi,%rax), %r11d
movzbl 0x3d(%rsi,%rax), %r15d
subq $0x8, %rsp
leaq 0x1338(%rip), %rdx      # 0x51d5
leaq 0x8(%rsp), %r14
movl $0x7f, %esi
movq %r14, %rdi
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
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 0x3eea
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x12c8(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d24
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3fde
cmpl $0x5, %ecx
setae %al
testl %edx, %edx
sets %dil
orb %al, %dil
jne 0x3fde
imull $0xcc0, %ecx, %ecx      # imm = 0xCC0
leal 0x60(%rcx), %edi
movq 0x8(%rsi), %rax
addq %rax, %rdi
xorl %esi, %esi
cmpb $0x0, (%rdi)
je 0x3f54
incl %esi
addq $0x20, %rdi
cmpl $0x63, %esi
jne 0x3f3f
movl $0x63, %esi
cmpl %edx, %esi
jle 0x3fde
movl %ecx, %ecx
movl %edx, %esi
shll $0x5, %esi
addl $0x40, %esi
xorl %edi, %edi
cmpl $0x63, %edx
cmovael %edi, %esi
addq %rcx, %rax
movzbl 0x38(%rsi,%rax), %ecx
addl $0x7bc, %ecx            # imm = 0x7BC
movzbl 0x39(%rsi,%rax), %r8d
movzbl 0x3a(%rsi,%rax), %r9d
movzbl 0x3b(%rsi,%rax), %r10d
movzbl 0x3c(%rsi,%rax), %r11d
movzbl 0x3d(%rsi,%rax), %r15d
subq $0x8, %rsp
leaq 0x124d(%rip), %rdx      # 0x51f2
leaq 0x8(%rsp), %r14
movl $0x7f, %esi
movq %r14, %rdi
xorl %eax, %eax
pushq %r15
pushq %r11
pushq %r10
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 0x3ff2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x11c0(%rip), %rdx      # 0x51ac
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2d24
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::ValidFile(int, int)
bool VoiceFile::ValidFile( int fileIndex, int folderIndex )
{
	if( !this->ValidFolder( folderIndex ) ) return false;
	if( fileIndex < 0 ) return false;
	if( fileIndex >= this->GetFileCountForFolder( folderIndex )) return false;
	return true;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
js 0x4081
cmpl $0x4, %edx
ja 0x4081
cmpb $0x0, (%rdi)
je 0x4081
imull $0xcc0, %edx, %ecx      # imm = 0xCC0
addl $0x60, %ecx
addq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
je 0x407c
incl %eax
addq $0x20, %rcx
cmpl $0x63, %eax
jne 0x4067
movl $0x63, %eax
cmpl %esi, %eax
setg %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f3e(%rip), %rbx      # 0x7fd0
leaq 0x117f(%rip), %rsi      # 0x5218
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2130
testq %r14, %r14
je 0x40c7
movq %r14, %rdi
callq 0x2070
movq 0x3f16(%rip), %rdi      # 0x7fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2130
jmp 0x40de
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2210
leaq 0x113c(%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 0x10f3(%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 0x10ed(%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 0x10b8(%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 0x10ad(%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 0x1091(%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 0x104e(%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_O3/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 0x11df0
movq %r15, %rdi
movq %r14, %rsi
callq 0x10516
testl %eax, %eax
js 0xe82a
movq 0x8(%r15), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
je 0xe82a
movq %rbx, %rdi
callq 0x11ef8
jmp 0xe848
movq (%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x11df0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14532
testl %eax, %eax
je 0xe862
leaq 0x8(%rsp), %rdi
callq 0x11fa8
movq %rbx, %rax
addq $0x450, %rsp            # imm = 0x450
popq %rbx
popq %r14
popq %r15
retq
leaq 0x487d7(%rip), %rdi     # 0x57040
movq %r14, %rsi
xorl %eax, %eax
callq 0x566f2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xc470
movq %rax, %r14
movq %rbx, %rdi
callq 0x11fa8
jmp 0xe88d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x11fa8
movq %r14, %rdi
callq 0xc650
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe94a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
xorl %r12d, %r12d
leaq 0x4879a(%rip), %r14     # 0x5705b
leaq 0x4879a(%rip), %r15     # 0x57062
movq (%rbx,%r12,8), %r13
cmpb $0x2d, (%r13)
jne 0xe8e1
cmpb $0x76, 0x1(%r13)
jne 0xe8e1
cmpb $0x0, 0x2(%r13)
je 0xe92d
movq %r13, %rdi
movq %r14, %rsi
callq 0xc500
testl %eax, %eax
je 0xe91b
movq %r13, %rdi
movq %r15, %rsi
callq 0xc500
testl %eax, %eax
je 0xe924
movq %r13, %rdi
leaq 0x48777(%rip), %rsi     # 0x57080
callq 0xc500
testl %eax, %eax
jne 0xe934
movb $0x0, 0x6e1a7(%rip)     # 0x7cac0
jmp 0xe934
movb $0x1, 0x6e19a(%rip)     # 0x7cabc
jmp 0xe934
movb $0x1, 0x6e195(%rip)     # 0x7cac0
jmp 0xe934
movb $0x1, 0x6e184(%rip)     # 0x7cab8
incq %r12
cmpq %r12, %rbp
jne 0xe8c8
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_O3/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 0x470a6(%rip), %rsi     # 0x573c1
callq 0xc500
movl $0x1, %ebx
testl %eax, %eax
je 0x10397
leaq 0x470b8(%rip), %rsi     # 0x573e8
movq %r14, %rdi
callq 0xc500
testl %eax, %eax
je 0x10397
movzbl (%r14), %eax
testl %eax, %eax
je 0x1038d
cmpl $0x2b, %eax
jne 0x10350
movb 0x1(%r14), %al
incq %r14
movzbl %al, %ecx
testb %cl, %cl
je 0x10395
cmpl $0x2d, %ecx
jne 0x10363
movb 0x1(%r14), %al
incq %r14
testb %al, %al
je 0x10391
incq %r14
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x10381
cmpb $0x45, %al
je 0x10381
movzbl %al, %eax
cmpl $0x2e, %eax
jne 0x10391
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x1036a
jmp 0x10397
movl %eax, %ebx
jmp 0x10397
xorl %ebx, %ebx
jmp 0x10397
movl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x6c718(%rip)     # 0x7cac0
je 0x103b3
movsd 0x46c86(%rip), %xmm0    # 0x57038
retq
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, 0x6c70a(%rip)     # 0x7cac8
je 0x10402
movq %rbx, %rdi
callq 0x15f56
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x103d8
sqrtsd %xmm0, %xmm0
jmp 0x103e1
callq 0xc2c0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x103fb
movsd 0x46c49(%rip), %xmm1    # 0x57038
divsd %xmm0, %xmm1
movsd %xmm1, 0x6bfb5(%rip)    # 0x7c3b0
movq %rbx, 0x6c6c6(%rip)     # 0x7cac8
movsd 0x6bfa6(%rip), %xmm0    # 0x7c3b0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
jne 0x4a8b
movq (%r15), %rdi
jmp 0x4ae8
cmpq %r12, %r15
je 0x4ad5
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 0x5c9a
movq -0x48(%rbp), %rdi
callq 0x2140
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4acc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
addq $0x20, %r15
cmpq %r12, %r15
jne 0x4a98
movq 0x160(%rbx), %rdi
callq 0x2140
movq 0x180(%rbx), %rdi
callq 0x2140
leaq 0x120(%rbx), %rsi
leaq 0x140(%rbx), %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x5a54
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 0x4b36
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 0x4b6b
jmp 0x4b77
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4b77
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2870(%rip), %rsi      # 0x7405
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2250
cmpq $-0x1, %rax
je 0x4bf4
movq %rax, %r14
leaq 0x28b3(%rip), %r15      # 0x7467
leaq 0x284a(%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 0x4bbb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5112(%rip), %rbx      # 0x9fd8
leaq 0x270b(%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 0x5280(%rip), %r14      # 0xa188
leaq 0x5269(%rip), %r15      # 0xa178
cmpq %r15, %r14
je 0x4fd6
movq 0x50b9(%rip), %r12      # 0x9fd8
leaq 0x26c7(%rip), %r13      # 0x75ed
leaq 0x20(%r14), %rsi
leaq -0x68(%rbp), %rdi
callq 0x5ab8
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 0x4fa9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4fc2
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
cmpq %r15, %rax
jne 0x4f26
movq 0x4ffb(%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 0x5b24
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1dced(%rip), %rdi     # 0x212a8
callq 0x2080
testb %al, %al
je 0x35d6
leaq 0x1dc6d(%rip), %rdi     # 0x21238
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2200
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x7dac
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36ff
movq $0x0, 0x60(%rbx)
jmp 0x3703
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x373a
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3794
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 0x3786
movslq %edi, %r8
addq %rcx, %r8
movl $0xa, %r9d
cmpb $0x47, (%r8)
jne 0x3786
addq %rsi, %r8
decq %r9
jne 0x3776
movl %edi, %eax
incq %rdi
cmpq %rsi, %rdi
jae 0x3793
cmpl $-0x1, %eax
je 0x375f
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %r12
xorl %r14d, %r14d
leaq 0x14da7(%rip), %r13     # 0x18560
xorl %ebp, %ebp
movq (%rbp,%r13), %r15
leaq (%r15,%r15,4), %rax
leaq (%r15,%rax,2), %rax
cmpq %rax, %r12
jb 0x384c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3740
cmpl $-0x1, %eax
jne 0x380c
addq $0x8, %rbp
cmpq $0x18, %rbp
jne 0x37bb
movl $0xbc, %eax
cmpq %rax, %r12
cmovbq %r12, %rax
addq %rax, 0x80(%rbx)
subq %rax, %r12
movq %r12, 0x88(%rbx)
movl $0x4, %r14d
jmp 0x384c
cltq
cmpq %rax, %r12
cmovbq %r12, %rax
addq %rax, 0x80(%rbx)
subq %rax, %r12
movq %r12, 0x88(%rbx)
leaq 0x31(%rip), %rax        # 0x385e
movq %rax, 0x108(%rbx)
movq $0x0, 0x110(%rbx)
movq %r15, 0x118(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3abb
movl %esi, %eax
leaq 0x14b2e(%rip), %rcx     # 0x18578
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x118, %rdi            # imm = 0x118
jmp 0x3ac5
addq $0x87960, %rdi          # imm = 0x87960
jmp 0x3ac5
cmpl $-0x1, %edx
jne 0x3a70
movl 0x87930(%rdi), %edx
cmpl $0xff, %edx
ja 0x3abb
movl %edx, %eax
imulq $0x718, %rax, %rax      # imm = 0x718
addq %rax, %rdi
addq $0x16130, %rdi          # imm = 0x16130
jmp 0x3ac5
addq $0x87938, %rdi          # imm = 0x87938
jmp 0x3ac5
cmpl $-0x1, %edx
jne 0x3aa1
movl 0x16128(%rdi), %edx
cmpl $0x1f, %edx
ja 0x3abb
movl %edx, %eax
imulq $0xb00, %rax, %rax      # imm = 0xB00
addq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
jmp 0x3ac5
xorl %eax, %eax
retq
addq $0x882e0, %rdi          # imm = 0x882E0
xorl %eax, %eax
cmpb $0x0, 0x8(%rdi)
cmovneq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0xa0(%rdi), %r8
movq 0xc0(%rdi), %rcx
testq %r8, %r8
sets %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x3b7c
movq %rbx, %rdi
callq 0x3ad0
testb %al, %al
je 0x3b8c
movq 0x80(%rbx), %rax
movq 0xc0(%rbx), %rcx
movq %rax, 0xa0(%rbx)
leaq (%rcx,%rax), %rdx
xorl %r8d, %r8d
testq %rax, %rax
cmovnsq %rdx, %r8
jmp 0x3b7f
addq %rcx, %r8
movq 0x88(%rbx), %rdx
cmpq $0x3, %rdx
jae 0x3b90
xorl %eax, %eax
jmp 0x3be3
movq 0x80(%rbx), %rdi
leaq -0x2(%rdx), %rsi
leal (%rdi,%rcx), %eax
subl %r8d, %eax
movq %rdi, %r8
cmpb $0x0, (%rcx,%r8)
jne 0x3bbb
cmpb $0x0, 0x1(%rcx,%r8)
jne 0x3bbb
cmpb $0x2, 0x2(%rcx,%r8)
jb 0x3be5
incq %r8
decq %rdx
incl %eax
cmpq $0x2, %rdx
jne 0x3ba4
addq %rdi, %rsi
movq %rsi, 0x80(%rbx)
movq $0x2, 0x88(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
movq %r8, 0x80(%rbx)
movq %rdx, 0x88(%rbx)
jmp 0x3be3
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6ee2
testb %al, %al
je 0x3cc7
addq %r12, %rbx
cmpl $0x0, (%r15)
je 0x3ce2
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 0x151fa(%rip), %rcx     # 0x18e60
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
movb $0x8, %bpl
xorl %r13d, %r13d
leaq 0x15285(%rip), %r15     # 0x18f00
movb $0x8, %al
testb %al, %al
je 0x3c9b
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x7410
testb %al, %al
je 0x3cdd
movb 0xc(%rsp), %al
addb %bpl, %al
jmp 0x3c9d
xorl %eax, %eax
testq %r13, %r13
jne 0x3ca6
testb %al, %al
je 0x3cce
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 0x3c7d
jmp 0x3ce2
orb $0x4, 0x20(%r14)
jmp 0x3ced
movq 0x10(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%r12)
jmp 0x3ce2
orb $0x4, 0x20(%r14)
cmpl $0x0, 0x20(%r14)
jne 0x3ced
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_O3/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 0x6ee2
testb %al, %al
je 0x3dc9
addq %r12, %rbx
cmpl $0x0, (%r15)
je 0x3e02
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 0x15118(%rip), %rcx     # 0x18e80
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
movb $0x8, %bpl
xorl %r13d, %r13d
leaq 0x15193(%rip), %r15     # 0x18f10
movb $0x8, %al
testb %al, %al
je 0x3d9d
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x7410
testb %al, %al
je 0x3dfd
movb 0xc(%rsp), %al
addb %bpl, %al
jmp 0x3d9f
xorl %eax, %eax
testq %r13, %r13
jne 0x3da8
testb %al, %al
je 0x3dd0
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 0x3d7f
jmp 0x3e02
orb $0x4, 0x20(%r14)
jmp 0x3e0d
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 0x3e02
orb $0x4, 0x20(%r14)
cmpl $0x0, 0x20(%r14)
jne 0x3e0d
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_O3/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::parse_scaling_matrices_4x4(ymn::istream<0>&, ymn::h264::scaling_matrices&)
void h264_parser::parse_scaling_matrices_4x4(istream_be& s, h264::scaling_matrices& sm)
{
    do {
        parse_scaling_list_4x4(s, sm.scaling_matrices_4x4, SL_4x4_INTRA_Y);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        parse_scaling_list_4x4(s, sm.scaling_matrices_4x4, SL_4x4_INTRA_Cb);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        parse_scaling_list_4x4(s, sm.scaling_matrices_4x4, SL_4x4_INTRA_Cr);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        parse_scaling_list_4x4(s, sm.scaling_matrices_4x4, SL_4x4_INTER_Y);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        parse_scaling_list_4x4(s, sm.scaling_matrices_4x4, SL_4x4_INTER_Cb);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        parse_scaling_list_4x4(s, sm.scaling_matrices_4x4, SL_4x4_INTER_Cr);
        if (s.status() != ISTREAM_STATUS_OK)
            break;
    } while (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
addq $0x10, %rbx
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3bf6
cmpl $0x0, 0x20(%r14)
jne 0x3e97
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x3bf6
cmpl $0x0, 0x20(%r14)
jne 0x3e97
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2, %ecx
callq 0x3bf6
cmpl $0x0, 0x20(%r14)
jne 0x3e97
movq %r14, %rsi
movq %rbx, %rdx
movl $0x3, %ecx
callq 0x3bf6
cmpl $0x0, 0x20(%r14)
jne 0x3e97
movq %r14, %rsi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0x3bf6
cmpl $0x0, 0x20(%r14)
je 0x3e9f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rsi
movq %rbx, %rdx
movl $0x5, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3bf6
// File: /workspace/github_cpp_makefile_star2_O3/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::parse_scaling_matrices_8x8(ymn::istream<0>&, ymn::h264::scaling_matrices&, unsigned int)
void h264_parser::parse_scaling_matrices_8x8(istream_be& s, h264::scaling_matrices& sm, uint32_t chroma_format_idc)
{
    do {
        parse_scaling_list_8x8(s, sm.scaling_matrices_8x8, SL_8x8_INTRA_Y);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        parse_scaling_list_8x8(s, sm.scaling_matrices_8x8, SL_8x8_INTER_Y);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        if (3 == chroma_format_idc) {
            parse_scaling_list_8x8(s, sm.scaling_matrices_8x8, SL_8x8_INTRA_Cb);
            if (s.status() != ISTREAM_STATUS_OK)
                break;

            parse_scaling_list_8x8(s, sm.scaling_matrices_8x8, SL_8x8_INTER_Cb);
            if (s.status() != ISTREAM_STATUS_OK)
                break;

            parse_scaling_list_8x8(s, sm.scaling_matrices_8x8, SL_8x8_INTRA_Cr);
            if (s.status() != ISTREAM_STATUS_OK)
                break;

            parse_scaling_list_8x8(s, sm.scaling_matrices_8x8, SL_8x8_INTER_Cr);
            if (s.status() != ISTREAM_STATUS_OK)
                break;
        }
    } while (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
addq $0xd0, %rbx
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3cfc
cmpl $0x0, 0x20(%r14)
je 0x3edf
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x3cfc
cmpl $0x3, %ebp
jne 0x3eda
cmpl $0x0, 0x20(%r14)
jne 0x3eda
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2, %ecx
callq 0x3cfc
cmpl $0x0, 0x20(%r14)
jne 0x3eda
movq %r14, %rsi
movq %rbx, %rdx
movl $0x3, %ecx
callq 0x3cfc
cmpl $0x0, 0x20(%r14)
jne 0x3eda
movq %r14, %rsi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0x3cfc
cmpl $0x0, 0x20(%r14)
jne 0x3eda
movq %r14, %rsi
movq %rbx, %rdx
movl $0x5, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x3cfc
// File: /workspace/github_cpp_makefile_star2_O3/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::parse_scaling_matrices(ymn::istream<0>&, ymn::h264::scaling_matrices&, bool, unsigned int)
bool h264_parser::parse_scaling_matrices(istream_be& s, h264::scaling_matrices& sm, bool parse8x8, uint32_t chroma_format_idc)
{
    bool retval = false;

    do {
        parse_scaling_matrices_4x4(s, sm);
        if (s.status() != ISTREAM_STATUS_OK)
            break;

        if (parse8x8) {
            parse_scaling_matrices_8x8(s, sm, chroma_format_idc);
            if (s.status() != ISTREAM_STATUS_OK)
                break;
        }

        sm.set_valid(true);
        retval = true;
    } while (0);

    return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r14
callq 0x3e1c
cmpl $0x0, 0x20(%r14)
je 0x3f77
xorl %eax, %eax
jmp 0x3f96
testb %r15b, %r15b
je 0x3f90
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x3eb6
cmpl $0x0, 0x20(%r14)
jne 0x3f73
movb $0x1, 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::parse_ref_pic_list_modification(ymn::istream<0>&, ymn::h264::ref_pic_list_modification&)
bool h264_parser::parse_ref_pic_list_modification(istream_be& s, h264::ref_pic_list_modification& rplm)
{
    bool retval = false;

    do {
        s.read_bits(1, rplm.ref_pic_list_modification_flag_lx);
        if (rplm.ref_pic_list_modification_flag_lx) {
            size_t i = 0;
            uint32_t modification_of_pic_nums_idc;
            uint32_t abs_diff_pic_num_minus1;
            uint32_t long_term_pic_num;

            do {
                s.read_exp_golomb_u(modification_of_pic_nums_idc);

                if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1)
                    s.read_exp_golomb_u(abs_diff_pic_num_minus1);
                else
                if (modification_of_pic_nums_idc == 2)
                    s.read_exp_golomb_u(long_term_pic_num);

                if (i < TABLE_ELEMENTS(rplm.m)) {
                    rplm.m[i].modification_of_pic_nums_idc = modification_of_pic_nums_idc;
                    if (modification_of_pic_nums_idc == 0 || modification_of_pic_nums_idc == 1)
                        rplm.m[i].u.abs_diff_pic_num_minus1 = abs_diff_pic_num_minus1;
                    else
                    if (modification_of_pic_nums_idc == 2)
                        rplm.m[i].u.long_term_pic_num = long_term_pic_num;
                }

                i++;
            } while ((s.status() == ISTREAM_STATUS_OK) && (modification_of_pic_nums_idc != 3));
        }

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

        rplm.set_valid(true);
        retval = true;
    }while (0);

    return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
addq $0xc, %rdx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x6ee2
cmpl $0x0, 0xc(%rbx)
je 0x44d2
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
leaq 0x14(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x70b4
movl 0xc(%rsp), %eax
movq %r13, %rsi
cmpl $0x2, %eax
jb 0x4495
movq %rbp, %rsi
jne 0x44a1
movq %r14, %rdi
callq 0x70b4
movl 0xc(%rsp), %eax
cmpq $0x3, %r12
ja 0x44c0
movl %eax, 0x10(%rbx,%r12,8)
movq %r13, %rcx
cmpl $0x2, %eax
jb 0x44b9
movq %rbp, %rcx
jne 0x44c0
movl (%rcx), %ecx
movl %ecx, 0x14(%rbx,%r12,8)
movl 0x20(%r14), %ecx
testl %ecx, %ecx
jne 0x44d6
incq %r12
cmpl $0x3, %eax
jne 0x4479
jmp 0x44d6
movl 0x20(%r14), %ecx
testl %ecx, %ecx
jne 0x44de
movb $0x1, 0x8(%rbx)
testl %ecx, %ecx
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lukasz-wiecaszek[P]h264iframedecoder/h264_parser.cpp
// Function: ymn::h264_parser::parse_pred_weight_table(ymn::istream<0>&, ymn::h264::pred_weight_table&)
bool h264_parser::parse_pred_weight_table(istream_be& s, h264::pred_weight_table& pwt)
{
    bool retval = false;

    do {
        s.read_exp_golomb_u(pwt.luma_log2_weight_denom);
        if (pwt.chroma_components_present)
            s.read_exp_golomb_u(pwt.chroma_log2_weight_denom);

        h264_parser_parse_pred_weight_table_lx(s, pwt.l0, pwt.num_ref_idx_l0_active_minus1, pwt.chroma_components_present);

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

        if (h264::slice_type_e::B == pwt.slice_type)
            h264_parser_parse_pred_weight_table_lx(s, pwt.l1, pwt.num_ref_idx_l1_active_minus1, pwt.chroma_components_present);

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

        pwt.set_valid(true);
        retval = true;
    } while (0);

    return retval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x14(%rdx), %rsi
movq %r14, %rdi
callq 0x70b4
cmpb $0x1, 0x10(%rbx)
jne 0x451f
leaq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x70b4
movb 0x10(%rbx), %al
jmp 0x4521
xorl %eax, %eax
leaq 0x20(%rbx), %rsi
movl 0x1c(%rbx), %edx
movzbl %al, %ecx
andl $0x1, %ecx
movq %r14, %rdi
callq 0x4575
cmpl $0x0, 0x20(%r14)
je 0x4541
xorl %eax, %eax
jmp 0x456d
cmpl $0x1, 0xc(%rbx)
jne 0x4567
leaq 0x424(%rbx), %rsi
movl 0x420(%rbx), %edx
movzbl 0x10(%rbx), %ecx
movq %r14, %rdi
callq 0x4575
cmpl $0x0, 0x20(%r14)
jne 0x453d
movb $0x1, 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq