LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Protocol.cpp
// Function: fprime::Protocol::getField(unsigned int)
fprime::Field::FieldPtr Protocol::getField(unsigned int id) {
        map<unsigned int, fprime::Field::FieldPtr >::iterator search;
        search = fields.find(id);
        if (search != fields.end())
            return search->second;
        else {
            stringstream msg;
            msg << "Field " << id << "does not exists in protocol " << version;
            throw runtime_error(msg.str());
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %rbx
movq 0x70(%rsi), %rcx
testq %rcx, %rcx
je 0x412d5
leaq 0x68(%rbx), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpl %ebp, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x4127c
cmpq %rdx, %rax
je 0x412d5
cmpl %ebp, 0x20(%rax)
ja 0x412d5
movq 0x28(%rax), %rcx
movq %rcx, (%rdi)
movq 0x30(%rax), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x412c6
movq 0x2fba0(%rip), %rcx     # 0x70e58
cmpb $0x0, (%rcx)
je 0x412c2
incl 0x8(%rax)
jmp 0x412c6
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x2f130
leaq 0x38(%rsp), %r14
leaq 0x1a2ea(%rip), %rsi     # 0x5b5d5
movl $0x6, %edx
movq %r14, %rdi
callq 0x2fb10
movl %ebp, %esi
movq %r14, %rdi
callq 0x2f090
movq %rax, %r14
leaq 0x1a694(%rip), %rsi     # 0x5b9a0
movl $0x1c, %edx
movq %rax, %rdi
callq 0x2fb10
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x2fb10
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305c0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x306f0
xorl %ebp, %ebp
movq 0x2fc7a(%rip), %rsi     # 0x70fd8
movq 0x2fa5b(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41383
callq 0x2f6c0
testb %bpl, %bpl
jne 0x4138d
jmp 0x4139a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
jmp 0x4139a
movq %rax, %r14
movq 0x2f8df(%rip), %rsi     # 0x70c80
leaq 0x28(%rsp), %rdi
callq 0x2f190
leaq 0xa8(%rsp), %rdi
callq 0x2e700
movq %r14, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Protocol.cpp
// Function: fprime::Protocol::getMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
fprime::Message Protocol::getMessage(string msgId) {
        map<const string, fprime::Message>::iterator search;
        search = messages.find(msgId);
        if (search != messages.end())
            return search->second;
        else
            throw std::runtime_error("at Protocol.getMessage: Message type " + msgId + " does not exists in protocol " + version);

    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsi), %rdi
movq %rdx, %rsi
callq 0x2f320
leaq 0xc8(%r14), %rcx
cmpq %rcx, %rax
je 0x452ed
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ec60
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2eae0
movq %rax, %rbx
leaq 0x16678(%rip), %rsi     # 0x5b979
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x2f510
leaq 0x1668a(%rip), %rsi     # 0x5b99f
leaq 0x28(%rsp), %rdi
callq 0x30e50
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x45340
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x4534d
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq $0x8, %r14
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x303e0
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x306f0
xorl %ebp, %ebp
movq 0x2bc45(%rip), %rsi     # 0x70fd8
movq 0x2ba26(%rip), %rdx     # 0x70dc0
movq %rbx, %rdi
callq 0x308e0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x453c0
callq 0x2f6c0
jmp 0x453c0
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x453cf
callq 0x2f6c0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x453e2
callq 0x2f6c0
testb %bpl, %bpl
jne 0x45404
jmp 0x4540c
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45404
callq 0x2f6c0
jmp 0x45404
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f150
movq %r14, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::create()
bool Socket::create() {
        m_sock = socket(AF_INET,
                SOCK_STREAM,
                0);

        if (!is_valid())
            return false;


        // TIME_WAIT - argh
        int on = 1;
        if (setsockopt(m_sock, SOL_SOCKET, SO_REUSEADDR, (const char*) &on, sizeof ( on)) == -1)
            return false;


        return true;

    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2e490
movl %eax, 0x8(%r14)
cmpl $-0x1, %eax
je 0x46795
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x30a40
cmpl $-0x1, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::recv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
int Socket::recv(std::string& s) const {
        char buf [ MAXRECV + 1 ];

        s = "";

        memset(buf, 0, MAXRECV + 1);

        int status = ::recv(m_sock, buf, MAXRECV, 0);

        if (status == -1) {
            std::cout << "status == -1   errno == " << errno << "  in Socket::recv\n";
            return 0;
        } else if (status == 0) {
            return 0;
        } else {
            s = buf;
            return status;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
leaq 0x13929(%rip), %rcx     # 0x5a198
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x304d0
movq %rsp, %r15
movl $0x401, %edx            # imm = 0x401
movq %r15, %rdi
xorl %esi, %esi
callq 0x2ecc0
movl 0x8(%r14), %edi
movl $0x400, %edx            # imm = 0x400
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x2e6e0
movq %rax, %r14
testl %r14d, %r14d
je 0x46914
cmpl $-0x1, %r14d
jne 0x468f2
movq 0x2a5aa(%rip), %rbx     # 0x70e60
leaq 0x15253(%rip), %rsi     # 0x5bb10
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2fb10
callq 0x2e0d0
movl (%rax), %esi
movq %rbx, %rdi
callq 0x30980
leaq 0x15249(%rip), %rsi     # 0x5bb29
movl $0x12, %edx
movq %rax, %rdi
callq 0x2fb10
xorl %r14d, %r14d
jmp 0x46914
movq 0x8(%rbx), %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x2e980
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x304d0
movl %r14d, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::set_non_blocking(bool)
void Socket::set_non_blocking(const bool b) {

        int opts;

        opts = fcntl(m_sock,
                F_GETFL);

        if (opts < 0) {
            return;
        }

        if (b)
            opts = (opts | O_NONBLOCK);
        else
            opts = (opts & ~O_NONBLOCK);

        fcntl(m_sock,
                F_SETFL, opts);

    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x2ed10
testl %eax, %eax
js 0x469c1
movl %eax, %ecx
orl $0x800, %ecx            # imm = 0x800
andl $0x7ffff7ff, %eax       # imm = 0x7FFFF7FF
testb %bpl, %bpl
cmovnel %ecx, %eax
movl 0x8(%rbx), %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ed10
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/SocketConnector.cpp
// Function: SocketConnector::SocketConnector(int)
SocketConnector::SocketConnector ( int port )
{
  if ( ! Socket::create() )
    {
      throw SocketException ( "Could not create server socket." );
    }

  if ( ! Socket::bind ( port ) )
    {
      throw SocketException ( "Could not bind to port." );
    }

  if ( ! Socket::listen() )
    {
      throw SocketException ( "Could not listen to socket." );
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2e070
movq 0x2a373(%rip), %rax     # 0x70d58
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2f360
testb %al, %al
je 0x46a27
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2f7e0
testb %al, %al
je 0x46a95
movq %rbx, %rdi
callq 0x30030
testb %al, %al
je 0x46b00
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15108(%rip), %rsi     # 0x5bb4d
leaq 0x15120(%rip), %rdx     # 0x5bb6c
leaq 0x40(%rsp), %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2a577(%rip), %rsi     # 0x70ff8
movq 0x2a258(%rip), %rdx     # 0x70ce0
movq %r15, %rdi
callq 0x308e0
jmp 0x46b66
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x150ba(%rip), %rsi     # 0x5bb6d
leaq 0x150ca(%rip), %rdx     # 0x5bb84
leaq 0x20(%rsp), %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2a509(%rip), %rsi     # 0x70ff8
movq 0x2a1ea(%rip), %rdx     # 0x70ce0
movq %r15, %rdi
callq 0x308e0
jmp 0x46b66
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x15067(%rip), %rsi     # 0x5bb85
leaq 0x1507b(%rip), %rdx     # 0x5bba0
movq %rsp, %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2a4a1(%rip), %rsi     # 0x70ff8
movq 0x2a182(%rip), %rdx     # 0x70ce0
movq %r15, %rdi
callq 0x308e0
movq %rax, %r14
movq (%rsp), %rdi
jmp 0x46b85
jmp 0x46b96
movq %rax, %r14
movq 0x20(%rsp), %rdi
jmp 0x46b85
jmp 0x46b96
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x46b8f
callq 0x2f6c0
testb %bpl, %bpl
jne 0x46b99
jmp 0x46ba6
movq %rax, %r14
movq %r15, %rdi
callq 0x2f150
jmp 0x46ba6
movq %rax, %r14
movq %rbx, %rdi
callq 0x30de0
movq %r14, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/SocketConnector.cpp
// Function: SocketConnector::SocketConnector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
SocketConnector::SocketConnector ( std::string host, int port )
{
  if ( ! Socket::create() )
    {
      throw SocketException ( "Could not create client socket." );
    }

  if ( ! Socket::connect ( host, port ) )
    {
      throw SocketException ( "Could not bind to port." );
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2e070
movq 0x2a182(%rip), %rax     # 0x70d58
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2f360
testb %al, %al
je 0x46c38
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x2e8a0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x30170
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x46c26
callq 0x2f6c0
testb %bpl, %bpl
je 0x46ca3
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x14f4b(%rip), %rsi     # 0x5bba1
leaq 0x14f63(%rip), %rdx     # 0x5bbc0
leaq 0x40(%rsp), %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2a366(%rip), %rsi     # 0x70ff8
movq 0x2a047(%rip), %rdx     # 0x70ce0
movq %r15, %rdi
callq 0x308e0
jmp 0x46d09
movl $0x20, %edi
callq 0x2eae0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x14eac(%rip), %rsi     # 0x5bb6d
leaq 0x14ebc(%rip), %rdx     # 0x5bb84
movq %rsp, %rdi
callq 0x2e860
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2e8a0
xorl %ebp, %ebp
movq 0x2a2fe(%rip), %rsi     # 0x70ff8
movq 0x29fdf(%rip), %rdx     # 0x70ce0
movq %r15, %rdi
callq 0x308e0
movq %rax, %r14
movq (%rsp), %rdi
jmp 0x46d1c
jmp 0x46d2d
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x46d26
callq 0x2f6c0
testb %bpl, %bpl
jne 0x46d30
jmp 0x46d51
movq %rax, %r14
movq %r15, %rdi
callq 0x2f150
jmp 0x46d51
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x46d51
callq 0x2f6c0
jmp 0x46d51
movq %rax, %r14
movq %rbx, %rdi
callq 0x30de0
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/StringDataHolder.cpp
// Function: fprime::StringDataHolder::validate()
bool StringDataHolder::validate() {
        try {
            int tmpData = boost::lexical_cast<unsigned int>(baseData);
            if (tmpData < 0)
                return false;
            else
                nativeData = tmpData;
                return true;
        } catch (boost::bad_lexical_cast& e) {
            return false;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
callq 0x30f90
testb %al, %al
je 0x4713a
movl 0xc(%rsp), %eax
testl %eax, %eax
js 0x47193
movl %eax, 0x28(%rbx)
movb $0x1, %al
jmp 0x47195
movq 0x29cbf(%rip), %rax     # 0x70e00
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x29b9c(%rip), %rax     # 0x70cf0
movq %rax, 0x8(%rdi)
movq 0x29dc9(%rip), %rax     # 0x70f28
movq %rax, 0x10(%rdi)
callq 0x2fd00
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x305b0
jmp 0x47180
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x4719d
callq 0x2e8b0
callq 0x30740
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::normalizeEOL[abi:cxx11](char const*, char const*)
static std::string normalizeEOL(Reader::Location begin, Reader::Location end) {
  std::string normalized;
  normalized.reserve(end - begin);
  Reader::Location current = begin;
  while (current != end) {
    char c = *current++;
    if (c == '\r') {
      if (current != end && *current == '\n')
         // convert dos EOL
         ++current;
      // convert Mac EOL
      normalized += '\n';
    } else {
      normalized += c;
    }
  }
  return normalized;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rdx, %rsi
subq %r15, %rsi
callq 0x30550
cmpq %r14, %r15
je 0x491b5
leaq 0x1(%r15), %r13
movb (%r15), %al
cmpb $0xd, %al
jne 0x491a2
cmpq %r14, %r13
je 0x49193
cmpb $0xa, 0x1(%r15)
jne 0x49193
addq $0x2, %r15
movq %r15, %r13
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2f460
jmp 0x491ad
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2f460
movq %r13, %r15
cmpq %r14, %r13
jne 0x49175
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x491c1
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x491d1
callq 0x2f6c0
movq %r14, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Reader::recoverFromError(Json::Reader::TokenType)
bool Reader::recoverFromError(TokenType skipUntilToken) {
  int errorCount = int(errors_.size());
  Token skip;
  for (;;) {
    if (!readToken(skip))
      errors_.resize(errorCount); // discard errors caused by recovery
    if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream)
      break;
  }
  errors_.resize(errorCount);
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x98(%rdi), %r13
movq 0x78(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rdi), %r12
movq 0x88(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rdi), %r15
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30630
movl 0x20(%rsp), %eax
cmpl %ebp, %eax
je 0x49479
testl %eax, %eax
jne 0x49462
subq 0x8(%rsp), %r12
shrq $0x6, %r12
movl %r13d, %eax
subl 0x10(%rsp), %eax
negq %r13
movl $0x0, %ecx
sbbl %ecx, %ecx
leal (%rax,%rcx,8), %eax
andl $-0x8, %eax
subq 0x18(%rsp), %r15
shrq $0x6, %r15
addl %r12d, %r15d
addl %eax, %r15d
addq $0x50, %rbx
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x300f0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Reader::getLocationLineAndColumn[abi:cxx11](char const*) const
std::string Reader::getLocationLineAndColumn(Location location) const {
  int line, column;
  getLocationLineAndColumn(location, line, column);
  char buffer[18 + 16 + 16 + 1];
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
#if defined(WINCE)
  _snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#else
  sprintf_s(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#endif
#else
  snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column);
#endif
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2e600
movl (%r14), %ecx
movl (%r15), %r8d
leaq 0x124a6(%rip), %rdx     # 0x5c548
leaq 0x10(%rsp), %r14
movl $0x33, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x30640
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2e980
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e860
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::asBool() const
bool Value::asBool() const {
  switch (type_) {
  case booleanValue:
    return value_.bool_;
  case nullValue:
    return false;
  case intValue:
    return value_.int_ ? true : false;
  case uintValue:
    return value_.uint_ ? true : false;
  case realValue:
    return value_.real_ ? true : false;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to bool.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x4dba1
leaq 0xe303(%rip), %rcx      # 0x5be70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, (%rdi)
setne %al
jmp 0x4db98
movb (%rdi), %al
jmp 0x4db98
xorpd %xmm0, %xmm0
cmpneqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x4db98
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ffd0
leaq 0xee52(%rip), %rsi      # 0x5ca07
movl $0x21, %edx
movq %rbx, %rdi
callq 0x2fb10
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305c0
leaq 0x8(%rsp), %rdi
callq 0x30340
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4dbf8
callq 0x2f6c0
jmp 0x4dbf8
jmp 0x4dbf5
movq %rax, %rbx
movq 0x231e9(%rip), %rsi     # 0x70de8
leaq 0x28(%rsp), %rdi
callq 0x2ec30
leaq 0x98(%rsp), %rdi
callq 0x2e700
movq %rbx, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::operator>>(std::istream&, Json::Value&)
std::istream& operator>>(std::istream& sin, Value& root) {
  CharReaderBuilder b;
  std::string errs;
  bool ok = parseFromStream(b, sin, &root, &errs);
  if (!ok) {
    fprintf(stderr,
            "Error from reader: %s",
            errs.c_str());

    throwRuntimeError("reader error");
  }
  return sin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x30b80
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2e2a0
testb %al, %al
je 0x4eaf9
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4eae0
callq 0x2f6c0
leaq 0x48(%rsp), %rdi
callq 0x2f260
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x22380(%rip), %rax     # 0x70e80
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0xdb88(%rip), %rsi      # 0x5c697
xorl %eax, %eax
callq 0x30260
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xdb87(%rip), %rsi      # 0x5c6ad
leaq 0xdb8c(%rip), %rdx      # 0x5c6b9
leaq 0x28(%rsp), %rdi
callq 0x2e860
leaq 0x28(%rsp), %rdi
callq 0x2f490
jmp 0x4eb57
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x4eb5a
callq 0x2f6c0
jmp 0x4eb5a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4eb69
callq 0x2f6c0
leaq 0x48(%rsp), %rdi
callq 0x2f260
movq %rbx, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::ValueIteratorBase::name[abi:cxx11]() const
std::string ValueIteratorBase::name() const {
  char const* key;
  char const* end;
  key = memberName(&end);
  if (!key) return std::string();
  return std::string(key, end);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x4ed26
movl 0x28(%rax), %edx
shrl $0x2, %edx
addq %rsi, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x2e860
jmp 0x4ed39
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::CZString::CZString(Json::Value::CZString const&)
Value::CZString::CZString(const CZString& other)
    : cstr_(other.storage_.policy_ != noDuplication && other.cstr_ != 0
                ? duplicateStringValue(other.cstr_, other.storage_.length_)
                : other.cstr_)
{
  storage_.policy_ = (other.cstr_
                 ? (other.storage_.policy_ == noDuplication
                     ? noDuplication : duplicate)
                 : other.storage_.policy_);
  storage_.length_ = other.storage_.length_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r12d
movq (%rsi), %r15
testb $0x3, %r12b
je 0x4f0e5
testq %r15, %r15
je 0x4f0e2
shrl $0x2, %r12d
leaq 0x1(%r12), %rdi
callq 0x2ff80
testq %rax, %rax
je 0x4f120
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2f3d0
movb $0x0, (%r13,%r12)
movq %r13, %r15
jmp 0x4f0e5
xorl %r15d, %r15d
movq %r15, (%rbx)
movl 0x8(%r14), %eax
xorl %ecx, %ecx
andl $0x3, %eax
setne %cl
cmpq $0x0, (%r14)
cmovel %eax, %ecx
movl 0x8(%rbx), %eax
andl $-0x4, %eax
orl %ecx, %eax
movl %eax, 0x8(%rbx)
movl 0x8(%r14), %eax
andl $-0x4, %eax
orl %ecx, %eax
movl %eax, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xdf17(%rip), %rsi      # 0x5d047
leaq 0xdf5e(%rip), %rdx      # 0x5d095
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2e860
movq %rbx, %rdi
callq 0x2f490
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4f15b
callq 0x2f6c0
movq %rbx, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::Value(Json::ValueType)
void Value::initBasic(ValueType type, bool allocated) {
  type_ = type;
  allocated_ = allocated;
  comments_ = 0;
  start_ = 0;
  limit_ = 0;
}

// Assembly:
pushq %rbx
movzbl %sil, %eax
movl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
andl 0x8(%rdi), %ecx
orl %eax, %ecx
movw %cx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
cmpl $0x7, %esi
ja 0x4f2af
movq %rdi, %rbx
movl %esi, %eax
leaq 0xcc35(%rip), %rcx      # 0x5bea0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x4f2ad
movl $0x30, %edi
callq 0x2f830
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, (%rbx)
jmp 0x4f2ad
movb $0x0, (%rbx)
popq %rbx
retq
leaq 0xd450(%rip), %rdi      # 0x5c706
leaq 0xd00d(%rip), %rsi      # 0x5c2ca
leaq 0xd448(%rip), %rcx      # 0x5c70c
movl $0xa9c, %edx            # imm = 0xA9C
callq 0x2efc0
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::getString(char const**, char const**) const
bool Value::getString(char const** str, char const** end) const {
  if (type_ != stringValue) return false;
  if (value_.string_ == 0) return false;
  unsigned length;
  decodePrefixedString(this->allocated_, this->value_.string_, &length, str);
  *end = *str + length;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzwl 0x8(%rdi), %eax
cmpb $0x4, %al
sete %cl
movq (%rdi), %r15
testq %r15, %r15
setne %bpl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0x4fc01
movq %rdx, %rbx
movq %rsi, %r14
btl $0x8, %eax
jb 0x4fbef
movq %r15, %rdi
callq 0x2e980
jmp 0x4fbf6
movl (%r15), %eax
addq $0x4, %r15
movq %r15, (%r14)
movl %eax, %eax
addq %r15, %rax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::valueToString[abi:cxx11](long long)
std::string valueToString(LargestInt value) {
  UIntToStringBuffer buffer;
  char* current = buffer + sizeof(buffer);
  bool isNegative = value < 0;
  if (isNegative)
    value = -value;
  uintToString(LargestUInt(value), current);
  if (isNegative)
    *--current = '-';
  assert(current >= buffer);
  return current;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rsi, %r8
negq %r8
cmovsq %rsi, %r8
movq %rdi, %rbx
leaq 0x27(%rsp), %rsi
movb $0x0, 0x1(%rsi)
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %r8, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r8d, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, (%rsi)
decq %rsi
cmpq $0x9, %r8
movq %rdx, %r8
ja 0x4fc36
testq %rcx, %rcx
js 0x4fc69
incq %rsi
jmp 0x4fc6c
movb $0x2d, (%rsi)
leaq 0x10(%rsp), %rax
cmpq %rax, %rsi
jb 0x4fc8c
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2e880
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0xd0ba(%rip), %rdi      # 0x5cd4d
leaq 0xc630(%rip), %rsi      # 0x5c2ca
leaq 0xd0be(%rip), %rcx      # 0x5cd5f
movl $0xfb2, %edx            # imm = 0xFB2
callq 0x2efc0
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::valueToString[abi:cxx11](double)
std::string valueToString(double value) {
  // Allocate a buffer that is more than large enough to store the 16 digits of
  // precision requested below.
  char buffer[32];
  int len = -1;

// Print into the buffer. We need not request the alternative representation
// that always has a decimal point because JSON doesn't distingish the
// concepts of reals and integers.
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with
                                                      // visual studio 2005 to
                                                      // avoid warning.
#if defined(WINCE)
  len = _snprintf(buffer, sizeof(buffer), "%.17g", value);
#else
  len = sprintf_s(buffer, sizeof(buffer), "%.17g", value);
#endif
#else
  if (isfinite(value)) {
    len = snprintf(buffer, sizeof(buffer), "%.17g", value);
  } else {
    // IEEE standard states that NaN values will not compare to themselves
    if (value != value) {
      len = snprintf(buffer, sizeof(buffer), "null");
    } else if (value < 0) {
      len = snprintf(buffer, sizeof(buffer), "-1e+9999");
    } else {
      len = snprintf(buffer, sizeof(buffer), "1e+9999");
    }
    // For those, we do not need to call fixNumLoc, but it is fast.
  }
#endif
  assert(len >= 0);
  fixNumericLocale(buffer, buffer + len);
  return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x4fd82
ucomisd %xmm0, %xmm0
jp 0x4fdf5
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4fda2
movabsq $0x393939392b65312d, %rax # imm = 0x393939392B65312D
movq %rax, (%rsp)
movb $0x0, 0x8(%rsp)
movl $0x8, %eax
jmp 0x4fdb5
leaq 0xd02f(%rip), %rdx      # 0x5cdb8
movq %rsp, %rdi
movl $0x20, %esi
movb $0x1, %al
callq 0x30640
testl %eax, %eax
js 0x4fe08
je 0x4fdc9
movl %eax, %eax
jmp 0x4fdb5
movabsq $0x393939392b6531, %rax # imm = 0x393939392B6531
movq %rax, (%rsp)
movl $0x7, %eax
xorl %ecx, %ecx
cmpb $0x2c, (%rsp,%rcx)
jne 0x4fdc1
movb $0x2e, (%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x4fdb7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2e980
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e860
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x4(%rsp)
movl $0x6c6c756e, (%rsp)     # imm = 0x6C6C756E
movl $0x4, %eax
jmp 0x4fdb5
leaq 0xcfbd(%rip), %rdi      # 0x5cdcc
leaq 0xc4b4(%rip), %rsi      # 0x5c2ca
leaq 0xcfb8(%rip), %rcx      # 0x5cdd5
movl $0xfea, %edx            # imm = 0xFEA
callq 0x2efc0
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::asFloat() const
float Value::asFloat() const {
  switch (type_) {
  case intValue:
    return static_cast<float>(value_.int_);
  case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return static_cast<float>(value_.uint_);
#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return integerToDouble(value_.uint_);
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  case realValue:
    return static_cast<float>(value_.real_);
  case nullValue:
    return 0.0;
  case booleanValue:
    return value_.bool_ ? 1.0f : 0.0f;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to float.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x505aa
leaq 0xba0d(%rip), %rcx      # 0x5bf60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2ssq (%rdi), %xmm0
jmp 0x505a1
cmpb $0x0, (%rdi)
jne 0x50582
xorps %xmm0, %xmm0
jmp 0x505a1
movq (%rdi), %rax
testq %rax, %rax
js 0x5058c
cvtsi2ss %rax, %xmm0
jmp 0x505a1
cvtsd2ss (%rdi), %xmm0
jmp 0x505a1
movss 0xbc96(%rip), %xmm0     # 0x5c220
jmp 0x505a1
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ffd0
leaq 0xc426(%rip), %rsi      # 0x5c9e4
movl $0x22, %edx
movq %rbx, %rdi
callq 0x2fb10
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x305c0
leaq 0x8(%rsp), %rdi
callq 0x30340
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50601
callq 0x2f6c0
jmp 0x50601
jmp 0x505fe
movq %rax, %rbx
movq 0x207e0(%rip), %rsi     # 0x70de8
leaq 0x28(%rsp), %rdi
callq 0x2ec30
leaq 0x98(%rsp), %rdi
callq 0x2e700
movq %rbx, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::find(char const*, char const*) const
Value const* Value::find(char const* key, char const* end) const
{
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == objectValue,
      "in Json::Value::find(key, end, found): requires objectValue or nullValue");
  if (type_ == nullValue) return NULL;
  CZString actualKey(key, static_cast<unsigned>(end-key), CZString::noDuplication);
  ObjectValues::const_iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end()) return NULL;
  return &(*it).second;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x5136a
cmpl $0x7, %eax
jne 0x5137a
movq %rdi, %rbx
subl %esi, %edx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x2f7c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x31010
movq (%rbx), %rcx
addq $0x8, %rcx
leaq 0x30(%rax), %rdx
xorl %ebx, %ebx
cmpq %rcx, %rax
cmovneq %rdx, %rbx
leaq 0x20(%rsp), %rdi
callq 0x301d0
jmp 0x5136c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2ffd0
leaq 0xb905(%rip), %rsi      # 0x5cc93
movl $0x48, %edx
movq %rbx, %rdi
callq 0x2fb10
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x305c0
movq %rsp, %rdi
callq 0x30340
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x513cd
callq 0x2f6c0
jmp 0x513cd
jmp 0x513ca
movq %rax, %rbx
movq 0x1fa14(%rip), %rsi     # 0x70de8
leaq 0x20(%rsp), %rdi
callq 0x2ec30
leaq 0x90(%rsp), %rdi
callq 0x2e700
jmp 0x513fa
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x301d0
movq %rbx, %rdi
callq 0x30a10
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::removeMember(char const*, char const*, Json::Value*)
bool Value::removeMember(const char* key, const char* end, Value* removed)
{
  if (type_ != objectValue) {
    return false;
  }
  CZString actualKey(key, static_cast<unsigned>(end-key), CZString::noDuplication);
  ObjectValues::iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end())
    return false;
  *removed = it->second;
  value_.map_->erase(it);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpb $0x7, 0x8(%rdi)
jne 0x51653
movq %rcx, %r14
movq %rdi, %rbx
subl %esi, %edx
movq %rsp, %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x2f7c0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x31010
movq %rax, %r15
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r15
setne %bpl
je 0x51649
leaq 0x30(%r15), %rsi
leaq 0x10(%rsp), %rdi
callq 0x30680
movzwl 0x8(%r14), %eax
leaq 0x10(%rsp), %rdi
movzwl 0x8(%rdi), %ecx
movl $0xfe00, %edx           # imm = 0xFE00
movl %eax, %esi
andl %edx, %esi
andl %ecx, %edx
movq (%r14), %r8
movq (%rdi), %r9
movq %r9, (%r14)
movq %r8, (%rdi)
movl $0x1ff, %r8d            # imm = 0x1FF
andl %r8d, %ecx
orl %esi, %ecx
movw %cx, 0x8(%r14)
andl %r8d, %eax
orl %edx, %eax
movw %ax, 0x8(%rdi)
movq 0x10(%r14), %rax
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x10(%rdi)
movups 0x18(%rdi), %xmm0
movups 0x18(%r14), %xmm1
movups %xmm0, 0x18(%r14)
movups %xmm1, 0x18(%rdi)
callq 0x2ebb0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x30890
movq %rsp, %rdi
callq 0x301d0
jmp 0x51655
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x301d0
movq %rbx, %rdi
callq 0x30a10
nop
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::begin() const
Value::const_iterator Value::begin() const {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return const_iterator(value_.map_->begin());
    break;
  default:
    break;
  }
  return const_iterator();
}

// Assembly:
subq $0x18, %rsp
movzwl 0x8(%rdi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x51ced
movq %rsp, %rdi
callq 0x30590
jmp 0x51d01
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x30fb0
movq (%rsp), %rax
movb 0x8(%rsp), %dl
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::end() const
Value::const_iterator Value::end() const {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return const_iterator(value_.map_->end());
    break;
  default:
    break;
  }
  return const_iterator();
}

// Assembly:
subq $0x18, %rsp
movzwl 0x8(%rdi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x51d39
movq %rsp, %rdi
callq 0x30590
jmp 0x51d4d
addq $0x8, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x30fb0
movq (%rsp), %rax
movb 0x8(%rsp), %dl
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::begin()
Value::iterator Value::begin() {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return iterator(value_.map_->begin());
    break;
  default:
    break;
  }
  return iterator();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x8(%rsi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rsi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x51d89
movq %rbx, %rdi
callq 0x302a0
jmp 0x51d9d
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x2eaa0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::end()
Value::iterator Value::end() {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return iterator(value_.map_->end());
    break;
  default:
    break;
  }
  return iterator();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x8(%rsi), %eax
andl $0xfe, %eax
cmpw $0x6, %ax
setne %cl
movq (%rsi), %rax
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x51dd5
movq %rbx, %rdi
callq 0x302a0
jmp 0x51de9
addq $0x8, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x2eaa0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::StyledWriter::isMultineArray(Json::Value const&)
bool StyledWriter::isMultineArray(const Value& value) {
  int size = value.size();
  bool isMultiLine = size * 3 >= rightMargin_;
  childValues_.clear();
  for (int index = 0; index < size && !isMultiLine; ++index) {
    const Value& childValue = value[index];
    isMultiLine =
        isMultiLine || ((childValue.isArray() || childValue.isObject()) &&
                        childValue.size() > 0);
  }
  if (!isMultiLine) // check if line length > max line length
  {
    childValues_.reserve(size);
    addChildValues_ = true;
    int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
    for (int index = 0; index < size; ++index) {
      if (hasCommentForValue(value[index])) {
        isMultiLine = true;
      }
      writeValue(value[index]);
      lineLength += int(childValues_[index].length());
    }
    addChildValues_ = false;
    isMultiLine = isMultiLine || lineLength >= rightMargin_;
  }
  return isMultiLine;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x30720
movl %eax, %r15d
leal (%r15,%r15,2), %eax
cmpl 0x60(%rbx), %eax
setge %bpl
leaq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x2f720
testl %r15d, %r15d
setle %al
orb %bpl, %al
testb $0x1, %al
jne 0x53acd
movl $0x1, %r13d
leal -0x1(%r13), %esi
movq %r14, %rdi
callq 0x2e3c0
movzwl 0x8(%rax), %ecx
andl $0xfe, %ecx
cmpw $0x6, %cx
jne 0x53abe
movq %rax, %rdi
callq 0x30720
testl %eax, %eax
setne %bpl
jmp 0x53ac0
xorl %ebp, %ebp
cmpl %r15d, %r13d
jge 0x53acd
incl %r13d
testb %bpl, %bpl
je 0x53a92
movb $0x1, %al
testb %bpl, %bpl
jne 0x53b78
movslq %r15d, %rsi
movq %r12, %rdi
callq 0x2fda0
movb $0x1, 0x68(%rbx)
leal 0x2(,%r15,2), %ebp
testl %r15d, %r15d
jle 0x53b62
movl %r15d, %r13d
movl $0x8, %r12d
xorl %r15d, %r15d
movl $0x0, 0x4(%rsp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e3c0
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x53b36
cmpq $0x0, (%rax)
jne 0x53b30
cmpq $0x0, 0x8(%rax)
jne 0x53b30
cmpq $0x0, 0x10(%rax)
je 0x53b36
movb $0x1, %al
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x2e3c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ed50
movq 0x8(%rbx), %rax
addl (%rax,%r12), %ebp
incq %r15
addq $0x20, %r12
cmpq %r15, %r13
jne 0x53b08
jmp 0x53b6a
movl $0x0, 0x4(%rsp)
movb $0x0, 0x68(%rbx)
cmpl 0x60(%rbx), %ebp
setge %al
orb 0x4(%rsp), %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::next_string(char)
Token Tokenizer::next_string(char strstart) {
	std::string *str = new std::string("");
	pos++;
	while (pos < source.length()) {
		char c = source[pos++];
		if (c == '\\') {
			char c = source[pos++];
			switch (c) {
			case 'n': c = '\n'; break;
			case 't': c = '\t'; break;
			case 'r': c = '\r'; break;
			case '"': c = '"';  break;
			case '\'': c = '\''; break;
			default:
				throw utils::tokenizer_error("not escapeable", line, c);
			}
		} else if (c == strstart)
			break;
		*str += c;
	}
	return Token(String, str, line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x20, %edi
callq 0x5380
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10a00(%rip), %rdx     # 0x17104
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6646
movq (%r14), %rax
movq 0x10(%r14), %rcx
incq %rax
movq %rax, (%r14)
cmpq 0x8(%rcx), %rax
jae 0x6781
movl $0x51, %r15d
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movq (%rcx), %rdx
movb (%rdx,%rax), %cl
cmpb $0x5c, %cl
jne 0x6764
leaq 0x2(%rax), %rsi
movq %rsi, (%r14)
movb 0x1(%rdx,%rax), %r12b
movzbl %r12b, %eax
leal -0x6e(%rax), %edx
cmpl $0x6, %edx
ja 0x6758
btl %edx, %r15d
jb 0x6769
cmpl $0x22, %eax
je 0x6769
cmpl $0x27, %eax
je 0x6769
jmp 0x6799
cmpb %bpl, %cl
je 0x6781
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x5300
movq (%r14), %rax
movq 0x10(%r14), %rcx
cmpq 0x8(%rcx), %rax
jb 0x6728
movl 0x8(%r14), %eax
shlq $0x20, %rax
orq $0x3, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x51b0
movq %rax, %rbx
movl 0x8(%r14), %edx
movsbl %r12b, %ecx
leaq 0x10c9a(%rip), %rsi     # 0x1744f
movq %rax, %rdi
callq 0xa6d8
leaq 0x19d74(%rip), %rsi     # 0x20538
leaq 0x126b(%rip), %rdx      # 0x7a36
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0x67f0
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::next_number()
Token Tokenizer::next_number() {
	std::string str = "";
	bool contains_dot = false;
	char c = source[pos];
	while (('0' <= c && c <= '9') || c == '.' || (c >= 'a' && c <= 'z')) {
		str += c;
		if (c == '.')
			contains_dot = true;
		if (++pos >= source.length())
			break;
		c = source[pos];
	}

	if (contains_dot)
		return Token(Real, std::stod(str, nullptr), line);
	else
		return Token(Int, std::stoi(str, nullptr, 0), line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x108eb(%rip), %rdx     # 0x17104
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6646
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movb (%rcx,%rax), %al
cmpb $0x2e, %al
sete %bpl
je 0x684f
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x684f
leal -0x61(%rax), %ecx
cmpb $0x19, %cl
ja 0x68e3
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
movsbl %al, %esi
movq %r14, %rdi
callq 0x5300
orb %bpl, %r15b
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rax
movq %rax, (%rbx)
cmpq 0x8(%rcx), %rax
jae 0x6896
movq (%rcx), %rcx
movb (%rcx,%rax), %al
cmpb $0x2e, %al
sete %bpl
je 0x6857
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x6857
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jb 0x6857
testb $0x1, %r15b
je 0x68e3
movq 0x10(%rsp), %r15
callq 0x5050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x52c0
cmpq %r15, (%r12)
je 0x6995
movl (%r14), %eax
testl %eax, %eax
je 0x6936
cmpl $0x22, %eax
jne 0x6939
leaq 0x10cbb(%rip), %rdi     # 0x17599
callq 0x54f0
movq 0x10(%rsp), %r15
callq 0x5050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x54e0
cmpq %r15, (%r12)
je 0x697d
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6989
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x6989
testl %ecx, %ecx
jne 0x6927
movl %ebp, (%r14)
movl 0x8(%rbx), %ebx
movl %eax, 0x8(%rsp)
movl $0x1, %r14d
jmp 0x6948
movl %ebp, (%r14)
movl 0x8(%rbx), %ebx
movsd %xmm0, 0x8(%rsp)
movl $0x2, %r14d
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x695f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5390
shlq $0x20, %rbx
orq %r14, %rbx
movq 0x8(%rsp), %rdx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10c1a(%rip), %rdi     # 0x1759e
callq 0x5200
leaq 0x10c0e(%rip), %rdi     # 0x1759e
callq 0x54f0
leaq 0x10bfd(%rip), %rdi     # 0x17599
callq 0x5200
jmp 0x69a3
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x69b4
movl %ebp, (%r14)
jmp 0x69b4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x69cb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::peek()
Token Tokenizer::peek() {
	if (tokbuffed)
		return tokbuf;

	tokbuf = next();
	tokbuffed = true;
	return tokbuf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x69e8
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
jmp 0x69fc
movq %rbx, %rdi
callq 0x69fe
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movb $0x1, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse()
ast::Node* Parser::parse() {
	std::vector<ast::Node*> parsed;
	while (tokenizer.peek().type != tok::EOFTok) {
		parsed.push_back(next());
	}

	return parsed.size() == 1 ? parsed[0] : new ast::Block(parsed);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x38(%rsp), %r15
movq %rbx, %rdi
callq 0x69d4
cmpl $0x25, %eax
je 0x80f6
movq %rbx, %rdi
callq 0x81d4
movq %rax, 0x38(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa198
jmp 0x80cf
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x810d
movq (%rax), %rbx
jmp 0x815d
movl $0x20, %edi
callq 0x5380
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x9eb0
leaq 0x18a0a(%rip), %rax     # 0x20b38
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9eb0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x815d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8173
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x819f
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
jmp 0x819f
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5390
jmp 0x81b5
jmp 0x81b2
jmp 0x81b2
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x81cb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
nop