LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::JSON(JSON&&)
inline
JSON::JSON(JSON && rhs)
  :m_data(0), m_type(no_type)  
{
    // copy the resource from rhs to current data
    memcpy(&m_data, &(rhs.m_data), sizeof(m_data));
    m_type = rhs.m_type;

    // set the rhs data to zero
    memset(&(rhs.m_data), 0, sizeof(rhs.m_data));
    rhs.m_type = no_type;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0xadb0
movq (%rsp), %rdi
movl $0x0, 0x28(%rdi)
movq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x31f0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3120
movq 0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/move/move.hpp
// Function: JSON* boost::move<JSON*, JSON*>(JSON*, JSON*, JSON*)
O move(I f, I l, O result)
   {
      while (f != l) {
         *result = ::boost::move(*f);
         ++f; ++result;
      }
      return result;
   }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0xae80
movq 0x10(%rsp), %rdi
callq 0xac90
movq %rax, %rsi
movq (%rsp), %rdi
callq 0x6630
movq 0x10(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
addq $0x30, %rax
movq %rax, (%rsp)
jmp 0xae42
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/destroyers.hpp
// Function: boost::container::container_detail::scoped_destructor_n<std::allocator<JSON>>::~scoped_destructor_n()
~scoped_destructor_n()
   {
      if(!m_p) return;
      value_type *raw_ptr = container_detail::to_raw_pointer(m_p);
      for(size_type i = 0; i < m_n; ++i, ++raw_ptr)
         AllocTraits::destroy(m_a, raw_ptr);
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0xaf0b
jmp 0xaf6b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x85b0
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq 0x10(%rcx), %rax
jae 0xaf6b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xaf80
jmp 0xaf4b
jmp 0xaf4d
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x18(%rsp)
jmp 0xaf26
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x88a0
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/unique.hpp
// Function: boost::unordered::detail::table_impl<boost::unordered::detail::map<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, JSON, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
value_type& operator[](key_type const& k)
        {
            typedef typename value_type::second_type mapped_type;
    
            std::size_t key_hash = this->hash(k);
            iterator pos = this->find_node(key_hash, k);
    
            if (pos.node_) return *pos;
    
            // Create the node before rehashing in case it throws an
            // exception (need strong safety in such a case).
            node_constructor a(this->node_alloc());
            a.construct_node();

            a.construct_value(BOOST_UNORDERED_EMPLACE_ARGS3(
                boost::unordered::piecewise_construct,
                boost::make_tuple(k),
                boost::make_tuple()));
    
            this->reserve_for_insert(this->size_ + 1);
            return *add_node(a, key_hash);
        }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x90(%rsp), %rsi
callq 0xb310
movq 0x20(%rsp), %rdi
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0xb340
movq %rax, 0x80(%rsp)
cmpq $0x0, 0x80(%rsp)
je 0xb1f0
leaq 0x80(%rsp), %rdi
callq 0xb3c0
movq %rax, 0xa0(%rsp)
jmp 0xb2f3
movq 0x20(%rsp), %rdi
callq 0xb3e0
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xb400
movq 0x18(%rsp), %rdi
callq 0xb430
jmp 0xb218
movq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xb5d0
jmp 0xb22c
callq 0xb600
jmp 0xb233
leaq 0x6dda(%rip), %rsi      # 0x12014
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rdx
leaq 0x37(%rsp), %rcx
callq 0xb4b0
jmp 0xb250
leaq 0x38(%rsp), %rdi
callq 0xb610
movq 0x20(%rsp), %rdi
movq 0x10(%rdi), %rsi
incq %rsi
callq 0xb620
jmp 0xb26d
movq 0x20(%rsp), %rdi
movq 0x88(%rsp), %rdx
leaq 0x68(%rsp), %rsi
callq 0xb720
movq %rax, 0x10(%rsp)
jmp 0xb28b
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb3c0
movq %rax, 0x8(%rsp)
jmp 0xb2a6
movq 0x8(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xb920
jmp 0xb2f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb2e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb610
leaq 0x68(%rsp), %rdi
callq 0xb920
jmp 0xb303
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x33e0
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: boost::unordered::detail::node_constructor<std::allocator<boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>>>::construct_node()
void node_constructor<Alloc>::construct_node()
    {
        if(!node_) {
            constructed_ = false;
            node_ = node_allocator_traits::allocate(alloc_, 1);
        }
        else if (constructed_) {
            boost::unordered::detail::destroy_node(alloc_,
                boost::addressof(*node_));
            constructed_ = false;
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0xb46e
movq 0x8(%rsp), %rax
movb $0x0, 0x10(%rax)
movq (%rax), %rdi
movl $0x1, %esi
callq 0xc180
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb4a5
movq 0x8(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0xb4a3
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rdi
callq 0xc1e0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc1b0
movq 0x8(%rsp), %rax
movb $0x0, 0x10(%rax)
jmp 0xb4a5
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/table.hpp
// Function: boost::unordered::detail::table<boost::unordered::detail::map<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, JSON, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reserve_for_insert(unsigned long)
inline void table<Types>::reserve_for_insert(std::size_t size)
    {
        if (!this->buckets_) {
            this->bucket_count_ = (std::max)(this->bucket_count_,
                this->min_buckets_for_size(size));
            this->create_buckets();
            this->max_load_ = this->calculate_max_load();
        }
        // According to the standard this should be 'size >= max_load_',
        // but I think this is better, defect report filed.
        else if(size > max_load_) {
            std::size_t num_buckets
                = this->min_buckets_for_size((std::max)(size,
                    this->size_ + (this->size_ >> 1)));
            if (num_buckets != this->bucket_count_) {
                static_cast<table_impl*>(this)->rehash_impl(num_buckets);
                this->max_load_ = this->calculate_max_load();
            }
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0xb697
movq 0x8(%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
callq 0xc7f0
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xc7b0
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rdi)
callq 0xc890
movq 0x8(%rsp), %rdi
callq 0xc930
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0xb719
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
cmpq 0x20(%rcx), %rax
jbe 0xb717
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq 0x10(%rcx), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc7b0
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xc7f0
movq 0x8(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rcx), %rax
je 0xb715
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xc980
movq 0x8(%rsp), %rdi
callq 0xc930
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0xb717
jmp 0xb719
addq $0x38, %rsp
retq
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: boost::unordered::detail::node_constructor<std::allocator<boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>>>::~node_constructor()
node_constructor<Alloc>::~node_constructor()
    {
        if (node_) {
            if (constructed_) {
                boost::unordered::detail::destroy_node(alloc_,
                    boost::addressof(*node_));
            }

            node_allocator_traits::deallocate(alloc_, node_, 1);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0xb984
movq 0x8(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0xb96a
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rdi
callq 0xc1e0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc1b0
jmp 0xb968
jmp 0xb96a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0xd880
jmp 0xb982
jmp 0xb984
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x88a0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: unsigned long boost::unordered::detail::mix64_policy<unsigned long>::apply_hash<boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(boost::hash<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 inline SizeT apply_hash(Hash const& hf, T const& x) {
            SizeT key = hf(x);
            key = (~key) + (key << 21); // key = (key << 21) - key - 1;
            key = key ^ (key >> 24);
            key = (key + (key << 3)) + (key << 8); // key * 265
            key = key ^ (key >> 14);
            key = (key + (key << 2)) + (key << 4); // key * 21
            key = key ^ (key >> 28);
            key = key + (key << 31);
            return key;
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xba90
movq %rax, (%rsp)
movq (%rsp), %rax
xorq $-0x1, %rax
movq (%rsp), %rcx
shlq $0x15, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rsp), %rcx
shrq $0x18, %rcx
xorq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rsp), %rcx
shrq $0xe, %rcx
xorq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rsp), %rcx
shrq $0x1c, %rcx
xorq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rsp), %rcx
shlq $0x1f, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/allocate.hpp
// Function: boost::enable_if<boost::unordered::detail::piecewise3<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON, boost::unordered::piecewise_construct_t const&>, void>::type boost::unordered::detail::construct_impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON, boost::unordered::piecewise_construct_t const&, boost::tuples::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>, boost::tuples::tuple<boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>>(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>*, boost::unordered::piecewise_construct_t const&, boost::tuples::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>&&, boost::tuples::tuple<boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>&&)
inline typename enable_if<piecewise3<A, B, A0>, void>::type
        construct_impl(std::pair<A, B>* address,
            BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
    {
        boost::unordered::detail::construct_from_tuple(
            boost::addressof(address->first), boost::forward<A1>(a1));
        boost::unordered::detail::construct_from_tuple(
            boost::addressof(address->second), boost::forward<A2>(a2));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc630
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc3e0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc5f0
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
callq 0xc660
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc3f0
movq 0x8(%rsp), %rdi
callq 0xc640
addq $0x38, %rsp
retq
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/table.hpp
// Function: boost::unordered::detail::table<boost::unordered::detail::map<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, JSON, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::min_buckets_for_size(unsigned long) const
std::size_t min_buckets_for_size(std::size_t size) const
        {
            BOOST_ASSERT(this->mlf_ >= minimum_max_load_factor);
    
            using namespace std;
    
            // From 6.3.1/13:
            // size < mlf_ * count
            // => count > size / mlf_
            //
            // Or from rehash post-condition:
            // count > size / mlf_

            return policy::new_bucket_count(
                boost::unordered::detail::double_to_size(floor(
                    static_cast<double>(size) /
                    static_cast<double>(mlf_))) + 1);
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movss 0x1c(%rax), %xmm0
movss 0x582c(%rip), %xmm1     # 0x12040
ucomiss %xmm1, %xmm0
jb 0xc81b
jmp 0xc83a
leaq 0x5e15(%rip), %rdi      # 0x12637
leaq 0x5e34(%rip), %rsi      # 0x1265d
movl $0x8b, %edx
leaq 0x5e56(%rip), %rcx      # 0x1268b
callq 0x3160
movq (%rsp), %rax
movaps 0x580b(%rip), %xmm1     # 0x12050
movq 0x8(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x5809(%rip), %xmm1     # 0x12060
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movss 0x1c(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x33b0
callq 0xcbb0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xcb00
addq $0x18, %rsp
retq
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: boost::unordered::detail::buckets<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::ptr_bucket, boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::mix64_policy<unsigned long>>::create_buckets()
void create_buckets()
        {
            boost::unordered::detail::array_constructor<bucket_allocator>
                constructor(bucket_alloc());
    
            // Creates an extra bucket to act as the start node.
            constructor.construct(bucket(), this->bucket_count_ + 1);
    
            if (bucket::extra_node)
            {
                node_constructor a(this->node_alloc());
                a.construct_node();

                // Since this node is just to mark the beginning it doesn't
                // contain a value, so just construct node::node_base
                // which containers the pointer to the next element.
                node_allocator_traits::construct(node_alloc(),
                    static_cast<typename node::node_base*>(
                        boost::addressof(*a.get())),
                    typename node::node_base());

                (constructor.get() +
                    static_cast<std::ptrdiff_t>(this->bucket_count_))->next_ =
                        a.release();
            }

            this->buckets_ = constructor.release();
        }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xcc60
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0xcc80
leaq 0x28(%rsp), %rdi
callq 0xcda0
jmp 0xc8c1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
incq %rdx
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xccc0
jmp 0xc8de
leaq 0x30(%rsp), %rdi
callq 0xcdc0
movq %rax, 0x8(%rsp)
jmp 0xc8ef
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x30(%rsp), %rdi
callq 0xcdf0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xcdf0
movq 0x20(%rsp), %rdi
callq 0x33e0
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/table.hpp
// Function: boost::unordered::detail::table<boost::unordered::detail::map<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, JSON, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::calculate_max_load()
std::size_t calculate_max_load()
        {
            using namespace std;
    
            // From 6.3.1/13:
            // Only resize when size >= mlf_ * count
            return boost::unordered::detail::double_to_size(ceil(
                    static_cast<double>(this->mlf_) *
                    static_cast<double>(this->bucket_count_)
                ));

        }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x8(%rax), %xmm1
movaps 0x5702(%rip), %xmm2     # 0x12050
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x5706(%rip), %xmm2     # 0x12060
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x3050
callq 0xcbb0
popq %rcx
retq
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/unique.hpp
// Function: boost::unordered::detail::table_impl<boost::unordered::detail::map<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, JSON, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::rehash_impl(unsigned long)
void rehash_impl(std::size_t num_buckets)
        {
            BOOST_ASSERT(this->size_);

            buckets dst(this->node_alloc(), num_buckets);
            dst.create_buckets();

            previous_pointer src_start = this->get_previous_start();
            previous_pointer dst_start = dst.get_previous_start();

            dst_start->next_ = src_start->next_;
            src_start->next_ = link_pointer();
            dst.size_ = this->size_;
            this->size_ = 0;

            previous_pointer prev = dst.get_previous_start();
            while (prev->next_)
                prev = place_in_bucket(dst, prev);

            // Swap the new nodes back into the container and setup the
            // variables.
            dst.swap(*this); // no throw
        }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x10(%rax)
je 0xc9ad
jmp 0xc9cc
leaq 0x6460(%rip), %rdi      # 0x12e14
leaq 0x5fdc(%rip), %rsi      # 0x12997
movl $0x2d7, %edx            # imm = 0x2D7
leaq 0x5fff(%rip), %rcx      # 0x129c6
callq 0x3160
movq 0x30(%rsp), %rdi
callq 0xb3e0
movq %rax, %rsi
movq 0x88(%rsp), %rdx
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xd090
movq 0x28(%rsp), %rdi
callq 0xc890
jmp 0xc9fc
movq 0x30(%rsp), %rdi
callq 0xd0e0
movq %rax, 0x20(%rsp)
jmp 0xca0d
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd0e0
movq %rax, 0x18(%rsp)
jmp 0xca28
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq 0x50(%rsp), %rcx
movq (%rcx), %rdx
movq 0x48(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x50(%rsp), %rcx
movq $0x0, (%rcx)
movq 0x10(%rax), %rcx
movq %rcx, 0x78(%rsp)
movq $0x0, 0x10(%rax)
leaq 0x68(%rsp), %rdi
callq 0xd0e0
movq %rax, 0x10(%rsp)
jmp 0xca75
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
je 0xcac6
movq 0x40(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0xd100
movq %rax, 0x8(%rsp)
jmp 0xcaa0
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xca7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd2d0
jmp 0xcae9
movq 0x30(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0xd230
jmp 0xcad7
leaq 0x68(%rsp), %rdi
callq 0xd2d0
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: boost::unordered::detail::mix64_policy<unsigned long>::new_bucket_count(unsigned long)
static inline SizeT new_bucket_count(SizeT min) {
            if (min <= 4) return 4;
            --min;
            min |= min >> 1;
            min |= min >> 2;
            min |= min >> 4;
            min |= min >> 8;
            min |= min >> 16;
            min |= min >> 32;
            return min + 1;
        }

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x4, -0x10(%rsp)
ja 0xcb1b
movq $0x4, -0x8(%rsp)
jmp 0xcba8
movq -0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x2, %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x4, %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/table.hpp
// Function: boost::unordered::detail::double_to_size(double)
inline std::size_t double_to_size(double f)
    {
        return f >= static_cast<double>(
            (std::numeric_limits<std::size_t>::max)()) ?
            (std::numeric_limits<std::size_t>::max)() :
            static_cast<std::size_t>(f);
    }

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xcc50
movsd 0x8(%rsp), %xmm0
movq %rax, %xmm1
movaps 0x5473(%rip), %xmm2     # 0x12050
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x5477(%rip), %xmm2     # 0x12060
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0xcc09
callq 0xcc50
movq %rax, (%rsp)
jmp 0xcc39
movsd 0x10(%rsp), %xmm0
movsd 0x5459(%rip), %xmm2     # 0x12070
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/allocate.hpp
// Function: void boost::unordered::detail::array_constructor<std::allocator<boost::unordered::detail::ptr_bucket>>::construct<boost::unordered::detail::ptr_bucket>(boost::unordered::detail::ptr_bucket const&, unsigned long)
void construct(V const& v, std::size_t l)
        {
            BOOST_ASSERT(!ptr_);
            length_ = l;
            ptr_ = traits::allocate(alloc_, length_);
            pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
            for(constructed_ = ptr_; constructed_ != end; ++constructed_)
                traits::construct(alloc_, boost::addressof(*constructed_), v);
        }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xcced
jmp 0xccef
jmp 0xcd0e
leaq 0x5b73(%rip), %rdi      # 0x12869
leaq 0x5b72(%rip), %rsi      # 0x1286f
movl $0x4bf, %edx            # imm = 0x4BF
leaq 0x5b97(%rip), %rcx      # 0x128a0
callq 0x3160
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq (%rax), %rdi
movq 0x18(%rax), %rsi
callq 0xceb0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x18(%rsp), %rax
je 0xcd9b
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rdi
callq 0xcf30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
callq 0xcee0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
jmp 0xcd50
addq $0x38, %rsp
retq
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/allocate.hpp
// Function: boost::unordered::detail::array_constructor<std::allocator<boost::unordered::detail::ptr_bucket>>::~array_constructor()
~array_constructor() {
            if (ptr_) {
                for(pointer p = ptr_; p != constructed_; ++p)
                    traits::destroy(alloc_, boost::addressof(*p));

                traits::deallocate(alloc_, ptr_, length_);
            }
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x8(%rax)
je 0xce79
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x10(%rcx), %rax
je 0xce60
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcf30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xcff0
jmp 0xce4e
jmp 0xce50
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0xce18
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0xd020
jmp 0xce77
jmp 0xce79
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x88a0
nopw %cs:(%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/unique.hpp
// Function: boost::unordered::detail::table_impl<boost::unordered::detail::map<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, JSON, boost::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::place_in_bucket(boost::unordered::detail::buckets<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::ptr_bucket, boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::mix64_policy<unsigned long>>&, boost::unordered::detail::ptr_bucket*)
static previous_pointer place_in_bucket(buckets& dst,
                previous_pointer prev)
        {
            node_pointer n = static_cast<node_pointer>(prev->next_);
            bucket_pointer b = dst.get_bucket(
                buckets::to_bucket(dst.bucket_count_, n->hash_));

            if (!b->next_) {
                b->next_ = prev;
                return static_cast<previous_pointer>(n);
            }
            else {
                prev->next_ = n->next_;
                n->next_ = b->next_->next_;
                b->next_->next_ = static_cast<link_pointer>(n);
                return prev;
            }
        }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0xd131
movq 0x38(%rsp), %rax
addq $-0x50, %rax
movq %rax, 0x30(%rsp)
jmp 0xd13a
xorl %eax, %eax
movq %rax, 0x30(%rsp)
jmp 0xd13a
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x48(%rsp), %rax
movq 0x58(%rax), %rsi
callq 0xbe70
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0xc010
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xd1c0
movq 0x50(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x20(%rsp)
je 0xd1b4
movq 0x18(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xd224
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x10(%rsp)
je 0xd20a
movq 0x8(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: boost::unordered::detail::buckets<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::ptr_bucket, boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::mix64_policy<unsigned long>>::swap(boost::unordered::detail::buckets<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::ptr_bucket, boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::mix64_policy<unsigned long>>&, std::integral_constant<bool, false>)
void swap(buckets& other, false_type = false_type())
        {
            BOOST_ASSERT(node_alloc() == other.node_alloc());
            boost::swap(buckets_, other.buckets_);
            boost::swap(bucket_count_, other.bucket_count_);
            boost::swap(size_, other.size_);
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xb3e0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb3e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd4d0
testb $0x1, %al
jne 0xd26e
jmp 0xd270
jmp 0xd28f
leaq 0x591c(%rip), %rdi      # 0x12b93
leaq 0x517a(%rip), %rsi      # 0x123f8
movl $0x2e8, %edx            # imm = 0x2E8
leaq 0x592c(%rip), %rcx      # 0x12bb6
callq 0x3160
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd4e0
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
callq 0xd510
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0xd510
addq $0x28, %rsp
retq
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: boost::unordered::detail::buckets<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::ptr_bucket, boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>, boost::unordered::detail::mix64_policy<unsigned long>>::delete_node(boost::unordered::iterator_detail::c_iterator<boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>> const*, boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>*, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>)
inline void delete_node(c_iterator n)
        {
            boost::unordered::detail::destroy_node(
                node_alloc(), boost::addressof(*n.node_));
            node_allocator_traits::deallocate(node_alloc(), n.node_, 1);
            --size_;
        }

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb3e0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc1e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc1b0
movq 0x10(%rsp), %rdi
callq 0xb3e0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0xd880
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: boost::container::vector<JSON, std::allocator<JSON>>::vector(unsigned long)
explicit vector(size_type n)
      :  base_t()
   {
      //Allocate
      size_type real_cap;
      std::pair<pointer, bool> ret =
         this->allocation_command(allocate_new, n, n, real_cap, this->members_.m_start);
      T *new_mem = container_detail::to_raw_pointer(ret.first);
      //Anti-exception rollback
      typename value_traits::ArrayDeallocator scoped_alloc(new_mem, this->alloc(), real_cap);
      //Default constructor
      container_detail::default_construct_aux_proxy<A, T*> proxy(this->alloc(), n);
      proxy.uninitialized_copy_remaining_to(new_mem);
      //All ok, commit
      this->members_.m_start = ret.first;
      this->members_.m_size  = n;
      this->members_.m_capacity = real_cap;
      scoped_alloc.release();
   }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdcc0
movq 0x10(%rsp), %r9
movq 0x98(%rsp), %rcx
movl $0x1, %esi
leaq 0x90(%rsp), %r8
movq %r9, %rdi
movq %rcx, %rdx
callq 0x99e0
movb %dl, 0x1f(%rsp)
movq %rax, 0x20(%rsp)
jmp 0xda89
movb 0x1f(%rsp), %al
movq 0x20(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movb %al, 0x68(%rsp)
movb 0x68(%rsp), %al
movb %al, 0x88(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x85b0
movq 0x10(%rsp), %rdi
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x85a0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x90(%rsp), %rcx
leaq 0x40(%rsp), %rdi
callq 0xaff0
jmp 0xdaf5
movq 0x10(%rsp), %rdi
callq 0x85a0
movq %rax, %rsi
movq 0x98(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0xdce0
jmp 0xdb16
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xdd30
jmp 0xdb27
movq 0x10(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rcx, (%rax)
movq 0x98(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x90(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x40(%rsp), %rdi
callq 0xb080
leaq 0x28(%rsp), %rdi
callq 0xdd60
leaq 0x40(%rsp), %rdi
callq 0xb0a0
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xdbb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xdbad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xdd60
leaq 0x40(%rsp), %rdi
callq 0xb0a0
movq 0x10(%rsp), %rdi
callq 0xdd70
movq 0x78(%rsp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::default_construct_aux_proxy<std::allocator<JSON>, JSON*>::uninitialized_copy_some_and_update(JSON*, long, bool)
virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
   {
      size_type new_count;
      if(first_n){
         new_count = division_count;
      }
      else{
         BOOST_ASSERT(difference_type(this->count_)>= division_count);
         new_count = this->count_ - division_count;
      }
      this->priv_uninitialized_copy(pos, new_count);
   }

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x1f(%rsp)
je 0xde88
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xdecc
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x20(%rsp), %rax
jl 0xde9a
jmp 0xdeb9
leaq 0x52bc(%rip), %rdi      # 0x1315d
leaq 0x51c3(%rip), %rsi      # 0x1306b
movl $0x7e, %edx
leaq 0x52d8(%rip), %rcx      # 0x1318c
callq 0x3160
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xe000
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::default_construct_aux_proxy<std::allocator<JSON>, JSON*>::copy_some_and_update(JSON*, long, bool)
virtual void copy_some_and_update(Iterator , difference_type division_count, bool first_n)
   {
      BOOST_ASSERT(this->count_ == 0);
      size_type new_count;
      if(first_n){
         new_count = division_count;
      }
      else{
         BOOST_ASSERT(difference_type(this->count_)>= division_count);
         new_count = this->count_ - division_count;
      }
      //This function should never called with a count different to zero
      BOOST_ASSERT(new_count == 0);
      (void)new_count;
   }

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0xdf1e
jmp 0xdf3d
leaq 0x5134(%rip), %rdi      # 0x13059
leaq 0x513f(%rip), %rsi      # 0x1306b
movl $0x86, %edx
leaq 0x5409(%rip), %rcx      # 0x13341
callq 0x3160
testb $0x1, 0x1f(%rsp)
je 0xdf50
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xdf94
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x20(%rsp), %rax
jl 0xdf62
jmp 0xdf81
leaq 0x51f4(%rip), %rdi      # 0x1315d
leaq 0x50fb(%rip), %rsi      # 0x1306b
movl $0x8c, %edx
leaq 0x53c5(%rip), %rcx      # 0x13341
callq 0x3160
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xdf9e
jmp 0xdfbd
leaq 0x546c(%rip), %rdi      # 0x13411
leaq 0x50bf(%rip), %rsi      # 0x1306b
movl $0x90, %edx
leaq 0x5389(%rip), %rcx      # 0x13341
callq 0x3160
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::default_construct_aux_proxy<std::allocator<JSON>, JSON*>::priv_uninitialized_copy(JSON*, unsigned long)
void priv_uninitialized_copy(Iterator p, const size_type n)
   {
      BOOST_ASSERT(n <= this->count_);
      Iterator orig_p = p;
      size_type i = 0;
      try{
         for(; i < n; ++i, ++p){
            alloc_traits::construct(this->a_, container_detail::to_raw_pointer(&*p));
         }
      }
      catch(...){
         while(i--){
            alloc_traits::destroy(this->a_, container_detail::to_raw_pointer(&*orig_p++));
         }
         throw;
      }
      this->count_ -= n;
   }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x10(%rcx), %rax
ja 0xe02a
jmp 0xe049
leaq 0x5239(%rip), %rdi      # 0x1326a
leaq 0x5033(%rip), %rsi      # 0x1306b
movl $0x97, %edx
leaq 0x5238(%rip), %rcx      # 0x1327c
callq 0x3160
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0xe117
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x85b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xe170
jmp 0xe093
jmp 0xe095
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x48(%rsp)
jmp 0xe05c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0x30d0
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rsp)
cmpq $0x0, %rax
je 0xe12e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0x38(%rsp)
callq 0x85b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xaf80
jmp 0xe115
jmp 0xe0cb
jmp 0xe137
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x33a0
jmp 0xe135
callq 0x3360
jmp 0xe163
jmp 0xe151
movq 0x18(%rsp), %rax
movq 0x40(%rsp), %rdx
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x88a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: boost::container::container_detail::vector_alloc_holder<std::allocator<JSON>>::prot_deallocate()
void prot_deallocate()
   {
      if(!this->members_.m_capacity)   return;
      this->alloc().deallocate(this->members_.m_start, this->members_.m_capacity);
      this->members_.m_start     = 0;
      this->members_.m_size      = 0;
      this->members_.m_capacity  = 0;
   }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0xe24c
jmp 0xe286
movq 0x8(%rsp), %rdi
callq 0x85a0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xb050
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: void boost::unordered::detail::node_constructor<std::allocator<boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>>>::construct_value2<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>&>(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>&)
void construct_value2(BOOST_FWD_REF(A0) a0)
        {
            BOOST_ASSERT(node_ && !constructed_);

            boost::unordered::detail::construct_node(alloc_,
                boost::addressof(*node_),
                BOOST_UNORDERED_EMPLACE_ARGS1(boost::forward<A0>(a0)));

            constructed_ = true;
            node_->init(static_cast<typename node::link_pointer>(node_));
        }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x28(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, 0x37(%rsp)
je 0x10f23
movq 0x28(%rsp), %rax
movb 0x10(%rax), %al
xorb $-0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x10f2d
jmp 0x10f2f
jmp 0x10f4e
leaq 0x14ab(%rip), %rdi      # 0x123e1
leaq 0x14bb(%rip), %rsi      # 0x123f8
movl $0x54, %edx
leaq 0x274e(%rip), %rcx      # 0x13697
callq 0x3160
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rdi
callq 0xc1e0
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11030
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x10fe0
movq 0x28(%rsp), %rax
movb $0x1, 0x10(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x20(%rsp)
je 0x10fbd
movq 0x18(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xc400
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)