LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ArgsHandler::getFlagValueInt(std::string flag, int dflt) {
	if (hasFlag(flag)) {
		std::string flgstr = flags.find(flag)->second.value;
		int ret = dflt;
		try {
			ret = std::stoi(flgstr);
		} catch (std::invalid_argument &e) {
			// ret is still dflt, so all good.
		}
		return ret;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2200
movq %r15, %rdi
movq %r12, %rsi
callq 0x3032
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x20b0
testb %bpl, %bpl
je 0x317a
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x518c
leaq 0x60(%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x2200
pushq $0xa
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3e3e
movl %eax, %ebx
movq %rsp, %rdi
callq 0x20b0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x31a3
movq %r14, %rdi
callq 0x2090
callq 0x2250
jmp 0x3172
movq %rax, %r14
movq %rsp, %rdi
jmp 0x31b0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
double ArgsHandler::getFlagValueDouble(std::string flag, double dflt) {
	if (hasFlag(flag)) {
		std::string flgstr = flags.find(flag)->second.value;
		double ret = dflt;
		try {
			ret = std::stod(flgstr);
		} catch (std::invalid_argument &e) {
			// ret is still dflt, so all good.
		}
		return ret;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2200
movq %r14, %rdi
movq %r15, %rsi
callq 0x3032
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x20b0
testb %bpl, %bpl
je 0x3235
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x518c
leaq 0x60(%rax), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2200
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3e5a
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x20b0
movsd (%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x325f
movq %rbx, %rdi
callq 0x2090
callq 0x2250
jmp 0x322b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x326e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool ArgsHandler::getFlagValueBool(std::string flag, bool dflt) {
	if (hasFlag(flag)) {
			std::string flgstr = flags.find(flag)->second.value;
			bool ret = dflt;
			if (flgstr == "true") {
				ret = true;
			} else if (flgstr == "false") {
				ret = false;
			}
			return ret;
		} else {
			return dflt;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2200
movq %r15, %rdi
movq %r12, %rsi
callq 0x3032
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x20b0
testb %bpl, %bpl
je 0x330e
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x518c
leaq 0x60(%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x2200
leaq 0x2e24(%rip), %rsi      # 0x6102
movq %r14, %rdi
callq 0x3e73
movb $0x1, %bpl
testb %al, %al
jne 0x3304
leaq 0x2e13(%rip), %rsi      # 0x6107
movq %rsp, %rdi
callq 0x3e73
movl %eax, %ebp
notb %bpl
andb %bl, %bpl
movq %rsp, %rdi
callq 0x20b0
movl %ebp, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> ArgsHandler::getFlagArguments(std::string flag) {
	std::vector<std::string> flagArguments;
	if (!hasFlag(flag)) {
		return flagArguments;
	}

	for (int arg:(flags.find(flag)->second.arguments)) {
		flagArguments.push_back(arguments[arg]);
	}

	return flagArguments;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x2200
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3032
movl %eax, %ebp
movq %rsp, %rdi
callq 0x20b0
testb %bpl, %bpl
je 0x33c0
leaq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x518c
movq 0x80(%rax), %r15
movq 0x88(%rax), %r12
cmpq %r12, %r15
je 0x33c0
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x3c0e
addq $0x4, %r15
jmp 0x33a3
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33e1
movq %rax, %r14
movq %rsp, %rdi
callq 0x20b0
jmp 0x33e4
jmp 0x33e1
movq %rax, %r14
movq %rbx, %rdi
callq 0x2838
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getStartArguments[abi:cxx11]() const
std::vector<std::string> ArgsHandler::getStartArguments() const {
	std::vector<std::string> startArguments;

	for (int arg:startargs) {
		startArguments.push_back(arguments[arg]);
	}

	return startArguments;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x48(%rsi), %r15
movq 0x50(%rsi), %r12
cmpq %r12, %r15
je 0x3432
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x3c0e
addq $0x4, %r15
jmp 0x3415
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2838
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlags[abi:cxx11]() const
std::vector<std::string> ArgsHandler::getFlags() const {
	std::vector<std::string> strflags;
	for (auto pair:flags) {
		strflags.push_back(pair.first);
	}
	return strflags;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r12
addq $0x20, %r14
movq %rsp, %r15
cmpq %r14, %r12
je 0x34bb
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x3ed4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c0e
movq %r15, %rdi
callq 0x2998
movq %r12, %rdi
callq 0x21c0
movq %rax, %r12
jmp 0x3489
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x34da
movq %rax, %r14
movq %rsp, %rdi
callq 0x2998
movq %rbx, %rdi
callq 0x2838
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/TheStanian[P]Args/Args/Args.cpp
// Function: Flag::Flag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Flag::Flag(std::string input) {
	if (input.find("=") != input.npos) {
	name = input.substr(0, input.find_first_of("="));
	value = input.substr(input.find_first_of("=")+1);
	} else {
		name = input;
		value = "";
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r15
leaq 0x20(%rdi), %r14
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x2bcd(%rip), %rsi      # 0x6100
movq %r15, %rdi
xorl %edx, %edx
callq 0x22a0
cmpq $-0x1, %rax
je 0x35bd
leaq 0x2bb6(%rip), %rsi      # 0x6100
movq %r15, %rdi
xorl %edx, %edx
callq 0x20d0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21a0
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21d0
movq %r12, %rdi
callq 0x20b0
leaq 0x2b7b(%rip), %rsi      # 0x6100
movq %r15, %rdi
xorl %edx, %edx
callq 0x20d0
leaq 0x1(%rax), %rdx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r15, %rsi
callq 0x21a0
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x20b0
jmp 0x35d7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20f0
leaq 0x2b5c(%rip), %rsi      # 0x612b
movq %r14, %rdi
callq 0x2280
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x35e7
jmp 0x35e7
movq %rax, %r15
leaq 0x40(%rbx), %rdi
callq 0x28fe
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/Tumelo4[P]STACK-IN-CPP/Main.cpp
// Function: main
int main()
{
	Stack* stack = new Stack();
	stack->push(1);
	stack->push(2);
	stack->push(3);
	stack->push(4);
	stack->push(5);
	cout<<*stack<<"\n";

	while(!stack->isEmpty())
	{
		int data = stack->pop();
		if (!stack->isEmpty())
		{
			cout<<data<<",";
		}
		else
		{
			cout<<data;
		}
	}
	cout<<"\n";
	cout<<"Stack is empty: "<<stack->pop()<<"\n";
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x8
popq %rdi
callq 0x405520
movq %rax, %rbx
movq %rax, %rdi
callq 0x4046e4
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x40472e
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x40472e
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x40472e
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x40472e
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x40472e
movq $0x5e3440, %r14         # imm = 0x5E3440
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4047cd
leaq 0x1785c1(%rip), %rsi    # 0x57cbca
movq %rax, %rdi
callq 0x46d800
leaq 0x1719ec(%rip), %r15    # 0x576004
movq %rbx, %rdi
callq 0x4047c0
testb %al, %al
jne 0x404657
movq %rbx, %rdi
callq 0x404794
movl %eax, %r12d
movq %rbx, %rdi
callq 0x4047c0
movl %eax, %r13d
movq %r14, %rdi
movl %r12d, %esi
callq 0x46dba0
testb %r13b, %r13b
jne 0x404618
movq %rax, %rdi
movq %r15, %rsi
callq 0x46d800
jmp 0x404618
movq $0x5e3440, %r14         # imm = 0x5E3440
leaq 0x178565(%rip), %r15    # 0x57cbca
movq %r14, %rdi
movq %r15, %rsi
callq 0x46d800
leaq 0x17198f(%rip), %rsi    # 0x576006
movq %r14, %rdi
callq 0x46d800
movq %rax, %r14
movq %rbx, %rdi
callq 0x404794
movq %r14, %rdi
movl %eax, %esi
callq 0x46dba0
movq %rax, %rdi
movq %r15, %rsi
callq 0x46d800
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x404820
movq %r14, %rdi
callq 0x4a53f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Tumelo4[P]STACK-IN-CPP/Stack.cpp
// Function: Stack::~Stack()
Stack::~Stack()
{
	while(top)
	{
		Node* tmp = top;
		top = top->next;
		delete tmp;
		tmp = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %r14
movq (%rbx), %r15
testq %r15, %r15
je 0x404722
movq (%r15), %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x4046d2
movq %r15, %rdi
movq %r14, %rsi
callq 0x404820
jmp 0x4046ff
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Tumelo4[P]STACK-IN-CPP/Stack.cpp
// Function: Stack::push(int)
void Stack::push(int data)
{
	if (top)
	{
		Node* newNode = new Node(data);
		newNode->next = top;
		top = newNode;
	}
	else
	{
		top = new Node(data);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %r12
pushq $0x10
popq %rdi
callq 0x405520
movq %rax, %rbx
testq %r12, %r12
je 0x404765
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4046c8
movq (%r14), %rax
movq %rax, (%rbx)
jmp 0x404770
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4046c8
movq %rbx, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40477e
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x404820
movq %r14, %rdi
callq 0x4a53f0
// File: /workspace/github_cpp_makefile_star2_O2/Tumelo4[P]STACK-IN-CPP/Stack.cpp
// Function: operator<<(std::ostream&, Stack&)
ostream& operator<<(ostream &os, Stack&obj)
{
	for(Node* curr = obj.top; curr!= NULL; curr=curr->next)
	{
		if(curr->next != NULL)
		{
			os<<curr->getData()<<",";
		}
		else os<<curr->getData();
	}
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x17181f(%rip), %r15    # 0x576004
movq (%r14), %r14
testq %r14, %r14
je 0x404814
movq (%r14), %r12
movq %r14, %rdi
callq 0x4046d8
movq %rbx, %rdi
movl %eax, %esi
callq 0x46dba0
testq %r12, %r12
je 0x4047e5
movq %rax, %rdi
movq %r15, %rsi
callq 0x46d800
jmp 0x4047e5
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/blur.cpp
// Function: main
int main(int argc, char** argv) {
    int xsz, ysz;
    imageP I1, I2, tmp_img;

    xsz = atoi(argv[2]);
    ysz = atoi(argv[3]);

    // bitwise operator to check if xsz & ysz are odd.
    if  (((xsz & 1 ) == 0) or ((ysz & 1) == 0)) {
        // xsz or ysz are even.
        cout << "xsz: " << xsz << endl;
        cout << "ysz: " << ysz << endl;
        cerr << "either xsz or ysz is not odd" << endl;
        exit(1);
    }


    I1 = IP_readImage(argv[1]);
    I2 = NEWIMAGE;
    tmp_img = NEWIMAGE;

    blur(I1, tmp_img, xsz, ysz, I2);

    cout << "done blurring" << endl;

    IP_saveImage(I2, argv[4]);

    IP_freeImage(I1);
    IP_freeImage(I2);
    IP_freeImage(tmp_img);

    cout << "done" << endl;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x1130
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x1130
movl %eax, %ebp
testb $0x1, %r14b
je 0x139a
movl %ebp, %eax
andl $0x1, %eax
je 0x139a
movq 0x8(%rbx), %rdi
callq 0x17b4
movq %rax, %r15
pushq $0x10
popq %r13
movq %r13, %rdi
callq 0x10f0
movq %rax, %r12
movq %r13, %rdi
callq 0x10f0
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0x1407
movq 0x2c9a(%rip), %r14      # 0x3fd0
leaq 0xcf0(%rip), %rsi       # 0x202d
movq %r14, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
movq 0x20(%rbx), %rsi
movq %r12, %rdi
callq 0x197e
movq %r15, %rdi
callq 0x1a7f
movq %r12, %rdi
callq 0x1a7f
movq %r13, %rdi
callq 0x1a7f
leaq 0xcc3(%rip), %rsi       # 0x203b
movq %r14, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2c2f(%rip), %rbx      # 0x3fd0
leaq 0xc5c(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
movl %r14d, %esi
callq 0x1140
movq %rax, %rdi
callq 0x1060
leaq 0xc40(%rip), %rsi       # 0x200a
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
movl %ebp, %esi
callq 0x1140
movq %rax, %rdi
callq 0x1060
movq 0x2c05(%rip), %rdi      # 0x3ff0
leaq 0xc1e(%rip), %rsi       # 0x2010
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/IPutil.cpp
// Function: IP_readImage(char*)
imageP
IP_readImage(char *file) 
{

	imageP	 I;
	int	 w, h, maxGray;
   	char  	 buf[1024];
	uchar	*out;

	// open binary file for reading
	ifstream inFile (file, ios::binary);
	
	// error checking
	if(!inFile) {
		cerr << "readImage: Can't open " << file << endl;
		exit(1);
	}

   	// verify that the image is in PGM format. 
   	inFile.getline(buf, 3);
   	if(strncmp(buf,"P5",2) && strncmp(buf,"P6",2)){
      		cerr << "The file " << file << " is not in PGM format" << endl;
      		inFile.close();
      		exit(1);
   	}

	// read width, height, and maximum gray value
	inFile >> w >> h >> maxGray;

	// skip over linefeed and carriage return
	inFile.getline(buf, 2);

	// allocate image and read file
	I = IP_allocImage(w, h, sizeof(uchar));
	out = I->image;
	inFile.read((char *) out, w*h);

	return (imageP) I;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x628, %rsp            # imm = 0x628
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1160
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x38(%rsp,%rax)
jne 0x189a
leaq 0x18(%rsp), %rdi
leaq 0x220(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x1050
movzwl 0x220(%rsp), %eax
cmpl $0x3550, %eax           # imm = 0x3550
je 0x1815
cmpl $0x3650, %eax           # imm = 0x3650
jne 0x18c8
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1070
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x1070
leaq 0x14(%rsp), %rsi
movq %rax, %rdi
callq 0x1070
leaq 0x18(%rsp), %rdi
leaq 0x220(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x1050
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
pushq $0x1
popq %rdx
callq 0x191e
movq %rax, %rbx
movq 0x8(%rax), %rsi
movslq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rdx
imulq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x10d0
leaq 0x18(%rsp), %rdi
callq 0x1040
movq %rbx, %rax
addq $0x628, %rsp            # imm = 0x628
popq %rbx
popq %r14
retq
movq 0x274f(%rip), %rdi      # 0x3ff0
leaq 0x7b8(%rip), %rsi       # 0x2060
callq 0x1090
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rdi
callq 0x10c0
movq 0x2721(%rip), %rdi      # 0x3ff0
leaq 0x7a4(%rip), %rsi       # 0x207a
callq 0x1090
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1090
leaq 0x797(%rip), %rsi       # 0x2084
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0x18(%rsp), %rdi
callq 0x1030
jmp 0x18c0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/IPutil.cpp
// Function: IP_allocImage(int, int, int)
imageP
IP_allocImage(int w, int h, int s)
{
	uchar	*p;
	imageP	 I;

	// allocate memory
	I = (imageP ) malloc(sizeof(imageS));
	p = (uchar *) malloc(w * h * s);
	if(p == NULL) {
		cerr << "IP_allocImage: Insufficient memory\n";
		return ((imageP) NULL);
	}

	// init structure
	I->width  = w;
	I->height = h;
	I->image  = p;

	return(I);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movl %edi, %r14d
pushq $0x10
popq %rdi
callq 0x10f0
movq %rax, %rbx
movl %ebp, %eax
imull %r14d, %eax
imull %r15d, %eax
movslq %eax, %rdi
callq 0x10f0
testq %rax, %rax
je 0x195b
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
movq %rax, 0x8(%rbx)
jmp 0x1970
movq 0x268e(%rip), %rdi      # 0x3ff0
leaq 0x74d(%rip), %rsi       # 0x20b6
callq 0x1090
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/brianwu02[P]ImageProcessing/IPutil.cpp
// Function: IP_saveImage(imageS*, char*)
void 
IP_saveImage(imageP I, char *file)
{

	uchar	*out;

	// open binary file for writing
	ofstream outFile(file, ios::binary);

	// error checking
	if (!outFile) {
		cerr << "IP_savePGM: Can't open " << file << endl;
		exit(1);
	}

	// save PGM header
	outFile <<"P5" << endl;
	outFile <<I->width<< " " << I->height << endl;
	outFile << "255" << endl;

	// save image data
	out = I->image;
	outFile.write((char *) out, I->width*I->height);
	outFile.close();

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0x10a0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0x1a3e
leaq 0x6c0(%rip), %rsi       # 0x2077
movq %rsp, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
movl (%rbx), %esi
movq %rsp, %rdi
callq 0x1140
leaq 0x686(%rip), %rsi       # 0x205e
movq %rax, %rdi
callq 0x1090
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x1140
movq %rax, %rdi
callq 0x1060
leaq 0x6b8(%rip), %rsi       # 0x20b2
movq %rsp, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
movq 0x8(%rbx), %rsi
movslq (%rbx), %rax
movslq 0x4(%rbx), %rdx
imulq %rax, %rdx
movq %rsp, %rdi
callq 0x10e0
movq %rsp, %rdi
callq 0x1100
movq %rsp, %rdi
callq 0x1110
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq 0x25ab(%rip), %rdi      # 0x3ff0
leaq 0x64e(%rip), %rsi       # 0x209a
callq 0x1090
movq %rax, %rdi
movq %r14, %rsi
callq 0x1090
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rdi
callq 0x10c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1110
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/sweeterthancandy[P]linux_event_debugger/./event_monitor.h
// Function: event_monitor::event_monitor(boost::asio::io_context&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit event_monitor(boost::asio::io_service& io, const std::string& dev)
                :io_(io)
                ,work_(io) // keep alive
                ,desc_(io)
                ,dev_(dev)
        {
                int fd = open(dev_.c_str(), O_RDONLY);
                if( fd < 0 ) 
                        BOOST_THROW_EXCEPTION(std::domain_error("unable to open file"));
                desc_.assign( fd );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
lock
incq 0xd0(%rax)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x17f20
leaq 0x68(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xb740
leaq 0xa0(%rbx), %r12
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x17e16
movq (%r15), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xb3e0
movl %eax, 0x4(%rsp)
testl %eax, %eax
js 0x17d80
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x17ec8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xffbd(%rip), %rsi      # 0x27d44
leaq 0x8(%rsp), %rdi
callq 0xb340
leaq 0xffc0(%rip), %rax      # 0x27d58
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xffc3(%rip), %rax      # 0x27d6a
movq %rax, 0x8(%rsi)
movq $0x19, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x17e7a
movq %rax, %r13
leaq 0x8(%rsp), %rdi
callq 0xb480
jmp 0x17de0
jmp 0x17ddd
movq %rax, %r13
jmp 0x17de8
movq %rax, %r13
jmp 0x17df0
movq %rax, %r13
jmp 0x17df8
movq %rax, %r13
movq %r12, %rdi
callq 0x17f0c
movq %r15, %rdi
callq 0xb240
movq %r14, %rdi
callq 0x18d5e
leaq 0x18(%rbx), %rdi
callq 0x150da
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x16dfa
movq %r13, %rdi
callq 0xb900
nop
// File: /workspace/github_cpp_makefile_star2_O2/sweeterthancandy[P]linux_event_debugger/./event_monitor.h
// Function: event_monitor::start_read()
void start_read(){
                auto self = shared_from_this();
                boost::asio::async_read( desc_, boost::asio::buffer(ev_buffer_),
                        [this,self](const boost::system::error_code& ec, size_t n){
                                if( ec ){
                                        // must of been cancelled
                                 
                                } else {
                                        assert( n == sizeof(struct input_event) && "unexpected read size");
                                        sig_(dev_, *reinterpret_cast<struct input_event*>(ev_buffer_.data()));
                                        start_read();
                                }
                });
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1919c
leaq 0x20(%rbx), %r15
leaq 0x88(%rbx), %rax
leaq 0x28(%rsp), %r12
movq %rax, (%r12)
movq $0x18, 0x8(%r12)
leaq 0x18(%rsp), %rdi
movq %rbx, -0x8(%rdi)
movq %r14, %rsi
callq 0x1bb3e
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x19175
leaq 0x20(%rsp), %rdi
callq 0x16e76
leaq 0x8(%rsp), %rdi
callq 0x16e76
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x16e76
leaq 0x8(%rsp), %rdi
callq 0x16e76
movq %rbx, %rdi
callq 0xb900
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/main.cpp
// Function: usage()
void usage()
{
  std::cout << std::endl << "Usage: intent [options] read1.fastq.gz read2.fastq.gz output" << std::endl <<
      "  read1.fastq.gz     read 1 fastq file (gzipped) from a v2 inDrop sequencing run." << std::endl <<
      "  read2.fastq.gz     read 2 fastq file (gzipped) from a v2 inDrop sequencing run." << std::endl <<
      "" << std::endl << 
      "  Options:" << std::endl <<
      "    -x               expanded barcodes and umi format (20 / 14) " << std::endl <<
      "    -t               Chromium v2 barcode format (16 / 10) " << std::endl <<
      "    -d 2             Maximum W1 alignment distance (default = 2)" << std::endl <<
      "    -h               Print this help" << std::endl << std::endl;
}

// Assembly:
pushq %rax
movq 0x24854(%rip), %rdi     # 0x37fb8
callq 0x6240
leaq 0x1499e(%rip), %rsi     # 0x2810e
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x149c4(%rip), %rsi     # 0x2814b
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x149ff(%rip), %rsi     # 0x2819d
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x14c80(%rip), %rsi     # 0x28435
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x14a23(%rip), %rsi     # 0x281ef
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x14a17(%rip), %rsi     # 0x281fa
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x14a41(%rip), %rsi     # 0x2823b
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x14a65(%rip), %rsi     # 0x28276
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
leaq 0x14a8f(%rip), %rsi     # 0x282b7
movq %rax, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6240
movq %rax, %rdi
popq %rax
jmp 0x6240
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/main.cpp
// Function: readFour[abi:cxx11](zstr::istream&)
std::vector<std::string> readFour(zstr::istream &f)
{
  std::vector<std::string> lines;
  std::string line;
  for(int i = 0; i < 4; i++) {
    if(f.peek() != EOF ) {
      getline(f, line);
      lines.push_back(line);
    } else {
      lines.push_back("");
    }
  }
  return lines;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb $0x0, (%rax)
pushq $0x4
popq %r15
leaq 0x28(%rsp), %r12
leaq 0x7(%rsp), %r13
leaq 0x8(%rsp), %rbp
subl $0x1, %r15d
jb 0x138d6
movq %r14, %rdi
callq 0x61a0
cmpl $-0x1, %eax
je 0x138af
movq %r14, %rdi
movq %rbp, %rsi
callq 0x60a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x146c4
jmp 0x13884
movq %r12, %rdi
leaq 0x14b7c(%rip), %rsi     # 0x28435
movq %r13, %rdx
callq 0x1463a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16428
movq %r12, %rdi
callq 0x6768
jmp 0x13884
leaq 0x8(%rsp), %rdi
callq 0x6768
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13903
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6768
jmp 0x13906
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6768
movq %rbx, %rdi
callq 0x146f0
movq %r14, %rdi
callq 0x66a0
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/main.cpp
// Function: update_stats(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>, int, int, int, int, int, int)
void update_stats(std::chrono::steady_clock::time_point start, int a, int b, int c, int d, int e, int f) {
  auto now = std::chrono::steady_clock::now();
  int secs = std::chrono::duration_cast<std::chrono::seconds>(now - start).count();
  printf("|%11d|%11d|%11d|%11d|%11d|%11d| (in %d secs)\r", a, b, c, d, e, f, secs);
  fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
movl 0x40(%rsp), %eax
movq %rax, (%rsp)
callq 0x6540
subq %r13, %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rax, %r10
leaq 0x1491b(%rip), %rdi     # 0x2838a
movl %r12d, %esi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
xorl %eax, %eax
pushq %r10
pushq 0x8(%rsp)
callq 0x6060
popq %rcx
popq %rdx
movq 0x244dc(%rip), %rax     # 0x37f70
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6490
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::istreambuf::istreambuf(std::basic_streambuf<char, std::char_traits<char>>*, unsigned long, bool)
istreambuf(std::streambuf * _sbuf_p,
               std::size_t _buff_size = default_buff_size, bool _auto_detect = true)
        : sbuf_p(_sbuf_p),
          zstrm_p(nullptr),
          buff_size(_buff_size),
          auto_detect(_auto_detect),
          auto_detect_run(false),
          is_text(false)
    {
        assert(sbuf_p);
        in_buff = new char [buff_size];
        in_buff_start = in_buff;
        in_buff_end = in_buff;
        out_buff = new char [buff_size];
        setg(out_buff, out_buff, out_buff);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6110
leaq 0x22a92(%rip), %rax     # 0x376f8
movq %rax, (%rbx)
movq %r15, 0x40(%rbx)
andq $0x0, 0x68(%rbx)
movq %r14, 0x70(%rbx)
movb %bpl, 0x78(%rbx)
andw $0x0, 0x79(%rbx)
testq %r15, %r15
je 0x14cbb
movq %r14, %rdi
callq 0x6030
movq %rax, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movq %r14, %rdi
callq 0x6030
movq %rax, 0x60(%rbx)
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x138a5(%rip), %rdi     # 0x28567
leaq 0x138a5(%rip), %rsi     # 0x2856e
leaq 0x138af(%rip), %rcx     # 0x2857f
pushq $0x74
popq %rdx
callq 0x62e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6750
movq %r14, %rdi
callq 0x66a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::detail::z_stream_wrapper::~z_stream_wrapper()
~z_stream_wrapper()
    {
        if (is_input)
        {
            inflateEnd(this);
        }
        else
        {
            deflateEnd(this);
        }
    }

// Assembly:
pushq %rax
cmpb $0x1, 0x70(%rdi)
jne 0x15006
callq 0x6430
jmp 0x1500b
callq 0x62a0
popq %rax
retq
movq %rax, %rdi
callq 0x14c22
nop
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::detail::z_stream_wrapper::z_stream_wrapper(bool, int)
z_stream_wrapper(bool _is_input = true, int _level = Z_DEFAULT_COMPRESSION)
        : is_input(_is_input)
    {
        this->zalloc = Z_NULL;
        this->zfree = Z_NULL;
        this->opaque = Z_NULL;
        int ret;
        if (is_input)
        {
            this->avail_in = 0;
            this->next_in = Z_NULL;
            ret = inflateInit2(this, 15+32);
        }
        else
        {
            ret = deflateInit2(this, _level, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY);
        }
        if (ret != Z_OK) throw Exception(this, ret);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb %sil, 0x70(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
testl %esi, %esi
je 0x15050
andl $0x0, 0x8(%rbx)
andq $0x0, (%rbx)
leaq 0x1361a(%rip), %rdx     # 0x2865a
pushq $0x2f
popq %rsi
pushq $0x70
popq %rcx
movq %rbx, %rdi
callq 0x6380
jmp 0x15073
leaq 0x13603(%rip), %rax     # 0x2865a
pushq $0x1f
popq %rcx
pushq $0x8
popq %r8
movq %rbx, %rdi
movl %edx, %esi
movl %r8d, %edx
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x6080
popq %rcx
popq %rdx
movl %eax, %ebp
testl %eax, %eax
jne 0x1507e
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x6250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x150c0
leaq 0x226e3(%rip), %rsi     # 0x37780
leaq 0x176(%rip), %rdx       # 0x1521a
movq %r14, %rdi
callq 0x6660
movq %rax, %rbx
movq %r14, %rdi
callq 0x6320
movq %rbx, %rdi
callq 0x66a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::Exception::Exception(z_stream_s*, int)
Exception(z_stream * zstrm_p, int ret)
        : _msg("zlib: ")
    {
        switch (ret)
        {
        case Z_STREAM_ERROR:
            _msg += "Z_STREAM_ERROR: ";
            break;
        case Z_DATA_ERROR:
            _msg += "Z_DATA_ERROR: ";
            break;
        case Z_MEM_ERROR:
            _msg += "Z_MEM_ERROR: ";
            break;
        case Z_VERSION_ERROR:
            _msg += "Z_VERSION_ERROR: ";
            break;
        case Z_BUF_ERROR:
            _msg += "Z_BUF_ERROR: ";
            break;
        default:
            std::ostringstream oss;
            oss << ret;
            _msg += "[" + oss.str() + "]: ";
            break;
        }
        _msg += zstrm_p->msg;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x226ca(%rip), %rax     # 0x377a8
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x13575(%rip), %rsi     # 0x28661
leaq 0x60(%rsp), %rdx
movq %r14, %rdi
callq 0x1463a
leal 0x6(%r12), %eax
cmpl $0x5, %eax
jae 0x15120
movl %eax, %eax
leaq 0x11f38(%rip), %rcx     # 0x27044
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r14, %rdi
callq 0x6700
jmp 0x151a1
leaq 0x60(%rsp), %rdi
callq 0x6560
leaq 0x60(%rsp), %rdi
movl %r12d, %esi
callq 0x6670
leaq 0x68(%rsp), %rsi
movq %rsp, %rdi
callq 0x6600
leaq 0x1356b(%rip), %rsi     # 0x286b6
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x15259
leaq 0x13559(%rip), %rdx     # 0x286b8
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1523a
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x6720
leaq 0x40(%rsp), %rdi
callq 0x6768
leaq 0x20(%rsp), %rdi
callq 0x6768
movq %rsp, %rdi
callq 0x6768
leaq 0x60(%rsp), %rdi
callq 0x60e0
movq 0x30(%r15), %rsi
movq %r14, %rdi
callq 0x6700
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x6768
jmp 0x151ce
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x6768
jmp 0x151dd
movq %rax, %r15
movq %rsp, %rdi
callq 0x6768
jmp 0x151ec
jmp 0x151e9
movq %rax, %r15
leaq 0x60(%rsp), %rdi
callq 0x60e0
jmp 0x15202
jmp 0x151ff
movq %rax, %r15
jmp 0x1520a
movq %rax, %r15
movq %r14, %rdi
callq 0x6768
movq %rbx, %rdi
callq 0x66d0
movq %r15, %rdi
callq 0x66a0
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::ostreambuf(std::basic_streambuf<char, std::char_traits<char>>*, unsigned long, int)
ostreambuf(std::streambuf * _sbuf_p,
               std::size_t _buff_size = default_buff_size, int _level = Z_DEFAULT_COMPRESSION)
        : sbuf_p(_sbuf_p),
          zstrm_p(new detail::z_stream_wrapper(false, _level)),
          buff_size(_buff_size)
    {
        assert(sbuf_p);
        in_buff = new char [buff_size];
        out_buff = new char [buff_size];
        setp(in_buff, in_buff + buff_size);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6110
leaq 0x22798(%rip), %rax     # 0x37a50
movq %rax, (%rbx)
movq %r15, 0x40(%rbx)
pushq $0x78
popq %rdi
callq 0x63d0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x15016
movq %r15, 0x58(%rbx)
movq %r14, 0x60(%rbx)
cmpq $0x0, 0x40(%rbx)
je 0x1531d
movq %r14, %rdi
callq 0x6030
movq %rax, %r15
movq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0x6030
movq %rax, 0x50(%rbx)
movq %r15, %rax
addq %r14, %rax
movq %r15, 0x28(%rbx)
movq %r15, 0x20(%rbx)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13243(%rip), %rdi     # 0x28567
leaq 0x13243(%rip), %rsi     # 0x2856e
leaq 0x13458(%rip), %rcx     # 0x2878a
movl $0xeb, %edx
callq 0x62e0
movq %rax, %r14
pushq $0x78
popq %rsi
movq %r15, %rdi
callq 0x63e0
jmp 0x1534f
movq %rax, %r14
movq %rbx, %rdi
callq 0x6750
movq %r14, %rdi
callq 0x66a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/strict_fstream.hpp
// Function: strict_fstream::ofstream::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_Ios_Openmode)
void open(const std::string& filename, std::ios_base::openmode mode = std::ios_base::out)
    {
        mode |= std::ios_base::out;
        exceptions(std::ios_base::badbit);
        detail::static_method_holder::check_mode(filename, mode);
        std::ofstream::open(filename, mode);
        detail::static_method_holder::check_open(this, filename, mode);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
orl $0x10, %ebx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
pushq $0x1
popq %rsi
callq 0x6140
movq %r14, %rdi
movl %ebx, %esi
callq 0x154b6
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x6230
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x156a2
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/strict_fstream.hpp
// Function: strict_fstream::detail::static_method_holder::mode_to_string[abi:cxx11](std::_Ios_Openmode)
static std::string mode_to_string(std::ios_base::openmode mode)
    {
        static const int n_modes = 6;
        static const std::ios_base::openmode mode_val_v[n_modes] =
            {
                std::ios_base::in,
                std::ios_base::out,
                std::ios_base::app,
                std::ios_base::ate,
                std::ios_base::trunc,
                std::ios_base::binary
            };

        static const char * mode_name_v[n_modes] =
            {
                "in",
                "out",
                "app",
                "ate",
                "trunc",
                "binary"
            };
        std::string res;
        for (int i = 0; i < n_modes; ++i)
        {
            if (mode & mode_val_v[i])
            {
                res += (! res.empty()? "|" : "");
                res += mode_name_v[i];
            }
        }
        if (res.empty()) res = "none";
        return res;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %esi, %ebp
movb $0x0, 0x10(%rdi)
leaq 0x229ad(%rip), %r14     # 0x383c0
xorl %r15d, %r15d
leaq 0x13723(%rip), %r12     # 0x29140
leaq 0x12dea(%rip), %r13     # 0x2880e
cmpq $0x18, %r15
je 0x15a60
testl %ebp, (%r15,%r12)
je 0x15a56
cmpq $0x0, 0x8(%rbx)
movq %r13, %rsi
leaq 0x129f6(%rip), %rax     # 0x28435
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x6700
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x6700
addq $0x4, %r15
addq $0x8, %r14
jmp 0x15a24
cmpq $0x0, 0x8(%rbx)
jne 0x15a76
leaq 0x12ced(%rip), %rsi     # 0x2875b
movq %rbx, %rdi
callq 0x6710
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15a8a
movq %rax, %r14
movq %rbx, %rdi
callq 0x6768
movq %r14, %rdi
callq 0x66a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::~ostreambuf()
virtual ~ostreambuf()
    {
        // flush the zlib stream
        //
        // NOTE: Errors here (sync() return value not 0) are ignored, because we
        // cannot throw in a destructor. This mirrors the behaviour of
        // std::basic_filebuf::~basic_filebuf(). To see an exception on error,
        // close the ofstream with an explicit call to close(), and do not rely
        // on the implicit call in the destructor.
        //
        sync();
        delete [] in_buff;
        delete [] out_buff;
        delete zstrm_p;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x21f0e(%rip), %rax     # 0x37a50
movq %rax, (%rdi)
callq 0x15bb0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x15b58
callq 0x6500
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x15b66
callq 0x6500
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x15b77
movq %r14, %rdi
callq 0x14ff8
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x63e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6750
movq %rax, %rdi
callq 0x14c22
nop
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::sync()
virtual int sync()
    {
        // first, call overflow to clear in_buff
        overflow();
        if (! pptr()) return -1;
        // then, call deflate asking to finish the zlib stream
        zstrm_p->next_in = nullptr;
        zstrm_p->avail_in = 0;
        if (deflate_loop(Z_FINISH) != 0) return -1;
        deflateReset(zstrm_p);
        return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
pushq $-0x1
popq %rbx
movl %ebx, %esi
callq *0x68(%rax)
cmpq $0x0, 0x28(%r14)
je 0x15bef
movq 0x58(%r14), %rax
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x15c74
testl %eax, %eax
jne 0x15bef
movq 0x58(%r14), %rdi
callq 0x65c0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::overflow(int)
virtual std::streambuf::int_type overflow(std::streambuf::int_type c = traits_type::eof())
    {
        zstrm_p->next_in = reinterpret_cast< decltype(zstrm_p->next_in) >(pbase());
        zstrm_p->avail_in = pptr() - pbase();
        while (zstrm_p->avail_in > 0)
        {
            int r = deflate_loop(Z_NO_FLUSH);
            if (r != 0)
            {
                setp(nullptr, nullptr);
                return traits_type::eof();
            }
        }
        setp(in_buff, in_buff + buff_size);
        return traits_type::eq_int_type(c, traits_type::eof()) ? traits_type::eof() : sputc(c);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x20(%rdi), %rax
movq 0x58(%rdi), %rcx
movq %rax, (%rcx)
movl 0x28(%rdi), %edx
subl %eax, %edx
movl %edx, 0x8(%rcx)
movq 0x58(%rbx), %rax
cmpl $0x0, 0x8(%rax)
je 0x15c40
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15c74
testl %eax, %eax
je 0x15c1a
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
jmp 0x15c6c
movq 0x48(%rbx), %rax
movq 0x60(%rbx), %rcx
addq %rax, %rcx
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x30(%rbx)
cmpl $-0x1, %ebp
je 0x15c6c
movsbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61d0
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::deflate_loop(int)
int deflate_loop(int flush)
    {
        while (true)
        {
            zstrm_p->next_out = reinterpret_cast< decltype(zstrm_p->next_out) >(out_buff);
            zstrm_p->avail_out = buff_size;
            int ret = deflate(zstrm_p, flush);
            if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR) throw Exception(zstrm_p, ret);
            std::streamsize sz = sbuf_p->sputn(out_buff, reinterpret_cast< decltype(out_buff) >(zstrm_p->next_out) - out_buff);
            if (sz != reinterpret_cast< decltype(out_buff) >(zstrm_p->next_out) - out_buff)
            {
                // there was an error in the sink stream
                return -1;
            }
            if (ret == Z_STREAM_END || ret == Z_BUF_ERROR || sz == 0)
            {
                break;
            }
        }
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x50(%rdi), %rdx
movq 0x58(%rdi), %rdi
pushq $0x61
popq %r12
pushq $-0x1
popq %r15
movq %rdx, 0x18(%rdi)
movl 0x60(%rbx), %eax
movl %eax, 0x20(%rdi)
movl %ebp, %esi
callq 0x6220
movl %eax, %r14d
leal 0x5(%r14), %eax
cmpl $0x6, %eax
ja 0x15d05
btl %eax, %r12d
jae 0x15d05
movq 0x40(%rbx), %rdi
movq 0x50(%rbx), %rsi
movq 0x58(%rbx), %rax
movq 0x18(%rax), %rdx
subq %rsi, %rdx
movq (%rdi), %rax
callq *0x60(%rax)
movq %rax, %rcx
movq 0x50(%rbx), %rdx
movq 0x58(%rbx), %rdi
movq 0x18(%rdi), %rax
subq %rdx, %rax
cmpq %rax, %rcx
jne 0x15cf9
xorl %eax, %eax
testq %rcx, %rcx
je 0x15cfc
cmpl $0x1, %r14d
je 0x15cfc
cmpl $-0x5, %r14d
jne 0x15c91
jmp 0x15cfc
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x6250
movq %rax, %r15
movq 0x58(%rbx), %rsi
movq %rax, %rdi
movl %r14d, %edx
callq 0x150c0
leaq 0x21a5a(%rip), %rsi     # 0x37780
leaq -0xb13(%rip), %rdx      # 0x1521a
movq %r15, %rdi
callq 0x6660
movq %rax, %rbx
movq %r15, %rdi
callq 0x6320
movq %rbx, %rdi
callq 0x66a0
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: buildPeq(int, unsigned char const*, int, EqualityDefinition const&)
static inline Word* buildPeq(const int alphabetLength,
                             const unsigned char* const query,
                             const int queryLength,
                             const EqualityDefinition& equalityDefinition) {
    int maxNumBlocks = ceilDiv(queryLength, WORD_SIZE);
    // table of dimensions alphabetLength+1 x maxNumBlocks. Last symbol is wildcard.
    Word* Peq = new Word[(alphabetLength + 1) * maxNumBlocks];

    // Build Peq (1 is match, 0 is mismatch). NOTE: last column is wildcard(symbol that matches anything) with just 1s
    for (unsigned char symbol = 0; symbol <= alphabetLength; symbol++) {
        for (int b = 0; b < maxNumBlocks; b++) {
            if (symbol < alphabetLength) {
                Peq[symbol * maxNumBlocks + b] = 0;
                for (int r = (b+1) * WORD_SIZE - 1; r >= b * WORD_SIZE; r--) {
                    Peq[symbol * maxNumBlocks + b] <<= 1;
                    // NOTE: We pretend like query is padded at the end with W wildcard symbols
                    if (r >= queryLength || equalityDefinition.areEqual(query[r], symbol))
                        Peq[symbol * maxNumBlocks + b] += 1;
                }
            } else { // Last symbol is wildcard, so it is all 1s
                Peq[symbol * maxNumBlocks + b] = static_cast<Word>(-1);
            }
        }
    }

    return Peq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r14
movl %edi, %r15d
testb $0x3f, %r12b
je 0x22b9a
pushq $0x40
popq %rcx
movl %r12d, %eax
cltd
idivl %ecx
incl %eax
jmp 0x22ba0
movl %r12d, %eax
sarl $0x6, %eax
movl %eax, 0xc(%rsp)
leal 0x1(%r15), %edx
imull %eax, %edx
leaq (,%rdx,8), %rcx
testl %edx, %edx
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x6030
movl 0xc(%rsp), %r9d
movq %rax, 0x10(%rsp)
movslq %r12d, %rcx
xorl %eax, %eax
testl %r9d, %r9d
movl $0x0, %esi
cmovgl %r9d, %esi
movzbl %al, %edi
cmpl %r15d, %edi
jg 0x22c63
imull %edi, %r9d
movl %edi, %r8d
movslq %r9d, %r9
movq 0x10(%rsp), %rdx
leaq (%rdx,%r9,8), %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpq %rsi, %r10
je 0x22c57
cmpl %r15d, %edi
jae 0x22c43
movl %r11d, %ebp
orl $0x3f, %ebp
movslq %ebp, %r12
movl %r10d, %ebp
shll $0x6, %ebp
movslq %ebp, %r13
xorl %ebp, %ebp
cmpq %r13, %r12
jl 0x22c4a
addq %rbp, %rbp
cmpq %rcx, %r12
jge 0x22c3a
movzbl (%r14,%r12), %edx
shll $0x8, %edx
addq %rbx, %rdx
cmpb $0x1, (%r8,%rdx)
jne 0x22c3e
orq $0x1, %rbp
decq %r12
jmp 0x22c1b
orq $-0x1, (%r9,%r10,8)
jmp 0x22c4e
movq %rbp, (%r9,%r10,8)
incq %r10
addl $0x40, %r11d
jmp 0x22bfd
incb %al
movl 0xc(%rsp), %r9d
jmp 0x22bdc
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq