LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::print()
void Vertices::print()
{
	for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
		std::cout<<iter->get_index() + 1<<"  ";
	}
	std::cout<<std::endl;

	for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
		std::cout<<iter->get_degree()<<"  ";
	}
	std::cout<<std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x2cdd
movq 0x532a(%rip), %r14      # 0x7fd8
leaq 0x238b(%rip), %r15      # 0x5040
movl (%r12), %esi
incl %esi
movq %r14, %rdi
callq 0x2270
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
addq $0x8, %r12
cmpq 0x8(%rbx), %r12
jne 0x2cb5
movq 0x52f4(%rip), %r14      # 0x7fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
movq (%rbx), %r13
cmpq 0x8(%rbx), %r13
je 0x2d48
movq 0x52bd(%rip), %r15      # 0x7fd8
leaq 0x231e(%rip), %r12      # 0x5040
movl 0x4(%r13), %esi
movq %r15, %rdi
callq 0x2270
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2200
addq $0x8, %r13
cmpq 0x8(%rbx), %r13
jne 0x2d22
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/app/tEvent.cpp
// Function: u::tEvent::onEvent2(u::Object*)
void onEvent2(Object *arg)
			{
				Event *event = (Event*)arg;
				//trace("onEvent2="+event->toString());
				event->destroy();
				dispatchEvent(new Event(Event::COMPLETE))->destroy();
				dispatchEvent(new Event(Event::PROGRESS))->destroy();
				dispatchEvent(new Event(Event::COMPLETE))->destroy();
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movl $0x48, %edi
callq 0x40ef10
movq %rax, %r14
movq $0x60f5d8, %rsi         # imm = 0x60F5D8
movq %rax, %rdi
callq 0x405f24
movq %rbx, %rdi
movq %r14, %rsi
callq 0x407d66
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movl $0x48, %edi
callq 0x40ef10
movq %rax, %r14
movq $0x60f630, %rsi         # imm = 0x60F630
movq %rax, %rdi
callq 0x405f24
movq %rbx, %rdi
movq %r14, %rsi
callq 0x407d66
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movl $0x48, %edi
callq 0x40ef10
movq %rax, %r14
movq $0x60f5d8, %rsi         # imm = 0x60F5D8
movq %rax, %rdi
callq 0x405f24
movq %rbx, %rdi
movq %r14, %rsi
callq 0x407d66
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx)
jmp 0x405689
jmp 0x405689
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x40dd80
movq %rbx, %rdi
callq 0x4b7fb0
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/Callback.cpp
// Function: u::Callback::operator==(u::Callback const&) const
bool Callback::operator==(const Callback& other) const
{
	bool ret = true;
	if(other.target != this->target) ret = false;
	if(ret && other.function != this->function) ret = false;
	if(ret && other.arg != this->arg) ret = false;
	return ret;
}

