LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/markov.h
// Function: efgy::markov::chain<char, 3u, std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>, unsigned long>::train(std::vector<char, std::allocator<char>> const&, unsigned long const&)
chain &train(const input &input, const counter &c) {
    memory m = std::accumulate(
        input.begin(), input.end(), memory(),
        [this, c](memory s, const T &v) -> memory {
          transitions[s][v] += c;

          std::transform(
              s.begin() + 1, s.end(), s.begin(),
              [](std::optional<T> &i) -> std::optional<T> { return i; });

          *(s.end() - 1) = v;

          return s;
        });

    transitions[m][std::optional<T>()]++;

    return *this;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %r12
leaq 0x10(%rsp), %r13
andw $0x0, 0x4(%r13)
movq %rdi, %rbx
andl $0x0, (%r13)
movq %r13, %rdi
callq 0x13864
movq (%r14), %r8
movl (%r13), %eax
movl 0x4(%r13), %edx
shlq $0x20, %rdx
orq %rax, %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x13826
leaq 0x18(%rsp), %rsi
movl %eax, (%rsi)
shrq $0x20, %rax
movw %ax, 0x4(%rsi)
leaq 0x1388(%rbx), %rdi
callq 0x13870
leaq 0xe(%rsp), %rsi
movb $0x0, 0x1(%rsi)
movq %rax, %rdi
callq 0x1230c
incq (%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/markov.h
// Function: efgy::markov::chain<char, 2u, std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>, unsigned long>::operator()()
output operator()(void) {
    output rv;
    memory m;

    for (typename std::map<memory, transition>::iterator it =
             transitions.find(m);
         it != transitions.end(); it = transitions.find(m)) {
      counter c = std::accumulate(
          it->second.begin(), it->second.end(), 0,
          [](const counter &v, const std::pair<std::optional<T>, counter> &t)
              -> counter { return v + t.second; });

      c = RNG() % c;

      for (const std::pair<std::optional<T>, counter> &t : it->second) {
        if (c > t.second) {
          c -= t.second;
        } else if (t.first) {
          rv.push_back(*t.first);

          std::transform(
              m.begin() + 1, m.end(), m.begin(),
              [](std::optional<T> &i) -> std::optional<T> { return i; });

          *(m.end() - 1) = t.first;
          break;
        } else {
          return rv;
        }
      }
    }

    throw std::runtime_error("impossible memory state in markov chain.");

    return output();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
xorl %eax, %eax
leaq 0x4(%rsp), %rsi
movb %al, 0x1(%rsi)
movb %al, 0x3(%rsi)
leaq 0x1388(%r14), %r15
movq %r15, %rdi
callq 0x136ba
movq %rax, %r13
leaq 0x1390(%r14), %r12
cmpq %r12, %r13
je 0x1363a
movq 0x40(%r13), %rdi
leaq 0x30(%r13), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x13694
movl %eax, %ebp
movq %r14, %rdi
callq 0x12c94
movslq %ebp, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %rbp
movq 0x40(%r13), %rax
cmpq %rbx, %rax
je 0x135eb
movzwl 0x20(%rax), %ecx
movw %cx, 0x10(%rsp)
movq 0x28(%rax), %rdx
movq %rdx, 0x18(%rsp)
subq %rdx, %rbp
jbe 0x135c2
movq %rax, %rdi
callq 0x41e0
jmp 0x1359c
btl $0x8, %ecx
jae 0x13600
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12cf8
movzwl 0x6(%rsp), %eax
movw %ax, 0x4(%rsp)
movzwl 0x10(%rsp), %eax
movw %ax, 0x6(%rsp)
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x136ba
movq %rax, %r13
jmp 0x13568
leaq 0x20(%rsp), %rdi
movaps (%rdi), %xmm0
movq 0x8(%rsp), %rbx
movups %xmm0, (%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x9bf6
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4140
movq %rax, %r14
leaq 0x148d(%rip), %rsi      # 0x14ad9
movq %rax, %rdi
callq 0x40d0
movq 0xc98d(%rip), %rsi      # 0x1ffe8
movq 0xc92e(%rip), %rdx      # 0x1ff90
movq %r14, %rdi
callq 0x43e0
jmp 0x1367f
jmp 0x1367f
jmp 0x1367f
movq %rax, %rbx
movq %r14, %rdi
callq 0x4200
jmp 0x13682
jmp 0x1367f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9bf6
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(JSON const&)
JSON & JSON::operator=(const JSON & rhs)
{
    this->clear();
    this->m_type = rhs.m_type;
    switch(m_type)
    {
        case type_array:
            new (&(m_data.u_arr)) Arr_t(rhs.m_data.u_arr);
            break;
        case type_obj:
            new (&(m_data.u_map)) Map_t(rhs.m_data.u_map);
            break;
        case type_str:
            new (&(m_data.u_str)) std::string(rhs.m_data.u_str);
            break;
        case type_double:
            m_data.u_double = rhs.m_data.u_double;
            break;
        default:
            m_data.u_bool = rhs.m_data.u_bool; 
            break;
    }
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x353a
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
decl %eax
cmpl $0x3, %eax
ja 0x2433
leaq 0x4c0c(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
jmp 0x2438
movq %rbx, %rdi
movq %r14, %rsi
callq 0x355a
jmp 0x2438
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0x2438
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6346
jmp 0x2438
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/jsonUnitTest.cpp
// Function: populate(JSON&)
void populate(JSON & rhs)
{
    JSON data;
    data["id"] = 15;
    data["secondID"] = getAJSON();
    data["name"](false);
    dummyFunc(data);
    data["person"][0]["name"] = "Benny";
    data["person"][0]["id"] = 3294;
    data["person"][1]["name"] = "Cunpu";
    data["person"][1]["id"] = 321312;
    rhs = data;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
andl $0x0, 0x28(%rdi)
leaq 0x514d(%rip), %rsi      # 0x8227
callq 0x385c
pushq $0xf
popq %rsi
movq %rax, %rdi
callq 0x39c8
movl $0x4, 0x60(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x38(%rsp)
leaq 0x40a8(%rip), %rsi      # 0x71b0
leaq 0x8(%rsp), %rdi
callq 0x385c
leaq 0x38(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x39f8
movq %r14, %rdi
callq 0x36bc
leaq 0x4088(%rip), %rsi      # 0x71b9
leaq 0x8(%rsp), %rdi
callq 0x385c
movq %rax, %rdi
xorl %esi, %esi
callq 0x2444
leaq 0x8(%rsp), %rdi
callq 0x308b
leaq 0x406e(%rip), %rsi      # 0x71c4
leaq 0x8(%rsp), %rdi
callq 0x385c
movq %rax, %rdi
xorl %esi, %esi
callq 0x3a4a
leaq 0x4048(%rip), %rsi      # 0x71b9
movq %rax, %rdi
callq 0x385c
leaq 0x403e(%rip), %rsi      # 0x71be
movq %rax, %rdi
callq 0x398e
leaq 0x4035(%rip), %rsi      # 0x71c4
leaq 0x8(%rsp), %rdi
callq 0x385c
movq %rax, %rdi
xorl %esi, %esi
callq 0x3a4a
leaq 0x507d(%rip), %rsi      # 0x8227
movq %rax, %rdi
callq 0x385c
movq %rax, %rdi
movl $0xcde, %esi            # imm = 0xCDE
callq 0x39c8
leaq 0x3ffe(%rip), %rsi      # 0x71c4
leaq 0x8(%rsp), %rdi
callq 0x385c
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x3a4a
leaq 0x3fd7(%rip), %rsi      # 0x71b9
movq %rax, %rdi
callq 0x385c
leaq 0x3fda(%rip), %rsi      # 0x71cb
movq %rax, %rdi
callq 0x398e
leaq 0x3fc4(%rip), %rsi      # 0x71c4
leaq 0x8(%rsp), %rdi
callq 0x385c
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x3a4a
leaq 0x500b(%rip), %rsi      # 0x8227
movq %rax, %rdi
callq 0x385c
movq %rax, %rdi
movl $0x4e720, %esi          # imm = 0x4E720
callq 0x39c8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23d4
leaq 0x8(%rsp), %rdi
callq 0x36bc
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x36bc
jmp 0x3262
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x36bc
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::push_back(JSON)
inline
void JSON::push_back(JSON rhs)
{
    if(m_type == type_array)
        m_data.u_arr.push_back(rhs);
    else
        throw JSONOperationException();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x3, 0x28(%rdi)
jne 0x363f
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4992
pushq $0x28
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x3d82(%rip), %rsi      # 0x73d3
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20a0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x493c
xorl %ebp, %ebp
leaq 0x85df(%rip), %rsi      # 0xbc58
leaq 0x12f2(%rip), %rdx      # 0x4972
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d0
testb %bpl, %bpl
jne 0x369f
jmp 0x36a7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON&)
inline
void JSON::push_back(const string & key, JSON & rhs)
{
    if(m_type == type_obj)
        m_data.u_map[key] = rhs;
    else
        throw JSONOperationException();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x2, 0x28(%rdi)
jne 0x3706
movq %rdx, %rbx
callq 0x4fba
leaq 0x20(%rax), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x23d4
pushq $0x28
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x3cbb(%rip), %rsi      # 0x73d3
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20a0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x493c
xorl %ebp, %ebp
leaq 0x8518(%rip), %rsi      # 0xbc58
leaq 0x122b(%rip), %rdx      # 0x4972
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d0
testb %bpl, %bpl
jne 0x3766
jmp 0x376e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline
JSON & JSON::operator=(std::string & content)
{
    if(this->m_type != type_str)
    {
        this->clear();
        this->m_type = type_str;
    }
    new (&(m_data.u_str)) std::string(content);
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, 0x28(%rdi)
je 0x3795
movq %rbx, %rdi
callq 0x353a
movl $0x1, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(double)
inline
JSON & JSON::operator=(double u_double)
{
    if(m_type != type_double)
    {
        this->clear();
        this->m_type = type_double;
    }
    this->m_data.u_double = u_double;
    return *this;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x4, 0x28(%rdi)
je 0x37d5
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x353a
movsd 0x8(%rsp), %xmm0
movl $0x4, 0x28(%rbx)
movsd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator[](char const*)
inline
JSON & JSON::operator[](const char *key)
{
    //turn itself into an array 
    if(m_type != type_obj)
    {
        this->clear();
        m_type = type_obj;
        new (&(m_data.u_map)) Map_t();
    }
    auto it = m_data.u_map.find(key);
    if(it == m_data.u_map.end())
        m_data.u_map[key] = JSON();
    return m_data.u_map[key];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
je 0x389a
movq %rbx, %rdi
callq 0x353a
movl $0x2, 0x28(%rbx)
pushq $0xb
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0xf(%rsp), %r8
movq %rbx, %rdi
callq 0x381c
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r14, %rsi
callq 0x20a0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5842
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x20d0
testq %r15, %r15
jne 0x3915
andl $0x0, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x20a0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x4fba
addq $0x20, %rax
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x39f8
leaq 0x40(%rsp), %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x36bc
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r14, %rsi
callq 0x20a0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4fba
movq %rax, %rbx
addq $0x20, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x20d0
jmp 0x3964
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x36bc
jmp 0x3986
jmp 0x3974
jmp 0x3983
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20d0
jmp 0x3986
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(char const*)
inline
JSON & JSON::operator=(const char * content)
{
    if(this->m_type != type_str)
    {
        this->clear();
        this->m_type = type_str;
    }
    new (&(m_data.u_str)) std::string(content);
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, 0x28(%rdi)
je 0x39ad
movq %rbx, %rdi
callq 0x353a
movl $0x1, 0x28(%rbx)
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(int)
inline
JSON & JSON::operator=(int u_int)
{
    if(m_type != type_double)
    {
        this->clear();
        this->m_type = type_double;
    }
    this->m_data.u_double = u_int;
    return *this;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x4, 0x28(%rdi)
je 0x39e5
movq %rbx, %rdi
callq 0x353a
movl $0x4, 0x28(%rbx)
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(JSON&&)
inline
JSON & JSON::operator=(JSON && rhs)
{
    // make sure it is not itself
    if(this!= &rhs)
    {
        //clear all current content;
        this->clear();
        //copy the resource over
        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;
    }
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x3a3f
movq %rsi, %r14
movq %rbx, %rdi
callq 0x353a
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator[](int)
inline
JSON & JSON::operator[](int i)
{
    //turn itself into an array 
    if(m_type != type_array)
    {
        this->clear();
        m_type = type_array;
        new (&(m_data.u_arr)) Arr_t(); 
    }
    //need to return the element at the given index
    int arrayOldSize = m_data.u_arr.size(); 
    //make sure the size of the arrray is big enough 
    if(i >= arrayOldSize) 
    {
        Arr_t append ( i-arrayOldSize +1);
        m_data.u_arr.insert(m_data.u_arr.end(),append.begin(),append.end()); 
    }
    return m_data.u_arr[i];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x3, 0x28(%rdi)
jne 0x3a62
movl 0x8(%rbx), %eax
jmp 0x3a7e
movq %rbx, %rdi
callq 0x353a
movl $0x3, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
cmpl %ebp, %eax
jg 0x3abd
movl %ebp, %ecx
subl %eax, %ecx
incl %ecx
movslq %ecx, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x587c
imulq $0x30, 0x8(%rbx), %rsi
addq (%rbx), %rsi
movq (%r14), %rdx
imulq $0x30, 0x8(%r14), %rcx
addq %rdx, %rcx
movq %rbx, %rdi
callq 0x5a72
leaq 0x8(%rsp), %rdi
callq 0x3842
movslq %ebp, %rax
imulq $0x30, %rax, %rax
addq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3842
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator int() const
inline
JSON::operator int()const
{
    switch(m_type)
    {
        case type_double:
            return (int)m_data.u_double;
        case type_bool:
            return (int)m_data.u_bool;
    }
    throw JSONOperationException("Not an int type");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x28(%rdi), %eax
cmpl $0x5, %eax
je 0x3b01
cmpl $0x4, %eax
jne 0x3b0d
cvttsd2si (%rdi), %eax
jmp 0x3b04
movzbl (%rdi), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x4689(%rip), %rsi      # 0x81a8
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20a0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x493c
xorl %ebp, %ebp
leaq 0x8111(%rip), %rsi      # 0xbc58
leaq 0xe24(%rip), %rdx       # 0x4972
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d0
testb %bpl, %bpl
jne 0x3b6d
jmp 0x3b75
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./json.h
// Function: JSONSyntaxError::what() const
const virtual char * what () const throw() { 
        if(pos == -1)
            return message.c_str(); 
        else
            return string(message.c_str() + JSONString.substr(pos, 30)).c_str();
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
movslq 0x28(%rdi), %rdx
cmpq $-0x1, %rdx
je 0x48e8
movq 0x8(%rsi), %rbx
addq $0x30, %rsi
movq %rsp, %rdi
pushq $0x1e
popq %rcx
callq 0x21a0
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x490d
leaq 0x20(%rsp), %rdi
movq (%rdi), %rbx
callq 0x20d0
movq %rsp, %rdi
callq 0x20d0
jmp 0x48ec
movq 0x8(%rsi), %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20d0
jmp 0x4905
movq %rax, %rbx
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: void boost::container::vector<JSON, std::allocator<JSON>>::priv_push_back<JSON const&>(JSON const&)
void priv_push_back(BOOST_MOVE_CATCH_FWD(U) x)
   {
      if (this->members_.m_size < this->members_.m_capacity){
         //There is more memory, just construct a new object at the end
         allocator_traits_type::construct
            ( this->alloc()
            , container_detail::to_raw_pointer(this->members_.m_start + this->members_.m_size)
            , ::boost::forward<U>(x) );
         ++this->members_.m_size;
      }
      else{
         this->insert(this->cend(), ::boost::forward<U>(x));
      }
   }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
imulq $0x30, %rax, %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
jae 0x49bb
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x37e2
incq 0x8(%rbx)
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x49c4
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: void boost::container::vector<JSON, std::allocator<JSON>>::priv_range_insert<boost::container::constant_iterator<JSON, long>>(boost::container::container_detail::vector_const_iterator<JSON*>, boost::container::constant_iterator<JSON, long>, boost::container::constant_iterator<JSON, long>, std::forward_iterator_tag)
void priv_range_insert(const_iterator pos, FwdIt first, FwdIt last, std::forward_iterator_tag)
   {
      if(first != last){       
         const size_type n = std::distance(first, last);
         container_detail::advanced_insert_aux_proxy<A, FwdIt, T*> proxy(this->alloc(), first, last);
         priv_range_insert(pos.get_ptr(), n, proxy);
      }
   }

// Assembly:
movq %rdx, %rax
movq %rcx, %rdx
subq %r9, %rdx
je 0x4a3c
subq $0x38, %rsp
leaq 0x726c(%rip), %r11      # 0xbc80
leaq 0x8(%rsp), %r10
movq %r11, (%r10)
movq %rdi, 0x8(%r10)
movq %rax, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
movq %r10, %rcx
callq 0x4a3e
addq $0x38, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::advanced_insert_aux_proxy<std::allocator<JSON>, boost::container::constant_iterator<JSON, long>, 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)
   {
      FwdIt mid = this->first_;
      std::advance(mid, division_count);
      if(first_n){
         ::boost::container::uninitialized_copy_or_move_alloc(this->a_, this->first_, mid, pos);
         this->first_ = mid;
      }
      else{
         ::boost::container::uninitialized_copy_or_move_alloc(this->a_, mid, this->last_, pos);
         this->last_ = mid;
      }
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rax
movq %rsi, %r9
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq 0x10(%r15), %rbx
movq 0x18(%r15), %rdx
movq %rdx, %r14
subq %rax, %r14
testl %ecx, %ecx
je 0x4b32
leaq 0x10(%r15), %r12
addq $0x18, %r15
movq %rbx, %rsi
movq %rbx, %rcx
movq %r14, %r8
callq 0x4c03
jmp 0x4b50
leaq 0x20(%r15), %r12
leaq 0x28(%r15), %r13
movq 0x20(%r15), %rcx
movq 0x28(%r15), %r8
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4c03
movq %r13, %r15
movq %rbx, (%r12)
movq %r14, (%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::advanced_insert_aux_proxy<std::allocator<JSON>, boost::container::constant_iterator<JSON, long>, JSON*>::copy_some_and_update(JSON*, long, bool)
virtual void copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
   {
      FwdIt mid = this->first_;
      std::advance(mid, division_count);
      if(first_n){
         ::boost::copy_or_move(this->first_, mid, pos);
         this->first_ = mid;
      }
      else{
         ::boost::copy_or_move(mid, this->last_, pos);
         this->last_ = mid;
      }
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r8
movq %rdi, %r15
movq 0x10(%rdi), %rbx
movq 0x18(%rdi), %rsi
movq %rsi, %r14
subq %rdx, %r14
testl %ecx, %ecx
je 0x4b9b
leaq 0x10(%r15), %r12
addq $0x18, %r15
movq %rbx, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x4bd0
jmp 0x4bb9
leaq 0x20(%r15), %r12
leaq 0x28(%r15), %r13
movq 0x20(%r15), %rdx
movq 0x28(%r15), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4bd0
movq %r13, %r15
movq %rbx, (%r12)
movq %r14, (%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/detail/utilities.hpp
// Function: JSON* boost::container::uninitialized_copy_alloc<std::allocator<JSON>, boost::container::constant_iterator<JSON, long>, JSON*>(std::allocator<JSON>&, boost::container::constant_iterator<JSON, long>, boost::container::constant_iterator<JSON, long>, JSON*)
F uninitialized_copy_alloc(A &a, I f, I l, F r)
{
   while (f != l) {
      allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), *f);
      ++f; ++r;
   }
   return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rsi, %r15
subq %rdx, %r14
testq %r14, %r14
je 0x4c2d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37e2
addq $0x30, %rbx
incq %r14
jmp 0x4c14
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: boost::container::vector<JSON, std::allocator<JSON>>::priv_range_insert_expand_forward(JSON*, unsigned long, boost::container::container_detail::advanced_insert_aux_int<JSON*>&)
void priv_range_insert_expand_forward(T* pos, size_type n, advanced_insert_aux_int_t &interf)
   {
      //n can't be 0, because there is nothing to do in that case
      if(!n) return;
      //There is enough memory
      T* old_finish = container_detail::to_raw_pointer(this->members_.m_start) + this->members_.m_size;
      const size_type elems_after = old_finish - pos;

      if (elems_after >= n){
         //New elements can be just copied.
         //Move to uninitialized memory last objects
         ::boost::container::uninitialized_move_alloc
            (this->alloc(), old_finish - n, old_finish, old_finish);
         this->members_.m_size += n;
         //Copy previous to last objects to the initialized end
         boost::move_backward(pos, old_finish - n, old_finish);
         //Insert new objects in the pos
         interf.copy_remaining_to(pos);
      }
      else {
         //The new elements don't fit in the [pos, end()) range. Copy
         //to the beginning of the unallocated zone the last new elements.
         interf.uninitialized_copy_some_and_update(old_finish, elems_after, false);
         this->members_.m_size += n - elems_after;
         //Copy old [pos, end()) elements to the uninitialized memory
         ::boost::container::uninitialized_move_alloc
            (this->alloc(), pos, old_finish, container_detail::to_raw_pointer(this->members_.m_start) + this->members_.m_size);
         this->members_.m_size += elems_after;
         //Copy first new elements in pos
         interf.copy_remaining_to(pos);
      }
   }

// Assembly:
testq %rdx, %rdx
je 0x4cc2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
imulq $0x30, 0x8(%rdi), %r12
addq (%rdi), %r12
movq %r12, %rax
movq %rsi, (%rsp)
subq %rsi, %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rbx, %r13
subq %rax, %r13
jbe 0x4cc3
movq %rax, %rbp
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq *0x10(%rax)
addq 0x8(%r15), %r13
movq %r13, 0x8(%r15)
imulq $0x30, %r13, %rcx
addq (%r15), %rcx
movq %r15, %rdi
movq (%rsp), %rbx
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4ec7
addq %rbp, 0x8(%r15)
jmp 0x4cf7
retq
movq %rbx, %rax
negq %rax
imulq $0x30, %rax, %rbp
addq %r12, %rbp
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r12, %rcx
callq 0x4ec7
addq %rbx, 0x8(%r15)
movq (%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4f0c
movq (%r14), %rax
movq (%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/detail/utilities.hpp
// Function: unsigned long boost::container::container_detail::get_next_capacity<unsigned long>(unsigned long, unsigned long, unsigned long)
SizeType
   get_next_capacity(const SizeType max_size
                    ,const SizeType capacity
                    ,const SizeType n)
{
//   if (n > max_size - capacity)
//      throw std::length_error("get_next_capacity");

   const SizeType m3 = max_size/3;

   if (capacity < m3)
      return capacity + max_value(3*(capacity+1)/5, n);

   if (capacity < m3*2)
      return capacity + max_value((capacity+1)/2, n);

   return max_size;
}

// Assembly:
movq %rdx, %rcx
pushq $0x3
popq %r8
movq %rdi, %rax
xorl %edx, %edx
divq %r8
cmpq %rsi, %rax
jbe 0x4e76
leaq (%rsi,%rsi,2), %rax
addq $0x3, %rax
pushq $0x5
popq %rdi
xorl %edx, %edx
divq %rdi
cmpq %rcx, %rax
cmovaq %rax, %rcx
addq %rsi, %rcx
movq %rcx, %rdi
jmp 0x4e8f
addq %rax, %rax
cmpq %rsi, %rax
jbe 0x4e8f
leaq 0x1(%rsi), %rdi
shrq %rdi
cmpq %rcx, %rdi
cmovbeq %rcx, %rdi
addq %rsi, %rdi
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/container/detail/utilities.hpp
// Function: JSON* boost::container::uninitialized_move_alloc<std::allocator<JSON>, JSON*, JSON*>(std::allocator<JSON>&, JSON*, JSON*, JSON*)
F uninitialized_move_alloc(A &a, I f, I l, F r)
{
   while (f != l) {
      allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), boost::move(*f));
      ++f; ++r;
   }
   return r;
}

// Assembly:
movq %rcx, %rax
xorps %xmm0, %xmm0
cmpq %rdx, %rsi
je 0x4f0b
andq $0x0, (%rax)
andl $0x0, 0x28(%rax)
movups (%rsi), %xmm1
movups 0x10(%rsi), %xmm2
movups %xmm1, (%rax)
movups %xmm2, 0x10(%rax)
movq 0x20(%rsi), %rcx
movq %rcx, 0x20(%rax)
movl 0x28(%rsi), %ecx
movl %ecx, 0x28(%rax)
movups %xmm0, 0x1c(%rsi)
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, %rsi
addq $0x30, %rax
jmp 0x4ecd
retq
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/move/move.hpp
// Function: JSON* boost::move_backward<JSON*, JSON*>(JSON*, JSON*, JSON*)
O move_backward(I f, I l, O result)
   {
      while (f != l) {
         --l; --result;
         *result = ::boost::move(*l);
      }
      return result;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %r15, %r14
je 0x4f34
addq $-0x30, %r14
addq $-0x30, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39f8
jmp 0x4f1a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x4f8e
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq 0x10(%rbx), %r15
jae 0x4f8e
movq %r14, %rdi
callq 0x36bc
incq %r15
addq $0x30, %r14
jmp 0x4f77
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5098
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x50a8
movq %rax, %r12
testq %rax, %rax
jne 0x5061
leaq 0x18(%rbx), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x50c4
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x21f0
leaq 0x1ffd(%rip), %rsi      # 0x7014
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0xf(%rsp), %rcx
callq 0x50f8
leaq 0x28(%rsp), %rdi
callq 0x20d0
movq 0x10(%rbx), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x5150
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x51c0
movq %rax, %r12
leaq 0x10(%rsp), %rdi
callq 0x5228
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5083
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
jmp 0x5086
jmp 0x5083
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5228
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x50e2
cmpb $0x1, 0x10(%rbx)
jne 0x50f5
callq 0x5406
movb $0x0, 0x10(%rbx)
jmp 0x50f5
movb $0x0, 0x10(%rbx)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x53ca
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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_value<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>>(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>&&)
void construct_value(BOOST_UNORDERED_EMPLACE_ARGS)
        {
            BOOST_ASSERT(node_ && !constructed_);
            boost::unordered::detail::construct_node(alloc_,
                boost::addressof(*node_), BOOST_UNORDERED_EMPLACE_FORWARD);
            node_->init(static_cast<typename node::link_pointer>(node_));
            constructed_ = true;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x5132
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
je 0x5132
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x21f0
andl $0x0, 0x48(%r14)
movb $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22b0(%rip), %rdi      # 0x73e9
leaq 0x22c0(%rip), %rsi      # 0x7400
leaq 0x22e9(%rip), %rcx      # 0x7430
pushq $0x4a
popq %rdx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x5192
cmpq %rsi, 0x20(%rbx)
jae 0x51bd
movq 0x10(%rbx), %rcx
movq %rcx, %rax
shrq %rax
addq %rcx, %rax
cmpq %rsi, %rax
cmovbeq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x541c
cmpq 0x8(%rbx), %rax
je 0x51bd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x557c
jmp 0x51b1
movq %rbx, %rdi
callq 0x541c
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x54b2
movq %rbx, %rdi
callq 0x5518
movq %rax, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x524a
cmpb $0x1, 0x10(%rbx)
jne 0x5244
callq 0x5406
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x2180
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
movq %rsi, %rdi
callq 0x5296
movq %rax, %rcx
notq %rcx
shlq $0x15, %rax
addq %rcx, %rax
movq %rax, %rcx
shrq $0x18, %rcx
xorq %rax, %rcx
imulq $0x109, %rcx, %rax      # imm = 0x109
movq %rax, %rcx
shrq $0xe, %rcx
xorq %rax, %rcx
imulq $0x15, %rcx, %rax
movq %rax, %rcx
shrq $0x1c, %rcx
xorq %rax, %rcx
movl $0x80000001, %eax       # imm = 0x80000001
imulq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/unique.hpp
// Function: boost::unordered::iterator_detail::iterator<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>> 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>>>>>::find_node_impl<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>>>>(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) const
iterator find_node_impl(
                std::size_t key_hash,
                Key const& k,
                Pred const& eq) const
        {
            std::size_t bucket_index =
                policy::to_bucket(this->bucket_count_, key_hash);
            iterator n = this->get_start(bucket_index);

            for (;;)
            {
                if (!n.node_) return n;

                std::size_t node_hash = n.node_->hash_;
                if (key_hash == node_hash)
                {
                    if (eq(k, this->get_key(*n)))
                        return n;
                }
                else
                {
                    if (policy::to_bucket(this->bucket_count_, node_hash)
                            != bucket_index)
                        return iterator();
                }

                ++n;
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rax
movq 0x8(%rdi), %r13
decq %r13
andq %rsi, %r13
movq (%rax,%r13,8), %rbx
testq %rbx, %rbx
jne 0x5348
xorl %ebx, %ebx
jmp 0x5356
movq (%rbx), %rax
leaq -0x50(%rax), %rbx
testq %rax, %rax
cmoveq %rax, %rbx
testq %rbx, %rbx
je 0x538b
movq 0x58(%rbx), %rax
cmpq %r15, %rax
jne 0x5375
movq %r14, %rdi
movq %rbx, %rsi
callq 0x539a
testb %al, %al
je 0x5385
jmp 0x538d
movq 0x8(%r12), %rcx
decq %rcx
andq %rax, %rcx
cmpq %r13, %rcx
jne 0x538b
addq $0x50, %rbx
jmp 0x5348
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
movss 0x1c(%rdi), %xmm1
ucomiss 0x1c17(%rip), %xmm1     # 0x7040
jb 0x5493
movq %rsi, %xmm2
punpckldq 0x1c18(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x1c20(%rip), %xmm2     # 0x7060
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
addsd %xmm2, %xmm0
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
callq 0x2230
cvttsd2si %xmm0, %rax
movq %rax, %rcx
movapd %xmm0, %xmm1
subsd 0x1c03(%rip), %xmm1     # 0x7070
cvttsd2si %xmm1, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
incq %rdx
xorl %edi, %edi
ucomisd 0x1bef(%rip), %xmm0     # 0x7078
cmovbq %rdx, %rdi
popq %rax
jmp 0x564e
leaq 0x21a5(%rip), %rdi      # 0x763f
leaq 0x21c4(%rip), %rsi      # 0x7665
leaq 0x21eb(%rip), %rcx      # 0x7693
movl $0x8b, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq 0x8(%rbx), %rdx
incq %rdx
callq 0x569a
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rax
andq $0x0, 0x8(%rdi)
movq %rax, (%rbx)
callq 0x5706
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5706
movq %rbx, %rdi
callq 0x2250