LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3fde0
leaq 0xc8(%r14), %rcx
cmpq %rcx, %rax
je 0x53f5d
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f320
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3f0e0
movq %rax, %rbx
leaq 0x12a5f(%rip), %rsi     # 0x669ce
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x40140
leaq 0x12a71(%rip), %rdx     # 0x669f4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3e640
addq $0x8, %r14
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x417c0
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x41c90
xorl %ebp, %ebp
movq 0x2b017(%rip), %rsi     # 0x7efd8
movq 0x2ae00(%rip), %rdx     # 0x7edc8
movq %rbx, %rdi
callq 0x42050
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3ef50
jmp 0x53fe5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3ef50
jmp 0x53ff7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x3ef50
testb %bpl, %bpl
jne 0x5400b
jmp 0x54013
movq %rax, %r14
movq %rbx, %rdi
callq 0x3faf0
movq %r14, %rdi
callq 0x42200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x3e7b0
movl %eax, 0x8(%r14)
cmpl $-0x1, %eax
je 0x5529b
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x42280
cmpl $-0x1, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
movl 0x8(%rdi), %eax
leaq 0xc(%rdi), %rsi
movl %eax, %edi
callq 0x3ea70
movl %eax, 0x8(%rbx)
testl %eax, %eax
setg %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movl 0x8(%rdi), %edi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x3f130
cmpl $-0x1, %eax
setne %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xfdf5(%rip), %rsi      # 0x6515e
movq %rbx, %rdi
callq 0x42870
movq %rsp, %r15
movl $0x401, %edx            # imm = 0x401
movq %r15, %rdi
xorl %esi, %esi
callq 0x3f380
movl 0x8(%r14), %edi
movl $0x400, %edx            # imm = 0x400
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x3eaf0
movq %rax, %r14
testl %r14d, %r14d
je 0x553e8
cmpl $-0x1, %r14d
jne 0x553dd
movq 0x29aad(%rip), %rdi     # 0x7ee58
leaq 0x117b3(%rip), %rsi     # 0x66b65
callq 0x405b0
movq %rax, %rbx
callq 0x3e140
movl (%rax), %esi
movq %rbx, %rdi
callq 0x42120
leaq 0x117ae(%rip), %rsi     # 0x66b7e
movq %rax, %rdi
callq 0x405b0
xorl %r14d, %r14d
jmp 0x553e8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x42870
movl %r14d, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x3
popq %rsi
xorl %eax, %eax
callq 0x3f450
testl %eax, %eax
js 0x5548b
movl %eax, %ecx
orl $0x800, %ecx            # imm = 0x800
andl $0x7ffff7ff, %eax       # imm = 0x7FFFF7FF
testb %bpl, %bpl
cmovnel %ecx, %eax
movl 0x8(%rbx), %edi
pushq $0x4
popq %rsi
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f450
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3e090
movq 0x298b1(%rip), %rax     # 0x7ed60
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3fe50
testb %al, %al
je 0x554eb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40580
testb %al, %al
je 0x55539
movq %rbx, %rdi
callq 0x41200
testb %al, %al
je 0x55584
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3f0e0
movq %rax, %r15
leaq 0x116a5(%rip), %rsi     # 0x66ba2
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3ed70
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x412d0
xorl %ebp, %ebp
movq 0x29ad3(%rip), %rsi     # 0x7eff8
movq 0x297c4(%rip), %rdx     # 0x7ecf0
movq %r15, %rdi
callq 0x42050
jmp 0x555cd
pushq $0x20
popq %rdi
callq 0x3f0e0
movq %rax, %r15
leaq 0x11677(%rip), %rsi     # 0x66bc2
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3ed70
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x412d0
xorl %ebp, %ebp
movq 0x29a85(%rip), %rsi     # 0x7eff8
movq 0x29776(%rip), %rdx     # 0x7ecf0
movq %r15, %rdi
callq 0x42050
jmp 0x555cd
pushq $0x20
popq %rdi
callq 0x3f0e0
movq %rax, %r15
leaq 0x11644(%rip), %rsi     # 0x66bda
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3ed70
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x412d0
xorl %ebp, %ebp
movq 0x29a3a(%rip), %rsi     # 0x7eff8
movq 0x2972b(%rip), %rdx     # 0x7ecf0
movq %r15, %rdi
callq 0x42050
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x555ed
jmp 0x555f9
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x555ed
jmp 0x555f9
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3ef50
testb %bpl, %bpl
jne 0x555fc
jmp 0x55609
movq %rax, %r14
movq %r15, %rdi
callq 0x3faf0
jmp 0x55609
movq %rax, %r14
movq %rbx, %rdi
callq 0x42780
movq %r14, %rdi
callq 0x42200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3e090
movq 0x29728(%rip), %rax     # 0x7ed60
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3fe50
testb %al, %al
je 0x55683
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x412d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x41450
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3ef50
testb %bpl, %bpl
je 0x556ce
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3f0e0
movq %rax, %r15
leaq 0x11561(%rip), %rsi     # 0x66bf6
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3ed70
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x412d0
xorl %ebp, %ebp
movq 0x2993b(%rip), %rsi     # 0x7eff8
movq 0x2962c(%rip), %rdx     # 0x7ecf0
movq %r15, %rdi
callq 0x42050
jmp 0x55717
pushq $0x20
popq %rdi
callq 0x3f0e0
movq %rax, %r15
leaq 0x114e2(%rip), %rsi     # 0x66bc2
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3ed70
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x412d0
xorl %ebp, %ebp
movq 0x298f0(%rip), %rsi     # 0x7eff8
movq 0x295e1(%rip), %rdx     # 0x7ecf0
movq %r15, %rdi
callq 0x42050
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x5572b
jmp 0x55737
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3ef50
testb %bpl, %bpl
jne 0x5573a
jmp 0x55756
movq %rax, %r14
movq %r15, %rdi
callq 0x3faf0
jmp 0x55756
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3ef50
jmp 0x55756
movq %rax, %r14
movq %rbx, %rdi
callq 0x42780
movq %r14, %rdi
callq 0x42200
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x3eda0
testl %eax, %eax
js 0x55a26
movl %eax, 0x28(%rbx)
movb $0x1, %al
jmp 0x55a28
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x55a2a
callq 0x3ed90
callq 0x41d30
xorl %eax, %eax
popq %rbx
retq
callq 0x42200
nop
// File: /workspace/github_cpp_makefile_star2_O2/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::Features::strictMode()
Features Features::strictMode() {
  Features features;
  features.allowComments_ = false;
  features.strictRoot_ = true;
  features.allowDroppedNullPlaceholders_ = false;
  features.allowNumericKeys_ = false;
  return features;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x40320
movl $0x100, (%rbx)          # imm = 0x100
movl $0x100, %eax            # imm = 0x100
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
movq %rdx, %rsi
subq %r15, %rsi
callq 0x41a00
pushq $0xa
popq %rbp
cmpq %r14, %r15
je 0x57333
leaq 0x1(%r15), %r12
movb (%r15), %al
cmpb $0xd, %al
jne 0x57323
cmpq %r14, %r12
je 0x57314
cmpb $0xa, 0x1(%r15)
jne 0x57314
addq $0x2, %r15
movq %r15, %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40000
movq %r12, %r15
jmp 0x572f1
movsbl %al, %esi
movq %rbx, %rdi
callq 0x40000
movq %r12, %r15
jmp 0x572f1
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57341
movq %rax, %r14
movq %rbx, %rdi
callq 0x3ef50
movq %r14, %rdi
callq 0x42200
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x3fb70
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x41b70
movl 0x8(%rsp), %eax
cmpl %ebp, %eax
je 0x57580
testl %eax, %eax
jne 0x57569
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x41370
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e9e0
movl (%r14), %ecx
movl (%r15), %r8d
leaq 0xf6f2(%rip), %rdx      # 0x675a8
leaq 0x10(%rsp), %r14
pushq $0x33
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x41b80
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ed70
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5a917
leaq 0xc5ed(%rip), %rcx      # 0x66ed0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, (%rdi)
setne %al
jmp 0x5a90e
movb (%rdi), %al
jmp 0x5a90e
xorpd %xmm0, %xmm0
cmpneqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x5a90e
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x41180
leaq 0xd13c(%rip), %rsi      # 0x67a67
movq %rbx, %rdi
callq 0x405b0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x41af0
leaq 0x8(%rsp), %rdi
callq 0x41700
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3ef50
jmp 0x5a960
jmp 0x5a95d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3e780
movq %rbx, %rdi
callq 0x42200
// File: /workspace/github_cpp_makefile_star2_O2/xjrueda[P]fixprime/src/jsoncpp.cpp
// Function: Json::CharReaderBuilder::strictMode(Json::Value*)
void CharReaderBuilder::strictMode(Json::Value* settings)
{
//! [CharReaderBuilderStrictMode]
  (*settings)["allowComments"] = false;
  (*settings)["strictRoot"] = true;
  (*settings)["allowDroppedNullPlaceholders"] = false;
  (*settings)["allowNumericKeys"] = false;
  (*settings)["allowSingleQuotes"] = false;
  (*settings)["failIfExtra"] = true;
  (*settings)["rejectDupKeys"] = true;
//! [CharReaderBuilderStrictMode]
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x427c0
leaq 0xc667(%rip), %rsi      # 0x67679
movq %rbx, %rdi
callq 0x3ed60
leaq 0xf0(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0xc8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x427c0
leaq 0xc638(%rip), %rsi      # 0x67687
movq %rbx, %rdi
callq 0x3ed60
leaq 0xc8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x427c0
leaq 0xc607(%rip), %rsi      # 0x67692
movq %rbx, %rdi
callq 0x3ed60
leaq 0xa0(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0x78(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x427c0
leaq 0xc5eb(%rip), %rsi      # 0x676af
movq %rbx, %rdi
callq 0x3ed60
leaq 0x78(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0x50(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x427c0
leaq 0xc5c6(%rip), %rsi      # 0x676c0
movq %rbx, %rdi
callq 0x3ed60
leaq 0x50(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0x28(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x427c0
leaq 0xc5ac(%rip), %rsi      # 0x676dd
movq %rbx, %rdi
callq 0x3ed60
leaq 0x28(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
movq %rsp, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x427c0
leaq 0xc583(%rip), %rsi      # 0x676e9
movq %rbx, %rdi
callq 0x3ed60
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41d80
movq %rbx, %rdi
callq 0x3f200
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
jmp 0x5b19b
jmp 0x5b19b
jmp 0x5b19b
jmp 0x5b19b
jmp 0x5b19b
jmp 0x5b19b
movq %rax, %rbx
movq %r14, %rdi
callq 0x3f200
movq %rbx, %rdi
callq 0x42200
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x42420
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3e4a0
testb %al, %al
je 0x5b325
leaq 0x10(%rsp), %rdi
callq 0x3ef50
leaq 0x50(%rsp), %rdi
callq 0x3fca0
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x23b54(%rip), %rax     # 0x7ee80
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0xc3bc(%rip), %rsi      # 0x676f7
xorl %eax, %eax
callq 0x415a0
leaq 0xc3c4(%rip), %rsi      # 0x6770d
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3ed70
leaq 0x30(%rsp), %rdi
callq 0x40060
jmp 0x5b373
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3ef50
jmp 0x5b376
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3ef50
leaq 0x50(%rsp), %rdi
callq 0x3fca0
movq %rbx, %rdi
callq 0x42200
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5b51e
movl 0x28(%rax), %edx
shrl $0x2, %edx
addq %rsi, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x3ed50
jmp 0x5b52e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movq (%r14), %rax
testb $0x3, %sil
je 0x5b870
testq %rax, %rax
je 0x5b86e
shrl $0x2, %esi
movq %rax, %rdi
callq 0x5b7b0
jmp 0x5b870
xorl %eax, %eax
movq %rax, (%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 $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x20(%rdi)
cmpl $0x7, %esi
ja 0x5b9e6
movq %rdi, %rbx
movl %esi, %eax
leaq 0xb556(%rip), %rcx      # 0x66f00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andq $0x0, (%rbx)
jmp 0x5b9e4
pushq $0x30
popq %rdi
callq 0x405e0
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rax, (%rbx)
jmp 0x5b9e4
movb $0x0, (%rbx)
popq %rbx
retq
leaq 0xbd79(%rip), %rdi      # 0x67766
leaq 0xb936(%rip), %rsi      # 0x6732a
leaq 0xbd71(%rip), %rcx      # 0x6776c
movl $0xa9c, %edx            # imm = 0xA9C
callq 0x3f890
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5c28f
movq %rdx, %rbx
movq %rsi, %r14
btl $0x8, %eax
jb 0x5c27d
movq %r15, %rdi
callq 0x3eec0
jmp 0x5c284
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_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x29(%rsp), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rsi, %rdi
negq %rdi
cmovsq %rsi, %rdi
movq %r15, %rsi
callq 0x5e210
movq (%r15), %rsi
testq %r14, %r14
jns 0x5c2d9
movb $0x2d, -0x1(%rsi)
decq %rsi
leaq 0x10(%rsp), %rax
cmpq %rax, %rsi
jb 0x5c2fd
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ed70
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xbaa9(%rip), %rdi      # 0x67dad
leaq 0xb01f(%rip), %rsi      # 0x6732a
leaq 0xbaad(%rip), %rcx      # 0x67dbf
movl $0xfb2, %edx            # imm = 0xFB2
callq 0x3f890
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x5c3cf
ucomisd %xmm0, %xmm0
jp 0x5c455
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5c408
movabsq $0x393939392b65312d, %rax # imm = 0x393939392B65312D
movq %rax, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
pushq $0x8
jmp 0x5c419
leaq 0xba42(%rip), %rdx      # 0x67e18
leaq 0x10(%rsp), %rdi
pushq $0x20
popq %rsi
movb $0x1, %al
callq 0x41b80
testl %eax, %eax
jns 0x5c41a
leaq 0xba3c(%rip), %rdi      # 0x67e2c
leaq 0xaf33(%rip), %rsi      # 0x6732a
leaq 0xba37(%rip), %rcx      # 0x67e35
movl $0xfea, %edx            # imm = 0xFEA
callq 0x3f890
movabsq $0x393939392b6531, %rax # imm = 0x393939392B6531
movq %rax, 0x10(%rsp)
pushq $0x7
popq %rax
movl %eax, %eax
addq %rsp, %rax
addq $0x10, %rax
leaq 0x10(%rsp), %rcx
cmpq %rax, %rcx
jae 0x5c43a
cmpb $0x2c, (%rcx)
jne 0x5c435
movb $0x2e, (%rcx)
incq %rcx
jmp 0x5c428
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ed70
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movb $0x0, 0x14(%rsp)
movl $0x6c6c756e, 0x10(%rsp) # imm = 0x6C6C756E
pushq $0x4
jmp 0x5c419
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5cad4
leaq 0xa543(%rip), %rcx      # 0x66fc0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2ssq (%rdi), %xmm0
jmp 0x5cacb
cmpb $0x0, (%rdi)
jne 0x5caac
xorps %xmm0, %xmm0
jmp 0x5cacb
movq (%rdi), %rax
testq %rax, %rax
js 0x5cab6
cvtsi2ss %rax, %xmm0
jmp 0x5cacb
cvtsd2ss (%rdi), %xmm0
jmp 0x5cacb
movss 0xa7cc(%rip), %xmm0     # 0x67280
jmp 0x5cacb
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 0x41180
leaq 0xaf5c(%rip), %rsi      # 0x67a44
movq %rbx, %rdi
callq 0x405b0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x41af0
leaq 0x8(%rsp), %rdi
callq 0x41700
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3ef50
jmp 0x5cb1d
jmp 0x5cb1a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3e780
movq %rbx, %rdi
callq 0x42200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d55c
cmpl $0x7, %eax
jne 0x5d56c
movq %rdi, %rbx
subl %esi, %edx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x40550
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x42a70
movq (%rbx), %rcx
addq $0x8, %rcx
leaq 0x30(%rax), %rdx
xorl %ebx, %ebx
cmpq %rcx, %rax
cmovneq %rdx, %rbx
leaq 0x20(%rsp), %rdi
callq 0x414f0
jmp 0x5d55e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x41180
leaq 0xa773(%rip), %rsi      # 0x67cf3
movq %rbx, %rdi
callq 0x405b0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x41af0
movq %rsp, %rdi
callq 0x41700
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3ef50
jmp 0x5d5af
jmp 0x5d5ac
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3e780
jmp 0x5d5c8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x414f0
movq %rbx, %rdi
callq 0x42200
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
cmpb $0x7, 0x8(%rdi)
jne 0x5d74c
movq %rcx, %r14
movq %rdi, %rbx
subl %esi, %edx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x40550
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x42a70
movq %rax, %r15
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r15
setne %bpl
je 0x5d740
leaq 0x30(%r15), %rsi
leaq 0x18(%rsp), %rdi
callq 0x41bd0
leaq 0x18(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x41d80
movq %r12, %rdi
callq 0x3f200
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x41fa0
leaq 0x8(%rsp), %rdi
callq 0x414f0
jmp 0x5d74e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x414f0
movq %rbx, %rdi
callq 0x42200
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5dccb
movq %rsp, %rdi
callq 0x41ab0
jmp 0x5dcdf
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x42a00
movq (%rsp), %rax
movb 0x8(%rsp), %dl
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5dd17
movq %rsp, %rdi
callq 0x41ab0
jmp 0x5dd2b
addq $0x8, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x42a00
movq (%rsp), %rax
movb 0x8(%rsp), %dl
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5dd67
movq %rbx, %rdi
callq 0x415f0
jmp 0x5dd7b
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3f090
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5ddb3
movq %rbx, %rdi
callq 0x415f0
jmp 0x5ddc7
addq $0x8, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3f090
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x41cf0
movl %eax, %r15d
leal (%r15,%r15,2), %eax
cmpl 0x60(%r12), %eax
setge %bl
movq %r12, 0x8(%rsp)
leaq 0x8(%r12), %r13
movq %r13, %rdi
callq 0x40470
xorl %ebp, %ebp
cmpl %r15d, %ebp
jge 0x5f3ee
testb $0x1, %bl
jne 0x5f3ee
movq %r14, %rdi
movl %ebp, %esi
callq 0x3e660
movzwl 0x8(%rax), %ecx
andl $0xfe, %ecx
cmpw $0x6, %cx
jne 0x5f3e8
movq %rax, %rdi
callq 0x41cf0
testl %eax, %eax
setne %bl
jmp 0x5f3ea
xorl %ebx, %ebx
incl %ebp
jmp 0x5f3b5
movb $0x1, %al
testb $0x1, %bl
jne 0x5f49b
movslq %r15d, %rsi
movq %r13, %rdi
callq 0x40dd0
movq 0x8(%rsp), %rax
movb $0x1, 0x68(%rax)
leal 0x2(,%r15,2), %r12d
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
pushq $0x8
popq %rbx
movq $0x0, 0x10(%rsp)
cmpq %r13, %r15
je 0x5f481
movq %r14, %rdi
movl %r13d, %esi
callq 0x3e660
movq %rax, %rsi
callq 0x401a0
movq 0x10(%rsp), %rcx
orb %al, %cl
movq %rcx, 0x10(%rsp)
movq %r14, %rdi
movl %r13d, %esi
callq 0x3e660
movq %r15, %rbp
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3f4c0
movq 0x8(%r15), %rax
movq %rbp, %r15
addl (%rax,%rbx), %r12d
incq %r13
addq $0x20, %rbx
jmp 0x5f42b
movq 0x8(%rsp), %rax
movb $0x0, 0x68(%rax)
cmpl 0x60(%rax), %r12d
setge %al
movq 0x10(%rsp), %rcx
orb %al, %cl
movq %rcx, %rax
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x7641(%rip), %rsi      # 0x68079
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0x41f20
leaq 0x75f0(%rip), %rsi      # 0x6803f
movq %rbx, %rdi
callq 0x3ed60
leaq 0x80(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0x73ea(%rip), %rsi      # 0x67e63
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x41f20
leaq 0x75a6(%rip), %rsi      # 0x68033
movq %rbx, %rdi
callq 0x3ed60
leaq 0x58(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x427c0
leaq 0x7589(%rip), %rsi      # 0x6804c
movq %rbx, %rdi
callq 0x3ed60
leaq 0x30(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x41d80
movq %r14, %rdi
callq 0x3f200
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x427c0
leaq 0x756b(%rip), %rsi      # 0x68064
movq %rbx, %rdi
callq 0x3ed60
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41d80
movq %rbx, %rdi
callq 0x3f200
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
jmp 0x60b2a
jmp 0x60b2a
jmp 0x60b2a
movq %rax, %rbx
movq %r14, %rdi
callq 0x3f200
movq %rbx, %rdi
callq 0x42200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x5390
movq %rax, %r14
leaq 0xdc45(%rip), %rsi      # 0x14104
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
callq 0x60ee
movq (%rbx), %rcx
incq %rcx
movq %rcx, (%rbx)
pushq $0x51
popq %r15
movq 0x10(%rbx), %rax
cmpq 0x8(%rax), %rcx
jae 0x6533
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rdx
movb (%rdx,%rcx), %al
cmpb $0x5c, %al
jne 0x651e
leaq 0x2(%rcx), %rsi
movq %rsi, (%rbx)
movb 0x1(%rdx,%rcx), %r12b
movzbl %r12b, %ecx
leal -0x6e(%rcx), %edx
cmpl $0x6, %edx
ja 0x6512
btl %edx, %r15d
jb 0x6523
cmpl $0x22, %ecx
je 0x6523
cmpl $0x27, %ecx
je 0x6523
jmp 0x654e
cmpb %bpl, %al
je 0x6533
movsbl %al, %esi
movq %r14, %rdi
callq 0x5300
movq (%rbx), %rcx
jmp 0x64d9
movl 0x8(%rbx), %eax
shlq $0x20, %rax
orq $0x3, %rax
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51b0
movq %rax, %r14
movl 0x8(%rbx), %edx
movsbl %r12b, %ecx
leaq 0xdef0(%rip), %rsi      # 0x14457
movq %rax, %rdi
callq 0x9d44
leaq 0x18fba(%rip), %rsi     # 0x1f530
leaq 0xaa5(%rip), %rdx       # 0x7022
movq %r14, %rdi
callq 0x55f0
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x53a0
jmp 0x65a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xdb48(%rip), %rsi      # 0x14104
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x60ee
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
xorl %ebp, %ebp
movq (%rcx), %rcx
movb (%rcx,%rax), %r15b
cmpb $0x2e, %r15b
je 0x65f4
leal -0x30(%r15), %eax
cmpb $0xa, %al
jb 0x65f4
leal -0x61(%r15), %eax
cmpb $0x19, %al
ja 0x661d
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x5300
cmpb $0x2e, %r15b
sete %al
orb %al, %bpl
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rax
movq %rax, (%rbx)
cmpq 0x8(%rcx), %rax
jb 0x65d7
testb $0x1, %bpl
je 0x6638
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x7042
movq %xmm0, %r14
pushq $0x2
jmp 0x664b
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x705b
movl %eax, %r14d
pushq $0x1
popq %r15
movl 0x8(%rbx), %ebx
leaq 0x8(%rsp), %rdi
callq 0x5170
shlq $0x20, %rbx
orq %r15, %rbx
movq %rbx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6674
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x669e
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
jmp 0x66b2
movq %rbx, %rdi
callq 0x66b4
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movb $0x1, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%r14)
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
callq 0x668a
cmpl $0x25, %eax
je 0x7a19
movq %rbx, %rdi
callq 0x7aaa
movq %rax, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x97fe
jmp 0x79f2
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x7a30
movq (%rax), %rbx
jmp 0x7a5f
pushq $0x20
popq %rdi
callq 0x5390
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x9318
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x9366
leaq 0x28(%rsp), %rdi
callq 0x9768
movq %rsp, %rdi
callq 0x9768
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9768
jmp 0x7a86
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x53a0
jmp 0x7a9a
jmp 0x7a97
jmp 0x7a97
movq %rax, %r14
movq %rsp, %rdi
callq 0x9768
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::next()
ast::Node* Parser::next() {
	auto node = parse_expr();
	auto t = tokenizer.peek().type;
	if (t == tok::EOFTok)
		return node;

	if (t == tok::Semicolon) {
		tokenizer.next();
		return node;
	}

	throw utils::parser_error("expected ';' or EOF", tokenizer.peek());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x7b36
movq %rax, %rbx
movq %r14, %rdi
callq 0x668a
cmpl $0x25, %eax
je 0x7ad3
cmpl $0x1e, %eax
jne 0x7ade
movq %r14, %rdi
callq 0x66b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x48
popq %rdi
callq 0x51b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x668a
movq %rdx, %rcx
leaq 0xcc1a(%rip), %rsi      # 0x14715
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9e26
leaq 0x17a63(%rip), %rsi     # 0x1f570
leaq 0x17e4(%rip), %rdx      # 0x92f8
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
nop