LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::parse(char const*, char const*, Json::Value&, bool)
bool 
Reader::parse( const char *beginDoc, const char *endDoc, 
               Value &root,
               bool collectComments )
{
   if ( !features_.allowComments_ )
   {
      collectComments = false;
   }

   begin_ = beginDoc;
   end_ = endDoc;
   collectComments_ = collectComments;
   current_ = begin_;
   lastValueEnd_ = 0;
   lastValue_ = 0;
   commentsBefore_ = "";
   errors_.clear();
   while ( !nodes_.empty() )
      nodes_.pop();
   nodes_.push( &root );
   
   bool successful = readValue();
   Token token;
   skipCommentTokens( token );
   if ( collectComments_  &&  !commentsBefore_.empty() )
      root.setComment( commentsBefore_, commentAfter );
   if ( features_.strictRoot_ )
   {
      if ( !root.isArray()  &&  !root.isObject() )
      {
         // Set error location to start of doc, ideally should be first token found in doc
         token.type_ = tokenError;
         token.start_ = beginDoc;
         token.end_ = endDoc;
         addError( "A valid JSON document must be either an array or an object value.",
                   token );
         return false;
      }
   }
   return successful;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andb 0x108(%rdi), %r8b
movq %rsi, 0xc0(%rdi)
movq %rdx, 0xc8(%rdi)
movb %r8b, 0x10a(%rdi)
movq %rsi, 0xd0(%rdi)
leaq 0xe8(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movq 0xf0(%rdi), %rdx
leaq 0xfa6b(%rip), %rcx      # 0x76817
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x278f0
leaq 0x50(%rbx), %rdi
movups 0x60(%rbx), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movups 0x70(%rbx), %xmm0
movaps %xmm0, 0x10(%rsi)
callq 0x69676
movq 0x30(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x66de8
movq %rbx, %rdi
callq 0x696ee
jmp 0x66dd4
movq %r12, (%rsp)
movq 0x40(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x66e03
movq %r12, (%rax)
addq $0x8, 0x30(%rbx)
jmp 0x66e0e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x69736
movq %rbx, %rdi
callq 0x66f92
movl %eax, %ebp
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x671c0
cmpb $0x1, 0x10a(%rbx)
jne 0x66e48
cmpq $0x0, 0xf0(%rbx)
je 0x66e48
movq %r12, %rdi
movq %r13, %rsi
movl $0x2, %edx
callq 0x6d19e
cmpb $0x1, 0x109(%rbx)
jne 0x66ec2
movq %r12, %rdi
callq 0x6c788
testb %al, %al
jne 0x66ec2
movq %r12, %rdi
callq 0x6c79c
testb %al, %al
jne 0x66ec2
leaq 0x20(%rsp), %r12
movl $0xd, (%r12)
movq %r15, 0x8(%r12)
movq %r14, 0x10(%r12)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf3a4(%rip), %rsi      # 0x76234
leaq 0xf3de(%rip), %rdx      # 0x76275
movq %rsp, %r14
movq %r14, %rdi
callq 0x2f1a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x671fe
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x66ec0
callq 0x27560
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x66ee4
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::parse(std::istream&, Json::Value&, bool)
bool
Reader::parse( std::istream& sin,
               Value &root,
               bool collectComments )
{
   //std::istream_iterator<char> begin(sin);
   //std::istream_iterator<char> end;
   // Those would allow streamed input from a file, if parse() were a
   // template function.

   // Since std::string is reference-counted, this at least does not
   // create an extra copy.
   std::string doc;
   std::getline(sin, doc, (char)EOF);
   return parse( doc, root, collectComments );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x27ba0
leaq 0xa0(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x27350
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
addq %rsi, %rdx
movzbl %bpl, %r8d
movq %r14, %rdi
movq %rbx, %rcx
callq 0x66d50
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x66f6a
callq 0x27560
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x66f89
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::skipCommentTokens(Json::Reader::Token&)
void 
Reader::skipCommentTokens( Token &token )
{
   if ( features_.allowComments_ )
   {
      do
      {
         readToken( token );
      }
      while ( token.type_ == tokenComment );
   }
   else
   {
      readToken( token );
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x108(%rdi)
jne 0x671eb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x67afc
cmpl $0xc, (%rbx)
je 0x671d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67afc
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::addError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Reader::Token&, char const*)
bool 
Reader::addError( const std::string &message, 
                  Token &token,
                  Location extra )
{
   ErrorInfo info;
   info.token_ = token;
   info.message_ = message;
   info.extra_ = extra;
   errors_.push_back( info );
   return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movups (%rdx), %xmm0
movaps %xmm0, -0x28(%r15)
movq 0x10(%rdx), %rax
movq %rax, -0x18(%r15)
callq 0x27350
movq %rsp, %rsi
movq %r14, 0x38(%rsi)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x68f3a
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x6725e
callq 0x27560
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x6727c
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readArray(Json::Reader::Token&)
bool 
Reader::readArray( Token &tokenStart )
{
   currentValue() = Value( arrayValue );
   skipSpaces();
   if ( *current_ == ']' ) // empty array
   {
      Token endArray;
      readToken( endArray );
      return true;
   }
   int index = 0;
   while ( true )
   {
      Value &value = currentValue()[ index++ ];
      nodes_.push( &value );
      bool ok = readValue();
      nodes_.pop();
      if ( !ok ) // error already set
         return recoverFromError( tokenArrayEnd );

      Token token;
      // Accept Comment after last item in the array.
      ok = readToken( token );
      while ( token.type_ == tokenComment  &&  ok )
      {
         ok = readToken( token );
      }
      bool badTokenType = ( token.type_ == tokenArraySeparator  &&  
                            token.type_ == tokenArrayEnd );
      if ( !ok  ||  badTokenType )
      {
         return addErrorAndRecover( "Missing ',' or ']' in array declaration", 
                                    token, 
                                    tokenArrayEnd );
      }
      if ( token.type_ == tokenArrayEnd )
         break;
   }
   return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0x6b93e
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x675f9
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6bdc0
leaq 0x8(%rsp), %rdi
callq 0x6bce2
movq 0xc8(%rbx), %rcx
movq 0xd0(%rbx), %rax
cmpq %rcx, %rax
je 0x6764c
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rax), %esi
cmpq $0x20, %rsi
ja 0x6764f
btq %rsi, %rdx
jae 0x6764f
incq %rax
movq %rax, 0xd0(%rbx)
cmpq %rcx, %rax
jne 0x6762e
movb (%rax), %sil
cmpb $0x5d, %sil
jne 0x67667
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x67afc
jmp 0x676f2
xorl %ebp, %ebp
movl $0x200, %r12d           # imm = 0x200
leaq 0x8(%rsp), %r14
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x67689
movq 0x48(%rbx), %rax
movq -0x8(%rax), %rax
addq %r12, %rax
movq -0x8(%rax), %rdi
movl %ebp, %esi
callq 0x6c906
movq %rax, 0x8(%rsp)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x676b4
movq %rax, (%rcx)
addq $0x8, 0x30(%rbx)
jmp 0x676bf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69736
movq %rbx, %rdi
callq 0x66f92
movl %eax, %r15d
movq %rbx, %rdi
callq 0x696ee
testb %r15b, %r15b
je 0x676f6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67afc
movl 0x8(%rsp), %eax
cmpl $0xc, %eax
je 0x676d7
incl %ebp
cmpl $0x4, %eax
jne 0x67674
movb $0x1, %al
jmp 0x67705
movq %rbx, %rdi
movl $0x4, %esi
callq 0x684d4
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6bce2
movq %rbx, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::decodeString(Json::Reader::Token&)
bool 
Reader::decodeString( Token &token )
{
   std::string decoded;
   if ( !decodeString( token, decoded ) )
      return false;
   currentValue() = decoded;
   return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdx
callq 0x68186
movl %eax, %ebx
testb %al, %al
je 0x67aad
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6bad8
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x67a95
movq 0x48(%r14), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6bdc0
leaq 0x8(%rsp), %rdi
callq 0x6bce2
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x67abc
callq 0x27560
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6bce2
jmp 0x67ae4
movq %rax, %rdi
callq 0x2e1cd
jmp 0x67ae1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x67af3
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::expectToken(Json::Reader::TokenType, Json::Reader::Token&, char const*)
bool 
Reader::expectToken( TokenType type, Token &token, const char *message )
{
   readToken( token );
   if ( token.type_ != type )
      return addError( message, token );
   return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq %rdx, %rsi
callq 0x67afc
movl (%r14), %ebp
cmpl %ebx, %ebp
je 0x67dba
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x272a0
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x671fe
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67dba
callq 0x27560
cmpl %ebx, %ebp
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67de4
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::skipSpaces()
void 
Reader::skipSpaces()
{
   while ( current_ != end_ )
   {
      Char c = *current_;
      if ( c == ' '  ||  c == '\t'  ||  c == '\r'  ||  c == '\n' )
         ++current_;
      else
         break;
   }
}

// Assembly:
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rcx
cmpq %rax, %rcx
je 0x67e27
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x67e27
btq %rsi, %rdx
jae 0x67e27
incq %rcx
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jne 0x67e09
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readString()
bool
Reader::readString()
{
   Char c = 0;
   while ( current_ != end_ )
   {
      c = getNextChar();
      if ( c == '\\' )
         getNextChar();
      else if ( c == '"' )
         break;
   }
   return c == '"';
}

// Assembly:
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rdx
cmpq %rax, %rdx
je 0x67e99
leaq 0x1(%rdx), %rsi
movq %rsi, 0xd0(%rdi)
movzbl (%rdx), %ecx
cmpl $0x5c, %ecx
je 0x67e77
cmpl $0x22, %ecx
jne 0x67e8a
jmp 0x67e92
cmpq %rax, %rsi
je 0x67e8a
addq $0x2, %rdx
movq %rdx, 0xd0(%rdi)
movq %rdx, %rsi
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x67e5d
cmpb $0x22, %cl
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readNumber()
void 
Reader::readNumber()
{
   while ( current_ != end_ )
   {
      if ( !(*current_ >= '0'  &&  *current_ <= '9')  &&
           !in( *current_, '.', 'e', 'E', '+', '-' ) )
         break;
      ++current_;
   }
}

// Assembly:
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rcx
cmpq %rax, %rcx
je 0x67ff7
movabsq $0x40000000400000d, %rdx # imm = 0x40000000400000D
movzbl (%rcx), %esi
leal -0x30(%rsi), %r8d
cmpb $0xa, %r8b
jb 0x67fe8
addl $-0x2b, %esi
cmpl $0x3a, %esi
ja 0x67ff7
btq %rsi, %rdx
jae 0x67ff7
incq %rcx
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jne 0x67fcd
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::match(char const*, int)
bool 
Reader::match( Location pattern, 
               int patternLength )
{
   if ( end_ - current_ < patternLength )
      return false;
   int index = patternLength;
   while ( index-- )
      if ( current_[index] != pattern[index] )
         return false;
   current_ += patternLength;
   return true;
}

// Assembly:
movq 0xc8(%rdi), %r8
movq 0xd0(%rdi), %rax
subq %rax, %r8
movslq %edx, %rcx
cmpq %rcx, %r8
jl 0x6802c
movq %rcx, %r8
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x6802f
movb -0x1(%rax,%r8), %r9b
cmpb -0x1(%rsi,%r8), %r9b
movq %rdx, %r8
je 0x68017
xorl %eax, %eax
retq
addq %rcx, %rax
movq %rax, 0xd0(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readCStyleComment()
bool 
Reader::readCStyleComment()
{
   while ( current_ != end_ )
   {
      Char c = getNextChar();
      if ( c == '*'  &&  *current_ == '/' )
         break;
   }
   return getNextChar() == '/';
}

// Assembly:
movq 0xc8(%rdi), %rcx
movq 0xd0(%rdi), %rax
cmpq %rcx, %rax
je 0x68064
incq %rax
movq %rax, 0xd0(%rdi)
cmpb $0x2a, -0x1(%rax)
jne 0x6804a
cmpb $0x2f, (%rax)
jne 0x6804a
cmpq %rcx, %rax
je 0x6807b
leaq 0x1(%rax), %rcx
movq %rcx, 0xd0(%rdi)
cmpb $0x2f, (%rax)
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::addComment(char const*, char const*, Json::CommentPlacement)
void 
Reader::addComment( Location begin, 
                    Location end, 
                    CommentPlacement placement )
{
   assert( collectComments_ );
   if ( placement == commentAfterOnSameLine )
   {
      assert( lastValue_ != 0 );
      lastValue_->setComment( std::string( begin, end ), placement );
   }
   else
   {
      if ( !commentsBefore_.empty() )
         commentsBefore_ += "\n";
      commentsBefore_ += std::string( begin, end );
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x1, %ecx
jne 0x680fb
movq 0xe0(%rdi), %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f1a0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x6d19e
jmp 0x68147
leaq 0xe8(%rdi), %r15
cmpq $0x0, 0xf0(%rdi)
je 0x6811b
leaq 0xaf27(%rip), %rsi      # 0x7303a
movq %r15, %rdi
callq 0x27c00
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f1a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x27210
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x68156
callq 0x27560
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x68164
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6817d
callq 0x27560
jmp 0x6817d
jmp 0x6817a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::recoverFromError(Json::Reader::TokenType)
bool 
Reader::recoverFromError( TokenType skipUntilToken )
{
   int errorCount = int(errors_.size());
   Token skip;
   while ( true )
   {
      if ( !readToken(skip) )
         errors_.resize( errorCount ); // discard errors caused by recovery
      if ( skip.type_ == skipUntilToken  ||  skip.type_ == tokenEndOfStream )
         break;
   }
   errors_.resize( errorCount );
   return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x98(%rdi), %rax
movq %rax, %rcx
subq 0x78(%rdi), %rcx
xorl %edx, %edx
negq %rax
sbbq %rdx, %rdx
leaq (%rcx,%rdx,8), %r15
movq 0x70(%rdi), %r12
movq 0x80(%rdi), %r13
subq 0x88(%rdi), %r13
shrq $0x6, %r13
subq 0x60(%rdi), %r12
shrq $0x6, %r12
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67afc
movl 0x8(%rsp), %eax
cmpl %ebp, %eax
je 0x6853b
testl %eax, %eax
jne 0x68524
addq $0x50, %rbx
andl $-0x8, %r15d
addl %r13d, %r12d
addl %r15d, %r12d
movslq %r12d, %rsi
xorps %xmm0, %xmm0
leaq 0x48(%rsp), %r14
movaps %xmm0, -0x18(%r14)
movaps %xmm0, -0x8(%r14)
movaps %xmm0, 0x8(%r14)
movaps %xmm0, -0x28(%r14)
movq %r14, -0x10(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x68fa6
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x6858c
callq 0x27560
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x685af
callq 0x27560
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::decodeUnicodeCodePoint(Json::Reader::Token&, char const*&, char const*, unsigned int&)
bool
Reader::decodeUnicodeCodePoint( Token &token, 
                                     Location &current, 
                                     Location end, 
                                     unsigned int &unicode )
{

   if ( !decodeUnicodeEscapeSequence( token, current, end, unicode ) )
      return false;
   if (unicode >= 0xD800 && unicode <= 0xDBFF)
   {
      // surrogate pairs
      if (end - current < 6)
         return addError( "additional six characters expected to parse unicode surrogate pair.", token, current );
      unsigned int surrogatePair;
      if (*(current++) == '\\' && *(current++)== 'u')
      {
         if (decodeUnicodeEscapeSequence( token, current, end, surrogatePair ))
         {
            unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
         } 
         else
            return false;
      } 
      else
         return addError( "expecting another \\u token to begin the second half of a unicode surrogate pair", token, current );
   }
   return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6893c
testb %al, %al
je 0x68905
movl $0xfffffc00, %eax       # imm = 0xFFFFFC00
andl (%r12), %eax
movb $0x1, %bpl
cmpl $0xd800, %eax           # imm = 0xD800
jne 0x68907
movq (%r15), %rax
movq %r13, %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
jg 0x6886c
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xdb27(%rip), %rsi      # 0x7636a
leaq 0xdb63(%rip), %rdx      # 0x763ad
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x671fe
jmp 0x688f6
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x5c, (%rax)
jne 0x688c1
leaq 0x2(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x75, 0x1(%rax)
jne 0x688c1
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x6893c
testb %al, %al
je 0x68905
movl (%r12), %eax
shll $0xa, %eax
andl $0xffc00, %eax          # imm = 0xFFC00
movl $0x3ff, %ecx            # imm = 0x3FF
andl 0x4(%rsp), %ecx
addl %ecx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%r12)
jmp 0x68907
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xdadc(%rip), %rsi      # 0x763ae
leaq 0xdb24(%rip), %rdx      # 0x763fd
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x671fe
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x68905
callq 0x27560
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6891c
jmp 0x68930
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x68933
callq 0x27560
jmp 0x68933
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::decodeUnicodeEscapeSequence(Json::Reader::Token&, char const*&, char const*, unsigned int&)
bool 
Reader::decodeUnicodeEscapeSequence( Token &token, 
                                     Location &current, 
                                     Location end, 
                                     unsigned int &unicode )
{
   if ( end - current < 4 )
      return addError( "Bad unicode escape sequence in string: four digits expected.", token, current );
   unicode = 0;
   for ( int index =0; index < 4; ++index )
   {
      Char c = *current++;
      unicode *= 16;
      if ( c >= '0'  &&  c <= '9' )
         unicode += c - '0';
      else if ( c >= 'a'  &&  c <= 'f' )
         unicode += c - 'a' + 10;
      else if ( c >= 'A'  &&  c <= 'F' )
         unicode += c - 'A' + 10;
      else
         return addError( "Bad unicode escape sequence in string: hexadecimal digit expected.", token, current );
   }
   return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
subq %rax, %rcx
cmpq $0x3, %rcx
jg 0x689a4
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xda91(%rip), %rsi      # 0x763fe
leaq 0xdac6(%rip), %rdx      # 0x7643a
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x671fe
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x689a0
callq 0x27560
xorl %eax, %eax
jmp 0x689fc
movl $0x0, (%r8)
incq %rax
xorl %ecx, %ecx
movl $0x4, %edx
movq %rax, (%r15)
movsbl -0x1(%rax), %esi
shll $0x4, %ecx
movl %ecx, (%r8)
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x689d2
addl %esi, %ecx
addl $-0x30, %ecx
jmp 0x689f0
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x689e2
addl %esi, %ecx
addl $-0x57, %ecx
jmp 0x689f0
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x68a08
addl %esi, %ecx
addl $-0x37, %ecx
movl %ecx, (%r8)
incq %rax
decl %edx
jne 0x689b5
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xda22(%rip), %rsi      # 0x7643b
leaq 0xda5d(%rip), %rdx      # 0x7647d
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x671fe
jmp 0x68991
jmp 0x68a46
jmp 0x68a5a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x68a5d
callq 0x27560
jmp 0x68a5d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::getLocationLineAndColumn(char const*, int&, int&) const
void 
Reader::getLocationLineAndColumn( Location location,
                                  int &line,
                                  int &column ) const
{
   Location current = begin_;
   Location lastLineStart = current;
   line = 0;
   while ( current < location  &&  current != end_ )
   {
      Char c = *current++;
      if ( c == '\r' )
      {
         if ( *current == '\n' )
            ++current;
         lastLineStart = current;
         ++line;
      }
      else if ( c == '\n' )
      {
         lastLineStart = current;
         ++line;
      }
   }
   // column & line start at 1
   column = int(location - lastLineStart) + 1;
   ++line;
}

// Assembly:
movq 0xc0(%rdi), %r8
movl $0x0, (%rdx)
cmpq %rsi, %r8
jae 0x68ac2
cmpq 0xc8(%rdi), %r8
je 0x68ac2
xorl %eax, %eax
movq %r8, %r9
leaq 0x1(%r8), %r10
movzbl (%r8), %r11d
cmpl $0xa, %r11d
je 0x68aa8
cmpl $0xd, %r11d
jne 0x68aaf
cmpb $0xa, 0x1(%r8)
jne 0x68aa8
addq $0x2, %r8
movq %r8, %r10
incl %eax
movl %eax, (%rdx)
movq %r10, %r9
movq %r10, %r8
cmpq %rsi, %r10
jae 0x68ac5
cmpq 0xc8(%rdi), %r8
jne 0x68a86
jmp 0x68ac5
movq %r8, %r9
subl %r9d, %esi
incl %esi
movl %esi, (%rcx)
incl (%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.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];
   sprintf( buffer, "Line %d, Column %d", line, column );
   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 0x68a66
movl (%r14), %edx
movl (%r15), %ecx
leaq 0xd97a(%rip), %rsi      # 0x7647e
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x27100
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x272f0
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f1a0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::operator>>(std::istream&, Json::Value&)
std::istream& operator>>( std::istream &sin, Value &root )
{
    Json::Reader reader;
    bool ok = reader.parse(sin, root, true);
    //JSON_ASSERT( ok );
    if (!ok) throw std::runtime_error(reader.getFormatedErrorMessages());
    return sin;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x66b04
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x66eec
testb %al, %al
je 0x68e9e
leaq 0x120(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68e63
callq 0x27560
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68e79
callq 0x27560
leaq 0x78(%rsp), %rdi
callq 0x3a5d2
leaq 0x28(%rsp), %rdi
callq 0x3a76a
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x68b42
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x2611d(%rip), %rsi     # 0x8eff0
movq 0x26096(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68ef8
callq 0x27560
testb %bpl, %bpl
jne 0x68f02
jmp 0x68f20
movq %rax, %r14
movq %rbx, %rdi
callq 0x27470
jmp 0x68f20
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3a76a
jmp 0x68f2a
jmp 0x68f32
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x39c44
movq %r14, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::CommentInfo::setComment(char const*)
void 
Value::CommentInfo::setComment( const char *text )
{
   if ( comment_ )
      releaseStringValue( comment_ );
   JSON_ASSERT( text );
   JSON_ASSERT_MESSAGE( text[0]=='\0' || text[0]=='/', "Comments must start with /");
   // It seems that /**/ style comments are acceptable as well.
   comment_ = duplicateStringValue( text );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6b6dd
callq 0x276f0
movzbl (%r14), %eax
testl %eax, %eax
je 0x6b6ea
cmpl $0x2f, %eax
jne 0x6b726
movq %r14, %rdi
callq 0x272f0
movq %rax, %r15
leal 0x1(%rax), %edi
callq 0x277a0
movq %rax, %r12
movl %r15d, %r15d
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x274c0
movb $0x0, (%r12,%r15)
movq %r12, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xaeb5(%rip), %rsi      # 0x765f8
leaq 0xaec8(%rip), %rdx      # 0x76612
movq %rsp, %rdi
callq 0x2f1a0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x23887(%rip), %rsi     # 0x8eff0
movq 0x23800(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6b789
callq 0x27560
testb %bpl, %bpl
jne 0x6b793
jmp 0x6b79b
movq %rax, %r14
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::~Value()
Value::~Value()
{
   switch ( type_ )
   {
   case nullValue:
   case intValue:
   case uintValue:
   case realValue:
   case booleanValue:
      break;
   case stringValue:
      if ( allocated_ )
         releaseStringValue( value_.string_ );
      break;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   case arrayValue:
   case objectValue:
      delete value_.map_;
      break;
#else
   case arrayValue:
      arrayAllocator()->destructArray( value_.array_ );
      break;
   case objectValue:
      mapAllocator()->destructMap( value_.map_ );
      break;
#endif
   default:
      JSON_ASSERT_UNREACHABLE;
   }

   if ( comments_ )
      delete[] comments_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
movzbl %al, %ecx
leal -0x6(%rcx), %edx
cmpl $0x2, %edx
jae 0x6bd1a
movq (%rbx), %r15
testq %r15, %r15
je 0x6bd10
movq 0x10(%r15), %rsi
movq %r15, %rdi
callq 0x6da2a
movq %r15, %rdi
callq 0x27560
jmp 0x6bd32
cmpl $0x4, %ecx
jne 0x6bd32
btl $0x8, %eax
jae 0x6bd32
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6bd32
callq 0x276f0
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x6bd6e
leaq -0x8(%r15), %rbx
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x6bd5b
shlq $0x3, %r12
leaq (%rbx,%r12), %rdi
callq 0x6b6b0
addq $-0x8, %r12
jne 0x6bd4c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x27750
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x27560
jmp 0x6bdaf
movq %rax, %r14
cmpq $0x8, %r12
je 0x6bda7
addq $-0x10, %r15
leaq (%r15,%r12), %rdi
callq 0x6b6b0
addq $-0x8, %r12
cmpq $0x8, %r12
jne 0x6bd94
movq %rbx, %rdi
callq 0x27750
movq %r14, %rdi
callq 0x27b10
movq %rax, %rdi
callq 0x2e1cd
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::operator<(Json::Value const&) const
bool 
Value::operator <( const Value &other ) const
{
   int typeDelta = type_ - other.type_;
   if ( typeDelta )
      return typeDelta < 0 ? true : false;
   switch ( type_ )
   {
   case nullValue:
      return false;
   case intValue:
      return value_.int_ < other.value_.int_;
   case uintValue:
      return value_.uint_ < other.value_.uint_;
   case realValue:
      return value_.real_ < other.value_.real_;
   case booleanValue:
      return value_.bool_ < other.value_.bool_;
   case stringValue:
      return ( value_.string_ == 0  &&  other.value_.string_ )
             || ( other.value_.string_  
                  &&  value_.string_  
                  && strcmp( value_.string_, other.value_.string_ ) < 0 );
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   case arrayValue:
   case objectValue:
      {
         int delta = int( value_.map_->size() - other.value_.map_->size() );
         if ( delta )
            return delta < 0;
         return (*value_.map_) < (*other.value_.map_);
      }
#else
   case arrayValue:
      return value_.array_->compare( *(other.value_.array_) ) < 0;
   case objectValue:
      return value_.map_->compare( *(other.value_.map_) ) < 0;
#endif
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return 0;  // unreachable
}

// Assembly:
movzbl 0x8(%rdi), %eax
movzbl 0x8(%rsi), %ecx
cmpw %cx, %ax
jne 0x6beec
movzwl %ax, %eax
decl %eax
cmpl $0x6, %eax
ja 0x6bf1b
leaq 0xa632(%rip), %rcx      # 0x764c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %r8
movl 0x28(%r8), %eax
movq (%rsi), %rcx
subl 0x28(%rcx), %eax
je 0x6bef0
shrl $0x1f, %eax
retq
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x6beec
movsd (%rsi), %xmm0
ucomisd (%rdi), %xmm0
seta %al
retq
movq (%rdi), %rdi
testq %rdi, %rdi
sete %al
movq (%rsi), %rsi
testq %rsi, %rsi
sete %dl
setne %cl
orb %al, %dl
je 0x6bf08
andb %cl, %al
retq
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
retq
movq (%rdi), %rax
cmpq (%rsi), %rax
setb %al
retq
movq 0x18(%r8), %rdi
addq $0x8, %r8
movq 0x18(%rcx), %rdx
addq $0x8, %rcx
movq %r8, %rsi
jmp 0x6dcd9
testq %rdi, %rdi
je 0x6bf1b
pushq %rax
callq 0x27830
shrl $0x1f, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::operator==(Json::Value const&) const
bool 
Value::operator ==( const Value &other ) const
{
   //if ( type_ != other.type_ )
   // GCC 2.95.3 says:
   // attempt to take address of bit-field structure member `Json::Value::type_'
   // Beats me, but a temp solves the problem.
   int temp = other.type_;
   if ( type_ != temp )
      return false;
   switch ( type_ )
   {
   case nullValue:
      return true;
   case intValue:
      return value_.int_ == other.value_.int_;
   case uintValue:
      return value_.uint_ == other.value_.uint_;
   case realValue:
      return value_.real_ == other.value_.real_;
   case booleanValue:
      return value_.bool_ == other.value_.bool_;
   case stringValue:
      return ( value_.string_ == other.value_.string_ )
             || ( other.value_.string_  
                  &&  value_.string_  
                  && strcmp( value_.string_, other.value_.string_ ) == 0 );
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   case arrayValue:
   case objectValue:
      return value_.map_->size() == other.value_.map_->size()
             && (*value_.map_) == (*other.value_.map_);
#else
   case arrayValue:
      return value_.array_->compare( *(other.value_.array_) ) == 0;
   case objectValue:
      return value_.map_->compare( *(other.value_.map_) ) == 0;
#endif
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return 0;  // unreachable
}

// Assembly:
movzwl 0x8(%rdi), %ecx
movb 0x8(%rsi), %al
xorb %cl, %al
je 0x6bf4e
xorl %eax, %eax
retq
cmpb $0x7, %cl
ja 0x6bf4b
movb $0x1, %al
movzwl %cx, %ecx
movzbl %cl, %ecx
leaq 0xa57e(%rip), %rdx      # 0x764e0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x6bfd8
movq (%rdi), %rax
movq 0x28(%rax), %rdx
movq (%rsi), %rcx
cmpq 0x28(%rcx), %rdx
jne 0x6bf4b
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
jmp 0x6ddf8
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0x6bf4d
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6bf4b
pushq %rax
callq 0x27830
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
movb (%rdi), %al
cmpb (%rsi), %al
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::asString[abi:cxx11]() const
std::string 
Value::asString() const
{
   switch ( type_ )
   {
   case nullValue:
      return "";
   case stringValue:
      return value_.string_ ? value_.string_ : "";
   case booleanValue:
      return value_.bool_ ? "true" : "false";
   case intValue:
   case uintValue:
   case realValue:
   case arrayValue:
   case objectValue:
      JSON_ASSERT_MESSAGE( false, "Type is not convertible to string" );
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return ""; // unreachable
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movzbl 0x8(%rsi), %eax
cmpq $0x7, %rax
ja 0x6c011
leaq 0xa4f8(%rip), %rcx      # 0x76500
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xa7f8(%rip), %rdx      # 0x76817
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x6c07c
movzbl (%rsi), %edx
leaq 0x5c90(%rip), %rax      # 0x71cc1
leaq 0x62b0(%rip), %rsi      # 0x722e8
testq %rdx, %rdx
cmovneq %rax, %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
xorq $0x5, %rdx
addq %rsi, %rdx
movq %rbx, %rdi
jmp 0x6c07c
movq (%rsi), %rax
testq %rax, %rax
leaq 0xa7b8(%rip), %r14      # 0x76817
cmovneq %rax, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x272f0
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f1a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa567(%rip), %rsi      # 0x76613
leaq 0xa581(%rip), %rdx      # 0x76634
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22f1a(%rip), %rsi     # 0x8eff0
movq 0x22e93(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c0f7
callq 0x27560
testb %bpl, %bpl
jne 0x6c101
jmp 0x6c109
movq %rax, %r14
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::asInt() const
Value::Int 
Value::asInt() const
{
   switch ( type_ )
   {
   case nullValue:
      return 0;
   case intValue:
      return value_.int_;
   case uintValue:
      JSON_ASSERT_MESSAGE( value_.uint_ < (unsigned)maxInt, "integer out of signed integer range" );
      return value_.uint_;
   case realValue:
      JSON_ASSERT_MESSAGE( value_.real_ >= minInt  &&  value_.real_ <= maxInt, "Real out of signed integer range" );
      return Int( value_.real_ );
   case booleanValue:
      return value_.bool_ ? 1 : 0;
   case stringValue:
   case arrayValue:
   case objectValue:
      JSON_ASSERT_MESSAGE( false, "Type is not convertible to int" );
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return 0; // unreachable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movzbl 0x8(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x6c1dc
leaq 0xa3ee(%rip), %rcx      # 0x76520
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
jmp 0x6c1de
movzbl (%rdi), %eax
jmp 0x6c1de
movsd (%rdi), %xmm0
movapd 0xa489(%rip), %xmm1     # 0x765e0
andpd %xmm0, %xmm1
movsd 0x892d(%rip), %xmm2     # 0x74a90
ucomisd %xmm1, %xmm2
jb 0x6c241
cvttsd2si %xmm0, %rax
jmp 0x6c1de
movq (%rdi), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jb 0x6c1de
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa497(%rip), %rsi      # 0x76635
leaq 0xa4b3(%rip), %rdx      # 0x76658
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22e28(%rip), %rsi     # 0x8eff0
movq 0x22da1(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
jmp 0x6c297
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa474(%rip), %rsi      # 0x7667a
leaq 0xa48b(%rip), %rdx      # 0x76698
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22dc0(%rip), %rsi     # 0x8eff0
movq 0x22d39(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
jmp 0x6c297
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa3fb(%rip), %rsi      # 0x76659
leaq 0xa414(%rip), %rdx      # 0x76679
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22d68(%rip), %rsi     # 0x8eff0
movq 0x22ce1(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
jmp 0x6c29f
jmp 0x6c29f
jmp 0x6c2b8
jmp 0x6c2b8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c2b1
callq 0x27560
testb %bpl, %bpl
jne 0x6c2bb
jmp 0x6c2c3
movq %rax, %r14
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::asUInt() const
Value::UInt 
Value::asUInt() const
{
   switch ( type_ )
   {
   case nullValue:
      return 0;
   case intValue:
      JSON_ASSERT_MESSAGE( value_.int_ >= 0, "Negative integer can not be converted to unsigned integer" );
      return value_.int_;
   case uintValue:
      return value_.uint_;
   case realValue:
      JSON_ASSERT_MESSAGE( value_.real_ >= 0  &&  value_.real_ <= maxUInt,  "Real out of unsigned integer range" );
      return UInt( value_.real_ );
   case booleanValue:
      return value_.bool_ ? 1 : 0;
   case stringValue:
   case arrayValue:
   case objectValue:
      JSON_ASSERT_MESSAGE( false, "Type is not convertible to uint" );
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return 0; // unreachable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movzbl 0x8(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x6c3ab
leaq 0xa250(%rip), %rcx      # 0x7653c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
testq %rax, %rax
jns 0x6c3ad
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa37b(%rip), %rsi      # 0x76699
leaq 0xa3ad(%rip), %rdx      # 0x766d2
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22ca8(%rip), %rsi     # 0x8eff0
movq 0x22c21(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
jmp 0x6c466
movzbl (%rdi), %eax
jmp 0x6c3ad
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x6c410
movsd 0xa275(%rip), %xmm1     # 0x765f0
ucomisd %xmm0, %xmm1
jb 0x6c410
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x86f7(%rip), %xmm0     # 0x74a90
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x6c3ad
movq (%rdi), %rax
jmp 0x6c3ad
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa321(%rip), %rsi      # 0x766f6
leaq 0xa339(%rip), %rdx      # 0x76715
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22bf1(%rip), %rsi     # 0x8eff0
movq 0x22b6a(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
jmp 0x6c466
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa2a6(%rip), %rsi      # 0x766d3
leaq 0xa2c1(%rip), %rdx      # 0x766f5
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22b99(%rip), %rsi     # 0x8eff0
movq 0x22b12(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
jmp 0x6c46e
jmp 0x6c487
jmp 0x6c46e
jmp 0x6c487
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c480
callq 0x27560
testb %bpl, %bpl
jne 0x6c48a
jmp 0x6c492
movq %rax, %r14
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b10
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::asDouble() const
double 
Value::asDouble() const
{
   switch ( type_ )
   {
   case nullValue:
      return 0.0;
   case intValue:
      return static_cast<double>( value_.int_ );
   case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
      return static_cast<double>( value_.uint_ );
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
      return static_cast<double>( Int(value_.uint_/2) ) * 2 + Int(value_.uint_ & 1);
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
   case realValue:
      return value_.real_;
   case booleanValue:
      return value_.bool_ ? 1.0 : 0.0;
   case stringValue:
   case arrayValue:
   case objectValue:
      JSON_ASSERT_MESSAGE( false, "Type is not convertible to double" );
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return 0; // unreachable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movzbl 0x8(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x6c4cb
leaq 0xa0a2(%rip), %rcx      # 0x76558
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq (%rdi), %xmm0
jmp 0x6c500
cmpb $0x0, (%rdi)
jne 0x6c4f8
xorpd %xmm0, %xmm0
jmp 0x6c500
movsd (%rdi), %xmm0
jmp 0x6c500
movsd (%rdi), %xmm1
unpcklps 0x8ede(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x8ee6(%rip), %xmm1     # 0x753d0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x6c500
movsd 0x6b28(%rip), %xmm0     # 0x73028
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa1ee(%rip), %rsi      # 0x76716
leaq 0xa208(%rip), %rdx      # 0x76737
leaq 0x8(%rsp), %rdi
callq 0x2f1a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279e0
xorl %ebp, %ebp
movq 0x22a9e(%rip), %rsi     # 0x8eff0
movq 0x22a17(%rip), %rdx     # 0x8ef70
movq %rbx, %rdi
callq 0x27aa0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c573
callq 0x27560
testb %bpl, %bpl
jne 0x6c57d
jmp 0x6c585
movq %rax, %r14
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b10
nop
// File: /workspace/github_cpp_makefile_star2_O3/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::asBool() const
bool 
Value::asBool() const
{
   switch ( type_ )
   {
   case nullValue:
      return false;
   case intValue:
   case uintValue:
      return value_.int_ != 0;
   case realValue:
      return value_.real_ != 0.0;
   case booleanValue:
      return value_.bool_;
   case stringValue:
      return value_.string_  &&  value_.string_[0] != 0;
   case arrayValue:
   case objectValue:
      return value_.map_->size() != 0;
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return false; // unreachable;
}

// Assembly:
movzbl 0x8(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x6c5c8
leaq 0x9fd4(%rip), %rcx      # 0x76574
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, (%rdi)
jmp 0x6c5c4
movq (%rdi), %rax
cmpq $0x0, 0x28(%rax)
jmp 0x6c5c4
movq (%rdi), %rax
testq %rax, %rax
je 0x6c5c8
cmpb $0x0, (%rax)
setne %al
retq
xorl %eax, %eax
retq
xorpd %xmm0, %xmm0
cmpneqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
movb (%rdi), %al
retq