// Assembly:
movq 0x38(%rsi), %rax
cmpq 0x38(%rdi), %rax
je 0x405a13
xorl %eax, %eax
retq
movq 0x40(%rsi), %r8
movq 0x48(%rsi), %rax
testq %r8, %r8
sete %cl
cmpq 0x48(%rdi), %rax
sete %dl
xorl %eax, %eax
cmpq 0x40(%rdi), %r8
jne 0x405a12
orb %dl, %cl
je 0x405a12
movq 0x50(%rsi), %rax
cmpq 0x50(%rdi), %rax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::operator=(u::EventDispatcher&)
EventDispatcher& EventDispatcher::operator=(EventDispatcher& value)
{
	int64 i, l, j, m;
	_eventVector *src;
	Vector<Callback> *dst;

	value.lock();
	lock();

	l = value._eventList.size();
	for(i=0; i<l; i++)
	{
		src = &value._eventList.at(i);
		dst = getEventVector(src->type);
		if(dst == null)
		{
			dst = addEventVector(src->type);
		}
		m = src->list.size();
		for(j=0; j<m; j++)
		{
			dst->push_back(src->list.at(j));
		}
	}

	unlock();
	value.unlock();
	return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40992e
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x40992e
movq 0x78(%r14), %rcx
movq %r14, 0x10(%rsp)
subq 0x70(%r14), %rcx
testq %rcx, %rcx
jle 0x406633
movq %rcx, %rax
shrq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r14 # imm = 0x2E8BA2E8BA2E8BA3
imulq %r14, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movq %rax, 0x18(%rsp)
xorl %ecx, %ecx
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rbx
movq 0x78(%rax), %rdx
subq %rbx, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
cmpq %rcx, %rdx
jbe 0x40666d
imulq $0x58, %rcx, %r13
movq (%rbx,%r13), %rsi
movq 0x8(%rsp), %rax
movq 0x70(%rax), %r12
movq 0x78(%rax), %rax
subq %r12, %rax
testq %rax, %rax
movq %rcx, 0x20(%rsp)
jle 0x4065b9
mulq %r14
shrq $0x4, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x8, %r12
cmpq %rsi, -0x8(%r12)
je 0x4065c6
addq $0x58, %r12
decq %rdx
jne 0x4065a9
movq 0x8(%rsp), %rdi
callq 0x407a6a
movq %rax, %r12
addq %r13, %rbx
movq 0x48(%rbx), %rax
subq 0x40(%rbx), %rax
testq %rax, %rax
jle 0x406620
mulq %r14
movq %rdx, %r13
shrq $0x4, %r13
addq $0x38, %r12
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
cmpq %rbp, %rdx
jbe 0x40665c
addq %r15, %rsi
movq %r12, %rdi
callq 0x408724
incq %rbp
addq $0x58, %r15
cmpq %rbp, %r13
jne 0x4065f1
movq 0x20(%rsp), %rcx
incq %rcx
cmpq 0x18(%rsp), %rcx
jne 0x406553
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4098e6
movq 0x10(%rsp), %rdi
callq 0x4098e6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x192bed(%rip), %rdi    # 0x599250
movq %rbp, %rsi
xorl %eax, %eax
callq 0x458600
leaq 0x192bdc(%rip), %rdi    # 0x599250
movq %rcx, %rsi
jmp 0x406666
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::delEventVector(u::String const*)
void EventDispatcher::delEventVector(const String* type)
{
	int64 i, l;

	l = _eventList.size();
	for(i=0; i<l; i++)
	{
		_eventVector* entry = &_eventList.at(i);
		if(entry->type == type)
		{
			_eventList.erase(i);
			return;
		}
	}
}

// Assembly:
movq %rsi, %rcx
movq 0x70(%rdi), %rsi
movq 0x78(%rdi), %rax
subq %rsi, %rax
testq %rax, %rax
jle 0x407a26
addq $0x70, %rdi
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
mulq %rdx
shrq $0x4, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
cmpq %rcx, (%rsi)
je 0x409796
addq $0x58, %rsi
decq %rdx
jne 0x407a14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::addEventVector(u::String const*)
Vector<Callback>* EventDispatcher::addEventVector(const String* type)
{
	_eventVector vec;
	int64 i;

	vec.type = type;
	i = _eventList.size();
	_eventList.push_back(vec);
	return &(_eventList.at(i).list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x406324
movq %r14, (%r15)
leaq 0x70(%rbx), %rdi
movq 0x78(%rbx), %r14
subq 0x70(%rbx), %r14
movq %r15, %rsi
callq 0x408750
movq %r14, %rsi
sarq $0x3, %rsi
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rsi
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x407af3
leaq (%rax,%r14), %rbx
addq $0x8, %rbx
leaq 0x10(%rsp), %rdi
callq 0x409a3a
leaq 0x48(%rsp), %rdi
callq 0x40877c
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x191756(%rip), %rdi    # 0x599250
xorl %eax, %eax
callq 0x458600
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x409a3a
leaq 0x48(%rsp), %rdi
callq 0x40877c
movq %rbx, %rdi
callq 0x4b7fb0
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::addEventListener(u::String const&, u::Callback)
void EventDispatcher::addEventListener(const String& type
		, Callback callback)
{
	int i, l;
	Vector<Callback>* vec;

	lock();

	vec = getEventVector(&type);
	if(vec == null)
	{
		vec = addEventVector(&type);
	}

	l = vec->size();

	for(i=0; i<l; i++)
	{
		if(vec->at(i).target == callback.target)
		{
			unlock();
			return;
		}
	}

	vec->push_back(callback);
	unlock();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x40992e
movq 0x70(%rbx), %rdi
movq 0x78(%rbx), %rax
subq %rdi, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r12 # imm = 0x2E8BA2E8BA2E8BA3
testq %rax, %rax
jle 0x407b72
mulq %r12
shrq $0x4, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x8, %rdi
cmpq %r15, -0x8(%rdi)
je 0x407b80
addq $0x58, %rdi
decq %rdx
jne 0x407b63
movq %rbx, %rdi
movq %r15, %rsi
callq 0x407a6a
movq %rax, %rdi
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
testl %edx, %edx
jle 0x407bbf
movl %edx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq $0x38, %rax
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x407bde
movq (%rax), %r8
cmpq 0x38(%r14), %r8
je 0x407bcb
incq %rsi
addq $0x58, %rax
cmpq %rsi, %rcx
jne 0x407ba5
addq $0x38, %rdi
movq %r14, %rsi
callq 0x408724
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4098e6
leaq 0x19166b(%rip), %rdi    # 0x599250
movq %rdx, %rsi
xorl %eax, %eax
callq 0x458600
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::removeEventListener(u::String const&, u::Callback)
void EventDispatcher::removeEventListener(const String& type
		, Callback callback)
{
	int i, l;
	Vector<Callback>* vec;

	//if(hasEventListener(type) == false) return;

	lock();

	vec = getEventVector(&type);
	if(vec == null)
	{
		unlock();
		return;
	}

	l = vec->size();

	for(i=0; i<l; i++)
	{
		if(vec->at(i) == callback)
		{
			vec->erase(i);
			break;
		}
	}

	if(vec->empty()) delEventVector(&type);

	unlock();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40992e
movq 0x70(%rbx), %r15
movq 0x78(%rbx), %rax
subq %r15, %rax
testq %rax, %rax
jle 0x407cda
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
mulq %rcx
shrq $0x4, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x40, %r15
cmpq %r14, -0x40(%r15)
je 0x407c4f
addq $0x58, %r15
decq %rdx
jne 0x407c3b
jmp 0x407cda
movq 0x8(%r15), %r12
subq (%r15), %r12
sarq $0x3, %r12
movabsq $0x2e8ba2e8ba2e8ba3, %rax # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %r12
testl %r12d, %r12d
jle 0x407cc6
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r15), %rdi
movq 0x8(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
movabsq $0x2e8ba2e8ba2e8ba3, %rax # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %rdx
cmpq %rbp, %rdx
jbe 0x407cf0
addq %r13, %rdi
movq (%rsp), %rsi
callq 0x405a06
testb %al, %al
jne 0x407cb8
incq %rbp
addq $0x58, %r13
cmpq %rbp, %r12
jne 0x407c79
jmp 0x407cc6
addq (%r15), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x409274
movq (%r15), %rax
cmpq 0x8(%r15), %rax
jne 0x407cda
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4079e4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4098e6
leaq 0x191559(%rip), %rdi    # 0x599250
movq %rbp, %rsi
xorl %eax, %eax
callq 0x458600
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::hasEventListener(u::String const&)
bool EventDispatcher::hasEventListener(const String& type)
{
	lock();
	bool ret = getEventVector(&type) != null;
	unlock();

	return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40992e
movq 0x70(%rbx), %rcx
movq 0x78(%rbx), %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x407d54
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
mulq %rdx
shrq $0x4, %rdx
cmpq $0x1, %rdx
adcq $-0x1, %rdx
subq $0x1, %rdx
setb %al
cmpq %r14, (%rcx)
sete %bpl
je 0x407d56
addq $0x58, %rcx
testb %al, %al
je 0x407d3a
jmp 0x407d56
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x4098e6
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/Mutex.cpp
// Function: u::Mutex::Mutex()
Mutex::Mutex()
{
	_isLocked = false;
	int ret = pthread_mutex_init(&_mutex, NULL);
#ifndef NDEBUG
	assert(ret == 0);
#endif
}

// Assembly:
pushq %rax
leaq 0x1fbfe8(%rip), %rax    # 0x605848
movq %rax, (%rdi)
movb $0x0, 0x30(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x4ec360
testl %eax, %eax
jne 0x409878
popq %rax
retq
leaq 0x18fb37(%rip), %rdi    # 0x5993b6
leaq 0x18fb39(%rip), %rsi    # 0x5993bf
leaq 0x18fb40(%rip), %rcx    # 0x5993cd
movl $0x12, %edx
callq 0x4ccc10
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/Mutex.cpp
// Function: u::Mutex::~Mutex()
Mutex::~Mutex()
{
	if(_isLocked == true) unlock();
	int ret = pthread_mutex_destroy(&_mutex);
#ifndef NDEBUG
	assert(ret == 0);
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1fbfa5(%rip), %rax    # 0x605848
movq %rax, (%rdi)
cmpb $0x1, 0x30(%rdi)
jne 0x4098b4
movq %rbx, %rdi
callq 0x4098e6
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4ec330
testl %eax, %eax
jne 0x4098c6
popq %rbx
retq
leaq 0x18fae9(%rip), %rdi    # 0x5993b6
leaq 0x18faeb(%rip), %rsi    # 0x5993bf
leaq 0x18fb04(%rip), %rcx    # 0x5993df
movl $0x1b, %edx
callq 0x4ccc10
nop
// File: /workspace/github_cpp_makefile_star2_O3/enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::Object::Object()
Object::Object() : Mutex()
{
	if(!__Object_mx_validObjects) __Object_mx_validObjects = new Mutex();
	if(!__Object_validObjects) __Object_validObjects = new std::vector<void const*>();

	__Object_mx_validObjects->lock();
	__Object_validObjects->push_back((void const*)this);
	__Object_mx_validObjects->unlock();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x409858
leaq 0x1fbef4(%rip), %rax    # 0x605880
movq %rax, (%rbx)
movq 0x205d02(%rip), %r14    # 0x60f698
testq %r14, %r14
jne 0x4099b7
movl $0x38, %edi
callq 0x40ef10
movq %rax, %r14
movq %rax, %rdi
callq 0x409858
movq %r14, 0x205ce1(%rip)    # 0x60f698
cmpq $0x0, 0x205ce1(%rip)    # 0x60f6a0
jne 0x4099e0
movl $0x18, %edi
callq 0x40ef10
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x205cc0(%rip)    # 0x60f6a0
movq %r14, %rdi
callq 0x40992e
movq 0x205cb1(%rip), %rdi    # 0x60f6a0
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x40ac38
movq 0x205c95(%rip), %rdi    # 0x60f698
callq 0x4098e6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x38, %esi
movq %r14, %rdi
callq 0x40dd80
jmp 0x409a29
jmp 0x409a26
movq %rax, %r15
movq %rbx, %rdi
callq 0x409898
movq %r15, %rdi
callq 0x4b7fb0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1fbe34(%rip), %rax    # 0x605880
movq %rax, (%rdi)
callq 0x40992e
movq 0x205c3d(%rip), %rdi    # 0x60f698
callq 0x40992e
movq 0x205c39(%rip), %r12    # 0x60f6a0
movq (%r12), %r14
movq 0x8(%r12), %r15
movq %r15, %rdx
subq %r14, %rdx
movq %rdx, %rcx
sarq $0x3, %rcx
testq %rcx, %rcx
jle 0x409ac4
movl $0x8, %eax
cmpq %rbx, -0x8(%r14,%rax)
je 0x409a99
addq $0x8, %rax
decq %rcx
jne 0x409a87
jmp 0x409ac4
leaq (%r14,%rax), %rsi
cmpq %r15, %rsi
je 0x409abb
leaq (%r14,%rax), %rdi
addq $-0x8, %rdi
subq %rax, %rdx
callq 0x401020
movq (%r12), %r14
movq 0x8(%r12), %r15
addq $-0x8, %r15
movq %r15, 0x8(%r12)
movq 0x205bcd(%rip), %rdi    # 0x60f698
callq 0x4098e6
cmpq %r14, %r15
jne 0x409b33
movq 0x205bc4(%rip), %r14    # 0x60f6a0
testq %r14, %r14
je 0x409af5
movq (%r14), %rdi
testq %rdi, %rdi
je 0x409af5
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x40dd80
movl $0x18, %esi
movq %r14, %rdi
callq 0x40dd80
movq 0x205b8f(%rip), %r14    # 0x60f698
testq %r14, %r14
je 0x409b16
movq %r14, %rdi
callq 0x409898
movl $0x38, %esi
movq %r14, %rdi
callq 0x40dd80
xorl %eax, %eax
movq %rax, 0x205b74(%rip)    # 0x60f6a0
movq %rax, 0x205b65(%rip)    # 0x60f698
movq %rbx, %rdi
callq 0x4098e6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x409898
movq %rax, %rdi
callq 0x40500f
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4091de
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq $-0x1, %rdx
callq 0x489d40
cmpq $-0x1, %rax
je 0x40a40f
movq (%r14), %rsi
movq 0x8(%r14), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x489d40
incq %rax
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
jb 0x40a444
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movb $0x0, (%rcx,%rax)
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x4091de
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x409f3c
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x40a41e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40dd80
jmp 0x40a41e
leaq 0x1ae2f4(%rip), %rsi    # 0x5b870a
movq %rbx, %rdi
callq 0x409ef6
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x40a435
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40dd80
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18efff(%rip), %rdi    # 0x59944a
leaq 0x18f02f(%rip), %rsi    # 0x599481
movq %rax, %rdx
xorl %eax, %eax
callq 0x458600
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x40a47b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40dd80
jmp 0x40a47b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x40a492
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40dd80
movq %rbx, %rdi
callq 0x4b7fb0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x38, %r15
movq 0x38(%rsi), %rsi
movq 0x40(%r14), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x489840
cmpq $-0x1, %rax
je 0x40a6af
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x489840
movq 0x40(%r14), %rdx
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %r8
movq %r15, %rdi
movq %rax, %rsi
callq 0x488dc0
movq 0x38(%r14), %rsi
jmp 0x40a66c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50, %edi
callq 0x40ef10
movq %rax, %r12
addq $0x38, %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
movq $0x0, 0x48(%r12)
movq %r12, %rdi
callq 0x409974
leaq 0x1fae3d(%rip), %rax    # 0x605540
movq %r12, 0x8(%rsp)
movq %rax, (%r12)
cmpq $0x0, 0x40(%rbx)
je 0x40a7c7
leaq 0x38(%rbx), %r13
movq 0x40(%r14), %rcx
xorl %r12d, %r12d
movq 0x38(%r14), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x489840
movq %rax, %rbp
cmpq $-0x1, %rax
jne 0x40a73e
movq 0x40(%rbx), %rbp
movq %rbp, %rcx
subq %r12, %rcx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x48a600
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x409f3c
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x40ae42
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x40a78f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x40dd80
movq %r12, %rdi
callq 0x409a3a
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x40a7b3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40dd80
movq 0x40(%r14), %rcx
addq %rcx, %rbp
movq %rbp, %r12
cmpq 0x40(%rbx), %rbp
jb 0x40a722
movq 0x8(%rsp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x404d0e
movl $0x50, %esi
movq %r12, %rdi
jmp 0x40a81d
movq %rax, %rbx
jmp 0x40a806
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x404a8c
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x40a822
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40dd80
movq %rbx, %rdi
callq 0x4b7fb0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x204b83(%rip), %rdi    # 0x60f698
callq 0x40992e
movq 0x204b7f(%rip), %rax    # 0x60f6a0
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
testq %rax, %rax
jle 0x40ab58
cmpq %rbx, (%rcx)
je 0x40ab5c
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x40ab50
leaq 0x1(%rdx), %rsi
cmpq %rbx, (%rcx,%rdx,8)
jne 0x40ab3e
cmpq %rax, %rdx
setl %bl
jmp 0x40ab5e
xorl %ebx, %ebx
jmp 0x40ab5e
movb $0x1, %bl
movq 0x204b33(%rip), %rdi    # 0x60f698
callq 0x4098e6
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x203867(%rip), %rbx    # 0x60f6b0
movq %rbx, %rdi
callq 0x40992e
movq 0x2038d0(%rip), %rax    # 0x60f728
subq 0x2038c1(%rip), %rax    # 0x60f720
sarq $0x3, %rax
movq 0x20390e(%rip), %r14    # 0x60f778
subq 0x2038ff(%rip), %r14    # 0x60f770
sarq $0x3, %r14
addq %rax, %r14
movq %rbx, %rdi
callq 0x4098e6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x203819(%rip), %rbx    # 0x60f6b0
movq %rbx, %rdi
callq 0x40992e
movq 0x203882(%rip), %r14    # 0x60f728
subq 0x203873(%rip), %r14    # 0x60f720
sarq $0x3, %r14
movq %rbx, %rdi
callq 0x4098e6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
leaq 0x202bec(%rip), %rdi    # 0x60f6b0
callq 0x40992e
movq 0x202ca8(%rip), %rax    # 0x60f778
subq 0x202c99(%rip), %rax    # 0x60f770
sarq $0x3, %rax
cmpq %rax, 0x200676(%rip)    # 0x60d158
jbe 0x40cb2d
leaq 0x202bc5(%rip), %rbx    # 0x60f6b0
movq 0x202c2e(%rip), %rax    # 0x60f720
cmpq 0x202c2f(%rip), %rax    # 0x60f728
je 0x40cb2d
movq %rbx, %rdi
callq 0x4098e6
xorl %edi, %edi
callq 0x40bec4
movq %rbx, %rdi
callq 0x40992e
movq 0x202c5f(%rip), %rax    # 0x60f778
subq 0x202c50(%rip), %rax    # 0x60f770
sarq $0x3, %rax
cmpq %rax, 0x20062d(%rip)    # 0x60d158
ja 0x40caeb
leaq 0x202b7c(%rip), %rdi    # 0x60f6b0
popq %rbx
jmp 0x4098e6
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, (%rdi)
addq $0x8, %rdi
movslq %esi, %rsi
leaq 0x10(%rsp), %rdx
movq $-0x1, (%rdx)
movl $0xffffffff, 0x8(%rdx)  # imm = 0xFFFFFFFF
movb $0x0, 0xc(%rdx)
leaq 0xf(%rsp), %rcx
callq 0x7b5e
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
cmpl $0x2, %ecx
jl 0x6d19
leal -0x1(%rcx), %esi
leaq 0x1(%rsi), %rdx
andq $-0x2, %rdx
decq %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm1     # xmm1 = xmm0[0,1,0,1]
leaq 0x14(%rax), %rsi
movdqa 0x1a412(%rip), %xmm2    # 0x21010
movdqa 0x1a41a(%rip), %xmm0    # 0x21020
pxor %xmm0, %xmm1
pcmpeqd %xmm3, %xmm3
movdqa 0x1a41a(%rip), %xmm4    # 0x21030
movdqa %xmm2, %xmm5
pxor %xmm0, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm1, %xmm6
pcmpeqd %xmm1, %xmm5
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pand %xmm6, %xmm5
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
por %xmm5, %xmm6
movdqa %xmm2, %xmm5
psubq %xmm3, %xmm5
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x6c55
movd %xmm5, -0x10(%rsi)
pxor %xmm3, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x6c6d
pshufd $0xee, %xmm5, %xmm5     # xmm5 = xmm5[2,3,2,3]
movd %xmm5, (%rsi)
paddq %xmm4, %xmm2
addq $0x20, %rsi
addq $-0x2, %rdx
jne 0x6c16
cmpl $0x2, %ecx
jl 0x6d19
movl %ecx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
andl $0x1, %ecx
movq %rsi, %rdx
subq %rcx, %rdx
addq $-0x2, %rsi
movq %rsi, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
addq $0x20, %rax
xorl %ecx, %ecx
movdqa 0x1a35f(%rip), %xmm2    # 0x21010
pxor %xmm0, %xmm1
pcmpeqd %xmm3, %xmm3
movq %rcx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm2, %xmm4
pxor %xmm0, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm1, %xmm5
pcmpeqd %xmm1, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x6cf8
movl %ecx, -0x10(%rax)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x6d0c
leal 0x1(%rcx), %esi
movl %esi, (%rax)
addq $0x2, %rcx
addq $0x20, %rax
cmpq %rcx, %rdx
jne 0x6cb9
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movl %edx, %r8d
movslq %esi, %rax
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %rdx
subq %r9, %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0x7b33
movslq %r8d, %r8
cmpq %r8, %rdx
jbe 0x7b3f
shlq $0x4, %rax
leaq (%r9,%rax), %r10
movq %r8, %rdi
shlq $0x4, %rdi
addq %r9, %rdi
movl %r8d, (%r9,%rax)
movq %rcx, %rax
shrq $0x20, %rax
andl $0x1, %eax
leaq 0x4(,%rax,4), %r8
testb $0x1, %cl
jne 0x7b10
movslq 0x4(%rdi), %rax
addq $0x4, %rdi
jmp 0x7b18
movslq 0x8(%rdi), %rax
addq $0x8, %rdi
movl %eax, (%r10,%r8)
cmpq $-0x1, %rax
je 0x7b2f
cmpq %rax, %rdx
jbe 0x7b33
shlq $0x4, %rax
movl %esi, (%r9,%rax)
movl %esi, (%rdi)
popq %rax
retq
leaq 0x195fb(%rip), %rdi     # 0x21135
movq %rax, %rsi
jmp 0x7b49
leaq 0x195ef(%rip), %rdi     # 0x21135
movq %r8, %rsi
xorl %eax, %eax
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/contour.cpp
// Function: Contour::Print(std::ostream&, int) const
void Contour::Print(ostream& os, int indent_level) const {
  const int indent_size = 2;
  os << string(indent_level * indent_size, ' ') << "Contour:" << endl;
  ++indent_level;
  os << string(indent_level * indent_size, ' ') << "max_y_: " << max_y_ << endl;
  os << string(indent_level * indent_size, ' ') << "coordinates_:" << endl;
  ++indent_level;
  for (const Point& point : coordinates_) {
    point.Print(os, indent_level);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal (%rbx,%rbx), %r13d
movslq %r13d, %rsi
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x8(%rsp), %rdi
movl $0x20, %edx
callq 0x6410
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x63f0
movq %rax, %r12
leaq 0x194e4(%rip), %rsi     # 0x2117f
movl $0x8, %edx
movq %rax, %rdi
callq 0x63f0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6370
movsbl %al, %esi
movq %r12, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6270
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7ce7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
addl $0x2, %r13d
movslq %r13d, %r12
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
movq %r12, %rsi
movl $0x20, %edx
callq 0x6410
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x63f0
movq %rax, %r13
leaq 0x19469(%rip), %rsi     # 0x21188
movl $0x8, %edx
movq %rax, %rdi
callq 0x63f0
movsd (%r15), %xmm0
movq %r13, %rdi
callq 0x6580
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x6370
movsbl %al, %esi
movq %r13, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6270
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7d7a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
movq %r12, %rsi
movl $0x20, %edx
callq 0x6410
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x63f0
movq %rax, %r12
leaq 0x193e6(%rip), %rsi     # 0x21191
movl $0xd, %edx
movq %rax, %rdi
callq 0x63f0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6370
movsbl %al, %esi
movq %r12, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6270
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7df7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq 0x8(%r15), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x7e1f
addl $0x2, %ebx
leaq 0x10(%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x20456
movq (%r12), %r12
cmpq %r15, %r12
jne 0x7e07
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7e32
jmp 0x7e32
movq %rax, %rbx
jmp 0x7e55
jmp 0x7e3b
jmp 0x7e3b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7e55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
addq $0x8, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x8110
leaq 0x10(%r14), %rdi
callq 0x20422
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x80f4
movq 0x8(%r14), %r15
xorpd %xmm0, %xmm0
cmpq %rbx, %r15
je 0x8160
movsd %xmm0, (%rsp)
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x20422
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8165
movq %r14, %rdi
callq 0x20428
ucomisd (%rsp), %xmm0
jbe 0x8156
movq %r14, %rdi
callq 0x20428
movsd %xmm0, (%rsp)
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x8122
jmp 0x8165
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq (%r14), %r13
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x6370
movsbl %al, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x66a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x9a4f
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9bc2
cmpq $0x0, 0x10(%rbx)
je 0x9a79
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%rbx)
movl %eax, %ebp
movq %r12, %rdi
callq 0x9cd2
testb %bpl, %bpl
jne 0x99ee
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x9a6a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6160
jmp 0x9a80
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9cd2
jmp 0x9a94
jmp 0x9a91
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x9aaf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq %rax, -0x8(%rbx)
movb $0x0, (%rbx)
movq 0x8(%rdx), %r13
testq %r13, %r13
je 0x9c75
movq %rsi, %r14
movq (%rdx), %r12
addq $0x8, %r14
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
movsbl (%r12,%rbx), %ebp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6490
cmpq $-0x1, %rax
je 0x9c48
cmpq $0x0, 0x10(%rsp)
je 0x9c52
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x9d30
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0x9c52
movq %r15, %rdi
movl %ebp, %esi
callq 0x6300
incq %rbx
cmpq %rbx, %r13
jne 0x9c0a
cmpq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
je 0x9c75
leaq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x9d30
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x9c8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9ca1
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9cc0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq (%rsp), %rdi
callq 0x9cd2
movq %r14, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0xe2a5
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x6380
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xe5c8
movb (%r14), %al
cmpb $0x1, %al
jne 0xe2f2
movq 0x8(%r14), %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0xe8c4
movq %rsp, %rsi
movq %r14, %rdi
callq 0xe848
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe2e6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xe972
leaq 0x13382(%rip), %rsi     # 0x21695
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xe901
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1ec29(%rip), %rsi     # 0x2cf60
movq 0x1ec52(%rip), %rdx     # 0x2cf90
movq %rbx, %rdi
callq 0x6610
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe364
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe37f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
testb %bpl, %bpl
jne 0xe3a9
jmp 0xe3d6
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe3a9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe3a9
movq %rax, %r14
movq %rbx, %rdi
callq 0x62a0
jmp 0xe3d6
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe3d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe3d6
movq %rax, %r14
movq %r14, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
sete %al
cmpq $0x2, %rdx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xe479
cmpb $0x3, (%r14)
jne 0xe479
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xfea2
addq $0x10, %r14
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xfd2c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfbfc
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0xe0aa
movq -0x20(%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xe45c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4a5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe4a5
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0xe11c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfd80
movq %rsp, %rdi
callq 0xe0aa
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe6ee
jmp 0xe4bf
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4e7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe4e7
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe0aa
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/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>::type_name() const
std::string type_name() const
    {
        {
            switch (m_type)
            {
                case value_t::null:
                    return "null";
                case value_t::object:
                    return "object";
                case value_t::array:
                    return "array";
                case value_t::string:
                    return "string";
                case value_t::boolean:
                    return "boolean";
                case value_t::discarded:
                    return "discarded";
                default:
                    return "number";
            }
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0x8, %rax
ja 0xe9c6
leaq 0x129e3(%rip), %rcx     # 0x21370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12d14(%rip), %rsi     # 0x216b1
leaq 0x12d11(%rip), %rdx     # 0x216b5
jmp 0xea04
leaq 0x12d10(%rip), %rsi     # 0x216bd
leaq 0x12d0e(%rip), %rdx     # 0x216c2
jmp 0xea04
leaq 0x12d15(%rip), %rsi     # 0x216d2
leaq 0x12d17(%rip), %rdx     # 0x216db
jmp 0xea04
leaq 0x12d0f(%rip), %rsi     # 0x216dc
leaq 0x12d0e(%rip), %rdx     # 0x216e2
jmp 0xea04
leaq 0x12cd9(%rip), %rsi     # 0x216b6
leaq 0x12cd8(%rip), %rdx     # 0x216bc
jmp 0xea04
leaq 0x12cd6(%rip), %rsi     # 0x216c3
leaq 0x12cd5(%rip), %rdx     # 0x216c9
jmp 0xea04
leaq 0x12ccd(%rip), %rsi     # 0x216ca
leaq 0x12ccd(%rip), %rdx     # 0x216d1
movq %rbx, %rdi
callq 0xa09a
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0xf133
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe972
leaq 0x12543(%rip), %rsi     # 0x21695
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe901
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1dde8(%rip), %rsi     # 0x2cf60
movq 0x1de11(%rip), %rdx     # 0x2cf90
movq %rbx, %rdi
callq 0x6610
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf1a5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf1c0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
testb %bpl, %bpl
jne 0xf1ea
jmp 0xf1f2
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf1ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xf1ea
movq %rax, %r14
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640