LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19a8c(%rip), %rsi     # 0x210d3
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 0x7693
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 0x19a11(%rip), %rsi     # 0x210dc
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 0x7726
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 0x1998e(%rip), %rsi     # 0x210e5
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 0x77a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq 0x8(%r15), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x77cb
addl $0x2, %ebx
leaq 0x10(%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x20916
movq (%r12), %r12
cmpq %r15, %r12
jne 0x77b3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x77de
jmp 0x77de
movq %rax, %rbx
jmp 0x7801
jmp 0x77e7
jmp 0x77e7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7801
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ad2
leaq 0x10(%r14), %rdi
callq 0x208dc
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x7ab6
movq 0x8(%r14), %r15
xorpd %xmm0, %xmm0
cmpq %rbx, %r15
je 0x7b22
movsd %xmm0, (%rsp)
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x208dc
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7b27
movq %r14, %rdi
callq 0x208e2
ucomisd (%rsp), %xmm0
jbe 0x7b18
movq %r14, %rdi
callq 0x208e2
movsd %xmm0, (%rsp)
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x7ae4
jmp 0x7b27
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9411
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9584
cmpq $0x0, 0x10(%rbx)
je 0x943b
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%rbx)
movl %eax, %ebp
movq %r12, %rdi
callq 0x9694
testb %bpl, %bpl
jne 0x93b0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x942c
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 0x9442
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9694
jmp 0x9456
jmp 0x9453
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x9471
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
movq 0x8(%rdx), %r13
testq %r13, %r13
je 0x961c
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 0x960a
cmpq $0x0, 0x10(%rsp)
je 0x9614
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x96f0
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0x9614
movq %r15, %rdi
movl %ebp, %esi
callq 0x6300
incq %rbx
cmpq %rbx, %r13
jne 0x95cc
cmpq $0x0, 0x10(%rsp)
je 0x9632
leaq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x96f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x964e
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 0x9663
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9682
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq (%rsp), %rdi
callq 0x9694
movq %r14, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::~basic_json()
~basic_json()
    {
        assert_invariant();

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe608
movzbl (%rbx), %eax
cmpl $0x3, %eax
je 0xe128
cmpl $0x2, %eax
je 0xe113
cmpl $0x1, %eax
jne 0xe15f
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
callq 0xe6aa
movl $0x30, %r14d
jmp 0xe14d
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
callq 0xe756
movl $0x18, %r14d
jmp 0xe14d
movq 0x8(%rbx), %rax
addq $0x8, %rbx
movq (%rax), %rdi
addq $0x10, %rax
movl $0x20, %r14d
cmpq %rax, %rdi
je 0xe14d
movq (%rax), %rsi
incq %rsi
callq 0x6390
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6390
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x0, (%rdi)
jne 0xe2ff
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x6380
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xe608
cmpb $0x1, (%r14)
jne 0xe34e
movq 0x8(%r14), %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
callq 0xe8fe
movq %rsp, %rsi
movq %r14, %rdi
callq 0xe882
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe342
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 0xe9ac
leaq 0x13276(%rip), %rsi     # 0x215e5
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xe93b
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1ebcd(%rip), %rsi     # 0x2cf60
movq 0x1ebf6(%rip), %rdx     # 0x2cf90
movq %rbx, %rdi
callq 0x6610
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe3c8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe3c8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe3eb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe3eb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xe41d
movq %rbx, %rdi
callq 0x62a0
jmp 0xe41d
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe41d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe41d
movq %rax, %r14
movq %r14, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe4c1
cmpb $0x3, (%r14)
jne 0xe4c1
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xfeb2
addq $0x10, %r14
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xfd52
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfc32
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0xe0e0
movq -0x20(%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xe4a4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4ed
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe4ed
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0xe168
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfda6
movq %rsp, %rdi
callq 0xe0e0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe72e
jmp 0xe507
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe52f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xe52f
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe0e0
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xea00
leaq 0x128e9(%rip), %rcx     # 0x212b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12c2a(%rip), %rsi     # 0x21601
leaq 0x12c27(%rip), %rdx     # 0x21605
jmp 0xea3e
leaq 0x12c26(%rip), %rsi     # 0x2160d
leaq 0x12c24(%rip), %rdx     # 0x21612
jmp 0xea3e
leaq 0x12c2b(%rip), %rsi     # 0x21622
leaq 0x12c2d(%rip), %rdx     # 0x2162b
jmp 0xea3e
leaq 0x12c25(%rip), %rsi     # 0x2162c
leaq 0x12c24(%rip), %rdx     # 0x21632
jmp 0xea3e
leaq 0x12bef(%rip), %rsi     # 0x21606
leaq 0x12bee(%rip), %rdx     # 0x2160c
jmp 0xea3e
leaq 0x12bec(%rip), %rsi     # 0x21613
leaq 0x12beb(%rip), %rdx     # 0x21619
jmp 0xea3e
leaq 0x12be3(%rip), %rsi     # 0x2161a
leaq 0x12be3(%rip), %rdx     # 0x21621
movq %rbx, %rdi
callq 0x9a8c
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/././json.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>* nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::create<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x6380
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x9912
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x6390
movq %r14, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf16d
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 0xe9ac
leaq 0x12459(%rip), %rsi     # 0x215e5
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe93b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1ddae(%rip), %rsi     # 0x2cf60
movq 0x1ddd7(%rip), %rdx     # 0x2cf90
movq %rbx, %rdi
callq 0x6610
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf1e7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xf1e7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf20a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xf20a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xf217
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfca4
cmpl $0x1, %eax
je 0xfce0
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe9ac
leaq 0x11a0c(%rip), %rsi     # 0x2167b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe93b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1d2cb(%rip), %rsi     # 0x2cf60
movq 0x1d2f4(%rip), %rdx     # 0x2cf90
movq %rbx, %rdi
callq 0x6610
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x6380
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xe608
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xffd8
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd1a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xfd1a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd3d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xfd3d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xfd4a
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfe14
cmpl $0x2, %eax
je 0xfe3c
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe9ac
leaq 0x1189c(%rip), %rsi     # 0x2167b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe93b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1d15b(%rip), %rsi     # 0x2cf60
movq 0x1d184(%rip), %rdx     # 0x2cf90
movq %rbx, %rdi
callq 0x6610
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x6380
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xe608
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x1009c
movb $0x0, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfe7a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xfe7a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfe9d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xfe9d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xfeaa
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1042c
leaq 0x8(%rsp), %r14
movb $0x0, (%r14)
movq %r14, %rdi
callq 0xe608
movq %r14, %rdi
callq 0xe608
movq %r14, %rdi
callq 0xe608
movb (%rbx), %al
movb (%r14), %cl
movb %cl, (%rbx)
movb %al, (%r14)
movq 0x8(%rbx), %rax
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0xe608
movq %r14, %rdi
callq 0xe0e0
jmp 0x1043c
movb $0x7, (%rbx)
movq %xmm0, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0xe608
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14b76
cmpl $0x2, %eax
je 0x14b9e
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe9ac
leaq 0xcb3a(%rip), %rsi      # 0x2167b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe93b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x183f9(%rip), %rsi     # 0x2cf60
movq 0x18422(%rip), %rdx     # 0x2cf90
movq %rbx, %rdi
callq 0x6610
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x6380
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xe608
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x15316
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14bd8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0x14bd8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14bfb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0x14bfb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x14c08
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O1/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 0x154d4
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x154c4
cmpl $0x1, %eax
jne 0x154cb
movq 0x8(%rbx), %rdi
callq 0x63a0
movq %rax, 0x8(%rbx)
jmp 0x154cf
addq $-0x10, 0x10(%rbx)
jmp 0x154cf
decq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xc3f2(%rip), %rdi      # 0x218cd
leaq 0xc3d8(%rip), %rsi      # 0x218ba
leaq 0xc56c(%rip), %rcx      # 0x21a55
movl $0x23bc, %edx           # imm = 0x23BC
callq 0x6240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1558b
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x1556e
cmpl $0x2, %ecx
je 0x15541
testl %ecx, %ecx
je 0x155aa
cmpq $0x0, 0x18(%rdi)
je 0x15583
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
leaq 0xc890(%rip), %rsi      # 0x21dc4
movq %rax, %rdi
callq 0x6090
jmp 0x155c6
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rcx), %rax
jne 0x15583
leaq 0xc838(%rip), %rdi      # 0x21d8e
leaq 0xc35d(%rip), %rsi      # 0x218ba
leaq 0xc671(%rip), %rcx      # 0x21bd5
movl $0x2349, %edx           # imm = 0x2349
callq 0x6240
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0x155dc
addq $0x40, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc33b(%rip), %rdi      # 0x218cd
leaq 0xc321(%rip), %rsi      # 0x218ba
leaq 0xc635(%rip), %rcx      # 0x21bd5
movl $0x233d, %edx           # imm = 0x233D
callq 0x6240
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
leaq 0xc806(%rip), %rsi      # 0x21dc4
movq %rax, %rdi
callq 0x6090
movq 0x179fb(%rip), %rsi     # 0x2cfc8
movq 0x179d4(%rip), %rdx     # 0x2cfa8
movq %rbx, %rdi
callq 0x6610
leaq 0xc773(%rip), %rdi      # 0x21d56
leaq 0xc2d0(%rip), %rsi      # 0x218ba
leaq 0xc5e4(%rip), %rcx      # 0x21bd5
movl $0x2343, %edx           # imm = 0x2343
callq 0x6240
jmp 0x155fd
movq %rax, %r14
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15648
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x15632
cmpl $0x1, %ecx
jne 0x1563f
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 0xc27d(%rip), %rdi      # 0x218cd
leaq 0xc263(%rip), %rsi      # 0x218ba
leaq 0xc283(%rip), %rcx      # 0x218e1
movl $0x231e, %edx           # imm = 0x231E
callq 0x6240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fe83
xorl %r8d, %r8d
movabsq $0x6666666666666667, %r9 # imm = 0x6666666666666667
movq %rsi, %rcx
cmpq $0x3f, %r8
je 0x1fe88
movq %rcx, %rax
imulq %r9
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r10
subq %rax, %r10
movq %r10, %rax
negq %rax
cmovsq %r10, %rax
addb $0x30, %al
movb %al, (%rdi,%r8)
incq %r8
addq $0x9, %rcx
cmpq $0x13, %rcx
movq %rdx, %rcx
jae 0x1fdf6
testq %rsi, %rsi
jns 0x1fe59
leaq -0x1(%r8), %rax
cmpq $0x3d, %rax
jae 0x1fea7
movb $0x2d, (%rdi,%r8)
incq %r8
leaq (%rdi,%r8), %rax
decq %rax
cmpq %rdi, %rax
jbe 0x1fe86
incq %rdi
movb -0x1(%rdi), %cl
movb (%rax), %dl
movb %dl, -0x1(%rdi)
movb %cl, (%rax)
decq %rax
leaq 0x1(%rdi), %rcx
cmpq %rax, %rdi
movq %rcx, %rdi
jb 0x1fe68
jmp 0x1fe86
movb $0x30, (%rdi)
popq %rax
retq
leaq 0x23eb(%rip), %rdi      # 0x2227a
leaq 0x1a24(%rip), %rsi      # 0x218ba
leaq 0x23e4(%rip), %rcx      # 0x22281
movl $0x2066, %edx           # imm = 0x2066
callq 0x6240
leaq 0x253f(%rip), %rdi      # 0x223ed
leaq 0x1a05(%rip), %rsi      # 0x218ba
leaq 0x23c5(%rip), %rcx      # 0x22281
movl $0x206b, %edx           # imm = 0x206B
callq 0x6240
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/net.cpp
// Function: Net::Net(std::vector<int, std::allocator<int>> const&, std::vector<Point, std::allocator<Point>> const&)
Net::Net(const vector<int>& macro_ids,
         const vector<Point>& terminal_coordinates)
    : min_x_(numeric_limits<double>::max()),
      min_y_(numeric_limits<double>::max()),
      max_x_(numeric_limits<double>::lowest()),
      max_y_(numeric_limits<double>::lowest()),
      macro_ids_(macro_ids) {
  for (const Point& terminal_coordinate : terminal_coordinates) {
    const double terminal_x = terminal_coordinate.x();
    const double terminal_y = terminal_coordinate.y();
    if (terminal_x < min_x_) {
      min_x_ = terminal_x;
    }
    if (terminal_y < min_y_) {
      min_y_ = terminal_y;
    }
    if (terminal_x > max_x_) {
      max_x_ = terminal_x;
    }
    if (terminal_y > max_y_) {
      max_y_ = terminal_y;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rdi, %rbx
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movabsq $-0x10000000000001, %rax # imm = 0xFFEFFFFFFFFFFFFF
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x14c3a
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x2030f
movq %r15, %rdi
callq 0x208dc
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x208e2
movsd (%rbx), %xmm1
ucomisd (%rsp), %xmm1
jbe 0x202dc
movsd (%rsp), %xmm1
movsd %xmm1, (%rbx)
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x202ec
movsd %xmm0, 0x8(%rbx)
movsd (%rsp), %xmm1
ucomisd 0x10(%rbx), %xmm1
jbe 0x202fd
movsd %xmm1, 0x10(%rbx)
ucomisd 0x18(%rbx), %xmm0
jbe 0x20309
movsd %xmm0, 0x18(%rbx)
addq $0x10, %r15
jmp 0x202ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2031d
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x20334
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x6390
movq %r15, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/net.cpp
// Function: Net::ComputeWirelength(std::vector<std::pair<Point, Point>, std::allocator<std::pair<Point, Point>>>) const
double Net::ComputeWirelength(
    vector<pair<Point, Point>> macro_bounding_box_by_id) const {
  double min_x = min_x_;
  double min_y = min_y_;
  double max_x = max_x_;
  double max_y = max_y_;
  for (int macro_id : macro_ids_) {
    auto bounding_box = macro_bounding_box_by_id.at(macro_id);
    Point center = Point::Center(bounding_box.first, bounding_box.second);
    double x = center.x();
    double y = center.y();
    if (x < min_x) {
      min_x = x;
    }
    if (x > max_x) {
      max_x = x;
    }
    if (y < min_y) {
      min_y = y;
    }
    if (y > max_y) {
      max_y = y;
    }
  }
  return Point::HPWL(Point(min_x, min_y), Point(max_x, max_y));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd (%rdi), %xmm3
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm5
movsd 0x18(%rdi), %xmm4
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %rbp
cmpq %rbp, %r13
je 0x2084e
movq %rsi, %rbx
leaq 0x50(%rsp), %r14
leaq 0x40(%rsp), %r15
leaq 0x30(%rsp), %r12
movsd %xmm5, 0x18(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x28(%rsp)
movsd %xmm2, 0x10(%rsp)
movslq (%r13), %rsi
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rdx
jbe 0x208a6
shlq $0x5, %rsi
movupd (%rax,%rsi), %xmm0
movups 0x10(%rax,%rsi), %xmm1
movaps %xmm1, 0x50(%rsp)
movapd %xmm0, 0x40(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x208e8
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x38(%rsp)
movq %r12, %rdi
callq 0x208dc
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x208e2
movapd %xmm0, %xmm6
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
minsd 0x28(%rsp), %xmm0
maxsd 0x18(%rsp), %xmm1
movapd %xmm1, %xmm5
movapd %xmm6, %xmm1
minsd 0x10(%rsp), %xmm1
maxsd 0x20(%rsp), %xmm6
addq $0x4, %r13
movapd %xmm0, %xmm3
movapd %xmm1, %xmm2
movsd %xmm5, 0x8(%rsp)
movapd %xmm6, %xmm4
cmpq %rbp, %r13
jne 0x20786
jmp 0x20860
movapd %xmm4, %xmm6
movsd %xmm5, 0x8(%rsp)
movapd %xmm2, %xmm1
movapd %xmm3, %xmm0
movsd %xmm6, 0x10(%rsp)
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x2090c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2090c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208b4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7dc(%rip), %rdi       # 0x21089
xorl %eax, %eax
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/point.cpp
// Function: Point::Print(std::ostream&, int) const
void Point::Print(ostream& os, int indent_level) const {
  const int indent_size = 2;
  os << string(indent_level * indent_size, ' ') << "Point:" << endl;
  ++indent_level;
  os << string(indent_level * indent_size, ' ') << "x_: " << x_ << endl;
  os << string(indent_level * indent_size, ' ') << "y_: " << y_ << 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
movl $0x20, %edx
callq 0x6410
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x63f0
movq %rax, %r15
leaq 0x22ab(%rip), %rsi      # 0x22c10
movl $0x6, %edx
movq %rax, %rdi
callq 0x63f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6370
movsbl %al, %esi
movq %r15, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6270
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x209b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
addl $0x2, %ebp
movslq %ebp, %r15
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq %r15, %rsi
movl $0x20, %edx
callq 0x6410
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x63f0
movq %rax, %r12
leaq 0x2230(%rip), %rsi      # 0x22c17
movl $0x4, %edx
movq %rax, %rdi
callq 0x63f0
movsd (%rbx), %xmm0
movq %r12, %rdi
callq 0x6580
movq %rax, %r12
movq (%rax), %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 %r13, %rdi
je 0x20a41
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq %r15, %rsi
movl $0x20, %edx
callq 0x6410
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x63f0
movq %rax, %r14
leaq 0x66e(%rip), %rsi       # 0x210e0
movl $0x4, %edx
movq %rax, %rdi
callq 0x63f0
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x6580
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6270
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x20acd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20ae0
jmp 0x20ae0
movq %rax, %rbx
jmp 0x20b03
jmp 0x20ae9
jmp 0x20ae9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x20b03
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/terminal.cpp
// Function: Terminal::Print(std::ostream&, int) const
void Terminal::Print(ostream& os, int indent_level) const {
  const int indent_size = 2;
  os << string(indent_level * indent_size, ' ') << "Terminal:" << endl;
  ++indent_level;
  os << string(indent_level * indent_size, ' ') << "name_: " << name_ << endl;
  os << string(indent_level * indent_size, ' ') << "coordinates_:" << endl;
  coordinates_.Print(os, indent_level + 1);
}

// 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 0x2053(%rip), %rsi      # 0x22c1c
movl $0x9, %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 0x20c15
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 0x118f(%rip), %rsi      # 0x21ddc
movl $0x7, %edx
movq %rax, %rdi
callq 0x63f0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r13, %rdi
callq 0x63f0
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 0x20caa
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 0x40a(%rip), %rsi       # 0x210e5
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 0x20d27
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
addq $0x20, %r15
addl $0x2, %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x20916
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20d4e
jmp 0x20d4e
movq %rax, %rbx
jmp 0x20d71
jmp 0x20d57
jmp 0x20d57
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x20d71
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O1/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: SeqNum::saveXml(std::ostream&) const
void SeqNum::saveXml(ostream &s) const

{
  s << "<seqnum";
  pc.getSpace()->saveXmlAttributes(s,pc.getOffset());
  a_v_u(s,"uniq",uniq);
  s << "/>";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3c3e6(%rip), %rsi     # 0x7f000
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b80
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3c3c0(%rip), %rsi     # 0x7f008
leaq 0x3c3bd(%rip), %rdx     # 0x7f00c
leaq 0x8(%rsp), %rdi
callq 0x3f8a0
movl 0x10(%r14), %r14d
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b80
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b80
movq %rax, %r15
leaq 0x3e424(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b80
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3ffb0
leaq 0x3e923(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b80
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x42ce8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
leaq 0x3d578(%rip), %rsi     # 0x80267
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b80
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x42d22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40870
movq %rbx, %rdi
callq 0x41f00