LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x40565e
andq $0x0, 0x58(%r14)
movups 0x8(%rbx), %xmm0
movups 0x18(%rbx), %xmm1
movups 0x21(%rbx), %xmm2
movups %xmm0, 0x8(%r14)
movups %xmm1, 0x18(%r14)
movups %xmm2, 0x21(%r14)
movups 0x38(%rbx), %xmm0
movups 0x48(%rbx), %xmm1
movups %xmm0, 0x38(%r14)
movups %xmm1, 0x48(%r14)
addq $0x60, %r14
movq %r14, %rdi
callq 0x4e7d70
pushq $0x1
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4e7da0
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::create(u::Callback*)
bool ThreadSystem::create(Callback *cb)
{
	_access.lock();
	if(isTerminating) {
		_access.unlock();
		return false;
	}

	Thread *t = new Thread(cb);

	_build.push_back(t);
	_access.unlock();

#ifndef NDEBUG
	trace(
		"\033[0mThreadSystem::create: " + Object::ptr2string(cb)
		 + " -> " +  Object::ptr2string(&(t->_call))
		 //+ "\n\033[37m" + ThreadSystem::toString()
	);
#endif

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %r15
leaq 0x203292(%rip), %rdi    # 0x60c6b0
callq 0x407cb6
movb 0x203280(%rip), %bl     # 0x60c6a9
cmpb $0x1, %bl
jne 0x40943f
leaq 0x20327b(%rip), %rdi    # 0x60c6b0
callq 0x407c72
jmp 0x40954b
movl $0x98, %edi
callq 0x40b890
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x408f74
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x2032ba(%rip), %rdi    # 0x60c720
callq 0x40a0e8
leaq 0x20323e(%rip), %rdi    # 0x60c6b0
callq 0x407c72
movq $0x60d6a0, %rdi         # imm = 0x60D6A0
leaq 0x18cbf4(%rip), %rsi    # 0x596079
callq 0x474850
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
movq %r15, %rsi
callq 0x408010
leaq 0x100(%rsp), %rdx
leaq 0x18cfd3(%rip), %rsi    # 0x59647f
leaq 0x10(%rsp), %rdi
callq 0x404ee4
leaq 0x18cd2f(%rip), %rdx    # 0x5961ec
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x404ec5
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x408010
leaq 0xa8(%rsp), %rdx
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x405951
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x4870d0
leaq 0x18cb7f(%rip), %rsi    # 0x596085
movq %rax, %rdi
callq 0x474850
movq %rax, %rdi
callq 0x474130
leaq 0x50(%rsp), %rdi
callq 0x484750
leaq 0x70(%rsp), %rdi
callq 0x404ab8
leaq 0x30(%rsp), %rdi
callq 0x484750
leaq 0x10(%rsp), %rdi
callq 0x484750
leaq 0xc8(%rsp), %rdi
callq 0x404ab8
xorb $0x1, %bl
movl %ebx, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x409590
movq %rax, %rbx
jmp 0x40959a
movq %rax, %rbx
jmp 0x4095a4
movq %rax, %rbx
jmp 0x4095ae
movq %rax, %rbx
movl $0x98, %esi
movq %r14, %rdi
callq 0x40a700
jmp 0x4095bb
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x484750
leaq 0x70(%rsp), %rdi
callq 0x404ab8
leaq 0x30(%rsp), %rdi
callq 0x484750
leaq 0x10(%rsp), %rdi
callq 0x484750
leaq 0xc8(%rsp), %rdi
callq 0x404ab8
movq %rbx, %rdi
callq 0x4b5490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leaq 0x203150(%rip), %rbx    # 0x60c720
leaq 0x203111(%rip), %r14    # 0x60c6e8
movq 0x203142(%rip), %rax    # 0x60c720
cmpq 0x203143(%rip), %rax    # 0x60c728
je 0x40961a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40a106
movq (%rax), %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x40a128
testq %r15, %r15
je 0x40960b
movq %r15, %rdi
callq 0x408fd4
movl $0x98, %esi
movq %r15, %rdi
callq 0x40a700
jmp 0x4095d7
leaq 0x20314f(%rip), %rbx    # 0x60c770
leaq 0x203110(%rip), %r14    # 0x60c738
movq 0x203141(%rip), %rax    # 0x60c770
cmpq 0x203142(%rip), %rax    # 0x60c778
je 0x40966b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40a106
movq (%rax), %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x40a128
testq %r15, %r15
je 0x40965c
movq %r15, %rdi
callq 0x408fd4
movl $0x98, %esi
movq %r15, %rdi
callq 0x40a700
jmp 0x409628
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x203033(%rip), %rbx    # 0x60c6b0
movq %rbx, %rdi
callq 0x407cb6
movq 0x20309c(%rip), %rax    # 0x60c728
subq 0x20308d(%rip), %rax    # 0x60c720
sarq $0x3, %rax
movq 0x2030da(%rip), %r14    # 0x60c778
subq 0x2030cb(%rip), %r14    # 0x60c770
sarq $0x3, %r14
addq %rax, %r14
movq %rbx, %rdi
callq 0x407c72
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x202fe5(%rip), %rbx    # 0x60c6b0
movq %rbx, %rdi
callq 0x407cb6
movq 0x20304e(%rip), %r14    # 0x60c728
subq 0x20303f(%rip), %r14    # 0x60c720
sarq $0x3, %r14
movq %rbx, %rdi
callq 0x407c72
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x202b30(%rip), %rbx    # 0x60c6b0
movq %rbx, %rdi
callq 0x407cb6
movq 0x202be9(%rip), %rax    # 0x60c778
subq 0x202bda(%rip), %rax    # 0x60c770
sarq $0x3, %rax
cmpq %rax, 0x2005b7(%rip)    # 0x60a158
jbe 0x409bc4
movq 0x202b76(%rip), %rax    # 0x60c720
cmpq 0x202b77(%rip), %rax    # 0x60c728
je 0x409bc4
movq %rbx, %rdi
callq 0x407c72
xorl %edi, %edi
callq 0x4096f8
jmp 0x409b80
leaq 0x202ae5(%rip), %rdi    # 0x60c6b0
popq %rbx
jmp 0x407c72
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rdi)
addq $0x8, %rdi
movslq %esi, %rsi
leaq 0x10(%rsp), %rdx
orq $-0x1, (%rdx)
orl $-0x1, 0x8(%rdx)
movb $0x0, 0xc(%rdx)
leaq 0xf(%rsp), %rcx
callq 0x7f94
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
cmpl $0x2, %ecx
pushq $0x1
popq %rdx
movl %edx, %esi
cmovgel %ecx, %esi
decl %esi
shlq $0x4, %rsi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x7a3c
movl %edx, 0x4(%rax,%rdi)
addq $0x10, %rdi
incl %edx
jmp 0x7a2b
movslq %ecx, %rcx
addq $0x10, %rax
xorl %edx, %edx
leaq 0x1(%rdx), %rsi
cmpq %rcx, %rsi
jge 0x7a59
movl %edx, (%rax)
addq $0x10, %rax
movq %rsi, %rdx
jmp 0x7a45
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
callq 0x7d86
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x7d86
movl %ebp, (%r15)
movq %r12, %rcx
shrq $0x20, %rcx
andl $0x1, %ecx
leaq 0x4(,%rcx,4), %rcx
testb $0x1, %r12b
jne 0x7f5b
movq %rax, %r12
addq $0x4, %r12
movl 0x4(%rax), %esi
jmp 0x7f65
movq %rax, %r12
addq $0x8, %r12
movl 0x8(%rax), %esi
movl %esi, (%r15,%rcx)
cmpl $-0x1, %esi
je 0x7f78
movq %r14, %rdi
callq 0x7d86
movl %ebx, (%rax)
movl %ebx, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12d
movslq %r12d, %rsi
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x7400
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x12f24(%rip), %rsi     # 0x1b0d3
movq %rax, %rdi
callq 0x7380
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x7758
addl $0x2, %r12d
movslq %r12d, %r12
movq %rbp, (%r13)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
movq %r12, %rsi
callq 0x7400
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x12ee1(%rip), %rsi     # 0x1b0dc
movq %rax, %rdi
callq 0x7380
movsd (%r15), %xmm0
movq %rax, %rdi
callq 0x75a0
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x7758
movq %rbp, (%r13)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
movq %r12, %rsi
callq 0x7400
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x12e98(%rip), %rsi     # 0x1b0e5
movq %rax, %rdi
callq 0x7380
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %rdi
callq 0x7758
addl $0x2, %ebx
addq $0x8, %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x828b
leaq 0x10(%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1aab2
jmp 0x8271
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x829e
jmp 0x829e
movq %rax, %rbx
jmp 0x82b4
jmp 0x82a7
jmp 0x82a7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7758
movq %rbx, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x851a
leaq 0x10(%r15), %rdi
callq 0x1aa7e
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x84fe
addq $0x8, %r15
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq (%r15), %r15
cmpq %rbx, %r15
je 0x8560
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x1aa7e
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8560
movq %r14, %rdi
callq 0x1aa84
ucomisd (%rsp), %xmm0
jbe 0x8527
movq %r14, %rdi
callq 0x1aa84
jmp 0x8522
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x138cc(%rip), %rsi     # 0x1c27c
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %r14
movq %r14, %rdx
callq 0x95d4
leaq 0x50(%rsp), %r15
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x9610
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x7758
andl $0x0, (%r12)
andl $0x0, 0xc(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
pushq $0x20
popq %rdi
callq 0x7390
movq %r12, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rbx, 0x18(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x6ef(%rip), %rax       # 0x9110
movq %rax, 0x18(%rsi)
leaq 0x8e6(%rip), %rax       # 0x9312
movq %rax, 0x10(%rsi)
movq %r15, %rdi
callq 0x9626
leaq 0x10(%rsp), %rdi
callq 0x96d2
leaq 0x58(%rsp), %rdi
callq 0x7758
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8a5a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x96d2
leaq 0x58(%rsp), %rdi
jmp 0x8a76
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7758
jmp 0x8a80
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq (%r14), %rdi
movq %r15, %rsi
callq 0x70a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x9694
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x97c8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x98a8
movl %eax, %ebp
movq %r12, %rdi
callq 0x98bc
testb %bpl, %bpl
jne 0x9653
leaq 0x8(%rsp), %rdi
callq 0x7758
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x98bc
jmp 0x96bf
jmp 0x96bc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7758
movq %rbx, %rdi
callq 0x7660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r14
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdx), %r12
movq 0x8(%rdx), %r13
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
cmpq %rbx, %r13
je 0x9852
movsbl (%r12,%rbx), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x98de
testb %al, %al
je 0x9843
cmpq $0x0, 0x10(%rsp)
je 0x984d
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x98f4
andq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0x984d
movq %r15, %rdi
movl %ebp, %esi
callq 0x7300
incq %rbx
jmp 0x9807
cmpq $0x0, 0x10(%rsp)
movq (%rsp), %rbx
je 0x986b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x98f4
leaq 0x8(%rsp), %rdi
callq 0x7758
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9889
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7758
movq (%rsp), %rdi
callq 0x98bc
movq %r14, %rdi
callq 0x7660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd426
movb $0x1, (%r14)
callq 0xddd8
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xd7fc
movb (%r14), %al
cmpb $0x1, %al
jne 0xd460
movq 0x8(%r14), %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0x95d4
movq %rsp, %rsi
movq %r14, %rdi
callq 0xdcbc
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7758
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xdd46
leaq 0xe172(%rip), %rsi      # 0x1b5f1
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xdd22
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7430
xorl %ebp, %ebp
movq 0x1cac5(%rip), %rsi     # 0x29f68
movq 0x1cae6(%rip), %rdx     # 0x29f90
movq %rbx, %rdi
callq 0x7630
movq %rax, %r14
movq %rsp, %rdi
callq 0x7758
jmp 0xd4c5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x7758
testb %bpl, %bpl
jne 0xd4d9
jmp 0xd4f3
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c0
jmp 0xd4f3
movq %rax, %r14
movq %rsp, %rdi
callq 0x7758
jmp 0xd4f3
movq %rax, %r14
movq %r14, %rdi
callq 0x7660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd666
cmpb $0x3, (%r14)
jne 0xd666
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf208
addq $0x10, %r14
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xf102
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xf036
movq %rsp, %rdi
callq 0xd902
leaq 0x30(%rsp), %rdi
callq 0x7758
jmp 0xd68e
movq %rsp, %r15
pushq $0x1
popq %rcx
pushq $0x2
popq %r8
movq %r15, %rdi
movq %r14, %rsi
callq 0xd2e8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf138
movq %rsp, %rdi
callq 0xd290
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd902
jmp 0xd6a8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7758
jmp 0xd6bf
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd290
movq %rbx, %rdi
callq 0x7660
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpq $0x8, %rax
ja 0xdd91
leaq 0xd56e(%rip), %rcx      # 0x1b2cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd89f(%rip), %rsi      # 0x1b60d
leaq 0xf(%rsp), %rdx
jmp 0xddc7
leaq 0xd89d(%rip), %rsi      # 0x1b619
leaq 0xd(%rsp), %rdx
jmp 0xddc7
leaq 0xd8a4(%rip), %rsi      # 0x1b62e
leaq 0xa(%rsp), %rdx
jmp 0xddc7
leaq 0xd8a0(%rip), %rsi      # 0x1b638
leaq 0x9(%rsp), %rdx
jmp 0xddc7
leaq 0xd86c(%rip), %rsi      # 0x1b612
leaq 0xe(%rsp), %rdx
jmp 0xddc7
leaq 0xd86b(%rip), %rsi      # 0x1b61f
leaq 0xc(%rsp), %rdx
jmp 0xddc7
leaq 0xd864(%rip), %rsi      # 0x1b626
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
callq 0x95d4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/harry830622[P]floorplanner/src/././json.hpp
// Function: std::map<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>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<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>>>>* 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::map<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>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<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>>>>>()
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 %rbx
subq $0x20, %rsp
pushq $0x30
popq %rdi
callq 0x7390
movq %rax, %rbx
leaq 0xf(%rsp), %rax
leaq 0x8(%rbx), %rcx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rcx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
leaq 0x10(%rsp), %rdi
andq $0x0, 0x28(%rbx)
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
callq 0xdebe
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe66d
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xdd46
leaq 0xcf67(%rip), %rsi      # 0x1b5f1
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xdd22
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7430
xorl %ebp, %ebp
movq 0x1b8b8(%rip), %rsi     # 0x29f68
movq 0x1b8d9(%rip), %rdx     # 0x29f90
movq %rbx, %rdi
callq 0x7630
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x7758
jmp 0xe6d4
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x7758
testb %bpl, %bpl
jne 0xe6e6
jmp 0xe6ee
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c0
movq %r14, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0xf0a2
cmpl $0x1, %eax
je 0xf0b7
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xdd46
leaq 0xc61a(%rip), %rsi      # 0x1b687
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xdd22
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7430
xorl %ebp, %ebp
movq 0x1aed5(%rip), %rsi     # 0x29f68
movq 0x1aef6(%rip), %rdx     # 0x29f90
movq %rbx, %rdi
callq 0x7630
movb $0x1, (%r14)
callq 0xddd8
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xd7fc
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xf2f8
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x7758
jmp 0xf0e0
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x7758
testb %bpl, %bpl
jne 0xf0f2
jmp 0xf0fa
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c0
movq %r14, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0xf1a4
cmpl $0x2, %eax
je 0xf1b9
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xdd46
leaq 0xc518(%rip), %rsi      # 0x1b687
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xdd22
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7430
xorl %ebp, %ebp
movq 0x1add3(%rip), %rsi     # 0x29f68
movq 0x1adf4(%rip), %rdx     # 0x29f90
movq %rbx, %rdi
callq 0x7630
movb $0x2, (%r14)
callq 0xde24
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xd7fc
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xf3a0
movb $0x0, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x7758
jmp 0xf1e6
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x7758
testb %bpl, %bpl
jne 0xf1f8
jmp 0xf200
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c0
movq %r14, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/harry830622[P]floorplanner/src/././json.hpp
// Function: void nlohmann::detail::external_constructor<(nlohmann::detail::value_t)7>::construct<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>&, 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>::number_float_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
    {
        // replace infinity and NAN by null
        if (not std::isfinite(val))
        {
            j = BasicJsonType{};
        }
        else
        {
            j.m_type = value_t::number_float;
            j.m_value = val;
        }
        j.assert_invariant();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xf64f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xe24c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd4fc
movq %r14, %rdi
callq 0xd290
jmp 0xf657
movb $0x7, (%rbx)
movq %xmm0, 0x8(%rbx)
movq %rbx, %rdi
callq 0xd7fc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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> const&)
void push_back(const 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
        m_value.array->push_back(val);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x12172
cmpl $0x2, %eax
je 0x12187
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xdd46
leaq 0x954a(%rip), %rsi      # 0x1b687
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xdd22
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7430
xorl %ebp, %ebp
movq 0x17e05(%rip), %rsi     # 0x29f68
movq 0x17e26(%rip), %rdx     # 0x29f90
movq %rbx, %rdi
callq 0x7630
movb $0x2, (%r14)
callq 0xde24
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xd7fc
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1291e
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x7758
jmp 0x121b0
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x7758
testb %bpl, %bpl
jne 0x121c2
jmp 0x121ca
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c0
movq %r14, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/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>::iter_impl<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--()
iter_impl& operator--()
        {
            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    std::advance(m_it.object_iterator, -1);
                    break;
                }

                case basic_json::value_t::array:
                {
                    std::advance(m_it.array_iterator, -1);
                    break;
                }

                default:
                {
                    --m_it.primitive_iterator;
                    break;
                }
            }

            return *this;
        }

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x12abd
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x12aad
cmpl $0x1, %eax
jne 0x12ab4
leaq 0x8(%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x12c4c
jmp 0x12ab8
addq $-0x10, 0x10(%rbx)
jmp 0x12ab8
decq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x8e29(%rip), %rdi      # 0x1b8ed
leaq 0x8e0f(%rip), %rsi      # 0x1b8da
leaq 0x8fa3(%rip), %rcx      # 0x1ba75
movl $0x23bc, %edx           # imm = 0x23BC
callq 0x7270
// File: /workspace/github_cpp_makefile_star2_O2/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>::iter_impl<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*() const
reference operator*() const
        {
            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    assert(m_it.object_iterator != m_object->m_value.object->end());
                    return m_it.object_iterator->second;
                }

                case basic_json::value_t::array:
                {
                    assert(m_it.array_iterator != m_object->m_value.array->end());
                    return *m_it.array_iterator;
                }

                case basic_json::value_t::null:
                {
                    JSON_THROW(std::out_of_range("cannot get value"));
                }

                default:
                {
                    if (m_it.primitive_iterator.is_begin())
                    {
                        return *m_object;
                    }

                    JSON_THROW(std::out_of_range("cannot get value"));
                }
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x12b71
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x12b54
cmpl $0x2, %ecx
je 0x12b27
testl %ecx, %ecx
je 0x12b90
cmpq $0x0, 0x18(%rdi)
je 0x12b69
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x92ca(%rip), %rsi      # 0x1bde4
movq %rax, %rdi
callq 0x7080
jmp 0x12baa
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rcx), %rax
jne 0x12b69
leaq 0x9272(%rip), %rdi      # 0x1bdae
leaq 0x8d97(%rip), %rsi      # 0x1b8da
leaq 0x90ab(%rip), %rcx      # 0x1bbf5
movl $0x2349, %edx           # imm = 0x2349
callq 0x7270
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0x12bc0
addq $0x40, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8d75(%rip), %rdi      # 0x1b8ed
leaq 0x8d5b(%rip), %rsi      # 0x1b8da
leaq 0x906f(%rip), %rcx      # 0x1bbf5
movl $0x233d, %edx           # imm = 0x233D
callq 0x7270
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x9242(%rip), %rsi      # 0x1bde4
movq %rax, %rdi
callq 0x7080
movq 0x17417(%rip), %rsi     # 0x29fc8
movq 0x173f8(%rip), %rdx     # 0x29fb0
movq %rbx, %rdi
callq 0x7630
leaq 0x91af(%rip), %rdi      # 0x1bd76
leaq 0x8d0c(%rip), %rsi      # 0x1b8da
leaq 0x9020(%rip), %rcx      # 0x1bbf5
movl $0x2343, %edx           # imm = 0x2343
callq 0x7270
jmp 0x12be1
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c0
movq %r14, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/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>::iter_impl<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>>::set_end()
void set_end() noexcept
        {
            assert(m_object != nullptr);

            switch (m_object->m_type)
            {
                case basic_json::value_t::object:
                {
                    m_it.object_iterator = m_object->m_value.object->end();
                    break;
                }

                case basic_json::value_t::array:
                {
                    m_it.array_iterator = m_object->m_value.array->end();
                    break;
                }

                default:
                {
                    m_it.primitive_iterator.set_end();
                    break;
                }
            }
        }

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x12c2c
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x12c16
cmpl $0x1, %ecx
jne 0x12c23
movq 0x8(%rax), %rax
addq $0x8, %rax
movq %rax, 0x8(%rdi)
retq
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdi)
retq
movq $0x1, 0x18(%rdi)
retq
pushq %rax
leaq 0x8cb9(%rip), %rdi      # 0x1b8ed
leaq 0x8c9f(%rip), %rsi      # 0x1b8da
leaq 0x8cbf(%rip), %rcx      # 0x1b901
movl $0x231e, %edx           # imm = 0x231E
callq 0x7270
// File: /workspace/github_cpp_makefile_star2_O2/harry830622[P]floorplanner/src/macro.cpp
// Function: Macro::Print(std::ostream&, int) const
void Macro::Print(ostream& os, int indent_level) const {
  const int indent_size = 2;
  os << string(indent_level * indent_size, ' ') << "Macro:" << endl;
  ++indent_level;
  os << string(indent_level * indent_size, ' ') << "name_: " << name_ << endl;
  os << string(indent_level * indent_size, ' ') << "width_: " << width_ << endl;
  os << string(indent_level * indent_size, ' ') << "height_: " << height_
     << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addl %edx, %ebp
movslq %ebp, %rsi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x7400
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x90e2(%rip), %rsi      # 0x1bdf5
movq %rax, %rdi
callq 0x7380
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7758
addl $0x2, %ebp
movslq %ebp, %r15
movq %r13, (%r12)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
movq %r15, %rsi
callq 0x7400
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x909e(%rip), %rsi      # 0x1bdfc
movq %rax, %rdi
callq 0x7380
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7330
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7758
movq %r13, (%r12)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
movq %r15, %rsi
callq 0x7400
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x843e(%rip), %rsi      # 0x1b1ec
movq %rax, %rdi
callq 0x7380
movsd 0x20(%rbx), %xmm0
movq %rax, %rdi
callq 0x75a0
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x7758
movq %r13, (%r12)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
movq %r15, %rsi
callq 0x7400
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x83fd(%rip), %rsi      # 0x1b1fd
movq %rax, %rdi
callq 0x7380
movsd 0x28(%rbx), %xmm0
movq %rax, %rdi
callq 0x75a0
movq %rax, %rdi
callq 0x71c0
leaq 0x8(%rsp), %rdi
callq 0x7758
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12e3c
jmp 0x12e3c
jmp 0x12e3c
movq %rax, %rbx
jmp 0x12e54
jmp 0x12e47
jmp 0x12e47
jmp 0x12e47
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7758
movq %rbx, %rdi
callq 0x7660
// File: /workspace/github_cpp_makefile_star2_O2/harry830622[P]floorplanner/src/./././json.hpp
// Function: nlohmann::operator<<(std::ostream&, 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&)
friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
    {
        // read width member and use it as indentation parameter if nonzero
        const bool pretty_print = (o.width() > 0);
        const auto indentation = (pretty_print ? o.width() : 0);

        // reset width to 0 for subsequent calls to this stream
        o.width(0);

        // do the actual serialization
        j.dump(o, pretty_print, static_cast<unsigned int>(indentation));

        return o;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0x10(%rdi,%rax), %rcx
xorl %edi, %edi
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdi, %rcx
setg %dl
andq $0x0, 0x10(%rbx,%rax)
movq %rsi, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x19b4e
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/harry830622[P]floorplanner/src/./././json.hpp
// Function: void 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>::numtostr::x_write<long>(long, std::integral_constant<bool, true>)
void x_write(NumberType x, /*is_integral=*/std::true_type)
        {
            // special case for "0"
            if (x == 0)
            {
                m_buf[0] = '0';
                return;
            }

            const bool is_negative = x < 0;
            size_t i = 0;

            // spare 1 byte for '\0'
            while (x != 0 and i < m_buf.size() - 1)
            {
                const auto digit = std::labs(static_cast<long>(x % 10));
                m_buf[i++] = static_cast<char>('0' + digit);
                x /= 10;
            }

            // make sure the number has been processed completely
            assert(x == 0);

            if (is_negative)
            {
                // make sure there is capacity for the '-'
                assert(i < m_buf.size() - 2);
                m_buf[i++] = '-';
            }

            std::reverse(m_buf.begin(), m_buf.begin() + i);
        }

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1a244
movq %rsi, %rcx
xorl %esi, %esi
pushq $0xa
popq %r8
movq %rcx, %rax
testq %rax, %rax
je 0x1a229
cmpq $0x3f, %rsi
je 0x1a249
cqto
idivq %r8
movq %rdx, %r9
negq %r9
cmovsq %rdx, %r9
addb $0x30, %r9b
movb %r9b, (%rdi,%rsi)
incq %rsi
jmp 0x1a202
testq %rcx, %rcx
jns 0x1a23b
cmpq $0x3e, %rsi
jae 0x1a268
movb $0x2d, (%rdi,%rsi)
incq %rsi
addq %rdi, %rsi
popq %rax
jmp 0x1a287
movb $0x30, (%rdi)
popq %rax
retq
leaq 0x204a(%rip), %rdi      # 0x1c29a
leaq 0x1683(%rip), %rsi      # 0x1b8da
leaq 0x2043(%rip), %rcx      # 0x1c2a1
movl $0x2066, %edx           # imm = 0x2066
callq 0x7270
leaq 0x219e(%rip), %rdi      # 0x1c40d
leaq 0x1664(%rip), %rsi      # 0x1b8da
leaq 0x2024(%rip), %rcx      # 0x1c2a1
movl $0x206b, %edx           # imm = 0x206B
callq 0x7270