LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xb0(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9a9c0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x9e3b0
movq -0xa8(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0xc0, %rdi
callq 0x9aa80
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x98800
testb $0x1, %al
jne 0xd60e3
jmp 0xd610f
leaq -0x20(%rbp), %rdi
callq 0x9fc30
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x9a4f0
movq -0xb8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movb $0x1, -0x9d(%rbp)
movl $0x10, %edi
callq 0x99e80
movq -0xb0(%rbp), %rdx
movq %rax, -0xc8(%rbp)
leaq 0x2d891(%rip), %rsi     # 0x1039c6
leaq -0x90(%rbp), %rdi
callq 0x9cf50
jmp 0xd6143
leaq 0x2d8a2(%rip), %rdx     # 0x1039ec
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x98100
jmp 0xd615c
movq -0xa8(%rbp), %rdx
addq $0x8, %rdx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa15c0
jmp 0xd6176
movq -0xc8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa2430
jmp 0xd6188
movq -0xc8(%rbp), %rdi
movb $0x0, -0x9d(%rbp)
movq 0x5ce3b(%rip), %rsi     # 0x132fd8
movq 0x5cbfc(%rip), %rdx     # 0x132da0
callq 0xa2fe0
jmp 0xd623f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xd621a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xd620e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xd6205
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa4f00
leaq -0x70(%rbp), %rdi
callq 0xa4f00
leaq -0x90(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x9d(%rbp)
jne 0xd6225
jmp 0xd6231
movq -0xc8(%rbp), %rdi
callq 0x9b9c0
jmp 0xd6233
movq -0x98(%rbp), %rdi
callq 0xa3520
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x98460
movq -0x20(%rbp), %rdi
movl %eax, 0x8(%rdi)
callq 0xa2d40
testb $0x1, %al
jne 0xdb4db
movb $0x0, -0x1(%rbp)
jmp 0xdb511
movq -0x20(%rbp), %rax
movl $0x1, -0x14(%rbp)
movl 0x8(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0xa36f0
cmpl $-0x1, %eax
jne 0xdb50d
movb $0x0, -0x1(%rbp)
jmp 0xdb511
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::bind(int)
bool Socket::bind(const int port) {

        if (!is_valid()) {
            return false;
        }



        m_addr.sin_family = AF_INET;
        m_addr.sin_addr.s_addr = INADDR_ANY;
        m_addr.sin_port = htons(port);

        int bind_return = ::bind(m_sock,
                (struct sockaddr *) &m_addr,
                sizeof ( m_addr));


        if (bind_return == -1) {
            return false;
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa2d40
testb $0x1, %al
jne 0xdb546
movb $0x0, -0x1(%rbp)
jmp 0xdb58e
movq -0x20(%rbp), %rax
movw $0x2, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x97430
movq -0x20(%rbp), %rsi
movw %ax, 0xe(%rsi)
movl 0x8(%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x97920
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0xdb58a
movb $0x0, -0x1(%rbp)
jmp 0xdb58e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::listen() const
bool Socket::listen() const {
        if (!is_valid()) {
            return false;
        }

        int listen_return = ::listen(m_sock, MAXCONNECTIONS);


        if (listen_return == -1) {
            return false;
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa2d40
testb $0x1, %al
jne 0xdb5c3
movb $0x0, -0x1(%rbp)
jmp 0xdb5e7
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movl $0x5, %esi
callq 0x9e9b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xdb5e3
movb $0x0, -0x1(%rbp)
jmp 0xdb5e7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::accept(fprime::Socket*) const
bool Socket::accept(Socket* new_socket) const {
        int addr_length = sizeof ( m_addr);
        new_socket->m_sock = ::accept(m_sock, (sockaddr *) & m_addr, (socklen_t *) & addr_length);

        if (new_socket->m_sock <= 0)
            return false;
        else
            return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl $0x10, -0x1c(%rbp)
movl 0x8(%rsi), %edi
addq $0xc, %rsi
leaq -0x1c(%rbp), %rdx
callq 0x98c10
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jg 0xdb644
movb $0x0, -0x1(%rbp)
jmp 0xdb648
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Socket::send(const std::string s) const {
        int status = ::send(m_sock, s.c_str(), s.size(), 0);
        if (status == -1) {
            return false;
        } else {
            return true;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x99590
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x9b8b0
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x99f40
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0xdb6bb
movb $0x0, -0x1(%rbp)
jmp 0xdb6bf
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x430(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x26a65(%rip), %rsi     # 0x10215e
callq 0xa0390
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x401, %edx            # imm = 0x401
callq 0x9a5f0
movq -0x430(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x98d70
movl %eax, -0x424(%rbp)
cmpl $-0x1, -0x424(%rbp)
jne 0xdb782
movq 0x576f4(%rip), %rdi     # 0x132e38
leaq 0x28412(%rip), %rsi     # 0x103b5d
callq 0x9dba0
movq %rax, -0x438(%rbp)
callq 0x97300
movq -0x438(%rbp), %rdi
movl (%rax), %esi
callq 0xa3150
movq %rax, %rdi
leaq 0x28402(%rip), %rsi     # 0x103b76
callq 0x9dba0
movl $0x0, -0x4(%rbp)
jmp 0xdb7ad
cmpl $0x0, -0x424(%rbp)
jne 0xdb794
movl $0x0, -0x4(%rbp)
jmp 0xdb7ad
leaq -0x420(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0xa0390
movl -0x424(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: xjrueda[P]fixprime/src/Socket.cpp
// Function: fprime::Socket::connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool Socket::connect(const std::string host, const int port) {
        if (!is_valid()) return false;

        m_addr.sin_family = AF_INET;
        m_addr.sin_port = htons(port);

        int status = inet_pton(AF_INET, host.c_str(), &m_addr.sin_addr);

        if (errno == EAFNOSUPPORT) return false;

        status = ::connect(m_sock, (sockaddr *) & m_addr, sizeof ( m_addr));

        if (status == 0)
            return true;
        else
            return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xa2d40
testb $0x1, %al
jne 0xdb7ee
movb $0x0, -0x1(%rbp)
jmp 0xdb86b
movq -0x28(%rbp), %rax
movw $0x2, 0xc(%rax)
movl -0x1c(%rbp), %eax
movzwl %ax, %edi
callq 0x97430
movq -0x30(%rbp), %rdi
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0xe(%rax)
callq 0x99590
movq -0x28(%rbp), %rdx
movq %rax, %rsi
addq $0xc, %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0xa44f0
movl %eax, -0x20(%rbp)
callq 0x97300
cmpl $0x61, (%rax)
jne 0xdb843
movb $0x0, -0x1(%rbp)
jmp 0xdb86b
movq -0x28(%rbp), %rsi
movl 0x8(%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x9c820
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0xdb867
movb $0x1, -0x1(%rbp)
jmp 0xdb86b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x9a8e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xdb8b6
jmp 0xdb8ea
testb $0x1, -0x9(%rbp)
je 0xdb8c9
movl -0x10(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x10(%rbp)
jmp 0xdb8d4
movl -0x10(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movl -0x10(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x9a8e0
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x97100
movq -0xa0(%rbp), %rdi
movq 0x570cd(%rip), %rax     # 0x132d28
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x9c4e0
movb %al, -0x93(%rbp)
jmp 0xdbc6f
movb -0x93(%rbp), %al
testb $0x1, %al
jne 0xdbd48
jmp 0xdbc7f
movb $0x1, -0x4a(%rbp)
movl $0x20, %edi
callq 0x99e80
movq %rax, -0xb8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa35e0
movq -0xb0(%rbp), %rdx
leaq 0x27f3c(%rip), %rsi     # 0x103bee
leaq -0x48(%rbp), %rdi
callq 0xa0510
jmp 0xdbcbd
movq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9d000
jmp 0xdbccf
movq -0xb8(%rbp), %rdi
movb $0x0, -0x4a(%rbp)
movq 0x57317(%rip), %rsi     # 0x132ff8
movq 0x56fa8(%rip), %rdx     # 0x132c90
callq 0xa2fe0
jmp 0xdbe9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xdbe88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xdbd26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa4f00
leaq -0x49(%rbp), %rdi
callq 0x9e350
testb $0x1, -0x4a(%rbp)
jne 0xdbd37
jmp 0xdbd43
movq -0xb8(%rbp), %rdi
callq 0x9b9c0
jmp 0xdbe88
movq -0xa8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x998d0
jmp 0xdbd5a
movq -0xa0(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x70(%rbp), %rsi
callq 0xa0ac0
movb %al, -0xb9(%rbp)
jmp 0xdbd75
movb -0xb9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xba(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa4f00
movb -0xba(%rbp), %al
testb $0x1, %al
jne 0xdbd9b
jmp 0xdbe7f
movb $0x1, -0x92(%rbp)
movl $0x20, %edi
callq 0x99e80
movq %rax, -0xd0(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xa35e0
movq -0xc8(%rbp), %rdx
leaq 0x27de6(%rip), %rsi     # 0x103bba
leaq -0x90(%rbp), %rdi
callq 0xa0510
jmp 0xdbde2
movq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x9d000
jmp 0xdbdf7
movq -0xd0(%rbp), %rdi
movb $0x0, -0x92(%rbp)
movq 0x571ec(%rip), %rsi     # 0x132ff8
movq 0x56e7d(%rip), %rdx     # 0x132c90
callq 0xa2fe0
jmp 0xdbe9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa4f00
jmp 0xdbe88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xdbe5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xa4f00
leaq -0x91(%rbp), %rdi
callq 0x9e350
testb $0x1, -0x92(%rbp)
jne 0xdbe71
jmp 0xdbe7d
movq -0xd0(%rbp), %rdi
callq 0x9b9c0
jmp 0xdbe88
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0xa44b0
movq -0x20(%rbp), %rdi
callq 0xa3520
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0x99560
movl %eax, -0x34(%rbp)
jmp 0xdc382
movl -0x34(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xdc3c4
movb $0x0, -0x1(%rbp)
jmp 0xdc3d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xdc3dd
movq -0x20(%rbp), %rdi
callq 0x99540
movq %rax, -0x30(%rbp)
movb $0x0, -0x1(%rbp)
callq 0xa2520
jmp 0xdc3d2
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/Value.cpp
// Function: fprime::Value::toDouble()
double Value::toDouble() {
        if (!value.empty()) {
            try {
                return boost::lexical_cast<double>(value);
            } catch (boost::bad_lexical_cast& badCast) {
                throw BadConvertion("Value " + value + " can't be converted to double datatype");
            }
        } else
            throw NullValue();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
callq 0xa2940
testb $0x1, %al
jne 0xdc788
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x9f6d0
movsd %xmm0, -0x78(%rbp)
jmp 0xdc68c
movsd -0x78(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xdc7d8
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movb $0x1, -0x61(%rbp)
movl $0x28, %edi
callq 0x99e80
movq -0x70(%rbp), %rdx
movq %rax, -0x80(%rbp)
addq $0x8, %rdx
leaq 0x275da(%rip), %rsi     # 0x103cbe
leaq -0x60(%rbp), %rdi
callq 0x9cf50
jmp 0xdc6ef
leaq 0x275cf(%rip), %rdx     # 0x103cc5
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x98100
jmp 0xdc705
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x98610
jmp 0xdc714
movq -0x80(%rbp), %rdi
movb $0x0, -0x61(%rbp)
movq 0x56875(%rip), %rsi     # 0x132f98
movq 0x56616(%rip), %rdx     # 0x132d40
callq 0xa2fe0
jmp 0xdc7e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xdc76e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xdc765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa4f00
leaq -0x60(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x61(%rbp)
jne 0xdc776
jmp 0xdc77f
movq -0x80(%rbp), %rdi
callq 0x9b9c0
callq 0xa2520
jmp 0xdc786
jmp 0xdc7d8
movl $0x8, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x9b000
jmp 0xdc7a6
movq -0x88(%rbp), %rdi
movq 0x567dc(%rip), %rsi     # 0x132f90
movq 0x56465(%rip), %rdx     # 0x132c20
callq 0xa2fe0
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopl (%rax)
// File: xjrueda[P]fixprime/src/Value.cpp
// Function: fprime::Value::toInt()
int Value::toInt() {
        if (!value.empty()) {
            try {
                return boost::lexical_cast<int>(value);
            } catch (boost::bad_lexical_cast& badCast) {
                throw BadConvertion("Value " + value + " can't be converted to int datatype");
            }
        } else
            throw NullValue();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
callq 0xa2940
testb $0x1, %al
jne 0xdc924
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x9e680
movl %eax, -0x74(%rbp)
jmp 0xdc82a
movl -0x74(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xdc974
movq -0x10(%rbp), %rdi
callq 0x99540
movq %rax, -0x20(%rbp)
movb $0x1, -0x61(%rbp)
movl $0x28, %edi
callq 0x99e80
movq -0x70(%rbp), %rdx
movq %rax, -0x80(%rbp)
addq $0x8, %rdx
leaq 0x2743e(%rip), %rsi     # 0x103cbe
leaq -0x60(%rbp), %rdi
callq 0x9cf50
jmp 0xdc88b
leaq 0x2745a(%rip), %rdx     # 0x103cec
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x98100
jmp 0xdc8a1
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x98610
jmp 0xdc8b0
movq -0x80(%rbp), %rdi
movb $0x0, -0x61(%rbp)
movq 0x566d9(%rip), %rsi     # 0x132f98
movq 0x5647a(%rip), %rdx     # 0x132d40
callq 0xa2fe0
jmp 0xdc985
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xdc90a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xdc901
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa4f00
leaq -0x60(%rbp), %rdi
callq 0xa4f00
testb $0x1, -0x61(%rbp)
jne 0xdc912
jmp 0xdc91b
movq -0x80(%rbp), %rdi
callq 0x9b9c0
callq 0xa2520
jmp 0xdc922
jmp 0xdc974
movl $0x8, %edi
callq 0x99e80
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x9b000
jmp 0xdc942
movq -0x88(%rbp), %rdi
movq 0x56640(%rip), %rsi     # 0x132f90
movq 0x562c9(%rip), %rdx     # 0x132c20
callq 0xa2fe0
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9b9c0
movq -0x10(%rbp), %rdi
callq 0xa3520
movq %rax, %rdi
callq 0xa6900
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa0780
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
callq 0xa1c80
jmp 0xdf27e
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xdf314
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %al
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0xd, %eax
jne 0xdf2fe
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xdf2ec
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xdf2ec
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xdf2ec
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa4f00
jmp 0xdf331
movq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x9b130
jmp 0xdf2fc
jmp 0xdf30f
movq -0x48(%rbp), %rdi
movsbl -0x39(%rbp), %esi
callq 0x9b130
jmp 0xdf30d
jmp 0xdf30f
jmp 0xdf286
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xdf327
movq -0x48(%rbp), %rdi
callq 0xa4f00
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xa3520
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x50, %rdi
callq 0x9bb70
movl %eax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa2110
testb $0x1, %al
jne 0xdf715
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa08e0
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0xdf723
cmpl $0x0, -0x28(%rbp)
jne 0xdf725
jmp 0xdf727
jmp 0xdf6f3
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa08e0
xorl %eax, %eax
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x98a10
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
leaq 0x23e01(%rip), %rdx     # 0x104acc
xorl %eax, %eax
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0x33, %esi
callq 0xa21a0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa35e0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0xa0510
jmp 0xe0d08
leaq -0x61(%rbp), %rdi
callq 0x9e350
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x9e350
movq -0x70(%rbp), %rdi
callq 0xa3520
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, -0x1c0(%rbp)
subw $0x5, %ax
ja 0xe5d91
movq -0x1c0(%rbp), %rax
leaq 0x1e738(%rip), %rcx     # 0x104448
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x1c8(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe5e2f
movb $0x0, -0x1(%rbp)
jmp 0xe5e2f
movq -0x1c8(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
negq %rcx
sbbl %eax, %eax
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe5e2f
movq -0x1c8(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
negq %rcx
sbbl %eax, %eax
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe5e2f
movq -0x1c8(%rbp), %rax
movsd (%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setp %cl
setne %al
orb %cl, %al
negb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe5e2f
jmp 0xe5d93
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xa0240
movq -0x1d0(%rbp), %rdi
leaq 0x1f1d3(%rip), %rsi     # 0x104f87
callq 0x9dba0
jmp 0xe5dbb
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9df20
jmp 0xe5dd0
leaq -0x1b8(%rbp), %rdi
callq 0xa12d0
jmp 0xe5dde
leaq -0x1b8(%rbp), %rdi
callq 0xa4f00
callq 0x9a610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xe5e21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xa4f00
leaq -0x188(%rbp), %rdi
callq 0x98420
jmp 0xe5e3d
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xa3520
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa3b60
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa0780
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rcx
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x97c70
movb %al, -0x9a(%rbp)
jmp 0xe7516
movb -0x9a(%rbp), %al
andb $0x1, %al
movb %al, -0x61(%rbp)
testb $0x1, -0x61(%rbp)
jne 0xe75f6
movq 0x4b92e(%rip), %rax     # 0x132e60
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x99590
movq -0xc0(%rbp), %rdi
movq %rax, %rdx
leaq 0x1d6c1(%rip), %rsi     # 0x104c17
xorl %eax, %eax
callq 0xa0ee0
leaq -0x99(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xa35e0
movq -0xb8(%rbp), %rdx
leaq 0x1d6af(%rip), %rsi     # 0x104c2d
leaq -0x98(%rbp), %rdi
callq 0xa0510
jmp 0xe758c
leaq -0x98(%rbp), %rdi
callq 0x9ccb0
jmp 0xe759a
leaq -0x98(%rbp), %rdi
callq 0xa4f00
leaq -0x99(%rbp), %rdi
callq 0x9e350
jmp 0xe75f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xe7623
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xe75e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xa4f00
leaq -0x99(%rbp), %rdi
callq 0x9e350
jmp 0xe7623
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa4f00
leaq -0x40(%rbp), %rdi
callq 0x9bee0
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0xa4f00
leaq -0x40(%rbp), %rdi
callq 0x9bee0
movq -0x70(%rbp), %rdi
callq 0xa3520
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9daf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe7aae
movq -0x48(%rbp), %rdi
callq 0xa0780
jmp 0xe7b04
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa35e0
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x99500
jmp 0xe7ae2
leaq -0x21(%rbp), %rdi
callq 0x9e350
jmp 0xe7b04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x9e350
jmp 0xe7b0e
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xa3520
nopw (%rax,%rax)
// File: xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::ValueIteratorBase::memberName(char const**) const
char const* ValueIteratorBase::memberName(char const** end) const {
  const char* name = (*current_).first.data();
  if (!name) {
    *end = NULL;
    return NULL;
  }
  *end = name + (*current_).first.length();
  return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xa0420
movq %rax, %rdi
callq 0x9f6a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe7b65
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xe7b96
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xa0420
movq %rax, %rdi
callq 0xa3920
movq -0x30(%rbp), %rcx
movl %eax, %eax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Value::Value(Json::ValueType)
Value::Value(ValueType type) {
  initBasic(type);
  switch (type) {
  case nullValue:
    break;
  case intValue:
  case uintValue:
    value_.int_ = 0;
    break;
  case realValue:
    value_.real_ = 0.0;
    break;
  case stringValue:
    value_.string_ = 0;
    break;
  case arrayValue:
  case objectValue:
    value_.map_ = new ObjectValues();
    break;
  case booleanValue:
    value_.bool_ = false;
    break;
  default:
    JSON_ASSERT_UNREACHABLE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0xa4870
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0xe864a
movq -0x18(%rbp), %rax
leaq 0x1be9f(%rip), %rcx     # 0x104478
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xe8669
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0xe8669
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0xe8669
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0xe8669
movl $0x30, %edi
callq 0x9dc00
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x9a5f0
movq -0x28(%rbp), %rdi
callq 0x9b2f0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xe8669
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0xe8669
leaq 0x1c635(%rip), %rdi     # 0x104c86
leaq 0x1c1f2(%rip), %rsi     # 0x10484a
movl $0xa9c, %edx            # imm = 0xA9C
leaq 0x1c628(%rip), %rcx     # 0x104c8c
callq 0x9b450
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x4, %eax
je 0xe9842
movb $0x0, -0x1(%rbp)
jmp 0xe9899
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xe9852
movb $0x0, -0x1(%rbp)
jmp 0xe9899
movq -0x30(%rbp), %rcx
movw 0x8(%rcx), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
setne %al
movq (%rcx), %rsi
movq -0x18(%rbp), %rcx
movzbl %al, %edi
andl $0x1, %edi
leaq -0x24(%rbp), %rdx
callq 0xe8ec0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movl -0x24(%rbp), %eax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
addq $0x19, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
je 0xe98f4
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xee2a0
testb $0x1, -0x39(%rbp)
je 0xe991a
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x2d, -0x1(%rax)
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jb 0xe9929
jmp 0xe9948
leaq 0x1b9a0(%rip), %rdi     # 0x1052d0
leaq 0x1af13(%rip), %rsi     # 0x10484a
movl $0xfb2, %edx            # imm = 0xFB2
leaq 0x1b99f(%rip), %rcx     # 0x1052e2
callq 0x9b450
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x3a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa35e0
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xa0510
jmp 0xe9970
leaq -0x3a(%rbp), %rdi
callq 0x9e350
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x3a(%rbp), %rdi
callq 0x9e350
movq -0x48(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, -0x1c0(%rbp)
subw $0x5, %ax
ja 0xead0c
movq -0x1c0(%rbp), %rax
leaq 0x19918(%rip), %rcx     # 0x104538
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x1c8(%rbp), %rax
cvtsi2ssq (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xeadaa
movq -0x1c8(%rbp), %rax
movq (%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x1d0(%rbp)
testq %rax, %rax
movss %xmm0, -0x1cc(%rbp)
js 0xeac8a
movss -0x1d0(%rbp), %xmm0
movss %xmm0, -0x1cc(%rbp)
movss -0x1cc(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xeadaa
movq -0x1c8(%rbp), %rax
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xeadaa
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xeadaa
movq -0x1c8(%rbp), %rax
movb (%rax), %al
movss 0x19acd(%rip), %xmm0    # 0x1047a0
xorps %xmm1, %xmm1
movss %xmm1, -0x1d8(%rbp)
testb $0x1, %al
movss %xmm0, -0x1d4(%rbp)
jne 0xeacfa
movss -0x1d8(%rbp), %xmm0
movss %xmm0, -0x1d4(%rbp)
movss -0x1d4(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xeadaa
jmp 0xead0e
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0xa0240
movq -0x1e0(%rbp), %rdi
leaq 0x1a235(%rip), %rsi     # 0x104f64
callq 0x9dba0
jmp 0xead36
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9df20
jmp 0xead4b
leaq -0x1b8(%rbp), %rdi
callq 0xa12d0
jmp 0xead59
leaq -0x1b8(%rbp), %rdi
callq 0xa4f00
callq 0x9a610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xead9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xa4f00
leaq -0x188(%rbp), %rdi
callq 0x98420
jmp 0xeadb8
movss -0x4(%rbp), %xmm0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xec5f0
movq -0x208(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0xec5f0
leaq -0x198(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0xa0240
movq -0x210(%rbp), %rdi
leaq 0x18ca1(%rip), %rsi     # 0x105213
callq 0x9dba0
jmp 0xec579
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x9df20
jmp 0xec58e
leaq -0x1c8(%rbp), %rdi
callq 0xa12d0
jmp 0xec59c
leaq -0x1c8(%rbp), %rdi
callq 0xa4f00
callq 0x9a610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0xec5df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xa4f00
leaq -0x198(%rbp), %rdi
callq 0x98420
jmp 0xec721
movq -0x208(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0xec614
movq $0x0, -0x8(%rbp)
jmp 0xec714
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x220(%rbp)
xorl %ecx, %ecx
callq 0x9da90
movq -0x208(%rbp), %rax
movq -0x220(%rbp), %rsi
movq (%rax), %rdi
callq 0xa1a20
movq %rax, -0x218(%rbp)
jmp 0xec653
movq -0x218(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0xa1f80
movq -0x208(%rbp), %rax
movq (%rax), %rdi
callq 0x9a370
movq %rax, -0x1f8(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xa1f80
leaq -0x1e0(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0xa1400
testb $0x1, %al
jne 0xec6b6
jmp 0xec6ea
movq $0x0, -0x8(%rbp)
movl $0x1, -0x1fc(%rbp)
jmp 0xec708
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xa0d30
jmp 0xec721
leaq -0x1e0(%rbp), %rdi
callq 0x97aa0
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x1fc(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xa0d30
movq -0x8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0xa3520
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0xec99f
movb $0x0, -0x1(%rbp)
jmp 0xecade
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
xorl %ecx, %ecx
callq 0x9da90
movq -0xa0(%rbp), %rax
movq -0xb0(%rbp), %rsi
movq (%rax), %rdi
callq 0xa1a20
movq %rax, -0xa8(%rbp)
jmp 0xec9db
movq -0xa0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
callq 0x9a370
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9acb0
testb $0x1, %al
jne 0xeca0c
jmp 0xeca2d
movb $0x0, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0xecac8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xecad3
leaq -0x40(%rbp), %rdi
callq 0xa1a60
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x88(%rbp), %rdi
callq 0xa2280
jmp 0xeca4b
movq -0x28(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x98040
jmp 0xeca5d
leaq -0x88(%rbp), %rdi
callq 0x9a180
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
callq 0xa4850
movq %rax, -0xb8(%rbp)
jmp 0xeca93
movq -0xb8(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0xecac8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x9a180
jmp 0xecad3
leaq -0x38(%rbp), %rdi
callq 0xa0d30
jmp 0xecade
leaq -0x38(%rbp), %rdi
callq 0xa0d30
jmp 0xecaec
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xa3520
nopw %cs:(%rax,%rax)
// File: xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::uintToString(unsigned long long, char*&)
static inline void uintToString(LargestUInt value, char*& current) {
  *--current = 0;
  do {
    *--current = char(value % 10) + '0';
    value /= 10;
  } while (value != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, -0x1(%rax)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movb %dl, %al
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $-0x1, %rsi
movq %rsi, (%rdx)
movb %cl, -0x1(%rax)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xee2c1
popq %rbp
retq
nopl (%rax,%rax)
// File: xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::StreamWriterBuilder::setDefaults(Json::Value*)
void StreamWriterBuilder::setDefaults(Json::Value* settings)
{
  //! [StreamWriterBuilderDefaults]
  (*settings)["commentStyle"] = "All";
  (*settings)["indentation"] = "\t";
  (*settings)["enableYAMLCompatibility"] = false;
  (*settings)["dropNullPlaceholders"] = false;
  //! [StreamWriterBuilderDefaults]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x12426(%rip), %rsi     # 0x10559c
leaq -0x30(%rbp), %rdi
callq 0xa2ce0
movq -0x8(%rbp), %rdi
leaq 0x123d8(%rip), %rsi     # 0x105562
callq 0x99470
movq %rax, -0xc0(%rbp)
jmp 0xf3198
movq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x98040
jmp 0xf31aa
leaq -0x30(%rbp), %rdi
callq 0x9a180
leaq 0x121cc(%rip), %rsi     # 0x105386
leaq -0x68(%rbp), %rdi
callq 0xa2ce0
movq -0x8(%rbp), %rdi
leaq 0x12388(%rip), %rsi     # 0x105556
callq 0x99470
movq %rax, -0xc8(%rbp)
jmp 0xf31dc
movq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x98040
jmp 0xf31ee
leaq -0x68(%rbp), %rdi
callq 0x9a180
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
callq 0xa45a0
movq -0x8(%rbp), %rdi
leaq 0x1235f(%rip), %rsi     # 0x10556f
callq 0x99470
movq %rax, -0xd0(%rbp)
jmp 0xf321e
movq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x98040
jmp 0xf3233
leaq -0x90(%rbp), %rdi
callq 0x9a180
leaq -0xb8(%rbp), %rdi
xorl %esi, %esi
callq 0xa45a0
movq -0x8(%rbp), %rdi
leaq 0x1232f(%rip), %rsi     # 0x105587
callq 0x99470
movq %rax, -0xd8(%rbp)
jmp 0xf3266
movq -0xd8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x98040
jmp 0xf327b
leaq -0xb8(%rbp), %rdi
callq 0x9a180
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9a180
jmp 0xf32f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9a180
jmp 0xf32f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x9a180
jmp 0xf32f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x9a180
movq -0x38(%rbp), %rdi
callq 0xa3520
nopl (%rax)
// File: iamlouk[P]asbi/src/main.cc
// Function: get_prompt(char*, unsigned long)
static const char* get_prompt(char* buf, size_t bufsize) {
	char* wdbuf = getcwd(NULL, 0);
	snprintf(buf, bufsize - 1, "\033[0;34m[%s]:\033[0m\033[0;36m%s\033[0m \033[0;37m>_\033[0m ", "asbi"/*getenv("USER")*/, wdbuf);
	free(wdbuf);
	return buf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x6220
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
subq $0x1, %rsi
movq (%rsp), %r8
leaq 0x305e1(%rip), %rdx     # 0x38188
leaq 0x30607(%rip), %rcx     # 0x381b5
movb $0x0, %al
callq 0x6710
movq (%rsp), %rdi
callq 0x6550
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: iamlouk[P]asbi/src/./include/types.hh
// Function: asbi::Value::map(asbi::MapContainer*)
static inline Value map(MapContainer* dc) {
			Value val;
			val.type = type_t::Map;
			val._map = dc;
			return val;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x7ce0
movl $0x6, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)