LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(std::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 0xfc6e
cmpl $0x1, %eax
je 0xfca4
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe972
leaq 0x11af2(%rip), %rsi     # 0x2172b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe901
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1d301(%rip), %rsi     # 0x2cf60
movq 0x1d32a(%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, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0xe5c8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xffde
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfcd6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfcf1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
testb %bpl, %bpl
jne 0xfd1b
jmp 0xfd23
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd1b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xfd1b
movq %rax, %r14
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::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 0xfdee
cmpl $0x2, %eax
je 0xfe16
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe972
leaq 0x11972(%rip), %rsi     # 0x2172b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe901
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x1d181(%rip), %rsi     # 0x2cf60
movq 0x1d1aa(%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 0xe5c8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x100a2
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 0xfe4c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfe67
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
testb %bpl, %bpl
jne 0xfe91
jmp 0xfe99
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfe91
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0xfe91
movq %rax, %r14
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1043a
leaq 0x8(%rsp), %r14
movb $0x0, (%r14)
movq %r14, %rdi
callq 0xe5c8
movq %r14, %rdi
callq 0xe5c8
movq %r14, %rdi
callq 0xe5c8
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 0xe5c8
movq %r14, %rdi
callq 0xe0aa
jmp 0x10442
movb $0x7, (%rbx)
movq %xmm0, 0x8(%rbx)
movq %rbx, %rdi
callq 0xe5c8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/./././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(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 0x14abc
cmpl $0x2, %eax
je 0x14ae4
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0xe972
leaq 0xcca4(%rip), %rsi      # 0x2172b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xe901
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
xorl %ebp, %ebp
movq 0x184b3(%rip), %rsi     # 0x2cf60
movq 0x184dc(%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 0xe5c8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x152b6
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14b16
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14b31
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
testb %bpl, %bpl
jne 0x14b5b
jmp 0x14b63
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14b5b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6390
jmp 0x14b5b
movq %rax, %r14
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/./././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::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 0x1542c
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x1541c
cmpl $0x1, %eax
jne 0x15423
movq 0x8(%rbx), %rdi
callq 0x63a0
movq %rax, 0x8(%rbx)
jmp 0x15427
addq $-0x10, 0x10(%rbx)
jmp 0x15427
decq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xc56a(%rip), %rdi      # 0x2199d
leaq 0xc550(%rip), %rsi      # 0x2198a
leaq 0xc6e4(%rip), %rcx      # 0x21b25
movl $0x23bc, %edx           # imm = 0x23BC
callq 0x6240
nop
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/./././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::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 0x154e3
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x154c6
cmpl $0x2, %ecx
je 0x15499
testl %ecx, %ecx
je 0x15502
cmpq $0x0, 0x18(%rdi)
je 0x154db
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
leaq 0xca08(%rip), %rsi      # 0x21e94
movq %rax, %rdi
callq 0x6090
jmp 0x1551e
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rcx), %rax
jne 0x154db
leaq 0xc9b0(%rip), %rdi      # 0x21e5e
leaq 0xc4d5(%rip), %rsi      # 0x2198a
leaq 0xc7e9(%rip), %rcx      # 0x21ca5
movl $0x2349, %edx           # imm = 0x2349
callq 0x6240
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0x15534
addq $0x40, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc4b3(%rip), %rdi      # 0x2199d
leaq 0xc499(%rip), %rsi      # 0x2198a
leaq 0xc7ad(%rip), %rcx      # 0x21ca5
movl $0x233d, %edx           # imm = 0x233D
callq 0x6240
movl $0x10, %edi
callq 0x61b0
movq %rax, %rbx
leaq 0xc97e(%rip), %rsi      # 0x21e94
movq %rax, %rdi
callq 0x6090
movq 0x17aa3(%rip), %rsi     # 0x2cfc8
movq 0x17a7c(%rip), %rdx     # 0x2cfa8
movq %rbx, %rdi
callq 0x6610
leaq 0xc8eb(%rip), %rdi      # 0x21e26
leaq 0xc448(%rip), %rsi      # 0x2198a
leaq 0xc75c(%rip), %rcx      # 0x21ca5
movl $0x2343, %edx           # imm = 0x2343
callq 0x6240
jmp 0x15555
movq %rax, %r14
movq %rbx, %rdi
callq 0x62a0
movq %r14, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/./././json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::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 0x155a0
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x1558a
cmpl $0x1, %ecx
jne 0x15597
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 0xc3f5(%rip), %rdi      # 0x2199d
leaq 0xc3db(%rip), %rsi      # 0x2198a
leaq 0xc3fb(%rip), %rcx      # 0x219b1
movl $0x231e, %edx           # imm = 0x231E
callq 0x6240
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f9cb
xorl %r8d, %r8d
movabsq $0x6666666666666667, %r9 # imm = 0x6666666666666667
movq %rsi, %rcx
cmpq $0x3f, %r8
je 0x1f9d0
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 0x1f93e
testq %rsi, %rsi
jns 0x1f9a1
leaq -0x1(%r8), %rax
cmpq $0x3d, %rax
jae 0x1f9ef
movb $0x2d, (%rdi,%r8)
incq %r8
leaq (%rdi,%r8), %rax
decq %rax
cmpq %rdi, %rax
jbe 0x1f9ce
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 0x1f9b0
jmp 0x1f9ce
movb $0x30, (%rdi)
popq %rax
retq
leaq 0x2973(%rip), %rdi      # 0x2234a
leaq 0x1fac(%rip), %rsi      # 0x2198a
leaq 0x296c(%rip), %rcx      # 0x22351
movl $0x2066, %edx           # imm = 0x2066
callq 0x6240
leaq 0x2ac7(%rip), %rdi      # 0x224bd
leaq 0x1f8d(%rip), %rsi      # 0x2198a
leaq 0x294d(%rip), %rcx      # 0x22351
movl $0x206b, %edx           # imm = 0x206B
callq 0x6240
// File: /workspace/github_cpp_makefile_star2_O3/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
movaps 0x2ec7(%rip), %xmm0     # 0x22ca0
movups %xmm0, (%rdi)
movapd 0x2ecc(%rip), %xmm0     # 0x22cb0
movupd %xmm0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x14ba4
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x1fe5f
movq %r15, %rdi
callq 0x20422
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x20428
movsd (%rbx), %xmm1
ucomisd (%rsp), %xmm1
jbe 0x1fe2c
movsd (%rsp), %xmm1
movsd %xmm1, (%rbx)
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1fe3c
movsd %xmm0, 0x8(%rbx)
movsd (%rsp), %xmm1
ucomisd 0x10(%rbx), %xmm1
jbe 0x1fe4d
movsd %xmm1, 0x10(%rbx)
ucomisd 0x18(%rbx), %xmm0
jbe 0x1fe59
movsd %xmm0, 0x18(%rbx)
addq $0x10, %r15
jmp 0x1fdfe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1fe6d
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1fe84
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x6390
movq %r15, %rdi
callq 0x6640
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2039e
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 0x203f6
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 0x2042e
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x38(%rsp)
movq %r12, %rdi
callq 0x20422
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x20428
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 0x202d6
jmp 0x203b0
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 0x2044c
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2044c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20404
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd38(%rip), %rdi       # 0x21135
xorl %eax, %eax
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O3/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 0x286b(%rip), %rsi      # 0x22d10
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 0x204f0
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 0x27f0(%rip), %rsi      # 0x22d17
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 0x20581
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 0xbda(%rip), %rsi       # 0x2118c
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 0x2060d
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 0x20620
jmp 0x20620
movq %rax, %rbx
jmp 0x20643
jmp 0x20629
jmp 0x20629
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x20643
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/harry830622[P]floorplanner/src/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 0x2613(%rip), %rsi      # 0x22d1c
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 0x20755
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 0x171f(%rip), %rsi      # 0x21eac
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 0x207ea
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 0x976(%rip), %rsi       # 0x21191
movl $0xd, %edx
movq %rax, %rdi
callq 0x63f0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6370
movsbl %al, %esi
movq %r12, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6270
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x20867
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
addq $0x20, %r15
addl $0x2, %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x20456
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2088e
jmp 0x2088e
movq %rax, %rbx
jmp 0x208b1
jmp 0x20897
jmp 0x20897
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x208b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6390
movq %rbx, %rdi
callq 0x6640
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c436(%rip), %rsi     # 0x7f000
movl $0x7, %edx
movq %rbx, %rdi
callq 0x40b90
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 0x3c410(%rip), %rsi     # 0x7f008
leaq 0x3c40d(%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 0x40b90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
movq %rax, %r15
leaq 0x3e474(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b90
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 0x3ffc0
leaq 0x3e973(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x42c98
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x3d5c8(%rip), %rsi     # 0x80267
movl $0x2, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x42cd2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: SeqNum::restoreXml(Element const*, AddrSpaceManager const*)
SeqNum SeqNum::restoreXml(const Element *el,const AddrSpaceManager *manage)

{
  uintm uniq = ~((uintm)0);
  Address pc = Address::restoreXml(el,manage); // Recover address
  for(int4 i=0;i<el->getNumAttributes();++i)
    if (el->getAttributeName(i) == "uniq") {
      istringstream s2(el->getAttributeValue(i)); // Recover unique (if present)
      s2.unsetf(ios::dec | ios::hex | ios::oct);
      s2 >> uniq;
      break;
    }
  return SeqNum(pc,uniq);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x42060
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rbp
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rax
subq %rdi, %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x42db4
xorl %r15d, %r15d
leaq 0x3c2d5(%rip), %r12     # 0x7f008
xorl %r13d, %r13d
addq %r15, %rdi
movq %r12, %rsi
callq 0x3f590
testl %eax, %eax
je 0x42d64
incq %r13
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rax
subq %rdi, %rax
shrq $0x5, %rax
cltq
addq $0x20, %r15
cmpq %rax, %r13
jl 0x42d36
jmp 0x42db4
addq 0x58(%r14), %r15
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x41c90
movq (%r14), %rax
movq -0x18(%rax), %rax
andl $-0x4b, 0x30(%rsp,%rax)
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x41ec0
movq 0x5ff73(%rip), %rsi     # 0xa2d10
leaq 0x18(%rsp), %rdi
callq 0x41450
leaq 0x90(%rsp), %rdi
callq 0x3f730
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq %rcx, (%rbx)
movq %rbp, 0x8(%rbx)
movl %eax, 0x10(%rbx)
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x5ff2a(%rip), %rsi     # 0xa2d10
leaq 0x18(%rsp), %rdi
callq 0x41450
leaq 0x90(%rsp), %rdi
callq 0x3f730
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::containedBy(int, Address const&, int) const
bool Address::containedBy(int4 sz,const Address &op2,int4 sz2) const

{
  if (base != op2.base) return false;
  if (op2.offset > offset) return false;
  uintb off1 = offset + (sz-1);
  uintb off2 = op2.offset + (sz2-1);
  return (off2 >= off1);
}

// Assembly:
movq (%rdi), %rax
cmpq (%rdx), %rax
jne 0x42e73
movq 0x8(%rdx), %rax
movq 0x8(%rdi), %rdx
cmpq %rdx, %rax
jbe 0x42e76
xorl %eax, %eax
retq
movslq %esi, %rsi
addq %rsi, %rdx
decq %rdx
movslq %ecx, %rcx
addq %rcx, %rax
decq %rax
cmpq %rdx, %rax
setae %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::justifiedContain(int, Address const&, int, bool) const
int4 Address::justifiedContain(int4 sz,const Address &op2,int4 sz2,bool forceleft) const

{ if (base != op2.base) return -1;
  if (op2.offset < offset) return -1;
  uintb off1 = offset + (sz-1);
  uintb off2 = op2.offset + (sz2-1);
  if (off2 > off1) return -1;
  if (base->isBigEndian()&&(!forceleft)) {
    return (int4)(off1 - off2);
  }
  return (int4)(op2.offset - offset);
}

// Assembly:
movq (%rdi), %r9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq (%rdx), %r9
je 0x42e9e
retq
movq 0x8(%rdx), %rdx
movq 0x8(%rdi), %rdi
cmpq %rdi, %rdx
jb 0x42e9d
movslq %esi, %rsi
addq %rdi, %rsi
decq %rsi
movslq %ecx, %rcx
addq %rdx, %rcx
decq %rcx
cmpq %rcx, %rsi
jb 0x42e9d
testb $0x1, 0x24(%r9)
sete %al
orb %r8b, %al
je 0x42ed4
subl %edi, %edx
movl %edx, %eax
retq
subl %ecx, %esi
movl %esi, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::overlap(int, Address const&, int) const
int4 Address::overlap(int4 skip,const Address &op,int4 size) const

{
  uintb dist;

  if (base != op.base) return -1; // Must be in same address space to overlap
  if (base->getType()==IPTR_CONSTANT) return -1; // Must not be constants

  dist = base->wrapOffset(offset+skip-op.offset);

  if (dist >= size) return -1; // but must fall before op+size
  return (int4) dist;
}

// Assembly:
movq (%rdi), %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpq (%rdx), %r9
jne 0x42f22
cmpl $0x0, 0x8(%r9)
je 0x42f22
movslq %esi, %rax
addq 0x8(%rdi), %rax
subq 0x8(%rdx), %rax
movq 0x28(%r9), %rsi
cmpq %rax, %rsi
jae 0x42f18
incq %rsi
cqto
idivq %rsi
movq %rdx, %rax
sarq $0x3f, %rax
andq %rsi, %rax
addq %rdx, %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
cmovbl %eax, %r8d
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Address::isContiguous(int, Address const&, int) const
bool Address::isContiguous(int4 sz,const Address &loaddr,int4 losz) const

{
  if (base != loaddr.base) return false;
  if (base->isBigEndian()) {
    uintb nextoff = base->wrapOffset(offset+sz);
    if (nextoff == loaddr.offset) return true;
  }
  else {
    uintb nextoff = base->wrapOffset(loaddr.offset+losz);
    if (nextoff == offset) return true;
  }
  return false;
}

// Assembly:
movq (%rdi), %rax
cmpq (%rdx), %rax
je 0x42f33
xorl %edx, %edx
movl %edx, %eax
retq
movq %rdx, %r8
testb $0x1, 0x24(%rax)
movq 0x28(%rax), %r9
jne 0x42f6b
movslq %ecx, %rax
addq 0x8(%r8), %rax
cmpq %rax, %r9
jae 0x42f61
incq %r9
cqto
idivq %r9
movq %rdx, %rax
sarq $0x3f, %rax
andq %r9, %rax
addq %rdx, %rax
movb $0x1, %dl
cmpq 0x8(%rdi), %rax
jne 0x42f2e
jmp 0x42f30
movslq %esi, %rax
addq 0x8(%rdi), %rax
cmpq %rax, %r9
jae 0x42f8c
incq %r9
cqto
idivq %r9
movq %rdx, %rax
sarq $0x3f, %rax
andq %r9, %rax
addq %rdx, %rax
movb $0x1, %dl
cmpq 0x8(%r8), %rax
jne 0x42f2e
jmp 0x42f30
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Range::getLastAddrOpen(AddrSpaceManager const*) const
Address Range::getLastAddrOpen(const AddrSpaceManager *manage) const

{
  AddrSpace *curspc = spc;
  uintb curlast = last;
  if (curlast == curspc->getHighest()) {
    curspc = manage->getNextSpaceInOrder(curspc);
    curlast = 0;
  }
  else
    curlast += 1;
  if (curspc == (AddrSpace *)0)
    return Address(Address::m_maximal);
  return Address(curspc,curlast);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
cmpq 0x28(%rax), %rcx
jne 0x42ff3
movq %rdx, %rdi
movq %rax, %rsi
callq 0x40100
testq %rax, %rax
je 0x43002
xorl %ecx, %ecx
jmp 0x42ff6
incq %rcx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f320
jmp 0x42ffd
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: Range::saveXml(std::ostream&) const
void Range::saveXml(ostream &s) const

{
  s << "<range";
  a_v(s,"space",spc->getName());
  a_v_u(s,"first",first);
  a_v_u(s,"last",last);
  s << "/>\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3bf63(%rip), %rsi     # 0x7f00d
movl $0x6, %edx
movq %rbx, %rdi
callq 0x40b90
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3ca56(%rip), %rsi     # 0x7fb1d
leaq 0x3ca54(%rip), %rdx     # 0x7fb22
leaq 0x10(%rsp), %rdi
callq 0x3f8a0
movq (%r14), %r15
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
leaq 0x3e64f(%rip), %rsi     # 0x81758
movl $0x2, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x3f3d0
leaq 0x3e4be(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4314d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x3beb8(%rip), %rsi     # 0x7f014
leaq 0x3beb6(%rip), %rdx     # 0x7f019
callq 0x3f8a0
movq 0x8(%r14), %r15
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
movq %rax, %r12
leaq 0x3df15(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b90
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r12,%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ffc0
leaq 0x3e413(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x431f8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x3be13(%rip), %rsi     # 0x7f01a
leaq 0x3be10(%rip), %rdx     # 0x7f01e
callq 0x3f8a0
movq 0x10(%r14), %r14
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x40b90
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rdi
callq 0x40b90
movq %rax, %r15
leaq 0x3de6a(%rip), %rsi     # 0x810b2
movl $0x4, %edx
movq %rax, %rdi
callq 0x40b90
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 0x3ffc0
leaq 0x3e369(%rip), %rsi     # 0x815e7
movl $0x1, %edx
movq %rax, %rdi
callq 0x40b90
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x432a2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
leaq 0x3d56c(%rip), %rsi     # 0x80815
movl $0x3, %edx
movq %rbx, %rdi
callq 0x40b90
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x432c8
jmp 0x432c8
movq %rax, %rbx
jmp 0x432eb
jmp 0x432d1
jmp 0x432d1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x432eb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40880
movq %rbx, %rdi
callq 0x41f10
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::insertRange(AddrSpace*, unsigned long, unsigned long)
void RangeList::insertRange(AddrSpace *spc,uintb first,uintb last)

{
  set<Range>::iterator iter1,iter2;

  // we must have iter1.first > first
  iter1 = tree.upper_bound(Range(spc,first,first));

  // Set iter1 to first range with range.last >=first
  // It is either current iter1 or the one before
  if (iter1 != tree.begin()) {
    --iter1;
    if (((*iter1).spc!=spc)||((*iter1).last < first))
      ++iter1;
  }

  // Set iter2 to first range with range.first > last
  iter2 = tree.upper_bound(Range(spc,last,last));
  
  while(iter1!=iter2) {
    if ((*iter1).first < first)
      first = (*iter1).first;
    if ((*iter1).last > last)
      last = (*iter1).last;
    tree.erase(iter1++);
  }
  tree.insert(Range(spc,first,last));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq 0x10(%rdi), %rbp
leaq 0x8(%rdi), %r12
movq %r12, %r13
testq %rbp, %rbp
je 0x4367a
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
movq %rbp, %rcx
movq %r12, %r13
xorl %edx, %edx
cmpq %r15, 0x28(%rcx)
seta %dl
movq 0x20(%rcx), %rsi
xorl %edi, %edi
cmpl 0x60(%rsi), %eax
setl %dil
cmovel %edx, %edi
testb %dil, %dil
cmovneq %rcx, %r13
xorb $0x1, %dil
movzbl %dil, %edx
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x43648
cmpq 0x18(%r14), %r13
je 0x436a7
movq %r13, %rdi
callq 0x3fe70
movq %rax, %r13
movq 0x8(%rsp), %rax
cmpq %rax, 0x20(%r13)
jne 0x4369c
cmpq %r15, 0x30(%r13)
jae 0x436a7
movq %r13, %rdi
callq 0x40bd0
movq %rax, %r13
testq %rbp, %rbp
je 0x436e6
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
xorl %ecx, %ecx
cmpq %rbx, 0x28(%rbp)
seta %cl
movq 0x20(%rbp), %rdx
xorl %esi, %esi
cmpl 0x60(%rdx), %eax
setl %sil
cmovel %ecx, %esi
testb %sil, %sil
cmovneq %rbp, %r12
xorb $0x1, %sil
movzbl %sil, %ecx
movq 0x10(%rbp,%rcx,8), %rbp
testq %rbp, %rbp
jne 0x436b4
cmpq %r12, %r13
je 0x4371f
movq 0x28(%r13), %rax
movq 0x30(%r13), %rcx
cmpq %r15, %rax
cmovbq %rax, %r15
cmpq %rbx, %rcx
cmovaq %rcx, %rbx
movq %r13, %rdi
callq 0x40bd0
movq %rax, %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x40300
movq %rbp, %r13
cmpq %r12, %rbp
jne 0x436eb
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, 0x10(%rsi)
movq %r14, %rdi
callq 0x41920
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::removeRange(AddrSpace*, unsigned long, unsigned long)
void RangeList::removeRange(AddrSpace *spc,uintb first,uintb last)

{				// remove a range
  set<Range>::iterator iter1,iter2;

  if (tree.empty()) return;	// Nothing to do

  // we must have iter1.first > first
  iter1 = tree.upper_bound(Range(spc,first,first));

  // Set iter1 to first range with range.last >=first
  // It is either current iter1 or the one before
  if (iter1 != tree.begin()) {
    --iter1;
    if (((*iter1).spc!=spc)||((*iter1).last < first))
      ++iter1;
  }

  // Set iter2 to first range with range.first > last
  iter2 = tree.upper_bound(Range(spc,last,last));
  
  while(iter1!=iter2) {
    uintb a,b;

    a = (*iter1).first;
    b = (*iter1).last;
    tree.erase(iter1++);
    if (a <first)
      tree.insert(Range(spc,a,first-1));
    if (b > last)
      tree.insert(Range(spc,last+1,b));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x28(%rdi)
je 0x438ea
movq %rcx, %r12
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r15
leaq 0x8(%rax), %rbp
movq %rbp, %r13
testq %r15, %r15
movq 0x18(%rsp), %rbx
je 0x437d1
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
movq %r15, %rcx
movq %rbp, %r13
xorl %edx, %edx
cmpq %rbx, 0x28(%rcx)
seta %dl
movq 0x20(%rcx), %rsi
xorl %edi, %edi
cmpl 0x60(%rsi), %eax
setl %dil
cmovel %edx, %edi
testb %dil, %dil
cmovneq %rcx, %r13
xorb $0x1, %dil
movzbl %dil, %edx
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x4379f
movq 0x10(%rsp), %rax
cmpq 0x18(%rax), %r13
je 0x43803
movq %r13, %rdi
callq 0x3fe70
movq %rax, %r13
movq 0x8(%rsp), %rax
cmpq %rax, 0x20(%r13)
jne 0x437f8
cmpq %rbx, 0x30(%r13)
jae 0x43803
movq %r13, %rdi
callq 0x40bd0
movq %rax, %r13
testq %r15, %r15
je 0x43842
movq 0x8(%rsp), %rax
movl 0x60(%rax), %eax
xorl %ecx, %ecx
cmpq %r12, 0x28(%r15)
seta %cl
movq 0x20(%r15), %rdx
xorl %esi, %esi
cmpl 0x60(%rdx), %eax
setl %sil
cmovel %ecx, %esi
testb %sil, %sil
cmovneq %r15, %rbp
xorb $0x1, %sil
movzbl %sil, %ecx
movq 0x10(%r15,%rcx,8), %r15
testq %r15, %r15
jne 0x43810
cmpq %rbp, %r13
je 0x438ea
movq 0x18(%rsp), %rax
decq %rax
movq %rax, 0x40(%rsp)
leaq 0x1(%r12), %rax
movq %rax, 0x38(%rsp)
movq 0x28(%r13), %r14
movq 0x30(%r13), %rbx
movq %r13, %rdi
callq 0x40bd0
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x40300
cmpq 0x18(%rsp), %r14
jae 0x438b1
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x41920
cmpq %r12, %rbx
jbe 0x438de
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x41920
movq %r15, %r13
cmpq %rbp, %r15
jne 0x43862
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::merge(RangeList const&)
void RangeList::merge(const RangeList &op2)

{ // Merge -op2- into this rangelist
  set<Range>::const_iterator iter1,iter2;
  iter1 = op2.tree.begin();
  iter2 = op2.tree.end();
  while(iter1 != iter2) {
    const Range &range( *iter1 );
    ++iter1;
    insertRange(range.spc, range.first, range.last);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x4393c
movq %rdi, %r14
movq %r15, %rdi
callq 0x40bd0
movq %rax, %r12
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rcx
movq %r14, %rdi
callq 0x3fd30
movq %r12, %r15
cmpq %rbx, %r12
jne 0x43915
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jstaursky[P]hutch/src/Sleigh/address.cc
// Function: RangeList::getLastSignedRange(AddrSpace*) const
const Range *RangeList::getLastSignedRange(AddrSpace *spaceid) const

{
  uintb midway = spaceid->getHighest() / 2;		// Maximal signed value
  Range range(spaceid,midway,midway);
  set<Range>::const_iterator iter = tree.upper_bound(range);	// First element greater than -range- (should be MOST negative)

  if (iter!=tree.begin()) {
    --iter;
    if ((*iter).getSpace() == spaceid)
      return &(*iter);
  }

  // If there were no "positive" ranges, search for biggest negative range
  range = Range(spaceid,spaceid->getHighest(),spaceid->getHighest());
  iter = tree.upper_bound(range);
  if (iter != tree.begin()) {
    --iter;
    if ((*iter).getSpace() == spaceid)
      return &(*iter);
  }
  return (const Range *)0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rsi), %r15
movq 0x10(%rdi), %r12
leaq 0x8(%rdi), %r14
movq %r14, %rax
testq %r12, %r12
je 0x43bd4
movq %r15, %rcx
shrq %rcx
movl 0x60(%rbx), %edx
movq %r12, %rsi
movq %r14, %rax
movq 0x20(%rsi), %r8
xorl %r9d, %r9d
cmpq 0x28(%rsi), %rcx
setb %r9b
xorl %r10d, %r10d
cmpl 0x60(%r8), %edx
setl %r10b
cmovel %r9d, %r10d
testb %r10b, %r10b
cmovneq %rsi, %rax
xorb $0x1, %r10b
movzbl %r10b, %r8d
movq 0x10(%rsi,%r8,8), %rsi
testq %rsi, %rsi
jne 0x43b9d
movq 0x18(%rdi), %r13
cmpq %r13, %rax
je 0x43beb
movq %rax, %rdi
callq 0x3fe70
cmpq %rbx, 0x20(%rax)
je 0x43c4b
testq %r12, %r12
je 0x43c27
movl 0x60(%rbx), %eax
movq 0x20(%r12), %rcx
xorl %edx, %edx
cmpq 0x28(%r12), %r15
setb %dl
xorl %esi, %esi
cmpl 0x60(%rcx), %eax
setl %sil
cmovel %edx, %esi
testb %sil, %sil
cmovneq %r12, %r14
xorb $0x1, %sil
movzbl %sil, %ecx
movq 0x10(%r12,%rcx,8), %r12
testq %r12, %r12
jne 0x43bf3
cmpq %r13, %r14
je 0x43c47
movq %r14, %rdi
callq 0x3fe70
movq %rax, %rcx
leaq 0x20(%rax), %rdx
xorl %eax, %eax
cmpq %rbx, 0x20(%rcx)
cmoveq %rdx, %rax
jmp 0x43c4f
xorl %eax, %eax
jmp 0x43c4f
addq $0x20, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop