LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/btreeindex/btreeindexbuilder_impl.h
// Function: hm3::btreeindex::BTreeIndexBuilder<hm3::DiskTable>::createFromList(StringRef const&, hm3::DiskTable const&)
bool BTreeIndexBuilder<LIST>::createFromList(const StringRef &filename, const LIST &list){
	auto const count = list.getCount();

	levels_ = calcDepth1__(count);

	printf("Records          : %zu\n",		size_t{ count }	);
	printf("Branching Factor : %u (const)\n",	BRANCHES	);
	printf("Tree Depth       : %u\n",		levels_		);

	file_indx_.open(filenameIndx(filename),	std::ios::out | std::ios::binary);
	file_data_.open(filenameData(filename),	std::ios::out | std::ios::binary);

	current_ = 0;

	for(level_type level = 0; level < levels_; ++level){
		printf("Processing level %u...\n", level);

		reorder(list, 0, count, level);
	}

	file_indx_.close();
	file_data_.close();

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%rdx), %r15
movq %r15, %rdi
callq 0x2816
movzbl %al, %eax
movw %ax, 0x408(%rbx)
leaq 0x2985(%rip), %rdi      # 0x501f
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x298c(%rip), %rdi      # 0x5037
movl $0x80, %esi
xorl %eax, %eax
callq 0x2030
movzwl 0x408(%rbx), %esi
leaq 0x2991(%rip), %rdi      # 0x5056
xorl %eax, %eax
callq 0x2030
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x282c
pushq $0x14
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x200(%rbx), %r12
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2861
pushq $0x14
popq %rdx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20b0
andq $0x0, 0x400(%rbx)
xorl %r13d, %r13d
leaq 0x2938(%rip), %rbp      # 0x506d
movzbl %r13b, %r13d
cmpw %r13w, 0x408(%rbx)
jbe 0x276b
movq %rbp, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x2896
incb %r13b
jmp 0x2735
movq %rbx, %rdi
callq 0x2200
movq %r12, %rdi
callq 0x2200
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x278e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/btreeindex/btreeindexbuilder_impl.h
// Function: hm3::btreeindex::BTreeIndexBuilder<hm3::DiskTable>::injectEmptyNode_(unsigned char, unsigned char)
void BTreeIndexBuilder<LIST>::injectEmptyNode_(level_type const level, level_type const this_level){
	if (this_level == level){
		// add empty node

		Node node;

		// fill gets refference to NIL
		auto const nil = Node::NIL;
		std::fill_n(node.values, VALUES, nil);

		// push the node
		file_indx_.write( (const char *) & node, sizeof node );
	}else if (this_level < level){
		// add children
		for(branch_type i = 0; i < BRANCHES; ++i)
			injectEmptyNode_( level, level_type(this_level + 1) );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %rbx
cmpb %sil, %dl
jne 0x2b00
xorl %eax, %eax
cmpq $0x3f8, %rax            # imm = 0x3F8
je 0x2b27
orq $-0x1, (%rsp,%rax)
addq $0x8, %rax
jmp 0x2aed
jae 0x2b37
incb %dl
movw $0x80, %r15w
movzbl %sil, %ebp
movzbl %dl, %r14d
subw $0x1, %r15w
jb 0x2b37
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2ad6
jmp 0x2b11
movq %rsp, %rsi
movl $0x3f8, %edx            # imm = 0x3F8
movq %rbx, %rdi
callq 0x21e0
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/btreeindex/btreeindexbuilder_impl.h
// Function: hm3::btreeindex::BTreeIndexBuilder<hm3::DiskTable>::injectValue_(hm3::DiskTable const&, unsigned long)
void BTreeIndexBuilder<LIST>::injectValue_(const LIST &list, size_type const index){
	// we need to have the pair,
	// because key "live" inside it.
	const auto &p = list.getAt(index);
	const StringRef &key = p.getKey();

	{
		NodeData nd;
		nd.keysize = htobe16(key.size());
		nd.dataid  = htobe64(index);

		// push NodeData
		file_data_.write( (const char *) &nd, sizeof nd );

		// push the key
		file_data_.write( key.data(), (std::streamsize) key.size() );
	}

	current_ += sizeof(uint16_t) + sizeof(uint64_t) + key.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2be0
movq %r14, %rdi
callq 0x2c90
movq %rax, %r14
movq %rdx, %r15
rolw $0x8, %ax
leaq 0xe(%rsp), %rsi
movw %ax, (%rsi)
bswapq %r12
movq %r12, 0x2(%rsi)
leaq 0x200(%rbx), %r12
pushq $0xa
popq %rdx
movq %r12, %rdi
callq 0x21e0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21e0
movq 0x400(%rbx), %rax
addq %r14, %rax
addq $0xa, %rax
movq %rax, 0x400(%rbx)
movq %rsp, %rdi
callq 0x2c0c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2c0c
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/player.cpp
// Function: ReadBuf(png_struct_def*, unsigned char*, unsigned long)
void ReadBuf(
    png_structp png_ptr, png_byte* raw_data, png_size_t read_length) {

    read_buf_str_t* read_buf_str = (read_buf_str_t*)png_get_io_ptr(png_ptr);
    const png_byte* src = read_buf_str->buf + read_buf_str->pos;
    memcpy(raw_data, src, read_length);
    read_buf_str->pos += read_length;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x2220
movq %rax, %r15
movl 0xc(%rax), %esi
addq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x21e0
addl %ebx, 0xc(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::ReadAVI(char const*)
ReadAVI::ReadAVI(const char *filename)
{
    data_buf = NULL;
    stream_format_vid.palette = NULL;
    data_buf_size = 0;
    inFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    inFile.open(filename, ios_base::ate | ios_base::in | ios_base::binary);
    fileSize = inFile.tellg();
    inFile.close();
    inFile.open(filename, ios_base::in | ios_base::binary);
    try {
	parse_riff();
    } catch (std::system_error& e) { //file corrupted?
	std::cerr << e.code().message() << "\n";
	if (index_entries.size() == 0) {
	    free();
	    throw;
	}
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x51c6(%rip), %rax      # 0x7d58
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x22a0
andq $0x0, 0x338(%rbx)
andq $0x0, 0x2c8(%rbx)
andl $0x0, 0x340(%rbx)
movq 0x20(%rbx), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
pushq $0x5
popq %rsi
callq 0x20f0
pushq $0xe
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2410
movq %rax, 0x328(%rbx)
movq %r14, %rdi
callq 0x20a0
pushq $0xc
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2cce
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x2cb1
movq %r15, %rdi
callq 0x2120
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq 0x53a9(%rip), %rdi      # 0x7ff0
movq %rsp, %rsi
callq 0x2200
leaq 0x2d37(%rip), %rsi      # 0x598d
movq %rax, %rdi
callq 0x2230
movq %rsp, %rdi
callq 0x2130
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x2c77
callq 0x23f0
jmp 0x2c12
movq %rbx, %rdi
callq 0x30d2
callq 0x23b0
jmp 0x2c88
jmp 0x2cae
movq %rax, %r15
jmp 0x2c98
movq %rax, %r15
movq %rsp, %rdi
callq 0x2130
callq 0x23f0
jmp 0x2cb1
movq %rax, %rdi
callq 0x2b70
jmp 0x2cae
movq %rax, %r15
jmp 0x2cb9
movq %rax, %r15
movq %r14, %rdi
callq 0x20d0
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x42c0
movq %r15, %rdi
callq 0x2430
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::free()
void ReadAVI::free()
{
    if (inFile.is_open()) {
	inFile.close();
    }

    delete[] stream_format_vid.palette;
    delete[] data_buf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x98, %rdi
callq 0x20b0
testb %al, %al
je 0x30ef
leaq 0x20(%rbx), %rdi
callq 0x20a0
movq 0x2c8(%rbx), %rdi
testq %rdi, %rdi
je 0x3100
callq 0x2300
movq 0x338(%rbx), %rdi
testq %rdi, %rdi
je 0x3112
popq %rbx
jmp 0x2300
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::check_data_buf(unsigned int)
void ReadAVI::check_data_buf(unsigned size)
{
    if (data_buf_size < size) {
	delete[] data_buf;
	data_buf = new unsigned char[size + 1];
	data_buf_size = size;
    }
}

// Assembly:
cmpl %esi, 0x340(%rdi)
jae 0x319d
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x338(%rdi), %rdi
testq %rdi, %rdi
je 0x3180
callq 0x2300
leal 0x1(%rbx), %edi
callq 0x2040
movq %rax, 0x338(%r14)
movl %ebx, 0x340(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::GetFrameFromIndex(ReadAVI::frame_entry_t*)
int ReadAVI::GetFrameFromIndex(frame_entry_t *frame_entry)
{
    if (frame_entry->pointer >= index_entries.size()){
	MSG_DBG(2, "Pointer out of range\n");
	return -5;
    }
    for (unsigned i = frame_entry->pointer; i < index_entries.size(); i++) {
	if (index_entries[i].type & frame_entry->type) {
	    check_data_buf(index_entries[i].dwChunkLength);
	    try {
		inFile.seekg(index_entries[i].dwChunkOffset, ios_base::beg);
		read_chars_bin(data_buf, index_entries[i].dwChunkLength);
	    } catch (...) {
		return -1;
	    }
	    frame_entry->buf = data_buf;
	    frame_entry->pointer = i + 1;
	    frame_entry->stream_num = index_entries[i].stream_num;
	    frame_entry->type = index_entries[i].type;
	    return index_entries[i].dwChunkLength;
	}
    }
    MSG_DBG(2, "No more frames\n");
    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x10(%rsi), %r15d
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
subq %rcx, %rax
pushq $0x14
popq %rsi
cqto
idivq %rsi
cmpq %r15, %rax
jbe 0x31e1
movq %rdi, %r14
movl %r15d, %r15d
cmpq %r15, %rax
jbe 0x3201
imulq $0x14, %r15, %r12
movl (%rbx), %edx
testl %edx, (%rcx,%r12)
jne 0x3222
incl %r15d
jmp 0x31c8
movq 0x4dc8(%rip), %rax      # 0x7fb0
movq (%rax), %rcx
leaq 0x1f6e(%rip), %rdi      # 0x5160
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2440
pushq $-0x5
jmp 0x321f
movq 0x4da8(%rip), %rax      # 0x7fb0
movq (%rax), %rcx
leaq 0x1f64(%rip), %rdi      # 0x5176
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x2440
pushq $-0x1
popq %rax
jmp 0x327e
addq %r12, %rcx
movl 0x10(%rcx), %esi
movq %r14, %rdi
callq 0x315e
leaq 0x20(%r14), %rdi
movq 0x8(%r14), %rax
movslq 0xc(%rax,%r12), %rsi
xorl %edx, %edx
callq 0x2330
movq 0x338(%r14), %rsi
movq 0x8(%r14), %rax
movl 0x10(%rax,%r12), %edx
movq %r14, %rdi
callq 0x329a
movq 0x338(%r14), %rax
movq %rax, 0x8(%rbx)
incl %r15d
movl %r15d, 0x10(%rbx)
movq 0x8(%r14), %rax
movq (%rax,%r12), %rcx
movq %rcx, (%rbx)
movl 0x10(%rax,%r12), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x2120
callq 0x23f0
jmp 0x321d
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::hex_dump_chunk(int)
int ReadAVI::hex_dump_chunk(int chunk_len)
{
    char chars[17];
    unsigned char c;
    int ch, n;

    chars[16] = 0;

    for (n = 0; n < chunk_len; n++) {
	if ((n % 16) == 0) {
	    if (n != 0)
		MSG_DBG(2, "%s\n", chars);
	    MSG_DBG(2, "      ");
	    memset(chars, ' ', 16);
	}
	read_chars_bin(&c, 1);
	ch = c;
	if (ch == EOF)
	    break;
	MSG_DBG(2, "%02x ", ch);
	if (ch >= ' ' && ch <= 126) {
	    chars[n % 16] = ch;
	} else {
	    chars[n % 16] = '.';
	}
    }

    if ((n % 16) != 0) {
	for (ch = n % 16; ch < 16; ch++) {
	    MSG_DBG(2, "   ");
	}
    }
    MSG_DBG(2, "%s\n", chars);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movb $0x0, 0x10(%rax)
addq $0x20, %r14
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebx
movq 0x4cdc(%rip), %r15      # 0x7fb0
xorl %r12d, %r12d
cmpl %r12d, %ebx
je 0x3368
movl %r12d, %ebp
andl $0xf, %ebp
jne 0x3324
testl %r12d, %r12d
je 0x3303
movq (%r15), %rdi
leaq 0x2186(%rip), %rsi      # 0x547d
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x2380
movq (%r15), %rcx
leaq 0x1e79(%rip), %rdi      # 0x5186
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x2440
movaps 0x1e31(%rip), %xmm0     # 0x5150
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
leaq 0xf(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x22f0
movzbl 0xf(%rsp), %r13d
movq (%r15), %rdi
leaq 0x1e49(%rip), %rsi      # 0x518d
movl %r13d, %edx
xorl %eax, %eax
callq 0x2380
leal -0x20(%r13), %eax
cmpb $0x5f, %al
pushq $0x2e
popq %rax
cmovael %eax, %r13d
movb %r13b, 0x10(%rsp,%rbp)
incl %r12d
jmp 0x32d7
andl $0xf, %ebx
je 0x3396
leaq 0x1e15(%rip), %r14      # 0x5189
pushq $0x3
popq %r13
pushq $0x1
popq %r12
cmpl $0xf, %ebx
ja 0x3396
movq (%r15), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2440
incl %ebx
jmp 0x337c
movq (%r15), %rdi
leaq 0x20dd(%rip), %rsi      # 0x547d
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x2380
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::decodeCkid(char*, ReadAVI::chunk_type_t*)
int ReadAVI::decodeCkid(char *ckid, chunk_type_t *chunk_type)
{
    int stream = (ckid[0] - '0') * 10 + (ckid[1] - '0');
    for (int i = 0; i < ChunkTypesCnt; i++) {
	if (chunk_types[i].type_id[0] == ckid[2] && chunk_types[i].type_id[1] == ckid[3]) {
	    *chunk_type = chunk_types[i].type;
	    return stream;
	}
    }
    return -1;
}

// Assembly:
movsbl (%rsi), %ecx
movsbl 0x1(%rsi), %eax
movb 0x2(%rsi), %r8b
xorl %edi, %edi
leaq 0x4e7e(%rip), %r9       # 0x8250
cmpq $0x4, %rdi
je 0x33f5
cmpb %r8b, (%r9,%rdi,8)
jne 0x33e9
movb 0x1(%r9,%rdi,8), %r10b
cmpb 0x3(%rsi), %r10b
je 0x33ee
incq %rdi
jmp 0x33d2
movl 0x4(%r9,%rdi,8), %esi
movl %esi, (%rdx)
imull $0xa, %ecx, %ecx
cmpq $0x4, %rdi
leal -0x210(%rax,%rcx), %ecx
pushq $-0x1
popq %rax
cmovbl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::parse_idx1(int)
int ReadAVI::parse_idx1(int chunk_len)
{
    index_entry_t index_entry;
    index_entry.type = ctype_none;
    int t;

    MSG_DBG(2, "      IDX1\n");
    MSG_DBG(2, "      -------------------------------\n");
    MSG_DBG(2, "      stream  type   dwFlags         dwChunkOffset        dwChunkLength\n");

    for (t = 0; t < chunk_len / 16; t++) {
	char buf[5];
	read_chars(buf, 4);
	index_entry.stream_num = decodeCkid(buf, &index_entry.type);
	index_entry.dwFlags = read_int();
	index_entry.dwChunkOffset = read_int() + movi_offset + 0x10;
	index_entry.dwChunkLength = read_int();

	MSG_DBG(2, "         %d     %d     0x%08x      0x%08x           0x%08x\n", index_entry.stream_num, index_entry.type,
		index_entry.dwFlags, index_entry.dwChunkOffset, index_entry.dwChunkLength);
	index_entries.push_back(index_entry);
    }

    MSG_DBG(2, "\n");

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
movl %esi, %ebp
movq %rdi, %r14
movq 0x4b84(%rip), %r12      # 0x7fb0
movq (%r12), %rcx
leaq 0x1d5c(%rip), %rdi      # 0x5193
pushq $0xb
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x2440
movq (%r12), %rcx
leaq 0x1d4e(%rip), %rdi      # 0x519f
pushq $0x26
popq %rsi
movq %r15, %rdx
callq 0x2440
movq (%r12), %rcx
leaq 0x1d5f(%rip), %rdi      # 0x51c6
pushq $0x48
popq %rsi
movq %r15, %rdx
callq 0x2440
pushq $0x10
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %ebp
leaq 0x8(%r14), %r15
leaq 0x23(%rsp), %r12
xorl %r13d, %r13d
cmpl %ebp, %r13d
jge 0x351e
movq %r14, %rdi
movq %r12, %rsi
pushq $0x4
popq %rdx
callq 0x3542
movq %r12, %rsi
movq %rbx, %rdx
callq 0x33be
movl %eax, 0x10(%rsp)
movq %r14, %rdi
callq 0x3566
movl %eax, 0x14(%rsp)
movq %r14, %rdi
callq 0x3566
movl 0x330(%r14), %ecx
addl %ecx, %eax
addl $0x10, %eax
movl %eax, 0x18(%rsp)
movq %r14, %rdi
callq 0x3566
movl %eax, 0x1c(%rsp)
movq 0x4acb(%rip), %rcx      # 0x7fb0
movq (%rcx), %rdi
movl 0xc(%rsp), %ecx
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %r8d
movl 0x18(%rsp), %r9d
movl %eax, (%rsp)
leaq 0x1d0b(%rip), %rsi      # 0x520f
xorl %eax, %eax
callq 0x2380
movq %r15, %rdi
movq %rbx, %rsi
callq 0x429c
incl %r13d
jmp 0x3488
movq 0x4a8b(%rip), %rax      # 0x7fb0
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x22e0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::read_int()
int ReadAVI::read_int()
{
    int c;
    unsigned char buf[4];

    inFile.read((char *) buf, 4);
    c = buf[0];
    c = c + (buf[1] << 8);
    c = c + (buf[2] << 16);
    c = c + (buf[3] << 24);

    return c;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
addq $0x20, %rdi
leaq 0xc(%rsp), %rbx
pushq $0x4
popq %rdx
movq %rbx, %rsi
callq 0x22f0
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::read_word()
int ReadAVI::read_word()
{
    int c;
    unsigned char buf[2];

    inFile.read((char *) buf, 2);
    c = buf[0];
    c = c + (buf[1] << 8);

    return c;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
addq $0x20, %rdi
leaq 0xe(%rsp), %rbx
pushq $0x2
popq %rdx
movq %rbx, %rsi
callq 0x22f0
movzwl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::read_stream_format_auds()
int ReadAVI::read_stream_format_auds()
{
#ifdef VERBOSE
    long offset = inFile.tellg();
#endif
    stream_format_auds.format = read_word();
    stream_format_auds.channels = read_word();
    stream_format_auds.samples_per_second = read_int();
    stream_format_auds.bytes_per_second = read_int();
    int block_align = read_word();
    stream_format_auds.block_size_of_data = read_word();
    stream_format_auds.bits_per_sample = read_word();
    //stream_format_auds.extended_size=read_word();

    MSG_DBG(2, "            offset=0x%lx\n", offset);
    MSG_DBG(2, "                        format: %d\n", stream_format_auds.format);
    MSG_DBG(2, "                      channels: %d\n", stream_format_auds.channels);
    MSG_DBG(2, "            samples_per_second: %d\n", stream_format_auds.samples_per_second);
    MSG_DBG(2, "              bytes_per_second: %d\n", stream_format_auds.bytes_per_second);
    MSG_DBG(2, "                   block_align: %d\n", block_align);
    MSG_DBG(2, "            block_size_of_data: %d\n", stream_format_auds.block_size_of_data);
    MSG_DBG(2, "               bits_per_sample: %d\n", stream_format_auds.bits_per_sample);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x2410
movq %rax, %r14
movq %rbx, %rdi
callq 0x3c4e
movl %eax, 0x308(%rbx)
movq %rbx, %rdi
callq 0x3c4e
movl %eax, 0x30c(%rbx)
movq %rbx, %rdi
callq 0x3566
movl %eax, 0x310(%rbx)
movq %rbx, %rdi
callq 0x3566
movl %eax, 0x314(%rbx)
movq %rbx, %rdi
callq 0x3c4e
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3c4e
movl %eax, 0x318(%rbx)
movq %rbx, %rdi
callq 0x3c4e
movl %eax, 0x31c(%rbx)
movq 0x42c5(%rip), %r15      # 0x7fb0
movq (%r15), %rdi
leaq 0x174e(%rip), %rsi      # 0x5443
movq %r14, %rdx
xorl %eax, %eax
callq 0x2380
movq (%r15), %rdi
movl 0x308(%rbx), %edx
leaq 0x19af(%rip), %rsi      # 0x56be
xorl %eax, %eax
callq 0x2380
movq (%r15), %rdi
movl 0x30c(%rbx), %edx
leaq 0x19bc(%rip), %rsi      # 0x56e2
xorl %eax, %eax
callq 0x2380
movq (%r15), %rdi
movl 0x310(%rbx), %edx
leaq 0x19c9(%rip), %rsi      # 0x5706
xorl %eax, %eax
callq 0x2380
movq (%r15), %rdi
movl 0x314(%rbx), %edx
leaq 0x19d6(%rip), %rsi      # 0x572a
xorl %eax, %eax
callq 0x2380
movq (%r15), %rdi
leaq 0x19e9(%rip), %rsi      # 0x574e
movl %ebp, %edx
xorl %eax, %eax
callq 0x2380
movq (%r15), %rdi
movl 0x318(%rbx), %edx
leaq 0x19f4(%rip), %rsi      # 0x5772
xorl %eax, %eax
callq 0x2380
movq (%r15), %rdi
movl 0x31c(%rbx), %edx
leaq 0x1a01(%rip), %rsi      # 0x5796
xorl %eax, %eax
callq 0x2380
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::parse_movi(int)
int ReadAVI::parse_movi(int size)
{
    char chunk_id[5];
    long end_of_chunk;
    index_entry_t index_entry;
    int blk_size;

    do {
	long offset = inFile.tellg();
	/*
	 if (fileSize - offset < 8)
	 break;
	 */
	read_chars(chunk_id, 4);
	index_entry.stream_num = decodeCkid(chunk_id, &index_entry.type);

	if (index_entry.stream_num < 0) {
	    inFile.seekg(offset - 4, ios_base::beg);
	    break;
	}

	index_entry.dwChunkLength = read_int();

	if (!(avi_header.Flags & AVIF_HASINDEX)) {
	    index_entry.dwChunkOffset = offset + 8;
	    index_entries.push_back(index_entry);
	}

	MSG_DBG(3, "      AVI Movi Chunk ( id=%s(%d-%d) chunk_size=%d offset=0x%lx)\n", chunk_id, index_entry.type,
		index_entry.stream_num, index_entry.dwChunkLength, offset);
	MSG_DBG(3, "      {\n");

	end_of_chunk = index_entry.dwChunkLength + inFile.tellg();
	end_of_chunk = (end_of_chunk + 1) & ~1;
	/*    if ((end_of_chunk % 4) != 0) {
	 end_of_chunk = end_of_chunk + (4 - (end_of_chunk % 4));
	 }
	 */
//    MSG_DBG(2, "end_of_chunk:%d  %X\n", end_of_chunk, end_of_chunk);
	inFile.seekg(end_of_chunk, ios_base::beg);
	MSG_DBG(3, "      }\n");

	blk_size = end_of_chunk - offset;
	size -= blk_size;
	MSG_DBG(3, "size:%d \n", size);

    } while (size > 7);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x23(%rsp), %r12
movq %rbx, %rdi
callq 0x2410
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
pushq $0x4
popq %rdx
callq 0x3542
movq %r12, %rsi
leaq 0x4(%rsp), %rdx
callq 0x33be
movl %eax, 0x8(%rsp)
testl %eax, %eax
js 0x41a1
movq %r14, %rdi
callq 0x3566
movl %eax, 0x14(%rsp)
testb $0x10, 0x234(%r14)
jne 0x416e
leal 0x8(%r15), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x429c
movl 0x14(%rsp), %eax
movslq %eax, %r13
movq %rbx, %rdi
callq 0x2410
addq %rax, %r13
incq %r13
andq $-0x2, %r13
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2330
subl %r13d, %r15d
addl %r15d, %ebp
cmpl $0x7, %ebp
jg 0x410f
jmp 0x41b2
addq $-0x4, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2330
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::parse_hdrl(unsigned int)
int ReadAVI::parse_hdrl(unsigned int size)
{
    char chunk_id[5];
    int chunk_size;
    int end_of_chunk;
    long offset = inFile.tellg();

    read_chars(chunk_id, 4);
    chunk_size = read_int();

    MSG_DBG(2, "      AVI Header Chunk (id=%s size=%d offset=0x%lx)\n", chunk_id, chunk_size, offset);
    MSG_DBG(2, "      {\n");

    end_of_chunk = chunk_size + inFile.tellg();
    if ((end_of_chunk % 4) != 0) {
	end_of_chunk = end_of_chunk + (4 - (end_of_chunk % 4));
    }

    read_avi_header();
    MSG_DBG(2, "      }\n");

    while (inFile.tellg() < offset + size - 4) {
	//MSG_DBG(2, "Should end at 0x%lx  0x%lx\n",offset+size,inFile.tellg());
	parse_hdrl_list();
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x2410
movq %rax, %r15
leaq 0x13(%rsp), %r12
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3542
movq %rbx, %rdi
callq 0x3566
movq 0x3da6(%rip), %rbp      # 0x7fb0
movq (%rbp), %rdi
leaq 0x1679(%rip), %rsi      # 0x588e
movq %r12, %rdx
movl %eax, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x2380
movq (%rbp), %rcx
leaq 0x15f5(%rip), %rdi      # 0x5824
pushq $0x8
popq %r12
pushq $0x1
popq %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x2440
movq %r14, %rdi
callq 0x2410
movq %rbx, %rdi
callq 0x3588
movq (%rbp), %rcx
leaq 0x1628(%rip), %rdi      # 0x5885
movq %r12, %rsi
movq %r13, %rdx
callq 0x2440
movl 0xc(%rsp), %eax
addq %rax, %r15
addq $-0x4, %r15
movq %r14, %rdi
callq 0x2410
cmpq %r15, %rax
jge 0x428a
movq %rbx, %rdi
callq 0x3daa
jmp 0x4273
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/reactor_client_test.cc
// Function: main
int main(int argc, char **argv)
{
    if (argc < 3) {
        fprintf(stderr, "usage: %s ip port\n", argv[0]);
        return EXIT_FAILURE;
    }

    TimeClient client;
    if (!client.ConnectServer(argv[1], atoi(argv[2]))) {
        fprintf(stderr, "connect remote server failed\n");
        return EXIT_FAILURE;
    }

    g_reactor.RegisterHandler(&client, reactor::kWriteEvent);
    while (1) {
        g_reactor.HandleEvents();
        sleep(1);
    }
    g_reactor.RemoveHandler(&client);
    return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0x24ab
movq 0x4b43(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x1b70(%rip), %rsi      # 0x4012
xorl %eax, %eax
callq 0x2210
jmp 0x24f9
movq %rsp, %r14
movq %r14, %rdi
callq 0x2548
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rdi
callq 0x2240
movzwl %ax, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x258a
testb %al, %al
jne 0x2506
movq 0x4afc(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
leaq 0x1b3f(%rip), %rdi      # 0x4025
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x2280
movq %rsp, %rdi
callq 0x262c
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x25e2
movq (%rax), %rdi
movq %rsp, %rsi
pushq $0x2
popq %rdx
callq 0x2fe6
pushq $0x1
popq %rbx
callq 0x25e2
movq (%rax), %rdi
callq 0x30a2
movl %ebx, %edi
callq 0x2130
jmp 0x251c
jmp 0x2534
movq %rax, %rbx
movq %rsp, %rdi
callq 0x262c
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeclient.hpp
// Function: TimeClient::ConnectServer(char const*, unsigned short)
bool ConnectServer(const char *ip, unsigned short port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip);
        if (connect(m_handle, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
            ReportSocketError("connect");
            return false;
        }
        return true;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movw $0x2, (%r14)
rolw $0x8, %dx
movw %dx, 0x2(%r14)
movq %rsi, %rdi
callq 0x2190
movl %eax, 0x4(%r14)
movl 0x8(%rbx), %edi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x2150
movl %eax, %ebx
testl %eax, %eax
jns 0x25d4
leaq 0x1ae3(%rip), %rdi      # 0x40b2
callq 0x2442
testl %ebx, %ebx
setns %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeclient.hpp
// Function: TimeClient::HandleRead()
virtual void HandleRead()
    {
        memset(g_read_buffer, 0, BUFFERSIZE);
        int len = recv(m_handle, g_read_buffer, BUFFERSIZE, 0);
        if (len > 0) {
            fprintf(stderr, "%s", g_read_buffer);
            g_reactor.RegisterHandler(this, reactor::kWriteEvent);
        } else {
            ReportSocketError("recv");
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4b1e(%rip), %r14      # 0x7190
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x20f0
movl 0x8(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2080
testl %eax, %eax
jg 0x26aa
leaq 0x19f4(%rip), %rdi      # 0x4092
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2442
movq 0x4927(%rip), %rax      # 0x6fd8
movq (%rax), %rsi
leaq 0x4ad5(%rip), %rdi      # 0x7190
callq 0x21c0
callq 0x25e2
movq (%rax), %rdi
pushq $0x2
popq %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2fe6
// File: /workspace/github_cpp_makefile_star2_O2/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeclient.hpp
// Function: TimeClient::HandleWrite()
virtual void HandleWrite()
    {
        memset(g_write_buffer, 0, BUFFERSIZE);
        int len = sprintf(g_write_buffer, "time\r\n");
        len = send(m_handle, g_write_buffer, len, 0);
        if (len > 0) {
            fprintf(stderr, "%s", g_write_buffer);
            g_reactor.RegisterHandler(this, reactor::kReadEvent);
        } else {
            ReportSocketError("send");
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4eb2(%rip), %rdi      # 0x7597
movl $0x3f9, %edx            # imm = 0x3F9
xorl %esi, %esi
callq 0x20f0
leaq 0x4e98(%rip), %rsi      # 0x7590
movl $0x656d6974, 0x4e8e(%rip) # imm = 0x656D6974
movl $0xa0d65, 0x4e87(%rip)  # imm = 0xA0D65
movl 0x8(%rbx), %edi
pushq $0x6
popq %rdx
xorl %ecx, %ecx
callq 0x20d0
testl %eax, %eax
jg 0x272a
leaq 0x197a(%rip), %rdi      # 0x409e
popq %rbx
jmp 0x2442
movq 0x48a7(%rip), %rax      # 0x6fd8
movq (%rax), %rsi
leaq 0x4e55(%rip), %rdi      # 0x7590
callq 0x21c0
callq 0x25e2
movq (%rax), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
popq %rbx
jmp 0x2fe6
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/test/test_binarysearch.cc
// Function: main
int main(){
	test<char>("char");
	test<short>("short");
	test<int>("int");
	test<long>("long");

	test<unsigned short>("u short");
	test<unsigned int>("u int");
	test<unsigned long>("u long");

	test<size_t>("size_t");
}

// Assembly:
pushq %rax
leaq 0xec0(%rip), %rdi       # 0x2004
callq 0x11a1
leaq 0xebb(%rip), %rdi       # 0x200b
callq 0x11c3
leaq 0xeb7(%rip), %rdi       # 0x2013
callq 0x11e7
leaq 0xeb1(%rip), %rdi       # 0x2019
callq 0x120b
leaq 0xe95(%rip), %rdi       # 0x2009
callq 0x122f
leaq 0xe91(%rip), %rdi       # 0x2011
callq 0x1253
leaq 0xe8b(%rip), %rdi       # 0x2017
callq 0x1277
leaq 0xe86(%rip), %rdi       # 0x201e
callq 0x1277
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/test/test_binarysearch.cc
// Function: void test<char>(char const*, char)
void test(const char *name, const T key){
	VVector<T, MAX> v;

	size_t result;

	bool const found = binarySearch(v, v.size(), key, BinarySearchCompStdandard{}, result);

	bool const ok = found && v[result] == key;

	printf("%10s %s\n", name, ok ? "OK" : "Error");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movb %sil, (%r14)
leaq 0x6(%rsp), %rdi
leaq 0x5(%rsp), %rcx
leaq 0x8(%rsp), %r15
pushq $0x5
popq %r9
movl $0x2710, %esi           # imm = 0x2710
movq %r14, %rdx
movq %r15, %r8
callq 0x137b
movq (%r15), %rcx
cmpb %cl, (%r14)
leaq 0xd4f(%rip), %rdx       # 0x202e
leaq 0xd4b(%rip), %rcx       # 0x2031
cmovneq %rcx, %rdx
testb %al, %al
cmoveq %rcx, %rdx
leaq 0xd2e(%rip), %rdi       # 0x2025
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/allocSP.cc
// Function: use_factory(int)
shared_ptr<Foo> use_factory(T arg)
{
	shared_ptr<Foo> p = factory(arg);
	print(cout, *p);
	cout << endl;
	// use p
	return p;  // reference count is incremented when we return p
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1236
movq (%rbx), %rsi
movq 0x2d60(%rip), %rdi      # 0x3fd0
callq 0x121c
movq 0x2d54(%rip), %rdi      # 0x3fd0
callq 0x1040
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x131e
movq %r14, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: display::xinerama_screens()
display::screens_vector display::xinerama_screens() {
	int number;
	XineramaScreenInfo *screens = XineramaQueryScreens( dpy, &number );
	if ( !screens ) ERR;

	screens_vector vec;
	for ( int i = 0; i < number; ++i )
		vec.push_back( xinerama_screen( *this, screens[ i ] ) );

	XFree( screens );
	return vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2120
testq %rax, %rax
je 0x2b93
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x20(%rsp), %r13
xorl %ebp, %ebp
leaq 0x18(%rsp), %r12
movq %rax, 0x10(%rsp)
movq %rax, %r15
movslq 0xc(%rsp), %rax
cmpq %rax, %rbp
jge 0x2b74
movq %r14, 0x18(%rsp)
movl 0x8(%r15), %eax
movl %eax, 0x8(%r13)
movq (%r15), %rax
movq %rax, (%r13)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4032
incq %rbp
addq $0xc, %r15
jmp 0x2b42
movq 0x10(%rsp), %rdi
callq 0x22e0
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x244e(%rip), %rdx      # 0x5004
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3686
leaq 0x24bb(%rip), %rdx      # 0x5087
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3686
leaq 0x2453(%rip), %rdx      # 0x5035
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x3686
leaq 0x2478(%rip), %rdx      # 0x5073
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x3686
leaq 0x2422(%rip), %rdx      # 0x5039
leaq 0x18(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x3686
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x23a0
xorl %ebp, %ebp
movq 0x53ae(%rip), %rsi      # 0x7ff0
movq 0x537f(%rip), %rdx      # 0x7fc8
movq %rbx, %rdi
callq 0x23d0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x20c0
jmp 0x2c66
movq %rax, %r14
movb $0x1, %bpl
leaq 0xb8(%rsp), %rdi
callq 0x20c0
jmp 0x2c7b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x98(%rsp), %rdi
callq 0x20c0
jmp 0x2c90
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rdi
callq 0x20c0
jmp 0x2ca2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rdi
callq 0x20c0
jmp 0x2cb4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
je 0x2cda
movq %rbx, %rdi
callq 0x2150
jmp 0x2cda
jmp 0x2ccf
movq %rax, %r14
movq %rbx, %rdi
callq 0x3ff6
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: usage(char const*)
void usage( const char *name )
{
	std::cerr
		<< "Usage: " << name << " <options>" << std::endl
		<< "Options:" << std::endl
		<< " -s <display name> (default :0)" << std::endl
		<< " -d <display name> (default :1)" << std::endl
		<< " -x <xinerama screen number> (default 0)" << std::endl;
	exit( 0 );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x4f3e(%rip), %rdi      # 0x7fe8
leaq 0x1fbc(%rip), %rsi      # 0x506d
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2230
leaq 0x1fad(%rip), %rsi      # 0x5075
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20e0
leaq 0x1fa1(%rip), %rsi      # 0x5080
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20e0
leaq 0x1f93(%rip), %rsi      # 0x5089
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20e0
leaq 0x1f9c(%rip), %rsi      # 0x50a9
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20e0
leaq 0x1fa5(%rip), %rsi      # 0x50c9
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20e0
xorl %edi, %edi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: mouse_replayer::mouse_replayer(display const&, display const&, xinerama_screen const&)
mouse_replayer( const display &_src, const display &_dst, const xinerama_screen &_src_screen )
		: src( _src ), dst( _dst), src_screen( _src_screen ), dst_window( dst.root() )
		, on( false )
	{
		// create invisible cursor
		Pixmap bitmapNoData;
		XColor black;
		static char noData[] = { 0,0,0,0,0,0,0,0 };
		black.red = black.green = black.blue = 0;

		bitmapNoData = XCreateBitmapFromData( dst.dpy, dst_window.win, noData, 8, 8 );
		invisibleCursor = XCreatePixmapCursor( dst.dpy, bitmapNoData, bitmapNoData,
				&black, &black, 0, 0);

		dst_window.define_cursor( invisibleCursor );
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rdi), %rax
movq 0x10(%rdx), %rsi
movq %rsi, 0x28(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x18(%rdi)
movups (%rcx), %xmm0
movups %xmm0, 0x30(%rdi)
movq 0x10(%rcx), %rcx
movq %rcx, 0x40(%rdi)
movq 0x18(%rdi), %rdi
movq 0xe8(%rdi), %rcx
movslq 0xe0(%rdi), %rdx
shlq $0x7, %rdx
movq 0x10(%rcx,%rdx), %rsi
movq %rax, 0x48(%rbx)
movq %rsi, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
movb $0x0, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x70(%rbx)
andq $0x0, 0x90(%rbx)
movl $0x1, 0x80(%rbx)
leaq 0x10(%rsp), %r14
andw $0x0, 0xc(%r14)
leaq 0x48(%rbx), %r15
andl $0x0, 0x8(%r14)
leaq 0x4aa5(%rip), %rdx      # 0x8252
pushq $0x8
popq %rcx
movl %ecx, %r8d
callq 0x2290
movq 0x18(%rbx), %rdi
andl $0x0, (%rsp)
movq %rax, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x2160
movq %rax, 0x60(%rbx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2fee
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: mouse_replayer::cursor_changed()
void cursor_changed() {
		std::lock_guard< std::recursive_mutex > guard( cursor_mutex );

		if ( !on )
			return;

		XFixesCursorImage *cur;
		XcursorImage image;
		Cursor cursor;

		cur = TC( XFixesGetCursorImage( src.dpy ) );
		if ( !cur )
			return;

		memset( &image, 0, sizeof( image ) );
		image.width  = cur->width;
		image.height = cur->height;
		image.size	 = std::max( image.width, image.height );
		image.xhot	 = cur->xhot;
		image.yhot	 = cur->yhot;

		if ( 0 && sizeof( * image.pixels ) == sizeof( * cur->pixels ) ) {
			// 32-bit machines where int is long
			image.pixels = (unsigned int *) cur->pixels;
		} else {
			image.pixels = (unsigned int *) alloca(
				image.width * image.height * sizeof( unsigned int ) );
			for ( unsigned i = 0; i < image.width * image.height; ++i )
				image.pixels[ i ] = cur->pixels[ i ];
		}

		cursor = TC( XcursorImageLoadCursor( dst.dpy, &image ) );
		XFree( cur );

		TC( XDefineCursor( dst.dpy, dst_window.win, cursor ) );
		XFreeCursor( dst.dpy, cursor );

		TC( XFlush( dst.dpy ) );

		DBG( std::cout << "cursor changed" << std::endl );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x70(%rdi), %rbx
movq %rbx, %rdi
callq 0x3f42
movb 0x68(%r14), %al
cmpb $0x1, %al
jne 0x3e81
movq (%r14), %rdi
callq 0x2270
movq %rax, %r15
testq %rax, %rax
je 0x3e81
pxor %xmm0, %xmm0
movdqa %xmm0, -0x40(%rbp)
movdqa %xmm0, -0x50(%rbp)
movzwl 0x4(%r15), %ecx
movl %ecx, -0x48(%rbp)
movzwl 0x6(%r15), %eax
cmpw %ax, %cx
movl %eax, %edx
cmoval %ecx, %edx
movl %eax, -0x44(%rbp)
movl %edx, -0x4c(%rbp)
movq 0x8(%r15), %xmm1
punpcklwd %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3]
movq %xmm1, -0x40(%rbp)
imull %ecx, %eax
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, %rsp
movq %rcx, -0x30(%rbp)
xorl %edx, %edx
cmpq %rax, %rdx
jae 0x3e44
movq 0x18(%r15), %rsi
movl (%rsi,%rdx,8), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
jmp 0x3e30
movq 0x18(%r14), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2050
movq %rax, %r12
movq %r15, %rdi
callq 0x22e0
movq 0x18(%r14), %rdi
movq 0x50(%r14), %rsi
movq %r12, %rdx
callq 0x23e0
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x2280
movq 0x18(%r14), %rdi
callq 0x2370
movq %rbx, %rdi
callq 0x2170
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: image_replayer::copy_if_damaged()
void copy_if_damaged() {
		if ( !damaged )
			return;

		TC( XShmGetImage( src->dpy, src_window.win, src_image,
				src_screen->info.x_org, src_screen->info.y_org, AllPlanes) );
		TC( XShmPutImage( dst->dpy, dst_window.win, dst_gc, dst_image, 0, 0, 0, 0,
				dst_image->width, dst_image->height, False ) );
		TC( XFlush( dst->dpy ) );

		DBG( std::cout << "damaged" << std::endl );

		damaged = false;
	}

// Assembly:
cmpb $0x1, 0xa0(%rdi)
jne 0x3f40
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %r8
movq (%rax), %rdi
movq 0x20(%rbx), %rsi
movq 0x88(%rbx), %rdx
movswl 0xc(%r8), %ecx
movswl 0xe(%r8), %r8d
pushq $-0x1
popq %r9
callq 0x2030
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %rsi
movq (%rax), %rdi
movq 0x98(%rbx), %rdx
movq 0x90(%rbx), %rcx
movl (%rcx), %eax
movl 0x4(%rcx), %r8d
andl $0x0, 0x20(%rsp)
andl $0x0, 0x8(%rsp)
andl $0x0, (%rsp)
movl %r8d, 0x18(%rsp)
movl %eax, 0x10(%rsp)
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2350
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x2370
movb $0x0, 0xa0(%rbx)
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: void record_thread<mouse_replayer>(display, mouse_replayer*)
void record_thread( display data, Fun *callback ) {
	int fd = ConnectionNumber( data.dpy );
	fd_set fds;
	FD_ZERO( &fds );

	for ( ;; ) {
		FD_SET( fd, &fds );
		select( fd + 1, &fds, NULL, NULL, NULL );
		XRecordProcessReplies( data.dpy );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq 0xb0(%rsp), %rbx
movl 0x10(%rbx), %ebp
xorl %eax, %eax
cmpq $0x10, %rax
je 0x421f
andq $0x0, (%rsp,%rax,8)
incq %rax
jmp 0x420f
pushq $0x40
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movslq %eax, %r15
shll $0x6, %eax
movl %ebp, %ecx
subl %eax, %ecx
pushq $0x1
popq %r12
shlq %cl, %r12
incl %ebp
movq %rsp, %r14
orq %r12, (%rsp,%r15,8)
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2210
movq %rbx, %rdi
callq 0x22a0
jmp 0x423d
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: mouse_replayer::operator()(XRecordInterceptData*)
void operator() ( XRecordInterceptData *data ) {
		if ( data->category == XRecordFromServer ) {
			const xEvent &e = * (const xEvent *) data->data;

			if ( e.u.u.type == MotionNotify ) {
				mouse_moved( e.u.keyButtonPointer.rootX, e.u.keyButtonPointer.rootY );
			}
		}

		XRecordFreeData( data );
	}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, 0x18(%rsi)
jne 0x4318
movq 0x20(%rbx), %rax
cmpb $0x6, (%rax)
jne 0x4318
movswl 0x14(%rax), %esi
movswl 0x16(%rax), %edx
callq 0x4322
movq %rbx, %rdi
popq %rbx
jmp 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O2/liskin[P]hybrid-screenclone/screenclone.cc
// Function: mouse_replayer::mouse_moved(int, int)
void mouse_moved( int x, int y ) {
		std::lock_guard< std::recursive_mutex > guard( cursor_mutex );

		bool old_on = on;
		on = src_screen.in_screen( x, y );

		if ( on )
			dst_window.warp_pointer( x - src_screen.info.x_org, y - src_screen.info.y_org );
		else
			// wiggle the cursor a bit to keep screensaver away
			dst_window.warp_pointer( x % 50, y % 50 );

		if ( old_on != on ) {
			if ( on )
				cursor_changed();
			else
				dst_window.define_cursor( invisibleCursor );
		}

		TC( XFlush( dst.dpy ) );

		DBG( std::cout << "mouse moved" << std::endl );
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
leaq 0x70(%rdi), %rbx
movq %rbx, %rdi
callq 0x3f42
movb 0x68(%r14), %r13b
leaq 0x30(%r14), %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x3000
movb %al, 0x68(%r14)
movb 0x68(%r14), %al
leaq 0x48(%r14), %r15
cmpb $0x1, %al
jne 0x4374
movswl 0x3c(%r14), %eax
subl %eax, %r12d
movswl 0x3e(%r14), %eax
subl %eax, %ebp
jmp 0x4387
pushq $0x32
popq %rcx
movl %r12d, %eax
cltd
idivl %ecx
movl %edx, %r12d
movl %ebp, %eax
cltd
idivl %ecx
movl %edx, %ebp
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x2fbc
cmpb 0x68(%r14), %r13b
je 0x43b8
movb 0x68(%r14), %al
cmpb $0x1, %al
jne 0x43ac
movq %r14, %rdi
callq 0x3d9c
jmp 0x43b8
movq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x2fee
movq 0x18(%r14), %rdi
callq 0x2370
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O2/TasnimAnas[P]Attendance-Management-System/src/LoginDetails.cpp
// Function: isRightUser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isRightUser(string Username)
{
    for (int i = 0; i < Username.size(); i++)
    {
        Username[i] = tolower(Username[i]);
    }
    string Username_ = "tasnimanas";
    if (Username == Username_)
    {
        return true;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x8(%rbx)
jbe 0x26d7
movq (%rbx), %r15
movsbl (%r15,%r14), %edi
callq 0x2280
movb %al, (%r15,%r14)
incq %r14
jmp 0x26bb
leaq 0x4926(%rip), %rsi      # 0x7004
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x2860
movq %rbx, %rdi
movq %r14, %rsi
callq 0x289b
movl %eax, %ebx
movq %r14, %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/TasnimAnas[P]Attendance-Management-System/src/LoginDetails.cpp
// Function: isRightPassword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isRightPassword(string Password)
{
    string mypassword = "323443443487279223215223231";
    Password = encript(Password);
    if (mypassword == Password)
    {
        return true;
    }
    return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x48ed(%rip), %rsi      # 0x700f
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2860
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2260
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x27b7
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x20d0
leaq 0x8(%rsp), %rdi
callq 0x20d0
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x289b
movl %eax, %ebx
movq %r14, %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
jmp 0x27a5
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/TasnimAnas[P]Attendance-Management-System/src/LoginDetails.cpp
// Function: encript(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string encript(string input)
{
    string password_ = "";
    for (int i = 0; i < input.size(); i++)
    {
        int chk = (int(input[i]) * 4) + 23;
        password_ = password_ + to_string(chk);
    }
    return password_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4ce1(%rip), %rsi      # 0x74b2
leaq 0x20(%rsp), %r15
movq %r15, %rdx
callq 0x2860
xorl %r13d, %r13d
movq %rsp, %r12
cmpq %r13, 0x8(%r14)
jbe 0x282f
movq (%r14), %rax
movsbl (%rax,%r13), %eax
leal 0x17(,%rax,4), %esi
movq %r12, %rdi
callq 0x28e8
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x28c4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2230
movq %r15, %rdi
callq 0x20d0
movq %r12, %rdi
callq 0x20d0
incq %r13
jmp 0x27e4
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x20d0
jmp 0x2850
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2330