LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::Object::~Object()
Object::~Object()
{
	lock();
	bool del = false;
	__Object_mx_validObjects->lock();
	int64 l, i;
	l = __Object_validObjects->size();
	for(i=0; i<l; i++)
	{
		if(__Object_validObjects->at(i) == (void const*)this)
		{
			__Object_validObjects->erase(__Object_validObjects->begin()+i);
			break;
		}
	}
	del = __Object_validObjects->size() == 0;
	__Object_mx_validObjects->unlock();
	if(del) {
		delete __Object_validObjects;
		delete __Object_mx_validObjects;
		__Object_validObjects = null;
		__Object_mx_validObjects = null;
	}
	unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq 0x201ec5(%rip), %rax    # 0x60f880
movq %rax, (%rdi)
callq 0x40d7d0
jmp 0x40d9c5
movb $0x0, -0x9(%rbp)
movq 0x20bcc8(%rip), %rdi    # 0x619698
callq 0x40d7d0
jmp 0x40d9d7
movq 0x20bcc2(%rip), %rdi    # 0x6196a0
callq 0x40f100
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x40da82
movq 0x20bc9c(%rip), %rdi    # 0x6196a0
movq -0x20(%rbp), %rsi
callq 0x40f120
movq %rax, -0x50(%rbp)
jmp 0x40da13
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq %rcx, (%rax)
jne 0x40da6f
movq 0x20bc79(%rip), %rdi    # 0x6196a0
movq %rdi, -0x60(%rbp)
callq 0x40f1d0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x40f200
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x40f240
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x40f160
movq %rax, -0x58(%rbp)
jmp 0x40da65
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x40da82
jmp 0x40da71
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x40d9ef
movq 0x20bc17(%rip), %rdi    # 0x6196a0
callq 0x40f100
testq %rax, %rax
sete -0x9(%rbp)
movq 0x20bbfc(%rip), %rdi    # 0x619698
callq 0x40d740
jmp 0x40daa3
testb $0x1, -0x9(%rbp)
je 0x40db0f
movq 0x20bbf0(%rip), %rax    # 0x6196a0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x40dad1
movq -0x68(%rbp), %rdi
callq 0x40f280
movq -0x68(%rbp), %rdi
movl $0x18, %esi
callq 0x413b20
movq 0x20bbc0(%rip), %rax    # 0x619698
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x40daf9
movq -0x70(%rbp), %rdi
callq 0x40d6b0
movq -0x70(%rbp), %rdi
movl $0x38, %esi
callq 0x413b20
movq $0x0, 0x20bb9c(%rip) # 0x6196a0
movq $0x0, 0x20bb89(%rip) # 0x619698
movq -0x48(%rbp), %rdi
callq 0x40d740
jmp 0x40db1a
movq -0x48(%rbp), %rdi
callq 0x40d6b0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x405580
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::String::trimRight(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
String String::trimRight(const std::string & t)
{
		std::string d (*this);
		std::string::size_type i (d.find_last_not_of (t));
		if (i == std::string::npos)
				return String("");
		else
				return String(d.erase (d.find_last_not_of (t) + 1)) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
leaq -0x38(%rbp), %rdi
callq 0x4902b0
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq $-0x1, %rdx
callq 0x48fbb0
movq %rax, -0x40(%rbp)
cmpq $-0x1, -0x40(%rbp)
jne 0x40e731
movq -0x80(%rbp), %rdi
leaq 0x1b037d(%rip), %rsi    # 0x5bea8a
callq 0x40e000
jmp 0x40e714
movl $0x1, -0x50(%rbp)
jmp 0x40e7bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x40e7d5
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq $-0x1, %rdx
movq %rdx, -0x90(%rbp)
callq 0x48fbb0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
movq %rax, %rsi
incq %rsi
callq 0x48e3e0
movq %rax, -0x88(%rbp)
jmp 0x40e775
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x4902b0
jmp 0x40e787
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x40e0a0
jmp 0x40e796
leaq -0x70(%rbp), %rdi
callq 0x48dbd0
movl $0x1, -0x50(%rbp)
jmp 0x40e7bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x48dbd0
jmp 0x40e7d5
leaq -0x38(%rbp), %rdi
callq 0x48dbd0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x48dbd0
movq -0x48(%rbp), %rdi
callq 0x4be910
nopw (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::String::replace(u::String, u::String)
void String::replace(String search, String replace)
{
	std::string * s = this;
	while(s->find(search) != std::string::npos) {
		s->replace(
			s->find(search)
			, search.length()
			, (const std::string&)replace
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x38, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x48f720
cmpq $-0x1, %rax
je 0x40ea37
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
addq $0x38, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x48f720
movq -0x30(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x40e460
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
addq $0x38, %rcx
callq 0x48ece0
jmp 0x40e9d8
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::String::explode(u::String)
Vector<String>* String::explode(String delimiter)
{
	std::string * s = this;
	size_t position = 0;
	Vector<String>* result = new Vector<String>;
	while (position < length()) {
		size_t found = s->find(delimiter, position);
		if(found == std::string::npos) {
			found = s->size();
		}
		result->push(String(s->substr(position, found - position)));
		position = found + delimiter.length();
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
addq $0x38, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x50, %edi
callq 0x414cb0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
callq 0x404c70
jmp 0x40ea93
movq -0xc0(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0xc8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xd8(%rbp)
callq 0x40e460
movq %rax, %rcx
movq -0xd8(%rbp), %rax
cmpq %rcx, %rax
jae 0x40ebec
movq -0xd0(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x38, %rsi
movq -0x20(%rbp), %rdx
callq 0x48f720
movq %rax, -0x40(%rbp)
cmpq $-0x1, -0x40(%rbp)
jne 0x40eb1c
movq -0x18(%rbp), %rdi
callq 0x48ddf0
movq %rax, -0x40(%rbp)
jmp 0x40eb1c
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x50, %esi
callq 0x413b20
jmp 0x40ebf9
movq -0x28(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rcx
subq %rdx, %rcx
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4904d0
movq -0xe0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x40e0a0
jmp 0x40eb5e
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x40f2e0
jmp 0x40eb73
leaq -0x98(%rbp), %rdi
callq 0x404d10
leaq -0xb8(%rbp), %rdi
callq 0x48dbd0
movq -0xd0(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0xf0(%rbp)
callq 0x40e460
movq %rax, %rcx
movq -0xf0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x40ea9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x40ebde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x404d10
leaq -0xb8(%rbp), %rdi
callq 0x48dbd0
jmp 0x40ebf9
movq -0x28(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4be910
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::Object::valid(void const*)
bool u::Object::valid(void const* ptr)
{
	__Object_mx_validObjects->lock();
	bool ret = false;
	int64 l, i;
	l = __Object_validObjects->size();
	for(i=0; i<l; i++)
	{
		if(__Object_validObjects->at(i) == ptr)
		{
			ret = true;
			/*std::cout
				<< "\033[34;1mu::Object::valid(): " << ptr
				<< "\033[0m"
				<< std::endl
			;*/
			break;
		}
	}
	__Object_mx_validObjects->unlock();
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x20a7e5(%rip), %rdi    # 0x619698
callq 0x40d7d0
movb $0x0, -0x9(%rbp)
movq 0x20a7dd(%rip), %rdi    # 0x6196a0
callq 0x40f100
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x40ef0d
movq 0x20a7bb(%rip), %rdi    # 0x6196a0
movq -0x20(%rbp), %rsi
callq 0x40f120
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x40eefd
movb $0x1, -0x9(%rbp)
jmp 0x40ef0d
jmp 0x40eeff
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x40eed4
movq 0x20a784(%rip), %rdi    # 0x619698
callq 0x40d740
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::Thread::Thread(u::Callback*)
Thread::Thread(Callback *cb)
{
	_thread = 0;
	_call = *cb; //copy
	pthread_attr_init(&_attr);
	pthread_attr_setdetachstate(&_attr, PTHREAD_CREATE_DETACHED);
}

// 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)
callq 0x4071c0
movq -0x18(%rbp), %rdi
movq $0x0, 0x58(%rdi)
movq -0x10(%rbp), %rsi
callq 0x40b100
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x4f11f0
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movl $0x1, %esi
callq 0x4f1220
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::Thread::execute(void*)
void* Thread::execute(void *thread)
{
	Thread *t = (Thread*)thread;
	t->_call.call();
	ThreadSystem::destroy(t);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x407270
movq -0x10(%rbp), %rdi
callq 0x410720
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::destroy()
void ThreadSystem::destroy()
{
	Thread *t;
	while(!_build.empty())
	{
		t = _build.at(0);
		_build.erase((int64)0);
		delete t;
	}
	while(!_run.empty())
	{
		t = _run.at(0);
		_run.erase((int64)0);
		delete t;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x2084f9(%rip), %rdi    # 0x6196e8
addq $0x38, %rdi
callq 0x4125d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x411200
jmp 0x411252
leaq 0x2084e1(%rip), %rdi    # 0x6196e8
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x412520
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0x2084c6(%rip), %rdi    # 0x6196e8
xorl %eax, %eax
movl %eax, %esi
callq 0x412560
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x411250
movq -0x10(%rbp), %rdi
callq 0x410690
movq -0x10(%rbp), %rdi
movl $0x98, %esi
callq 0x413b20
jmp 0x4111e8
jmp 0x411254
leaq 0x2084dd(%rip), %rdi    # 0x619738
addq $0x38, %rdi
callq 0x4125d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x41126c
jmp 0x4112be
leaq 0x2084c5(%rip), %rdi    # 0x619738
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x412520
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0x2084aa(%rip), %rdi    # 0x619738
xorl %eax, %eax
movl %eax, %esi
callq 0x412560
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4112bc
movq -0x18(%rbp), %rdi
callq 0x410690
movq -0x18(%rbp), %rdi
movl $0x98, %esi
callq 0x413b20
jmp 0x411254
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::numThreads()
int64 ThreadSystem::numThreads()
{
	_access.lock();
	int64 num = _build.size();
	num += _run.size();
	_access.unlock();
	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2083d1(%rip), %rdi    # 0x6196b0
callq 0x40d7d0
leaq 0x2083fd(%rip), %rdi    # 0x6196e8
addq $0x38, %rdi
callq 0x412500
movq %rax, -0x8(%rbp)
leaq 0x208439(%rip), %rdi    # 0x619738
addq $0x38, %rdi
callq 0x412500
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x208399(%rip), %rdi    # 0x6196b0
callq 0x40d740
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::numQueuedThreads()
int64 ThreadSystem::numQueuedThreads()
{
	_access.lock();
	int64 num = _build.size();
	_access.unlock();
	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x208371(%rip), %rdi    # 0x6196b0
callq 0x40d7d0
leaq 0x20839d(%rip), %rdi    # 0x6196e8
addq $0x38, %rdi
callq 0x412500
movq %rax, -0x8(%rbp)
leaq 0x208351(%rip), %rdi    # 0x6196b0
callq 0x40d740
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::tick()
void ThreadSystem::tick()
{
	_access.lock();

	while(threadLimit > _run.size() && _build.empty() == false)
	{
		_access.unlock();
		run(0);
		_access.lock();
	}

	_access.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x207ab1(%rip), %rdi    # 0x6196b0
callq 0x40d7d0
movq 0x20554d(%rip), %rax    # 0x617158
movq %rax, -0x10(%rbp)
leaq 0x207b22(%rip), %rdi    # 0x619738
addq $0x38, %rdi
callq 0x412500
movq -0x10(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x1(%rbp)
jbe 0x411c4e
leaq 0x207ab1(%rip), %rdi    # 0x6196e8
addq $0x38, %rdi
callq 0x4125d0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x411c57
jmp 0x411c7a
leaq 0x207a52(%rip), %rdi    # 0x6196b0
callq 0x40d740
xorl %eax, %eax
movl %eax, %edi
callq 0x411370
leaq 0x207a3d(%rip), %rdi    # 0x6196b0
callq 0x40d7d0
jmp 0x411c04
leaq 0x207a2f(%rip), %rdi    # 0x6196b0
callq 0x40d740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: harry830622[P]floorplanner/src/b_star_tree.cpp
// Function: BStarTree::BStarTree(int)
BStarTree::BStarTree(int num_macros)
    : root_id_(0), nodes_(num_macros, Node(-1, -1, -1)) {
  const int num_nodes = nodes_.size();

  for (int i = 0; i < num_nodes - 1; ++i) {
    nodes_[i].left_child_id_ = i + 1;
  }
  for (int i = 1; i < num_nodes; ++i) {
    nodes_[i].parent_id_ = i - 1;
  }

  /* for (int i = 0; i < num_nodes / 2 + 1; ++i) { */
  /*   const int right_child_id = (i + 1) * 2; */
  /*   const int left_child_id = right_child_id - 1; */
  /*   if (left_child_id < num_nodes) { */
  /*     nodes_[i].left_child_id_ = left_child_id; */
  /*   } */
  /*   if (right_child_id < num_nodes) { */
  /*     nodes_[i].right_child_id_ = right_child_id; */
  /*   } */
  /* } */
  /* for (int i = 1; i < num_nodes; ++i) { */
  /*   nodes_[i].parent_id_ = (i - 1) / 2; */
  /* } */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, (%rax)
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x1c(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %esi
movl %ecx, %edx
callq 0xabd0
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xac00
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xac20
jmp 0x9e27
leaq -0x1d(%rbp), %rdi
callq 0xaca0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0xacc0
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9e96
movq -0x60(%rbp), %rdi
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
addq $0x8, %rdi
movslq -0x34(%rbp), %rsi
callq 0xace0
movl -0x64(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9e47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0xaca0
jmp 0x9ed5
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x9ecf
movq -0x60(%rbp), %rdi
movl -0x38(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x68(%rbp)
addq $0x8, %rdi
movslq -0x38(%rbp), %rsi
callq 0xace0
movl -0x68(%rbp), %ecx
movl %ecx, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9e9d
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x98f0
nop
// File: harry830622[P]floorplanner/src/b_star_tree.cpp
// Function: BStarTree::Insert(int, int, std::pair<int, int>)
void BStarTree::Insert(int inserted_node_id, int target_node_id,
                       pair<int, int> inserted_positions) {
  Node& inserted_node = node(inserted_node_id);
  Node& target_node = node(target_node_id);
  inserted_node.parent_id_ = target_node_id;
  if (inserted_positions.first % 2 == 0) {
    if (inserted_positions.second % 2 == 0) {
      inserted_node.left_child_id_ = target_node.left_child_id_;
    } else {
      inserted_node.right_child_id_ = target_node.left_child_id_;
    }
    if (target_node.left_child_id_ != -1) {
      node(target_node.left_child_id_).parent_id_ = inserted_node_id;
    }
    target_node.left_child_id_ = inserted_node_id;
  } else {
    if (inserted_positions.second % 2 == 0) {
      inserted_node.left_child_id_ = target_node.right_child_id_;
    } else {
      inserted_node.right_child_id_ = target_node.right_child_id_;
    }
    if (target_node.right_child_id_ != -1) {
      node(target_node.right_child_id_).parent_id_ = inserted_node_id;
    }
    target_node.right_child_id_ = inserted_node_id;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xa7c0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %esi
callq 0xa7c0
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xab62
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xab23
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0xab31
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
je 0xab56
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xa7c0
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0xabbf
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xab82
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0xab90
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0xabb5
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xa7c0
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: harry830622[P]floorplanner/src/contour.cpp
// Function: Contour::FindMaxYBetween(double, double) const
double Contour::FindMaxYBetween(double x_begin, double x_end) const {
  list<Point>::const_iterator it = coordinates_.begin();

  while (it != coordinates_.end() && it->x() <= x_begin) {
    ++it;
  }
  --it;

  double max_y = 0;
  while (it != coordinates_.end() && it->x() < x_end) {
    if (it->y() > max_y) {
      max_y = it->y();
    }
    ++it;
  }

  return max_y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0xc2e0
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0xc310
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc340
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0xc117
jmp 0xc13a
leaq -0x20(%rbp), %rdi
callq 0xc6a0
movq %rax, %rdi
callq 0x48a20
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xc143
jmp 0xc14e
leaq -0x20(%rbp), %rdi
callq 0xc3a0
jmp 0xc0eb
leaq -0x20(%rbp), %rdi
callq 0xc6c0
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0xc310
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc340
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x42(%rbp)
jne 0xc18b
jmp 0xc1ae
leaq -0x20(%rbp), %rdi
callq 0xc6a0
movq %rax, %rdi
callq 0x48a20
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0xc1b7
jmp 0xc1f3
leaq -0x20(%rbp), %rdi
callq 0xc6a0
movq %rax, %rdi
callq 0x48a40
ucomisd -0x30(%rbp), %xmm0
jbe 0xc1e5
leaq -0x20(%rbp), %rdi
callq 0xc6a0
movq %rax, %rdi
callq 0x48a40
movsd %xmm0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc3a0
jmp 0xc15f
movsd -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: harry830622[P]floorplanner/src/database.cpp
// Function: Database::ParseNets(std::istream&)
void Database::ParseNets(istream& net_input) {
  simple_parser::Parser net_parser(net_input, ":");
  int num_nets = 0;
  int nth_net = 0;
  net_parser.Parse([&](const simple_parser::Tokens& tokens) -> bool {
    if (!tokens.empty()) {
      string first_word = tokens[0];
      if (first_word == "NumNets") {
        num_nets = stoi(tokens[1]);
      } else if (first_word == "NetDegree") {
        ++nth_net;
        const int num_terminals = stoi(tokens[1]);
        int nth_terminal = 0;
        vector<int> net_macro_ids;
        vector<Point> net_terminal_coordinates;
        net_parser.Parse([&](const simple_parser::Tokens& tokens) -> bool {
          if (!tokens.empty()) {
            ++nth_terminal;
            const string name = tokens[0];
            if (is_terminal_existed(name)) {
              const int terminal_id = terminal_id_by_name(name);
              net_terminal_coordinates.push_back(
                  terminal(terminal_id).coordinates());
            } else {
              net_macro_ids.push_back(macro_id_by_name(name));
            }
            if (nth_terminal == num_terminals) {
              return false;
            }
          }
          return true;
        });
        nets_.push_back(Net(net_macro_ids, net_terminal_coordinates));
        if (nth_net == num_nets) {
          return false;
        }
      }
    }
    return true;
  });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x9910
movq -0xc0(%rbp), %rdx
leaq 0x3eaf2(%rip), %rsi     # 0x4bf79
leaq -0x58(%rbp), %rdi
callq 0xfcf0
jmp 0xd492
movq -0xc8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xfda0
jmp 0xd4a8
leaq -0x58(%rbp), %rdi
callq 0x9a48
leaq -0x59(%rbp), %rdi
callq 0x9520
movq -0xd0(%rbp), %rax
movl $0x0, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
leaq -0x70(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
leaq -0x74(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
leaq -0x38(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0xdfe0
jmp 0xd50c
leaq -0x38(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xfde0
jmp 0xd51e
leaq -0x98(%rbp), %rdi
callq 0xfef0
leaq -0x38(%rbp), %rdi
callq 0xff10
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xd55f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9a48
leaq -0x59(%rbp), %rdi
callq 0x9520
jmp 0xd599
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xd590
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xfef0
leaq -0x38(%rbp), %rdi
callq 0xff10
movq -0x68(%rbp), %rdi
callq 0x98f0
nopw %cs:(%rax,%rax)
// File: harry830622[P]floorplanner/src/././simple_parser.hpp
// Function: simple_parser::Parser::Parse(std::function<bool (std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)>)
void Parse(Handler handler) {
    std::string line;
    while (std::getline(input_, line)) {
      Tokens tokens = Tokenize(line);
      bool is_ending_condition_met = !handler(tokens);
      if (is_ending_condition_met) {
        break;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x96f0
movq -0x68(%rbp), %rax
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x90c0
movq %rax, -0x78(%rbp)
jmp 0xfe1e
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x9620
movb %al, -0x79(%rbp)
jmp 0xfe36
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xfe42
jmp 0xfec5
movq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x107f0
jmp 0xfe55
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x10960
movb %al, -0x7a(%rbp)
jmp 0xfe67
movb -0x7a(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
je 0xfea5
movl $0x3, -0x60(%rbp)
jmp 0xfeac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfed7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x109a0
jmp 0xfed7
movl $0x0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x109a0
movl -0x60(%rbp), %eax
testl %eax, %eax
je 0xfec0
jmp 0xfebe
jmp 0xfec5
jmp 0xfe08
leaq -0x30(%rbp), %rdi
callq 0x9a48
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x9a48
movq -0x38(%rbp), %rdi
callq 0x98f0
nopl (%rax)
// File: harry830622[P]floorplanner/src/././simple_parser.hpp
// Function: simple_parser::Parser::Tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Tokens Tokenize(const std::string& str) {
    Tokens tokens;

    Token token;
    for (const char c : str) {
      if (IsDelimiter(c)) {
        if (!token.empty()) {
          tokens.push_back(token);
          token.clear();
        }
        continue;
      }
      token.push_back(c);
    }
    if (!token.empty()) {
      tokens.push_back(token);
    }

    return tokens;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x10a00
leaq -0x40(%rbp), %rdi
callq 0x96f0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x9490
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x9970
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x10a20
testb $0x1, %al
jne 0x10867
jmp 0x10904
leaq -0x50(%rbp), %rdi
callq 0x10a60
movq -0x78(%rbp), %rdi
movb (%rax), %al
movb %al, -0x59(%rbp)
movsbl -0x59(%rbp), %esi
callq 0x10a80
movb %al, -0x89(%rbp)
jmp 0x1088a
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x10896
jmp 0x108e5
leaq -0x40(%rbp), %rdi
callq 0x9860
testb $0x1, %al
jne 0x108e3
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10ac0
jmp 0x108b5
leaq -0x40(%rbp), %rdi
callq 0x9690
jmp 0x108e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9a48
movq -0x88(%rbp), %rdi
callq 0x109a0
jmp 0x10951
jmp 0x108f6
movsbl -0x59(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9430
jmp 0x108f4
jmp 0x108f6
leaq -0x50(%rbp), %rdi
callq 0x10b30
jmp 0x10851
leaq -0x40(%rbp), %rdi
callq 0x9860
testb $0x1, %al
jne 0x10925
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x10ac0
jmp 0x10923
jmp 0x10925
movb $0x1, -0x19(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9a48
testb $0x1, -0x19(%rbp)
jne 0x10944
movq -0x88(%rbp), %rdi
callq 0x109a0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x98f0
nopw (%rax,%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::~basic_json()
~basic_json()
    {
        assert_invariant();

        switch (m_type)
        {
            case value_t::object:
            {
                AllocatorType<object_t> alloc;
                alloc.destroy(m_value.object);
                alloc.deallocate(m_value.object, 1);
                break;
            }

            case value_t::array:
            {
                AllocatorType<array_t> alloc;
                alloc.destroy(m_value.array);
                alloc.deallocate(m_value.array, 1);
                break;
            }

            case value_t::string:
            {
                AllocatorType<string_t> alloc;
                alloc.destroy(m_value.string);
                alloc.deallocate(m_value.string, 1);
                break;
            }

            default:
            {
                // all other types need no specific destructor
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1d260
jmp 0x1c07b
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
subb $0x1, %al
je 0x1c0a3
jmp 0x1c08a
movb -0x19(%rbp), %al
subb $0x2, %al
je 0x1c0e7
jmp 0x1c093
movb -0x19(%rbp), %al
subb $0x3, %al
je 0x1c128
jmp 0x1c169
leaq -0x9(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1d350
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x1d370
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x1d390
jmp 0x1c0d9
leaq -0x9(%rbp), %rdi
callq 0x1d3c0
jmp 0x1c16b
leaq -0xa(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1d3e0
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x1d400
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x1d420
jmp 0x1c11d
leaq -0xa(%rbp), %rdi
callq 0x1d450
jmp 0x1c16b
leaq -0xb(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x10ba0
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x11530
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x11610
jmp 0x1c15e
leaq -0xb(%rbp), %rdi
callq 0x116c0
jmp 0x1c16b
jmp 0x1c16b
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb170
nopl (%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>& nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[]<char const>(char const*)
reference operator[](T* key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value = value_t::object;
            assert_invariant();
        }

        // at only works for objects
        if (is_object())
        {
            return m_value.object->operator[](key);
        }

        JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1ef90
testb $0x1, %al
jne 0x1c3b9
jmp 0x1c3e5
movq -0xa0(%rbp), %rax
movb $0x1, (%rax)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1efb0
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0x1d260
movq -0xa0(%rbp), %rdi
callq 0x1f0d0
testb $0x1, %al
jne 0x1c3fa
jmp 0x1c4ac
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x9910
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xfcf0
jmp 0x1c440
movq -0xb8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1f0f0
movq %rax, -0xc0(%rbp)
jmp 0x1c459
leaq -0x38(%rbp), %rdi
callq 0x9a48
leaq -0x39(%rbp), %rdi
callq 0x9520
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1c49e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9a48
leaq -0x39(%rbp), %rdi
callq 0x9520
jmp 0x1c57d
movb $0x1, -0x91(%rbp)
movl $0x10, %edi
callq 0x9240
movq -0xa0(%rbp), %rsi
movq %rax, -0xc8(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1f220
jmp 0x1c4d9
leaq 0x2e125(%rip), %rsi     # 0x4a605
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x1f1d0
jmp 0x1c4f2
movq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x95e0
jmp 0x1c504
movq -0xc8(%rbp), %rdi
movb $0x0, -0x91(%rbp)
movq 0x4fa27(%rip), %rsi     # 0x6bf40
movq 0x4fa60(%rip), %rdx     # 0x6bf80
callq 0x9890
jmp 0x1c586
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1c564
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1c558
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9a48
leaq -0x90(%rbp), %rdi
callq 0x9a48
testb $0x1, -0x91(%rbp)
jne 0x1c56f
jmp 0x1c57b
movq -0xc8(%rbp), %rdi
callq 0x93a0
jmp 0x1c57d
movq -0x48(%rbp), %rdi
callq 0x98f0
nopw %cs:(%rax,%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(std::initializer_list<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>)
void push_back(std::initializer_list<basic_json> init)
    {
        if (is_object() and init.size() == 2 and init.begin()->is_string())
        {
            const string_t key = *init.begin();
            push_back(typename object_t::value_type(key, *(init.begin() + 1)));
        }
        else
        {
            push_back(basic_json(init));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1f0d0
testb $0x1, %al
jne 0x1c8e0
jmp 0x1c9ac
leaq -0x10(%rbp), %rdi
callq 0x229d0
cmpq $0x2, %rax
jne 0x1c9ac
leaq -0x10(%rbp), %rdi
callq 0x222a0
movq %rax, %rdi
callq 0x22930
testb $0x1, %al
jne 0x1c90d
jmp 0x1c9ac
leaq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x222a0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x25b00
movq -0xb8(%rbp), %rdi
callq 0x222a0
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
addq $0x10, %rdx
leaq -0x68(%rbp), %rdi
callq 0x25c90
jmp 0x1c955
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x25b30
jmp 0x1c967
leaq -0x68(%rbp), %rdi
callq 0x1d710
leaq -0x38(%rbp), %rdi
callq 0x9a48
jmp 0x1ca20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1c9a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1d710
leaq -0x38(%rbp), %rdi
callq 0x9a48
jmp 0x1ca29
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x1c180
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x25cf0
jmp 0x1c9f8
leaq -0x88(%rbp), %rdi
callq 0x1c060
jmp 0x1ca20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1c060
jmp 0x1ca29
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x98f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>* nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::create<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [1]>(char const (&) [1])
static T* create(Args&& ... args)
    {
        AllocatorType<T> alloc;
        auto deleter = [&](T * object)
        {
            alloc.deallocate(object, 1);
        };
        std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
        alloc.construct(object.get(), std::forward<Args>(args)...);
        assert(object != nullptr);
        return object.release();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10ba0
movq -0x48(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x11320
movq %rax, -0x40(%rbp)
jmp 0x1f675
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x20440
movq -0x50(%rbp), %rdi
callq 0x20500
movq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq -0x9(%rbp), %rdi
callq 0x20480
jmp 0x1f6a5
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20530
testb $0x1, %al
jne 0x1f6b8
jmp 0x1f6ba
jmp 0x1f6fe
leaq 0x2ad21(%rip), %rdi     # 0x4a3e2
leaq 0x2ad2c(%rip), %rsi     # 0x4a3f4
movl $0x663, %edx            # imm = 0x663
leaq 0x2b280(%rip), %rcx     # 0x4a954
callq 0x9330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1f727
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20580
jmp 0x1f727
leaq -0x28(%rbp), %rdi
callq 0x20560
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20580
leaq -0x9(%rbp), %rdi
callq 0x116c0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
leaq -0x9(%rbp), %rdi
callq 0x116c0
movq -0x30(%rbp), %rdi
callq 0x98f0
nopl (%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::size() const
size_type size() const noexcept
    {
        switch (m_type)
        {
            case value_t::null:
            {
                // null values are empty
                return 0;
            }

            case value_t::array:
            {
                // delegate call to array_t::size()
                return m_value.array->size();
            }

            case value_t::object:
            {
                // delegate call to object_t::size()
                return m_value.object->size();
            }

            default:
            {
                // all other types have size 1
                return 1;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
testb %al, %al
je 0x227e1
jmp 0x227cf
movb -0x11(%rbp), %al
subb $0x1, %al
je 0x227fe
jmp 0x227d8
movb -0x11(%rbp), %al
subb $0x2, %al
je 0x227eb
jmp 0x22811
movq $0x0, -0x8(%rbp)
jmp 0x22819
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22950
movq %rax, -0x8(%rbp)
jmp 0x22819
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22970
movq %rax, -0x8(%rbp)
jmp 0x22819
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](unsigned long) const
const_reference operator[](size_type idx) const
    {
        // const operator[] only works for arrays
        if (is_array())
        {
            return m_value.array->operator[](idx);
        }

        JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x22790
testb $0x1, %al
jne 0x22853
jmp 0x2286a
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x22990
addq $0x70, %rsp
popq %rbp
retq
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x9240
movq -0x68(%rbp), %rsi
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1f220
jmp 0x2288b
leaq 0x27d73(%rip), %rsi     # 0x4a605
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1f1d0
jmp 0x228a1
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x95e0
jmp 0x228b0
movq -0x70(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
movq 0x49681(%rip), %rsi     # 0x6bf40
movq 0x496ba(%rip), %rdx     # 0x6bf80
callq 0x9890
jmp 0x22923
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x22907
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x228fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9a48
leaq -0x50(%rbp), %rdi
callq 0x9a48
testb $0x1, -0x5d(%rbp)
jne 0x2290f
jmp 0x22918
movq -0x70(%rbp), %rdi
callq 0x93a0
jmp 0x2291a
movq -0x58(%rbp), %rdi
callq 0x98f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>> const&)
void push_back(const typename object_t::value_type& val)
    {
        // push_back only works for null objects or objects
        if (not(is_null() or is_object()))
        {
            JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));
        }

        // transform null object into an object
        if (is_null())
        {
            m_type = value_t::object;
            m_value = value_t::object;
            assert_invariant();
        }

        // add element to array
        m_value.object->insert(val);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1ef90
testb $0x1, %al
jne 0x25c28
movq -0x80(%rbp), %rdi
callq 0x1f0d0
testb $0x1, %al
jne 0x25c28
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x9240
movq -0x80(%rbp), %rsi
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1f220
jmp 0x25b8d
leaq 0x25656(%rip), %rsi     # 0x4b1ea
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1f1d0
jmp 0x25ba3
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x95e0
jmp 0x25bb5
movq -0x88(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
movq 0x46379(%rip), %rsi     # 0x6bf40
movq 0x463b2(%rip), %rdx     # 0x6bf80
callq 0x9890
jmp 0x25c87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x25c12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x25c09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9a48
leaq -0x50(%rbp), %rdi
callq 0x9a48
testb $0x1, -0x5d(%rbp)
jne 0x25c1a
jmp 0x25c26
movq -0x88(%rbp), %rdi
callq 0x93a0
jmp 0x25c7e
movq -0x80(%rbp), %rdi
callq 0x1ef90
testb $0x1, %al
jne 0x25c37
jmp 0x25c5d
movq -0x80(%rbp), %rax
movb $0x1, (%rax)
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0x1efb0
movq -0x80(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0x1d260
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x260c0
movq %rax, -0x78(%rbp)
movb %dl, -0x70(%rbp)
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x98f0
nopw (%rax,%rax)
// File: harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>&&)
void push_back(basic_json&& val)
    {
        // push_back only works for null objects or arrays
        if (not(is_null() or is_array()))
        {
            JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));
        }

        // transform null object into an array
        if (is_null())
        {
            m_type = value_t::array;
            m_value = value_t::array;
            assert_invariant();
        }

        // add element to array (move semantics)
        m_value.array->push_back(std::move(val));
        // invalidate object
        val.m_type = value_t::null;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1ef90
testb $0x1, %al
jne 0x25ddc
movq -0x70(%rbp), %rdi
callq 0x22790
testb $0x1, %al
jne 0x25ddc
movb $0x1, -0x5d(%rbp)
movl $0x10, %edi
callq 0x9240
movq -0x70(%rbp), %rsi
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1f220
jmp 0x25d4a
leaq 0x25499(%rip), %rsi     # 0x4b1ea
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1f1d0
jmp 0x25d60
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x95e0
jmp 0x25d6f
movq -0x78(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
movq 0x461c2(%rip), %rsi     # 0x6bf40
movq 0x461fb(%rip), %rdx     # 0x6bf80
callq 0x9890
jmp 0x25e3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x25dc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x25dc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9a48
leaq -0x50(%rbp), %rdi
callq 0x9a48
testb $0x1, -0x5d(%rbp)
jne 0x25dd1
jmp 0x25dda
movq -0x78(%rbp), %rdi
callq 0x93a0
jmp 0x25e32
movq -0x70(%rbp), %rdi
callq 0x1ef90
testb $0x1, %al
jne 0x25deb
jmp 0x25e11
movq -0x70(%rbp), %rax
movb $0x2, (%rax)
leaq -0x68(%rbp), %rdi
movl $0x2, %esi
callq 0x1efb0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0x1d260
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x26290
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x98f0
nopl (%rax,%rax)