LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<IMethod*>::hasCandidates(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool hasCandidates(const std::string& type) const
		{
			for (typename std::list<value_type>::const_iterator it = _elements.begin(); it != _elements.end(); it++)
				if ((*it)->getType().substr(0, type.size()) == type)
					return true;
			return false;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
callq 0x4dbf0
movq %rax, -0x20(%rbp)
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x4dc50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4dc20
testb $0x1, %al
jne 0x618c5
jmp 0x6196b
leaq -0x20(%rbp), %rdi
callq 0x4dcc0
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x9480
movq -0x90(%rbp), %rsi
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
callq 0x96b0
jmp 0x61907
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x144e0
movb %al, -0x91(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9c98
leaq -0x68(%rbp), %rdi
callq 0x9c98
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x61938
jmp 0x61955
movb $0x1, -0x1(%rbp)
jmp 0x6196f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9c98
jmp 0x6197d
jmp 0x61957
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x4dcf0
movq %rax, -0x80(%rbp)
jmp 0x6189b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<Header*>::contains_ignore_case(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool contains_ignore_case(const std::string& type) const
		{
			for (typename std::list<value_type>::const_iterator it = _elements.begin(); it != _elements.end(); it++)
				if (compare_type_lowercase((*it)->getType(), type))
					return true;
			return false;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
callq 0x628d0
movq %rax, -0x20(%rbp)
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
callq 0x62930
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x62900
testb $0x1, %al
jne 0x61a75
jmp 0x61b21
leaq -0x20(%rbp), %rdi
callq 0x62a30
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x92c0
jmp 0x61a9d
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x62960
movb %al, -0x89(%rbp)
jmp 0x61ab9
leaq -0x68(%rbp), %rdi
callq 0x9c98
leaq -0x48(%rbp), %rdi
callq 0x9c98
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x61ad7
jmp 0x61b0b
movb $0x1, -0x1(%rbp)
jmp 0x61b25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x61b00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9c98
leaq -0x48(%rbp), %rdi
callq 0x9c98
jmp 0x61b33
jmp 0x61b0d
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x62a60
movq %rax, -0x80(%rbp)
jmp 0x61a4b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x9af0
nopl (%rax)
// File: mbourand[P]webserv/incs/Utils/Factory.hpp
// Function: Factory<Header*>::compare_type_lowercase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool	compare_type_lowercase(std::string str1, std::string str2) const
		{
			if (str1.length() != str2.length())
				return (false);
			for (std::string::size_type i = 0; i < str1.length(); i++)
				if (tolower(str1[i]) != tolower(str2[i]))
					return (false);
			return (true);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x9960
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x9960
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x629ab
movb $0x0, -0x1(%rbp)
jmp 0x62a20
movq $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x9960
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x62a1c
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9c70
movsbl (%rax), %edi
callq 0x9900
movq -0x38(%rbp), %rdi
movl %eax, -0x54(%rbp)
movq -0x28(%rbp), %rsi
callq 0x9c70
movsbl (%rax), %edi
callq 0x9900
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
je 0x62a0c
movb $0x0, -0x1(%rbp)
jmp 0x62a20
jmp 0x62a0e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x629b3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mbourand[P]webserv/srcs/Response.cpp
// Function: Response::operator=(Response const&)
Response& Response::operator=(const Response& other)
{
	_code = other._code;
	_message = other._message;
	_headers = other._headers;
	_body = other._body;
	_path = other._path;
	_cangzip = other._cangzip;
	_candeflate = other._candeflate;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x4d780
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
addq $0x60, %rdi
callq 0x9070
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
addq $0x80, %rdi
callq 0x9070
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0xd(%rcx), %cl
andb $0x1, %cl
movb %cl, 0xd(%rax)
movq -0x10(%rbp), %rcx
movb 0xc(%rcx), %cl
andb $0x1, %cl
movb %cl, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mbourand[P]webserv/srcs/Response.cpp
// Function: Response::Chunk(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string	Response::Chunk(const std::string& str)
{
	std::string result;

	for (size_t start = 0; start < str.size(); start += CHUNK_SIZE)
	{
		std::string line = str.substr(start, std::min(CHUNK_SIZE, str.size() - start));
		result += ft::toHex(line.size()) + "\r\n" + line + "\r\n";
	}
	result += "0\r\n\r\n";

	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x98c0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9480
movq %rax, %rcx
movq -0x100(%rbp), %rax
cmpq %rcx, %rax
jae 0x63a04
movq -0x18(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x110(%rbp)
movq $0x64, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9480
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22650
movq %rax, -0x108(%rbp)
jmp 0x63888
movq -0x110(%rbp), %rdx
movq -0x118(%rbp), %rsi
movq -0x108(%rbp), %rax
movq (%rax), %rcx
leaq -0x48(%rbp), %rdi
callq 0x96b0
jmp 0x638ab
leaq -0x48(%rbp), %rdi
callq 0x9480
movl %eax, %esi
leaq -0xe8(%rbp), %rdi
callq 0x2f7a0
jmp 0x638c4
leaq 0xa3e5(%rip), %rdx      # 0x6dcb0
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x13970
jmp 0x638e0
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x14140
jmp 0x638f9
leaq 0xa3b0(%rip), %rdx      # 0x6dcb0
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x13970
jmp 0x63915
movq -0xf8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x9830
jmp 0x6392a
leaq -0x88(%rbp), %rdi
callq 0x9c98
leaq -0xa8(%rbp), %rdi
callq 0x9c98
leaq -0xc8(%rbp), %rdi
callq 0x9c98
leaq -0xe8(%rbp), %rdi
callq 0x9c98
leaq -0x48(%rbp), %rdi
callq 0x9c98
movq -0x28(%rbp), %rax
addq $0x64, %rax
movq %rax, -0x28(%rbp)
jmp 0x63819
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x63a3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x639f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x639ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x639e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x639d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x9c98
leaq -0xa8(%rbp), %rdi
callq 0x9c98
leaq -0xc8(%rbp), %rdi
callq 0x9c98
leaq -0xe8(%rbp), %rdi
callq 0x9c98
leaq -0x48(%rbp), %rdi
callq 0x9c98
jmp 0x63a3f
movq -0xf8(%rbp), %rdi
leaq 0xa29b(%rip), %rsi      # 0x6dcad
callq 0x9650
jmp 0x63a19
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x63a2f
movq -0xf8(%rbp), %rdi
callq 0x9c98
movq -0xf0(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x9c98
movq -0x60(%rbp), %rdi
callq 0x9af0
nopw %cs:(%rax,%rax)
// File: mbourand[P]webserv/srcs/Response.cpp
// Function: Response::addDateHeader()
void Response::addDateHeader(void)
{
	struct timeval		tv;
	char				buffer[1024];
	std::stringstream	ss;
	struct tm			time;

	gettimeofday(&tv, NULL);
	tv.tv_sec -= 7200;
	ss << tv.tv_sec;
	strptime(std::string(ss.str()).c_str(), "%s", &time);
	strftime(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S GMT", &time);
	this->addHeader("Date", buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x690, %rsp            # imm = 0x690
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x668(%rbp)
leaq -0x5a8(%rbp), %rdi
callq 0x9490
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
callq 0x9a10
movq -0x18(%rbp), %rax
addq $-0x1c20, %rax          # imm = 0xE3E0
movq %rax, -0x18(%rbp)
leaq -0x598(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b70
jmp 0x63ab3
leaq -0x610(%rbp), %rdi
leaq -0x5a8(%rbp), %rsi
callq 0x9660
jmp 0x63ac8
leaq -0x610(%rbp), %rdi
movq %rdi, -0x680(%rbp)
callq 0x92b0
movq %rax, %rdi
leaq 0x6884(%rip), %rsi      # 0x6a369
leaq -0x5e0(%rbp), %rdx
movq %rdx, -0x678(%rbp)
callq 0x90e0
movq -0x680(%rbp), %rdi
callq 0x9c98
movq -0x678(%rbp), %rcx
leaq 0x6c0c(%rip), %rdx      # 0x6a71e
leaq -0x420(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x9550
leaq -0x631(%rbp), %rdi
movq %rdi, -0x670(%rbp)
callq 0x9b10
movq -0x670(%rbp), %rdx
leaq 0x663e(%rip), %rsi      # 0x6a182
leaq -0x630(%rbp), %rdi
callq 0xa780
jmp 0x63b52
leaq -0x659(%rbp), %rdi
movq %rdi, -0x688(%rbp)
callq 0x9b10
movq -0x688(%rbp), %rdx
leaq -0x658(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0xa780
jmp 0x63b81
movq -0x668(%rbp), %rdi
leaq -0x630(%rbp), %rsi
leaq -0x658(%rbp), %rdx
callq 0x63770
jmp 0x63b9d
leaq -0x658(%rbp), %rdi
callq 0x9c98
leaq -0x659(%rbp), %rdi
callq 0x9700
leaq -0x630(%rbp), %rdi
callq 0x9c98
leaq -0x631(%rbp), %rdi
callq 0x9700
leaq -0x5a8(%rbp), %rdi
callq 0x94e0
addq $0x690, %rsp            # imm = 0x690
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5e8(%rbp)
movl %eax, -0x5ec(%rbp)
jmp 0x63c60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5e8(%rbp)
movl %eax, -0x5ec(%rbp)
jmp 0x63c54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5e8(%rbp)
movl %eax, -0x5ec(%rbp)
jmp 0x63c3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x5e8(%rbp)
movl %eax, -0x5ec(%rbp)
leaq -0x658(%rbp), %rdi
callq 0x9c98
leaq -0x659(%rbp), %rdi
callq 0x9700
leaq -0x630(%rbp), %rdi
callq 0x9c98
leaq -0x631(%rbp), %rdi
callq 0x9700
leaq -0x5a8(%rbp), %rdi
callq 0x94e0
movq -0x5e8(%rbp), %rdi
callq 0x9af0
nopl (%rax,%rax)
// File: pollo[P]graph-partitioning/preprocessing.cpp
// Function: dfs(int, int, std::vector<int, std::allocator<int>>&, Graph const&)
int dfs(int node,
        int component_id,
        vector<int>& component,
        const Graph& graph)
{
  component[node] = component_id;
  int discovered = 1;
  for (size_t j = 0;
       j < graph.get_neighbors(node).size();
       j++)
  {
    int neighbor = graph.get_neighbors(node)[j];
    if (component[neighbor] == -1)
      discovered += dfs(neighbor, component_id, component, graph);
  }

  return discovered;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x2c30
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movl $0x1, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x4d00
movq %rax, %rdi
callq 0x2c50
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x2448
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x4d00
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x2c70
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x2c30
cmpl $-0x1, (%rax)
jne 0x2433
movl 0xc(%rsp), %edi
movl 0x30(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x2370
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x2435
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x23b4
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pollo[P]graph-partitioning/preprocessing.cpp
// Function: find_largest_component(std::vector<int, std::allocator<int>>&, Graph const&)
int find_largest_component(vector<int>& component,
                           const Graph& graph) {
  component.resize(graph.get_nodes_number(), -1);
  int largest_component = -1;
  int largest_size = 0;
  int component_id = 1;
  for (int i=0; i<graph.get_nodes_number(); i++)
  {
    if (component[i] == -1)
    {
      int component_size = dfs(i, component_id, component, graph);
      if (component_size > largest_size)
      {
        largest_size = component_size;
        largest_component = component_id;
      }
      component_id ++;
    }
  }

  return largest_component;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2d50
movq 0x8(%rsp), %rdi
movslq %eax, %rsi
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
leaq 0x24(%rsp), %rdx
callq 0x2c90
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x1c(%rsp)
movl $0x1, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2d50
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x253b
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x2c30
cmpl $-0x1, (%rax)
jne 0x252c
movl 0x14(%rsp), %edi
movl 0x18(%rsp), %esi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x2370
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x2521
movl 0x10(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x252e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x24bc
movl 0x20(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pollo[P]graph-partitioning/preprocessing.cpp
// Function: count_nodes_edges(int, std::vector<int, std::allocator<int>> const&, Graph const&, int*, int*)
void count_nodes_edges(int component_id,
                      const vector<int>& component,
                      const Graph& graph,
                      int* n,
                      int *m)
{
  int nodes = 0, edges = 0;

  for (size_t i=0; i<component.size(); i++)
  {
    if (component[i] == component_id)
    {
      nodes ++;
      edges += graph.get_neighbors(i).size();
    }
  }

  edges /= 2.0;

  *n = nodes;
  *m = edges;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2602
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2c70
movl (%rax), %eax
cmpl 0x44(%rsp), %eax
jne 0x25f0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
callq 0x4d00
movq %rax, %rdi
callq 0x2c50
movq %rax, %rcx
movslq 0x18(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x18(%rsp)
jmp 0x25f2
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2585
cvtsi2sdl 0x18(%rsp), %xmm0
movsd 0x79f8(%rip), %xmm1     # 0xa008
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: eatonphil[P]cpp-json/json.cpp
// Function: json::JSONTokenType_to_string[abi:cxx11](json::JSONTokenType)
std::string JSONTokenType_to_string(JSONTokenType jtt) {
  switch (jtt) {
  case JSONTokenType::String:
    return "String";
  case JSONTokenType::Number:
    return "Number";
  case JSONTokenType::Syntax:
    return "Syntax";
  case JSONTokenType::Boolean:
    return "Boolean";
  case JSONTokenType::Null:
    return "Null";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x45ba
movq -0x28(%rbp), %rax
leaq 0x10bbe(%rip), %rcx     # 0x15004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x42b0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x10bd9(%rip), %rsi     # 0x15044
callq 0x8560
jmp 0x4472
leaq -0xd(%rbp), %rdi
callq 0x41d0
jmp 0x45bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x41d0
jmp 0x45c6
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x42b0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x10b95(%rip), %rsi     # 0x1504b
callq 0x8560
jmp 0x44bd
leaq -0x1d(%rbp), %rdi
callq 0x41d0
jmp 0x45bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x41d0
jmp 0x45c6
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x42b0
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x10b51(%rip), %rsi     # 0x15052
callq 0x8560
jmp 0x4508
leaq -0x1e(%rbp), %rdi
callq 0x41d0
jmp 0x45bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x41d0
jmp 0x45c6
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x42b0
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x10b0d(%rip), %rsi     # 0x15059
callq 0x8560
jmp 0x4553
leaq -0x1f(%rbp), %rdi
callq 0x41d0
jmp 0x45bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x41d0
jmp 0x45c6
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x42b0
movq -0x38(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x10ad0(%rip), %rsi     # 0x15061
callq 0x8560
jmp 0x4598
leaq -0x20(%rbp), %rdi
callq 0x41d0
jmp 0x45bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x41d0
jmp 0x45c6
ud2
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x42a0
nop
// File: eatonphil[P]cpp-json/json.cpp
// Function: json::lex_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int lex_whitespace(std::string raw_json, int index) {
  while (std::isspace(raw_json[index])) {
    if (index == raw_json.length()) {
      break;
    }

    index++;
  }

  return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x87c0
movsbl (%rax), %edi
callq 0x4040
cmpl $0x0, %eax
je 0x4ad7
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8830
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x4acc
jmp 0x4ad7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4a93
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: eatonphil[P]cpp-json/json.cpp
// Function: json::lex_syntax(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::tuple<JSONToken, int, std::string> lex_syntax(std::string raw_json,
                                                   int index) {
  JSONToken token{"", JSONTokenType::Syntax, index};
  std::string value = "";
  auto c = raw_json[index];
  if (c == '[' || c == ']' || c == '{' || c == '}' || c == ':' || c == ',') {
    token.value += c;
    index++;
  }

  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x42b0
movq -0x98(%rbp), %rdx
leaq 0x106bf(%rip), %rsi     # 0x151eb
leaq -0x50(%rbp), %rdi
callq 0x8560
jmp 0x4b37
movl $0x2, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8850
leaq -0x51(%rbp), %rdi
callq 0x41d0
leaq -0x89(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x42b0
movq -0xb8(%rbp), %rdx
leaq 0x10674(%rip), %rsi     # 0x151eb
leaq -0x88(%rbp), %rdi
callq 0x8560
jmp 0x4b85
leaq -0x89(%rbp), %rdi
callq 0x41d0
movq -0xb0(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x87c0
movq %rax, -0xc0(%rbp)
jmp 0x4baa
movq -0xc0(%rbp), %rax
movb (%rax), %al
movb %al, -0x8a(%rbp)
movsbl -0x8a(%rbp), %eax
cmpl $0x5b, %eax
je 0x4c01
movsbl -0x8a(%rbp), %eax
cmpl $0x5d, %eax
je 0x4c01
movsbl -0x8a(%rbp), %eax
cmpl $0x7b, %eax
je 0x4c01
movsbl -0x8a(%rbp), %eax
cmpl $0x7d, %eax
je 0x4c01
movsbl -0x8a(%rbp), %eax
cmpl $0x3a, %eax
je 0x4c01
movsbl -0x8a(%rbp), %eax
cmpl $0x2c, %eax
jne 0x4c69
movsbl -0x8a(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0x8750
jmp 0x4c13
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x41d0
jmp 0x4cb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x89(%rbp), %rdi
callq 0x41d0
jmp 0x4cab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x87f0
jmp 0x4cab
movq -0xa8(%rbp), %rdi
leaq 0x10574(%rip), %rcx     # 0x151eb
leaq -0x50(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x8870
jmp 0x4c86
leaq -0x88(%rbp), %rdi
callq 0x87f0
leaq -0x50(%rbp), %rdi
callq 0x88b0
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x88b0
movq -0x60(%rbp), %rdi
callq 0x42a0
nopl (%rax)
// File: eatonphil[P]cpp-json/json.cpp
// Function: json::lex_number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::tuple<JSONToken, int, std::string> lex_number(std::string raw_json,
                                                   int original_index) {
  int index = original_index;
  JSONToken token = {"", JSONTokenType::Number, index};
  std::string value = "";
  // TODO: handle not just integers
  while (true) {
    if (index == raw_json.length()) {
      break;
    }

    auto c = raw_json[index];
    if (!(c >= '0' && c <= '9')) {
      break;
    }

    token.value += c;
    index++;
  }

  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x42b0
movq -0x98(%rbp), %rdx
leaq 0x10149(%rip), %rsi     # 0x151eb
leaq -0x50(%rbp), %rdi
callq 0x8560
jmp 0x50ad
movl $0x1, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8850
leaq -0x51(%rbp), %rdi
callq 0x41d0
leaq -0x89(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x42b0
movq -0xb8(%rbp), %rdx
leaq 0x100fe(%rip), %rsi     # 0x151eb
leaq -0x88(%rbp), %rdi
callq 0x8560
jmp 0x50fb
leaq -0x89(%rbp), %rdi
callq 0x41d0
jmp 0x5109
movq -0xb0(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x8830
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jne 0x516b
jmp 0x51e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x41d0
jmp 0x5232
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x89(%rbp), %rdi
callq 0x41d0
jmp 0x5229
movq -0xb0(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x87c0
movq %rax, -0xc8(%rbp)
jmp 0x5184
movq -0xc8(%rbp), %rax
movb (%rax), %al
movb %al, -0x8a(%rbp)
movsbl -0x8a(%rbp), %eax
cmpl $0x30, %eax
jl 0x51ab
movsbl -0x8a(%rbp), %eax
cmpl $0x39, %eax
jle 0x51c7
jmp 0x51e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x87f0
jmp 0x5229
movsbl -0x8a(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0x8750
jmp 0x51d9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5107
movq -0xa8(%rbp), %rdi
leaq 0xfff6(%rip), %rcx      # 0x151eb
leaq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x8870
jmp 0x5204
leaq -0x88(%rbp), %rdi
callq 0x87f0
leaq -0x50(%rbp), %rdi
callq 0x88b0
movq -0xa0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x88b0
movq -0x60(%rbp), %rdi
callq 0x42a0
nopl (%rax,%rax)
// File: eatonphil[P]cpp-json/json.cpp
// Function: json::lex_keyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, json::JSONTokenType, int)
std::tuple<JSONToken, int, std::string> lex_keyword(std::string raw_json,
                                                    std::string keyword,
                                                    JSONTokenType type,
                                                    int original_index) {
  int index = original_index;
  JSONToken token{"", type, index};
  while (keyword[index - original_index] == raw_json[index]) {
    if (index == raw_json.length()) {
      break;
    }

    index++;
  }

  if (index - original_index == keyword.length()) {
    token.value = keyword;
  }
  return {token, index, ""};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xa0(%rbp)
movq %rsi, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x42b0
movq -0x80(%rbp), %rdx
leaq 0xff50(%rip), %rsi      # 0x151eb
leaq -0x60(%rbp), %rdi
callq 0x8560
jmp 0x52a6
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
addq $0x28, %rdi
callq 0x8850
leaq -0x61(%rbp), %rdi
callq 0x41d0
movq -0xa0(%rbp), %rdi
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
subl %ecx, %eax
movslq %eax, %rsi
callq 0x87c0
movq %rax, -0xa8(%rbp)
jmp 0x52e8
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xb4(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x87c0
movq %rax, -0xb0(%rbp)
jmp 0x5311
movl -0xb4(%rbp), %eax
movq -0xb0(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x538f
movq -0x98(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x8830
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jne 0x5381
jmp 0x538f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x41d0
jmp 0x5403
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x88b0
jmp 0x5403
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x52c8
movq -0xa0(%rbp), %rdi
movl -0x24(%rbp), %eax
subl -0x20(%rbp), %eax
cltq
movq %rax, -0xc8(%rbp)
callq 0x8830
movq %rax, %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
jne 0x53cd
movq -0xa0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x8a00
jmp 0x53cb
jmp 0x53cd
movq -0x90(%rbp), %rdi
leaq 0xfe10(%rip), %rcx      # 0x151eb
leaq -0x60(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x8870
jmp 0x53ea
leaq -0x60(%rbp), %rdi
callq 0x88b0
movq -0x88(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x42a0
nopl (%rax)
// File: eatonphil[P]cpp-json/json.cpp
// Function: json::format_parse_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, json::JSONToken)
std::string format_parse_error(std::string base, JSONToken token) {
  std::ostringstream s;
  s << "Unexpected token '" << token.value << "', type '"
    << JSONTokenType_to_string(token.type) << "', index ";
  s << std::endl << base;
  return format_error(s.str(), *token.full_source, token.location);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdx, -0x230(%rbp)
movq %rsi, -0x228(%rbp)
movq %rdi, -0x220(%rbp)
movq %rdi, %rax
movq %rax, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x41e0
movq -0x210(%rbp), %rdi
leaq 0xf419(%rip), %rsi      # 0x150c0
callq 0x4180
movq %rax, -0x208(%rbp)
jmp 0x5cb5
movq -0x230(%rbp), %rsi
movq -0x208(%rbp), %rdi
callq 0x4170
movq %rax, -0x238(%rbp)
jmp 0x5cd1
movq -0x238(%rbp), %rdi
leaq 0xf3f4(%rip), %rsi      # 0x150d3
callq 0x4180
movq %rax, -0x240(%rbp)
jmp 0x5ced
movq -0x230(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x1c0(%rbp), %rdi
callq 0x4410
jmp 0x5d05
movq -0x240(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x4170
movq %rax, -0x248(%rbp)
jmp 0x5d21
movq -0x248(%rbp), %rdi
leaq 0xf3ae(%rip), %rsi      # 0x150dd
callq 0x4180
jmp 0x5d36
leaq -0x1c0(%rbp), %rdi
callq 0x87f0
movq 0x1a257(%rip), %rsi     # 0x1ffa0
leaq -0x190(%rbp), %rdi
callq 0x41c0
movq %rax, -0x250(%rbp)
jmp 0x5d5e
movq -0x228(%rbp), %rsi
movq -0x250(%rbp), %rdi
callq 0x4170
jmp 0x5d73
leaq -0x1e0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x4280
jmp 0x5d88
movq -0x230(%rbp), %rdi
addq $0x28, %rdi
callq 0x8d20
movq %rax, %rsi
leaq -0x200(%rbp), %rdi
callq 0x88e0
jmp 0x5da9
movq -0x220(%rbp), %rdi
movq -0x230(%rbp), %rax
movl 0x24(%rax), %ecx
leaq -0x1e0(%rbp), %rsi
leaq -0x200(%rbp), %rdx
callq 0x45d0
jmp 0x5dcf
leaq -0x200(%rbp), %rdi
callq 0x87f0
leaq -0x1e0(%rbp), %rdi
callq 0x87f0
leaq -0x190(%rbp), %rdi
callq 0x4070
movq -0x218(%rbp), %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x5e75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x87f0
jmp 0x5e75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x5e69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x87f0
leaq -0x1e0(%rbp), %rdi
callq 0x87f0
leaq -0x190(%rbp), %rdi
callq 0x4070
movq -0x198(%rbp), %rdi
callq 0x42a0
nopl (%rax)
// File: eatonphil[P]cpp-json/json.cpp
// Function: json::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::tuple<JSONValue, std::string> parse(std::string source) {
  auto [tokens, error] = json::lex(source);
  if (error.size()) {
    return {{}, error};
  }

  auto [ast, _, error1] = json::parse(tokens);
  return {ast, error1};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x240(%rbp)
movq %rdi, %rax
movq %rax, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x88e0
movq -0x230(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x56b0
jmp 0x7966
leaq -0x68(%rbp), %rdi
callq 0x87f0
leaq -0x48(%rbp), %rdi
callq 0x9820
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9840
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x87a0
cmpq $0x0, %rax
je 0x7a5d
leaq -0x128(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x9450
leaq -0x100(%rbp), %rdi
callq 0x9580
leaq -0xf0(%rbp), %rdi
callq 0x94a0
leaq -0xe8(%rbp), %rdi
callq 0x94c0
leaq -0xc8(%rbp), %rdi
callq 0x94e0
movq -0x240(%rbp), %rdi
movq -0x248(%rbp), %rsi
movl $0x0, -0x90(%rbp)
movq -0x88(%rbp), %rdx
callq 0x9860
jmp 0x7a0b
leaq -0x128(%rbp), %rdi
callq 0x9540
movl $0x1, -0x12c(%rbp)
jmp 0x7b48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x87f0
jmp 0x7b6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x9540
jmp 0x7b61
movq -0x80(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x8fa0
jmp 0x7a6f
leaq -0x1f8(%rbp), %rdi
leaq -0x210(%rbp), %rsi
xorl %edx, %edx
callq 0x6480
jmp 0x7a86
leaq -0x210(%rbp), %rdi
callq 0x8bb0
leaq -0x1f8(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x9090
movq -0x250(%rbp), %rdi
movq %rax, -0x218(%rbp)
callq 0x90b0
movq -0x250(%rbp), %rdi
movq %rax, -0x220(%rbp)
callq 0x90d0
movq -0x240(%rbp), %rdi
movq %rax, -0x228(%rbp)
movq -0x218(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x9890
jmp 0x7aee
movl $0x1, -0x12c(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x9160
jmp 0x7b48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7b61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x8bb0
jmp 0x7b61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x9160
jmp 0x7b61
leaq -0x48(%rbp), %rdi
callq 0x98c0
movq -0x238(%rbp), %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x98c0
movq -0x70(%rbp), %rdi
callq 0x42a0
nopw %cs:(%rax,%rax)
// File: gossterrible[P]Calendar-/Calendar.cpp
// Function: Calendar::InputDate()
void Calendar::InputDate() {
    int year, month, day;
    do {
        cout << "Year:";
        cin >>year;
    } while (year < 0);

    do {
        cout << "Month:";
        cin>>month;
    } while (1 > month || month > 12);

    do {
        cout << "day:";
        cin>>day;
    } while (1 > day || day > 31);
    currentDate.setDate(day, month, year);
    ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x5a1d(%rip), %rdi      # 0x9fc8
leaq 0x2ba7(%rip), %rsi      # 0x7159
callq 0x3200
movq 0x5a1a(%rip), %rdi      # 0x9fd8
leaq -0xc(%rbp), %rsi
callq 0x30f0
cmpl $0x0, -0xc(%rbp)
jl 0x45a4
jmp 0x45cf
movq 0x59f2(%rip), %rdi      # 0x9fc8
leaq 0x2b88(%rip), %rsi      # 0x7165
callq 0x3200
movq 0x59ef(%rip), %rdi      # 0x9fd8
leaq -0x10(%rbp), %rsi
callq 0x30f0
movb $0x1, %al
movl $0x1, %ecx
cmpl -0x10(%rbp), %ecx
movb %al, -0x21(%rbp)
jg 0x460b
cmpl $0xc, -0x10(%rbp)
setg %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x45cf
jmp 0x4614
movq 0x59ad(%rip), %rdi      # 0x9fc8
leaq 0x2b50(%rip), %rsi      # 0x7172
callq 0x3200
movq 0x59aa(%rip), %rdi      # 0x9fd8
leaq -0x14(%rbp), %rsi
callq 0x30f0
movb $0x1, %al
movl $0x1, %ecx
cmpl -0x14(%rbp), %ecx
movb %al, -0x22(%rbp)
jg 0x4650
cmpl $0x1f, -0x14(%rbp)
setg %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x4614
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x6480
addq $0x30, %rsp
popq %rbp
retq
nop
// File: gossterrible[P]Calendar-/Calendar.cpp
// Function: Calendar::CreateEvent()
void Calendar::CreateEvent() {
    Event event;

    int year, month, day;
    cout << "Input Year:";
    cin >> year;

    cout << "Input Month:";
    cin >> month;

    cout << "Input day:";
    cin >> day;

    event.date.setDate(year, month, day);

    string desc;
    cout << "Input description: ";
    cin >> event.description;

    events.push_back(event);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4f60
movq 0x5931(%rip), %rdi      # 0x9fc8
leaq 0x2ab5(%rip), %rsi      # 0x7153
callq 0x3200
jmp 0x46a5
movq 0x592c(%rip), %rdi      # 0x9fd8
leaq -0x3c(%rbp), %rsi
callq 0x30f0
jmp 0x46b7
movq 0x590a(%rip), %rdi      # 0x9fc8
leaq 0x2a9a(%rip), %rsi      # 0x715f
callq 0x3200
jmp 0x46cc
movq 0x5905(%rip), %rdi      # 0x9fd8
leaq -0x40(%rbp), %rsi
callq 0x30f0
jmp 0x46de
movq 0x58e3(%rip), %rdi      # 0x9fc8
leaq 0x2a80(%rip), %rsi      # 0x716c
callq 0x3200
jmp 0x46f3
movq 0x58de(%rip), %rdi      # 0x9fd8
leaq -0x44(%rbp), %rsi
callq 0x30f0
jmp 0x4705
movl -0x3c(%rbp), %esi
movl -0x40(%rbp), %edx
movl -0x44(%rbp), %ecx
leaq -0x38(%rbp), %rdi
callq 0x6480
jmp 0x4719
leaq -0x78(%rbp), %rdi
callq 0x3320
movq 0x589f(%rip), %rdi      # 0x9fc8
leaq 0x2a47(%rip), %rsi      # 0x7177
callq 0x3200
jmp 0x4737
leaq -0x28(%rbp), %rsi
movq 0x5896(%rip), %rdi      # 0x9fd8
callq 0x32f0
jmp 0x4749
movq -0x80(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0x4f90
jmp 0x475c
leaq -0x78(%rbp), %rdi
callq 0x3100
leaq -0x38(%rbp), %rdi
callq 0x5000
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x479a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3100
leaq -0x38(%rbp), %rdi
callq 0x5000
movq -0x50(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: gossterrible[P]Calendar-/Calendar.cpp
// Function: Calendar::DeleteEvent()
void Calendar::DeleteEvent() {
    int id;
    cout << "Input event ID: ";
    cin >> id;

    if (id < events.size() + 1) {
        events.erase(events.begin() + id - 1);
    } else {
        cerr << "Invalid event ID" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x56fd(%rip), %rdi      # 0x9fc8
leaq 0x28b9(%rip), %rsi      # 0x718b
callq 0x3200
movq 0x56fa(%rip), %rdi      # 0x9fd8
leaq -0xc(%rbp), %rsi
callq 0x30f0
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rdi
callq 0x5020
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x496b
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x51c0
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x51f0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x5230
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5270
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5150
movq %rax, -0x38(%rbp)
jmp 0x498d
movq 0x567e(%rip), %rdi      # 0x9ff0
leaq 0x2823(%rip), %rsi      # 0x719c
callq 0x3200
movq %rax, %rdi
movq 0x5630(%rip), %rsi      # 0x9fb8
callq 0x3230
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gossterrible[P]Calendar-/Calendar.cpp
// Function: Calendar::Save()
void Calendar::Save() {
    //string filename = ;
    ofstream file;
    file.open("db.event", ios::app);

    for (int i = 0; i < events.size(); ++i) {
        file << events[i].date.getYear()
                << events[i].date.getMonth()
                << events[i].date.getDay()
                << events[i].description << endl;
    }

    file.close();

    cout << "Save to file success." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x33a0
movq -0x220(%rbp), %rdi
leaq 0x27d2(%rip), %rsi      # 0x71ad
movl $0x1, %edx
callq 0x3040
jmp 0x49e7
movl $0x0, -0x218(%rbp)
movq -0x228(%rbp), %rdi
movslq -0x218(%rbp), %rax
movq %rax, -0x230(%rbp)
addq $0x10, %rdi
callq 0x5020
movq %rax, %rcx
movq -0x230(%rbp), %rax
cmpq %rcx, %rax
jae 0x4b66
movq -0x228(%rbp), %rdi
addq $0x10, %rdi
movslq -0x218(%rbp), %rsi
callq 0x5070
movq %rax, %rdi
callq 0x64f0
movl %eax, -0x234(%rbp)
jmp 0x4a49
movl -0x234(%rbp), %esi
leaq -0x208(%rbp), %rdi
callq 0x33b0
movq %rax, -0x240(%rbp)
jmp 0x4a64
movq -0x228(%rbp), %rdi
addq $0x10, %rdi
movslq -0x218(%rbp), %rsi
callq 0x5070
movq %rax, %rdi
callq 0x64d0
movl %eax, -0x244(%rbp)
jmp 0x4a8b
movl -0x244(%rbp), %esi
movq -0x240(%rbp), %rdi
callq 0x33b0
movq %rax, -0x250(%rbp)
jmp 0x4aa6
movq -0x228(%rbp), %rdi
addq $0x10, %rdi
movslq -0x218(%rbp), %rsi
callq 0x5070
movq %rax, %rdi
callq 0x64b0
movl %eax, -0x254(%rbp)
jmp 0x4acd
movl -0x254(%rbp), %esi
movq -0x250(%rbp), %rdi
callq 0x33b0
movq %rax, -0x260(%rbp)
jmp 0x4ae8
movq -0x228(%rbp), %rdi
addq $0x10, %rdi
movslq -0x218(%rbp), %rsi
callq 0x5070
movq -0x260(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rsi
callq 0x31d0
movq %rax, -0x268(%rbp)
jmp 0x4b1b
movq -0x268(%rbp), %rdi
movq 0x548f(%rip), %rsi      # 0x9fb8
callq 0x3230
jmp 0x4b30
jmp 0x4b32
movl -0x218(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x218(%rbp)
jmp 0x49f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3360
jmp 0x4bba
leaq -0x208(%rbp), %rdi
callq 0x3340
jmp 0x4b74
movq 0x544d(%rip), %rdi      # 0x9fc8
leaq 0x2634(%rip), %rsi      # 0x71b6
callq 0x3200
movq %rax, -0x270(%rbp)
jmp 0x4b90
movq -0x270(%rbp), %rdi
movq 0x541a(%rip), %rsi      # 0x9fb8
callq 0x3230
jmp 0x4ba5
leaq -0x208(%rbp), %rdi
callq 0x3360
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: gossterrible[P]Calendar-/Date.cpp
// Function: Date::Date()
Date::Date() {


    time_t t = time(0); //time(0); or time(NULL); returns the system
    //time in seconds 
    struct tm *now = localtime(&t);
    year = now->tm_year + 1900; //http://soen.kr/lecture/ccpp/cpp1/8-1-1.htm 
    month = now->tm_mon + 1;
    day = now->tm_mday;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x31e0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3150
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gossterrible[P]Calendar-/Date.cpp
// Function: Date::IncreaseMonth()
void Date::IncreaseMonth() {
    if (month < 12)
        ++month;
    else {
        month = 1;
        ++year;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0xc, 0x4(%rax)
jge 0x6525
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x6537
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: gossterrible[P]Calendar-/Date.cpp
// Function: Date::DecreaseMonth()
void Date::DecreaseMonth() {
    if (month > 1)
        --month;
    else {
        month = 12;
        --year;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x4(%rax)
jle 0x6565
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x6577
movq -0x10(%rbp), %rax
movl $0xc, 0x4(%rax)
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: gossterrible[P]Calendar-/main.cpp
// Function: main
int main(int argc, char** argv) {
    system("Color 1A");
    Calendar calendar;
    //Create event data file if it doesn't exist
    ifstream ifs("db.event");
    if (!ifs.is_open()) {
        ofstream outfile("db.event"); // create file
    }
    calendar.Draw(); // print calendar 
    calendar.Run(); //Menu options

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x910(%rip), %rdi       # 0x7320
callq 0x31b0
leaq -0x38(%rbp), %rdi
callq 0x3fd0
leaq 0x788(%rip), %rsi       # 0x71ad
leaq -0x240(%rbp), %rdi
movl $0x8, %edx
callq 0x3400
jmp 0x6a38
leaq -0x240(%rbp), %rdi
callq 0x3380
movb %al, -0x451(%rbp)
jmp 0x6a4c
movb -0x451(%rbp), %al
testb $0x1, %al
jne 0x6ab4
jmp 0x6a58
leaq 0x74e(%rip), %rsi       # 0x71ad
leaq -0x450(%rbp), %rdi
movl $0x10, %edx
callq 0x3260
jmp 0x6a72
leaq -0x450(%rbp), %rdi
callq 0x3360
jmp 0x6ab4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x6af2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3070
jmp 0x6af2
leaq -0x38(%rbp), %rdi
callq 0x42a0
jmp 0x6abf
leaq -0x38(%rbp), %rdi
callq 0x4000
jmp 0x6aca
movl $0x0, -0x4(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3070
leaq -0x38(%rbp), %rdi
callq 0x6b10
movl -0x4(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x6b10
movq -0x248(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: kkloberdanz[P]Sort/main.cpp
// Function: testIsSorted()
void testIsSorted() {
    std::vector<int> V {0,1,1,1,3,3,5,6,6,7,8,8,6,8,10,10,11,11,11,12,17,17,17,17,17,19,19,20,20,21,22,22,22,23,24,24,25,25,25,26,27,27,28,28,28,30,31,33,34,36,37,40,41,42,42,43,44,44,44,45,47,47,48,49,54,54,55,55,55,57,57,57,57,58,59,59,59,59,61,62,62,63,63,64,65,65,68,68,69,70,70,72,72,72,73,73,74,76,78,78,78,79,80,80,82,84,84,85,86,87,87,89,89,90,90,90,91,91,92,93,93,93,95,98,99,99,99,39};

    std::cout << "size = " << V.size() << std::endl;
    if (kgk::isSorted(V, 0, V.size()-1)) {
        std::cout << "is sorted" << std::endl;
    } else {
        std::cout << "Not sorted" << std::endl;
    }
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
leaq 0x64c6(%rip), %rsi      # 0x90f4
leaq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x200, %edx            # imm = 0x200
callq 0x20d0
movq 0x30(%rsp), %rax
movq %rax, 0x270(%rsp)
movq $0x80, 0x278(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x3840
movq 0x38(%rsp), %rcx
movq 0x270(%rsp), %rsi
movq 0x278(%rsp), %rdx
leaq 0x280(%rsp), %rdi
callq 0x3850
jmp 0x2c8e
leaq 0x6f(%rsp), %rdi
callq 0x38e0
movq 0xa339(%rip), %rdi      # 0xcfd8
leaq 0x63e6(%rip), %rsi      # 0x908c
callq 0x2120
movq %rax, 0x28(%rsp)
jmp 0x2cb2
leaq 0x280(%rsp), %rdi
callq 0x2e60
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x2030
movq %rax, 0x20(%rsp)
jmp 0x2cd3
movq 0x20(%rsp), %rdi
movq 0xa2e9(%rip), %rsi      # 0xcfc8
callq 0x2140
jmp 0x2ce6
leaq 0x40(%rsp), %rdi
leaq 0x280(%rsp), %rsi
callq 0x2f50
jmp 0x2cfa
leaq 0x280(%rsp), %rdi
callq 0x2e60
movl %eax, %edx
decl %edx
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x38f0
movb %al, 0x1f(%rsp)
jmp 0x2d1d
leaq 0x40(%rsp), %rdi
callq 0x3050
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x2d31
jmp 0x2da4
movq 0xa2a0(%rip), %rdi      # 0xcfd8
leaq 0x6355(%rip), %rsi      # 0x9094
callq 0x2120
movq %rax, 0x10(%rsp)
jmp 0x2d4b
movq 0x10(%rsp), %rdi
movq 0xa271(%rip), %rsi      # 0xcfc8
callq 0x2140
jmp 0x2d5e
jmp 0x2dd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x38e0
jmp 0x2df5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x2de8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3050
jmp 0x2de8
movq 0xa22d(%rip), %rdi      # 0xcfd8
leaq 0x62ec(%rip), %rsi      # 0x909e
callq 0x2120
movq %rax, 0x8(%rsp)
jmp 0x2dbe
movq 0x8(%rsp), %rdi
movq 0xa1fe(%rip), %rsi      # 0xcfc8
callq 0x2140
jmp 0x2dd1
jmp 0x2dd3
leaq 0x280(%rsp), %rdi
callq 0x3050
addq $0x298, %rsp            # imm = 0x298
retq
leaq 0x280(%rsp), %rdi
callq 0x3050
movq 0x60(%rsp), %rdi
callq 0x21e0
nop
// File: kkloberdanz[P]Sort/main.cpp
// Function: main
int main() {
    //testIsSorted();
    test();
    timeAnalysis();
    return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
callq 0x2860
callq 0x2350
xorl %eax, %eax
popq %rcx
retq
nopw (%rax,%rax)