LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pranavmodx[P]modlang/rlpl.cpp
// Function: RLPL()
void RLPL()
{
	const std::string PROMPT = ">> ";

	Token token;
	Lexer lexer;
	
	std::string line;

	while (true)
	{
		std::cout << PROMPT;

		std::getline(std::cin, line);

		lexer.New(line);
		token = lexer.nextToken();

		while (token.type != END)
		{
			std::cout << "Type: " << token.type << ", Literal: " << token.literal << std::endl;
			token = lexer.nextToken();
		}

		line.clear();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
leaq -0x21(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x22e0
movq -0x150(%rbp), %rdx
leaq 0x4823(%rip), %rsi      # 0xb0ac
leaq -0x20(%rbp), %rdi
callq 0x6aa0
jmp 0x6894
leaq -0x21(%rbp), %rdi
callq 0x21e0
leaq -0x78(%rbp), %rdi
callq 0x6b50
jmp 0x68a8
leaq -0xa8(%rbp), %rdi
callq 0x6b80
leaq -0xc8(%rbp), %rdi
callq 0x2270
jmp 0x68c2
movq 0xa707(%rip), %rdi      # 0x10fd0
leaq -0x20(%rbp), %rsi
callq 0x2160
jmp 0x68d4
movq 0xa705(%rip), %rdi      # 0x10fe0
leaq -0xc8(%rbp), %rsi
callq 0x2050
jmp 0x68e9
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x97f0
jmp 0x68fe
leaq -0x108(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x98a0
jmp 0x6913
leaq -0x78(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x6ba0
leaq -0x108(%rbp), %rdi
callq 0x6be0
leaq -0x78(%rbp), %rdi
leaq 0xa896(%rip), %rsi      # 0x111d0
callq 0x6c10
testb $0x1, %al
jne 0x6948
jmp 0x6a51
movq 0xa681(%rip), %rdi      # 0x10fd0
leaq 0x475a(%rip), %rsi      # 0xb0b0
callq 0x2180
movq %rax, -0x158(%rbp)
jmp 0x6964
movq -0x158(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2160
movq %rax, -0x160(%rbp)
jmp 0x697d
movq -0x160(%rbp), %rdi
leaq 0x472c(%rip), %rsi      # 0xb0b7
callq 0x2180
movq %rax, -0x168(%rbp)
jmp 0x6999
movq -0x168(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2160
movq %rax, -0x170(%rbp)
jmp 0x69b2
movq -0x170(%rbp), %rdi
movq 0xa5f8(%rip), %rsi      # 0x10fb8
callq 0x21c0
jmp 0x69c7
leaq -0x148(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x98a0
jmp 0x69dc
leaq -0x78(%rbp), %rdi
leaq -0x148(%rbp), %rsi
callq 0x6ba0
leaq -0x148(%rbp), %rdi
callq 0x6be0
jmp 0x692f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x21e0
jmp 0x6a6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6a62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x2328
leaq -0xa8(%rbp), %rdi
callq 0x6c40
leaq -0x78(%rbp), %rdi
callq 0x6be0
jmp 0x6a62
leaq -0xc8(%rbp), %rdi
callq 0x2250
jmp 0x68c0
leaq -0x20(%rbp), %rdi
callq 0x2328
movq -0x30(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/lexer.cpp
// Function: Lexer::readChar()
void Lexer::readChar()
{
	if (readPos >= input.size())
		curChar = 0; // 0 -> end of file
	else
		curChar = input[readPos];

	pos = readPos;
	readPos++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movslq 0x24(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x20f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jb 0x9867
movq -0x18(%rbp), %rax
movb $0x0, 0x28(%rax)
jmp 0x9880
movq -0x18(%rbp), %rdi
movslq 0x24(%rdi), %rsi
callq 0x2310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movb (%rcx), %cl
movb %cl, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
movl %ecx, 0x20(%rax)
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: pranavmodx[P]modlang/src/lexer.cpp
// Function: Lexer::readString[abi:cxx11]()
std::string Lexer::readString()
{
	int start = pos + 1;

	do
	{
		readChar();
	} while (curChar != '"' && curChar != 0);

	// todo: throw error if ending " not found

	return input.substr(start, pos - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9830
movq -0x20(%rbp), %rax
movsbl 0x28(%rax), %ecx
xorl %eax, %eax
cmpl $0x22, %ecx
movb %al, -0x31(%rbp)
je 0xad78
movq -0x20(%rbp), %rax
movsbl 0x28(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xad4c
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movl 0x20(%rsi), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rcx
callq 0x21b0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pranavmodx[P]modlang/src/lexer.cpp
// Function: Lexer::readIdentifier[abi:cxx11]()
std::string Lexer::readIdentifier()
{
	int start = pos;

	while (isLetter(curChar))
		readChar();

	return input.substr(start, pos - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x28(%rax), %edi
callq 0x9780
testb $0x1, %al
jne 0xadec
jmp 0xadf7
movq -0x20(%rbp), %rdi
callq 0x9830
jmp 0xadd9
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movl 0x20(%rsi), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rcx
callq 0x21b0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pranavmodx[P]modlang/src/lexer.cpp
// Function: Lexer::readNumber[abi:cxx11]()
std::string Lexer::readNumber()
{
	int start = pos;

	while (isDigit(curChar))
		readChar();

	return input.substr(start, pos - start); // check
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x28(%rax), %edi
callq 0x97c0
testb $0x1, %al
jne 0xae5c
jmp 0xae67
movq -0x20(%rbp), %rdi
callq 0x9830
jmp 0xae49
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movl 0x20(%rsi), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rcx
callq 0x21b0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xnevs[P]bullimp/examples/../graph/ullimp_sub_graph_iso.hpp
// Function: bool ullimp::ullimp_subgraph_iso<boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, std::vector<unsigned long, std::allocator<unsigned long>>, main::$_0, boost::always_equivalent, main::$_1>(boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS> const&, boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS> const&, main::$_1, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long> const&, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&, main::$_0, boost::always_equivalent)
bool ullimp_subgraph_iso(GraphSmall const & graph_small, GraphLarge const & graph_large,
                         SubGraphIsoMapCallback user_callback,
                         IndexMapSmall const & index_map_small, IndexMapLarge const & index_map_large, 
                         VertexOrderSmall const &vertex_order_small,
                         EdgeEquivalencePredicate edge_comp,
                         VertexEquivalencePredicate vertex_comp) {
    detail::UllImp<GraphSmall, GraphLarge, IndexMapSmall, IndexMapLarge, VertexOrderSmall,
                   EdgeEquivalencePredicate, VertexEquivalencePredicate, SubGraphIsoMapCallback> 
        ullimp{graph_small, graph_large, user_callback,
               index_map_small, index_map_large,
               vertex_order_small, edge_comp, vertex_comp};
    return ullimp.find();
}

// Assembly:
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rcx, 0x38(%rsp)
movq %rdx, %rax
movq 0x38(%rsp), %rdx
movq %rax, 0x40(%rsp)
movq %rsi, %rax
movq 0x40(%rsp), %rsi
movq %rax, 0x48(%rsp)
movq %rdi, %r9
movq 0x48(%rsp), %rdi
leaq 0x4d0(%rsp), %rax
leaq 0x4b0(%rsp), %rcx
movq %r9, 0x498(%rsp)
movq %rdi, 0x490(%rsp)
movq %rsi, 0x488(%rsp)
movq %rdx, 0x480(%rsp)
movq %r8, 0x478(%rsp)
movq 0x498(%rsp), %rsi
movq 0x490(%rsp), %rdx
vmovdqu (%rcx), %ymm0
vmovdqu %ymm0, 0x80(%rsp)
movq 0x488(%rsp), %rcx
movq 0x480(%rsp), %r8
movq 0x478(%rsp), %r9
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x70(%rsp), %xmm0
movq %rsp, %rax
vmovdqu %xmm0, 0x20(%rax)
vmovdqu 0x80(%rsp), %ymm0
vmovdqu %ymm0, (%rax)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
vzeroupper
callq 0x2e10
movq 0x50(%rsp), %rdi
callq 0x3db0
movb %al, 0x5b(%rsp)
jmp 0x2dc5
leaq 0xa0(%rsp), %rdi
callq 0x3de0
movb 0x5b(%rsp), %al
andb $0x1, %al
addq $0x4a8, %rsp            # imm = 0x4A8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x3de0
movq 0x60(%rsp), %rdi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: xnevs[P]bullimp/examples/../graph/ullimp_sub_graph_iso.hpp
// Function: ullimp::detail::UllImp<boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, std::vector<unsigned long, std::allocator<unsigned long>>, main::$_0, boost::always_equivalent, main::$_1>::Map::Map(unsigned long, unsigned long, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long> const&, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long> const&)
Map(vertices_small_size_type rows, vertices_large_size_type cols,
                IndexMapSmall const & index_map_small, IndexMapLarge const & index_map_large)
                : rows(rows), cols(cols),
                  index_map_small(index_map_small), index_map_large(index_map_large) {

                auto size = rows * cols;
                data = new bool[size];
                history = new int[size];

                index = -1;
                lastindex = -1;
                shots = new int[size];
                shotidx = -1;
            }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
imulq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: xnevs[P]bullimp/examples/../graph/ullimp_sub_graph_iso.hpp
// Function: ullimp::detail::UllImp<boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, std::vector<unsigned long, std::allocator<unsigned long>>, main::$_0, boost::always_equivalent, main::$_1>::init()
void init() {
            BGL_FORALL_VERTICES_T(i, g, GraphSmall) {
                auto a = in_degree(i, g);
                auto b = out_degree(i, g);
                BGL_FORALL_VERTICES_T(j, h, GraphLarge) {
                    map(i, j) = in_degree(j, h) >= a && out_degree(j, h) >= b;
                }
            }

            refineMapFull();
        }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
callq 0xaf50
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x40(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x4031
jmp 0x41d4
jmp 0x4033
leaq 0x40(%rsp), %rdi
leaq 0x40(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x404c
jmp 0x4063
leaq 0x40(%rsp), %rdi
callq 0xb030
movq %rax, 0x38(%rsp)
movb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x406b
xorl %eax, %eax
movb %al, 0x7(%rsp)
jmp 0x406b
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x4078
jmp 0x41c3
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rdi
movq (%rax), %rsi
callq 0xd350
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq (%rax), %rsi
callq 0xd390
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rdi
callq 0xaf50
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x40e0
jmp 0x41b2
jmp 0x40e2
leaq 0x18(%rsp), %rdi
leaq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x40fb
jmp 0x4112
leaq 0x18(%rsp), %rdi
callq 0xb030
movq %rax, 0x10(%rsp)
movb $0x1, %al
movb %al, 0x6(%rsp)
jmp 0x411a
xorl %eax, %eax
movb %al, 0x6(%rsp)
jmp 0x411a
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x4124
jmp 0x41a1
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0xd350
movq %rax, %rcx
xorl %eax, %eax
cmpq 0x30(%rsp), %rcx
movb %al, 0x5(%rsp)
jb 0x4166
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0xd390
cmpq 0x28(%rsp), %rax
setae %al
movb %al, 0x5(%rsp)
movq 0x8(%rsp), %rdi
movb 0x5(%rsp), %al
movb %al, 0x4(%rsp)
addq $0x2f8, %rdi            # imm = 0x2F8
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x46e0
movb 0x4(%rsp), %cl
andb $0x1, %cl
movb %cl, (%rax)
leaq 0x18(%rsp), %rdi
callq 0xb820
jmp 0x40e2
jmp 0x41a3
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x40c4
jmp 0x41b4
leaq 0x40(%rsp), %rdi
callq 0xb820
jmp 0x4033
jmp 0x41c5
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x4015
movq 0x8(%rsp), %rdi
callq 0x4750
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: xnevs[P]bullimp/examples/../graph/ullimp_sub_graph_iso.hpp
// Function: ullimp::detail::UllImp<boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, std::vector<unsigned long, std::allocator<unsigned long>>, main::$_0, boost::always_equivalent, main::$_1>::refineMapFull()
void refineMapFull() {
            bool changed;
            do {
                changed = false;
                BGL_FORALL_VERTICES_T(i, g, GraphSmall) {
                    BGL_FORALL_VERTICES_T(j, h, GraphLarge) {
                        if(map(i, j) && !canMapFull(i, j)) {
                            map(i, j) = false;
                            changed = true;
                        }
                    }
                }
            } while(changed);
        }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, 0x4f(%rsp)
movq (%rax), %rdi
callq 0xaf50
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x38(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x479b
jmp 0x48f9
jmp 0x479d
leaq 0x38(%rsp), %rdi
leaq 0x38(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x47b6
jmp 0x47cd
leaq 0x38(%rsp), %rdi
callq 0xb030
movq %rax, 0x30(%rsp)
movb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x47d5
xorl %eax, %eax
movb %al, 0xf(%rsp)
jmp 0x47d5
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x47e2
jmp 0x48e8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xaf50
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x4816
jmp 0x48d7
jmp 0x4818
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
addq $0x8, %rsi
callq 0xafe0
testb $0x1, %al
jne 0x4831
jmp 0x4848
leaq 0x20(%rsp), %rdi
callq 0xb030
movq %rax, 0x18(%rsp)
movb $0x1, %al
movb %al, 0xe(%rsp)
jmp 0x4850
xorl %eax, %eax
movb %al, 0xe(%rsp)
jmp 0x4850
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x485a
jmp 0x48c6
movq 0x10(%rsp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x46e0
testb $0x1, (%rax)
je 0x48b5
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4910
testb $0x1, %al
jne 0x48b5
movq 0x10(%rsp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x46e0
movb $0x0, (%rax)
movb $0x1, 0x4f(%rsp)
jmp 0x48b7
leaq 0x20(%rsp), %rdi
callq 0xb820
jmp 0x4818
jmp 0x48c8
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x47fa
jmp 0x48d9
leaq 0x38(%rsp), %rdi
callq 0xb820
jmp 0x479d
jmp 0x48ea
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x477f
jmp 0x48fb
testb $0x1, 0x4f(%rsp)
jne 0x4763
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: xnevs[P]bullimp/examples/../graph/ullimp_sub_graph_iso.hpp
// Function: ullimp::detail::UllImp<boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::adjacency_list<boost::setS, boost::vecS, boost::bidirectionalS, boost::no_property, Color, boost::no_property, boost::listS>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, boost::vec_adj_list_vertex_id_map<boost::no_property, unsigned long>, std::vector<unsigned long, std::allocator<unsigned long>>, main::$_0, boost::always_equivalent, main::$_1>::Map::annul(unsigned long, unsigned long)
void annul(vertex_small_type row, vertex_large_type col) {
                auto idx = index_map_small[row] * cols + index_map_large[col];
                if (data[idx]) {
                    data[idx] = false;
                    history[++index] = idx;
                }
            }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
movq 0x28(%rsp), %rsi
callq 0xd470
movq 0x10(%rsp), %rdi
imulq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x11, %rdi
movq 0x20(%rsp), %rsi
callq 0xd470
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
addq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
testb $0x1, (%rax,%rcx)
je 0x6218
movq 0x10(%rsp), %rsi
movq 0x18(%rsi), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movl %eax, %edx
movq 0x20(%rsi), %rax
movl 0x28(%rsi), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x38, %rsp
retq
nopl (%rax)
// File: aempirei[P]Chat-Art/pgmtobrailedux.c
// Function: getmean
int getmean(int *data, size_t sz) {
	int mean = 0;
	for(size_t z = 0; z < sz; z++)
	mean += data[sz];
	return mean / sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1254
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x122b
movslq -0x14(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/ofxget.cc
// Function: ofxget::CurlWriteToString(char*, unsigned long, unsigned long, void*)
static size_t CurlWriteToString(char *ptr, size_t size, size_t nmemb, void *userdata) {
  OfxGetContext* context = static_cast<OfxGetContext*>(userdata);
  if (size != 1) {
    char err[255];
    sprintf(err, "In response, expected char size 1, got %ld", size);
    context->error_string_ = string(err);
  }
  string to_add;
  to_add.resize(nmemb);
  memcpy((void*) to_add.c_str(), (void*) ptr, nmemb);
  context->response_ += to_add;
  return size * nmemb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x10(%rbp)
je 0xa68e
movq -0x10(%rbp), %rdx
leaq 0x5ebf7(%rip), %rsi     # 0x691f0
xorl %eax, %eax
leaq -0x130(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x7980
leaq -0x151(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x78f0
movq -0x198(%rbp), %rsi
movq -0x190(%rbp), %rdx
leaq -0x150(%rbp), %rdi
callq 0x77b0
jmp 0xa63d
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
leaq -0x150(%rbp), %rsi
callq 0x74e0
leaq -0x150(%rbp), %rdi
callq 0x7b88
leaq -0x151(%rbp), %rdi
callq 0x7b70
jmp 0xa68e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x151(%rbp), %rdi
callq 0x7b70
jmp 0xa736
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x7320
movq -0x1a0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x73c0
jmp 0xa6b3
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x7100
movq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x70b0
movq -0x1a8(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
callq 0x70d0
jmp 0xa6ec
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x7b88
movq -0x1b0(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x7b88
movq -0x160(%rbp), %rdi
callq 0x7600
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/ofxget.cc
// Function: ofxget::OfxDate[abi:cxx11]()
string OfxDate() {
  time_t now = time(nullptr);
  struct tm* ltime = localtime(&now);
  char time_str[255];
  sprintf(time_str, "%04d%02d%02d%02d%02d%02d.000",
          1900 + ltime->tm_year, 1 + ltime->tm_mon, ltime->tm_mday,
          ltime->tm_hour, ltime->tm_min, ltime->tm_sec);
  return time_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x150(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, -0x154(%rbp)
movl %eax, %edi
callq 0x76e0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x7620
movq %rax, %rcx
movl -0x154(%rbp), %eax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl 0x14(%rsi), %edx
addl $0x76c, %edx            # imm = 0x76C
movl 0x10(%rsi), %ecx
incl %ecx
movl 0xc(%rsi), %r8d
movl 0x8(%rsi), %r9d
movl (%rsi), %r10d
movl 0x4(%rsi), %edi
movq %rsp, %rsi
movl %r10d, 0x8(%rsi)
movl %edi, (%rsi)
leaq 0x5e9b2(%rip), %rsi     # 0x691cb
leaq -0x120(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x7980
leaq -0x121(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x78f0
movq -0x150(%rbp), %rdi
movq -0x148(%rbp), %rsi
movq -0x140(%rbp), %rdx
callq 0x77b0
jmp 0xa85b
leaq -0x121(%rbp), %rdi
callq 0x7b70
movq -0x160(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x121(%rbp), %rdi
callq 0x7b70
movq -0x130(%rbp), %rdi
callq 0x7600
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/ofxhome.cc
// Function: ofxget::CurlWriteToString(char*, unsigned long, unsigned long, void*)
static size_t CurlWriteToString(char *ptr, size_t size, size_t nmemb, void *userdata) {
  if (size != 1) {
    char err[255];
    sprintf(err, "In response, expected char size 1, got %ld", size);
    throw string(err);
  }
  string* out = static_cast<string*>(userdata);
  string to_add;
  to_add.resize(nmemb);
  memcpy((void*) to_add.c_str(), (void*) ptr, nmemb);
  *out += to_add;
  return size * nmemb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x1, -0x10(%rbp)
je 0xef44
movq -0x10(%rbp), %rdx
leaq 0x5a36f(%rip), %rsi     # 0x691f0
xorl %eax, %eax
leaq -0x120(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x7980
movb $0x1, -0x135(%rbp)
movl $0x20, %edi
callq 0x7380
movq %rax, -0x178(%rbp)
movq %rax, -0x180(%rbp)
leaq -0x121(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x78f0
movq -0x178(%rbp), %rdi
movq -0x170(%rbp), %rsi
movq -0x168(%rbp), %rdx
callq 0x77b0
jmp 0xeee4
movq -0x180(%rbp), %rdi
movb $0x0, -0x135(%rbp)
leaq 0x85687(%rip), %rsi     # 0x94580
movq 0x860a0(%rip), %rdx     # 0x94fa0
callq 0x75e0
jmp 0xf002
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x121(%rbp), %rdi
callq 0x7b70
testb $0x1, -0x135(%rbp)
jne 0xef33
jmp 0xef3f
movq -0x180(%rbp), %rdi
callq 0x7840
jmp 0xeff6
movq -0x20(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x160(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x7320
movq -0x188(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x73c0
jmp 0xef74
leaq -0x160(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x7100
movq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x70b0
movq -0x190(%rbp), %rsi
movq -0x140(%rbp), %rdi
callq 0x70d0
jmp 0xefac
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x198(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x7b88
movq -0x198(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x7b88
movq -0x130(%rbp), %rdi
callq 0x7600
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/ofxhome.cc
// Function: ofxget::FindInstitutionByName(std::vector<ofxget::Institution, std::allocator<ofxget::Institution>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Institution* FindInstitutionByName(
    const vector<Institution>& institutions,
    const string& name)
{
  for (const Institution& i : institutions) {
    if (i.name.find(name) != string::npos) {
      return &i;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10ae0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10b10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10b40
testb $0x1, %al
jne 0xfbc5
jmp 0xfc04
leaq -0x28(%rbp), %rdi
callq 0x10b80
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x75f0
cmpq $-0x1, %rax
je 0xfbf7
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfc0c
jmp 0xfbf9
leaq -0x28(%rbp), %rdi
callq 0x10ba0
jmp 0xfbb2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/ofxhome.cc
// Function: ofxget::AnonymizeRequest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string AnonymizeRequest(const string& request) {
  string r = request;
  std::regex userid("<USERID>[^<]*", icase);
  std::regex acctid("<ACCTID>[^<]*", icase);
  std::regex userpass("<USERPASS>[^<]*", icase);
  r = regex_replace(r, userid, "<USERID>X\n");
  r = regex_replace(r, acctid, "<ACCTID>X\n");
  r = regex_replace(r, userpass, "<USERPASS>X\n");
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7110
leaq 0x59981(%rip), %rsi     # 0x695d9
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
callq 0x10bc0
jmp 0xfc68
leaq 0x59978(%rip), %rsi     # 0x695e7
leaq -0x68(%rbp), %rdi
movl $0x1, %edx
callq 0x10bc0
jmp 0xfc7f
leaq 0x5996f(%rip), %rsi     # 0x695f5
leaq -0x88(%rbp), %rdi
movl $0x1, %edx
callq 0x10bc0
jmp 0xfc99
movq -0xf8(%rbp), %rsi
leaq 0x5f6a8(%rip), %rcx     # 0x6f34f
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rdx
xorl %r8d, %r8d
callq 0x10c60
jmp 0xfcbc
movq -0xf8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movq %rsi, -0x100(%rbp)
callq 0x74e0
movq -0x100(%rbp), %rdi
callq 0x7b88
movq -0xf8(%rbp), %rsi
leaq 0x59915(%rip), %rcx     # 0x69605
leaq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rdx
xorl %r8d, %r8d
callq 0x10c60
jmp 0xfd05
movq -0xf8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movq %rsi, -0x108(%rbp)
callq 0x74e0
movq -0x108(%rbp), %rdi
callq 0x7b88
movq -0xf8(%rbp), %rsi
leaq 0x598d7(%rip), %rcx     # 0x69610
leaq -0xe8(%rbp), %rdi
leaq -0x88(%rbp), %rdx
xorl %r8d, %r8d
callq 0x10c60
jmp 0xfd51
movq -0xf8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x74e0
leaq -0xe8(%rbp), %rdi
callq 0x7b88
movb $0x1, -0x11(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x10d40
leaq -0x68(%rbp), %rdi
callq 0x10d40
leaq -0x38(%rbp), %rdi
callq 0x10d40
testb $0x1, -0x11(%rbp)
jne 0xfdfc
jmp 0xfdf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xfe0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xfde5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xfddc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x10d40
leaq -0x68(%rbp), %rdi
callq 0x10d40
leaq -0x38(%rbp), %rdi
callq 0x10d40
jmp 0xfe0c
movq -0xf8(%rbp), %rdi
callq 0x7b88
movq -0xf0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x7b88
movq -0x40(%rbp), %rdi
callq 0x7600
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArg::validate_flags()
bool CmdArg::validate_flags()
{
  if ((_syntaxFlags & isOPT) && (_syntaxFlags & isREQ))
    {
      cerr << "Warning: keyword " << getKeyword()
	   << " can't be optional AND required" << endl;
      cerr << "changing the sytax of "
	   << getKeyword() << " to be required." << endl;
      _syntaxFlags &= ~isOPT;
      return false;
    }
  if ((_syntaxFlags & isVALOPT) && (_syntaxFlags & isVALREQ  ))
    {
      cerr << "Warning: value for keyword " << getKeyword()
	   << " can't be optional AND required" << endl;
      cerr << "changing the sytax of the value of "
	   << getKeyword() << " to be required." << endl;
      _syntaxFlags &= ~isVALREQ;
      return false;
    }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x28(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3b340
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3b340
movq 0x59d3b(%rip), %rdi     # 0x94fd8
leaq 0x2f23c(%rip), %rsi     # 0x6a4e0
callq 0x7580
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x3b4e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2f226(%rip), %rsi     # 0x6a4f2
callq 0x7580
movq %rax, %rdi
movq 0x59ced(%rip), %rsi     # 0x94fc8
callq 0x7970
movq 0x59cf1(%rip), %rdi     # 0x94fd8
leaq 0x2f224(%rip), %rsi     # 0x6a512
callq 0x7580
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3b4e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2f213(%rip), %rsi     # 0x6a529
callq 0x7580
movq %rax, %rdi
movq 0x59ca3(%rip), %rsi     # 0x94fc8
callq 0x7970
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x28(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x3b411
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x3b40d
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3b40d
movq 0x59c6b(%rip), %rdi     # 0x94fd8
leaq 0x2f1c6(%rip), %rsi     # 0x6a53a
callq 0x7580
movq -0x18(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x3b4e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2f156(%rip), %rsi     # 0x6a4f2
callq 0x7580
movq %rax, %rdi
movq 0x59c1d(%rip), %rsi     # 0x94fc8
callq 0x7970
movq 0x59c21(%rip), %rdi     # 0x94fd8
leaq 0x2f198(%rip), %rsi     # 0x6a556
callq 0x7580
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x3b4e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2f143(%rip), %rsi     # 0x6a529
callq 0x7580
movq %rax, %rdi
movq 0x59bd3(%rip), %rsi     # 0x94fc8
callq 0x7970
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
andl $-0x9, %ecx
movl %ecx, 0x28(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x3b411
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgInt::getValue(int*, int, char**)
bool CmdArgInt::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      _v = strtol(arg, (char **)&ptr, 0);
      if (ptr == arg)
	{
	  cout << " invalid integer value \"" << arg << "\"" << endl;
	  return false;
	}
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3b847
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x77e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x3b838
movq 0x5978c(%rip), %rdi     # 0x94f88
leaq 0x2ed77(%rip), %rsi     # 0x6a57a
callq 0x7580
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2edb6(%rip), %rsi     # 0x6a5d4
callq 0x7580
movq %rax, %rdi
movq 0x5979b(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3b84b
movq -0x40(%rbp), %rdi
callq 0x3b660
movb $0x1, -0x1(%rbp)
jmp 0x3b84b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgFloat::getValue(int*, int, char**)
bool CmdArgFloat::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      _v = strtod(arg, (char **)&ptr);
      if (ptr == arg)
	{
	  cout << " invalid float value \"" << arg << "\"" << endl;
	  return false;
	}
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3ba33
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b60
movq -0x40(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x3ba24
movq 0x595a0(%rip), %rdi     # 0x94f88
leaq 0x2eba4(%rip), %rsi     # 0x6a593
callq 0x7580
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2ebca(%rip), %rsi     # 0x6a5d4
callq 0x7580
movq %rax, %rdi
movq 0x595af(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3ba37
movq -0x40(%rbp), %rdi
callq 0x3b660
movb $0x1, -0x1(%rbp)
jmp 0x3ba37
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgStr::getValue(int*, int, char**)
bool CmdArgStr::getValue(int *i, int argc, char *argv[])
{
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      if (arg[0] == '-') return false;      
      _v = arg;
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3bd46
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3bd2f
movb $0x0, -0x1(%rbp)
jmp 0x3bd4a
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, 0x30(%rdi)
callq 0x3b660
movb $0x1, -0x1(%rbp)
jmp 0x3bd4a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgStr::operator char*()
CmdArgStr::operator char*() {
  char* str = new char[strlen(_v) + 1];
  int i;
  for (i = 0; i < strlen(_v); i++)
    str[i] = _v[i];
  str[i] = '\0';
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0x7390
movq %rax, %rdi
addq $0x1, %rdi
callq 0x7420
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x30(%rax), %rdi
callq 0x7390
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3bdda
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3bd94
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgChar::getValue(int*, int, char**)
bool CmdArgChar::getValue(int *i, int argc, char *argv[])
{
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      if (strlen(arg) > 1){
	cout << "value \"" << arg << "\" is to long. ignoring" << endl;
	return false;
      }
      _v = arg[0];
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3bf9b
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7390
cmpq $0x1, %rax
jbe 0x3bf83
movq 0x59041(%rip), %rdi     # 0x94f88
leaq 0x2e680(%rip), %rsi     # 0x6a5ce
callq 0x7580
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2e641(%rip), %rsi     # 0x6a5aa
callq 0x7580
movq %rax, %rdi
movq 0x59050(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3bf9f
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, 0x30(%rdi)
callq 0x3b660
movb $0x1, -0x1(%rbp)
jmp 0x3bf9f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgIntList::getValue(int*, int, char**)
bool CmdArgIntList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  long val;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  val = strtol(tok, (char **)&ptr, 0);
	  if (ptr == tok)
	    {
	      cout << "invalid integer value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(val);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3c1fa
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x3cad0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x7280
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3c1ea
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x77e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x3c1bd
movq 0x58e07(%rip), %rdi     # 0x94f88
leaq 0x2e3f3(%rip), %rsi     # 0x6a57b
callq 0x7580
movq %rax, %rdi
movq -0x48(%rbp), %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2e431(%rip), %rsi     # 0x6a5d4
callq 0x7580
movq %rax, %rdi
movq 0x58e16(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3c1fe
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, %esi
callq 0x3caf0
movq -0x50(%rbp), %rdi
callq 0x3cad0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7280
movq %rax, -0x48(%rbp)
jmp 0x3c152
movq -0x50(%rbp), %rdi
callq 0x3cb40
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3c1fe
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgFloatList::getValue(int*, int, char**)
bool CmdArgFloatList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  double val;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  val = strtod(tok, (char **)&ptr);
	  if (ptr == tok)
	    {
	      cout << "invalid float value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(val);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3c438
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x3ce70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x7280
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3c428
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7b60
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x3c3fc
movq 0x58bc8(%rip), %rdi     # 0x94f88
leaq 0x2e1cd(%rip), %rsi     # 0x6a594
callq 0x7580
movq %rax, %rdi
movq -0x48(%rbp), %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2e1f2(%rip), %rsi     # 0x6a5d4
callq 0x7580
movq %rax, %rdi
movq 0x58bd7(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3c43c
movq -0x50(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x3ce90
movq -0x50(%rbp), %rdi
callq 0x3ce70
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7280
movq %rax, -0x48(%rbp)
jmp 0x3c392
movq -0x50(%rbp), %rdi
callq 0x3cee0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3c43c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgStrList::getValue(int*, int, char**)
bool CmdArgStrList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  insert(strdup(tok));
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3c619
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x3d210
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x7280
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3c609
movq -0x40(%rbp), %rdi
callq 0x7040
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3d230
movq -0x48(%rbp), %rdi
callq 0x3d210
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7280
movq %rax, -0x40(%rbp)
jmp 0x3c5d2
movq -0x48(%rbp), %rdi
callq 0x3d280
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3c61d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgCharList::getValue(int*, int, char**)
bool CmdArgCharList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  if (strlen(tok) != 1)
	    {
	      cout << "invalid char value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(tok[0]);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3c84d
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7040
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x3d5b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x7280
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3c83d
movq -0x40(%rbp), %rdi
callq 0x7390
cmpq $0x1, %rax
je 0x3c80f
movq 0x587b5(%rip), %rdi     # 0x94f88
leaq 0x2dde7(%rip), %rsi     # 0x6a5c1
callq 0x7580
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x7580
movq %rax, %rdi
leaq 0x2dddf(%rip), %rsi     # 0x6a5d4
callq 0x7580
movq %rax, %rdi
movq 0x587c4(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3c851
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movsbl (%rax), %esi
callq 0x3d5d0
movq -0x48(%rbp), %rdi
callq 0x3d5b0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x7280
movq %rax, -0x40(%rbp)
jmp 0x3c7b2
movq -0x48(%rbp), %rdi
callq 0x3d620
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3c851
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)