LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
andb 0x108(%rdi), %r8b
movq %rsi, %r15
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)
leaq 0xe6ba(%rip), %rsi      # 0x767f7
movq %r13, %rdi
callq 0x35c40
leaq 0x50(%rbx), %rdi
callq 0x69dda
movq 0x30(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x68162
movq %rbx, %rdi
callq 0x6a5c8
jmp 0x6814e
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x6a618
movq %rbx, %rdi
callq 0x682ba
movl %eax, %ebp
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x684de
cmpb $0x1, 0x10a(%rbx)
jne 0x681aa
cmpq $0x0, 0xf0(%rbx)
je 0x681aa
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x6da02
cmpb $0x1, 0x109(%rbx)
jne 0x68217
movq %r12, %rdi
callq 0x6d270
testb %al, %al
jne 0x68217
movq %r12, %rdi
callq 0x6d284
testb %al, %al
jne 0x68217
leaq 0x30(%rsp), %r12
movl $0xd, (%r12)
movq %r15, 0x8(%r12)
movq %r14, 0x10(%r12)
leaq 0xdffb(%rip), %rsi      # 0x761e4
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x35280
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x6851c
leaq 0x10(%rsp), %rdi
callq 0x35730
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movq %rsp, %rsi
pushq $-0x1
popq %rdx
movq %rax, %rdi
callq 0x35be0
movzbl %bpl, %ecx
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x680aa
movl %eax, %ebx
movq %rsp, %rdi
callq 0x35730
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/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 0x68509
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68ce8
cmpl $0xc, (%rbx)
je 0x684f1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68ce8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movups (%rdx), %xmm0
movaps %xmm0, -0x28(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, -0x18(%rax)
movq %rbx, %rdi
callq 0x35340
movq %rsp, %rsi
movq %r15, 0x38(%rsi)
addq $0x50, %r14
movq %r14, %rdi
callq 0x69dfa
movq %rbx, %rdi
callq 0x35730
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x35730
movq %r14, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x6
popq %rsi
callq 0x6c604
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x688d1
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6c95e
leaq 0x8(%rsp), %rdi
callq 0x6c88a
movq %rbx, %rdi
callq 0x68eb6
movq 0xd0(%rbx), %rax
cmpb $0x5d, (%rax)
jne 0x6890c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x68ce8
jmp 0x6897c
xorl %ebp, %ebp
movl $0x200, %r12d           # imm = 0x200
leaq 0x8(%rsp), %r14
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x6892e
movq 0x48(%rbx), %rax
movq -0x8(%rax), %rax
addq %r12, %rax
movq -0x8(%rax), %rdi
movl %ebp, %esi
callq 0x6d384
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6a618
movq %rbx, %rdi
callq 0x682ba
movl %eax, %r15d
movq %rbx, %rdi
callq 0x6a5c8
testb %r15b, %r15b
je 0x68980
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68ce8
movl 0x8(%rsp), %eax
cmpl $0xc, %eax
je 0x68963
cmpl $0x4, %eax
jne 0x68919
movb $0x1, %al
jmp 0x6898d
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x69540
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 0x6c88a
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x18(%rsp), %rdx
callq 0x6920e
movl %eax, %ebx
testb %al, %al
je 0x68ca7
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x6c70c
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x68c93
movq 0x48(%r14), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x6c95e
movq %rsp, %rdi
callq 0x6c88a
leaq 0x18(%rsp), %rdi
callq 0x35730
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6c88a
jmp 0x68ccd
jmp 0x68cca
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readToken(Json::Reader::Token&)
bool 
Reader::readToken( Token &token )
{
   skipSpaces();
   token.start_ = current_;
   Char c = getNextChar();
   bool ok = true;
   switch ( c )
   {
   case '{':
      token.type_ = tokenObjectBegin;
      break;
   case '}':
      token.type_ = tokenObjectEnd;
      break;
   case '[':
      token.type_ = tokenArrayBegin;
      break;
   case ']':
      token.type_ = tokenArrayEnd;
      break;
   case '"':
      token.type_ = tokenString;
      ok = readString();
      break;
   case '/':
      token.type_ = tokenComment;
      ok = readComment();
      break;
   case '0':
   case '1':
   case '2':
   case '3':
   case '4':
   case '5':
   case '6':
   case '7':
   case '8':
   case '9':
   case '-':
      token.type_ = tokenNumber;
      readNumber();
      break;
   case 't':
      token.type_ = tokenTrue;
      ok = match( "rue", 3 );
      break;
   case 'f':
      token.type_ = tokenFalse;
      ok = match( "alse", 4 );
      break;
   case 'n':
      token.type_ = tokenNull;
      ok = match( "ull", 3 );
      break;
   case ',':
      token.type_ = tokenArraySeparator;
      break;
   case ':':
      token.type_ = tokenMemberSeparator;
      break;
   case 0:
      token.type_ = tokenEndOfStream;
      break;
   default:
      ok = false;
      break;
   }
   if ( !ok )
      token.type_ = tokenError;
   token.end_ = current_;
   return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x68eb6
movq 0xd0(%r14), %rax
movq %rax, 0x8(%rbx)
cmpq 0xc8(%r14), %rax
je 0x68d80
leaq 0x1(%rax), %rcx
movq %rcx, 0xd0(%r14)
movzbl (%rax), %eax
leal -0x22(%rax), %ecx
cmpl $0x18, %ecx
ja 0x68d41
leaq 0xd438(%rip), %rax      # 0x76160
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x6, (%rbx)
movq %r14, %rdi
callq 0x6901c
jmp 0x68d83
testl %eax, %eax
je 0x68d80
cmpl $0x5b, %eax
je 0x68df0
cmpl $0x5d, %eax
je 0x68e23
cmpl $0x66, %eax
je 0x68df8
cmpl $0x6e, %eax
je 0x68dc8
cmpl $0x74, %eax
je 0x68ddf
cmpl $0x7d, %eax
je 0x68dd7
cmpl $0x7b, %eax
jne 0x68e18
movl $0x1, (%rbx)
jmp 0x68d83
andl $0x0, (%rbx)
movq 0xd0(%r14), %rax
movq %rax, 0x10(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xa, (%rbx)
jmp 0x68d83
movl $0xb, (%rbx)
jmp 0x68d83
movl $0x5, (%rbx)
movq %r14, %rdi
callq 0x68f12
jmp 0x68e10
movl $0xc, (%rbx)
movq %r14, %rdi
callq 0x68f60
jmp 0x68e10
movl $0x9, (%rbx)
leaq 0xda39(%rip), %rsi      # 0x7680e
jmp 0x68dec
movl $0x2, (%rbx)
jmp 0x68d83
movl $0x7, (%rbx)
leaq 0x8e63(%rip), %rsi      # 0x71c4f
pushq $0x3
jmp 0x68e07
movl $0x3, (%rbx)
jmp 0x68d83
movl $0x8, (%rbx)
leaq 0x9471(%rip), %rsi      # 0x72276
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x69062
testb %al, %al
jne 0x68d83
movl $0xd, (%rbx)
jmp 0x68d83
movl $0x4, (%rbx)
jmp 0x68d83
// File: /workspace/github_cpp_makefile_star2_O2/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 0x68ce8
movl (%r14), %ebp
cmpl %ebx, %ebp
je 0x68e85
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x35280
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x6851c
leaq 0x8(%rsp), %rdi
callq 0x35730
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 0x8(%rsp), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/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
movabsq $0x100002600, %rdx      # imm = 0x100002600
cmpq %rax, %rcx
je 0x68eee
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x68eee
btq %rsi, %rdx
jae 0x68eee
incq %rcx
movq %rcx, 0xd0(%rdi)
jmp 0x68ece
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
cmpq %rax, %rdx
je 0x68f58
movq %rdx, %rsi
incq %rdx
movq %rdx, 0xd0(%rdi)
movzbl (%rsi), %ecx
cmpl $0x5c, %ecx
je 0x68f43
cmpl $0x22, %ecx
jne 0x68f22
jmp 0x68f58
cmpq %rax, %rdx
je 0x68f22
addq $0x2, %rsi
movq %rsi, 0xd0(%rdi)
movq %rsi, %rdx
jmp 0x68f22
cmpb $0x22, %cl
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::readComment()
bool
Reader::readComment()
{
   Location commentBegin = current_ - 1;
   Char c = getNextChar();
   bool successful = false;
   if ( c == '*' )
      successful = readCStyleComment();
   else if ( c == '/' )
      successful = readCppStyleComment();
   if ( !successful )
      return false;

   if ( collectComments_ )
   {
      CommentPlacement placement = commentBefore;
      if ( lastValueEnd_  &&  !containsNewLine( lastValueEnd_, commentBegin ) )
      {
         if ( c != '*'  ||  !containsNewLine( commentBegin, current_ ) )
            placement = commentAfterOnSameLine;
      }

      addComment( commentBegin, current_, placement );
   }
   return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xd0(%rdi), %rbx
cmpq 0xc8(%rdi), %rbx
je 0x6900f
movq %rdi, %r14
leaq 0x1(%rbx), %rax
movq %rax, 0xd0(%rdi)
movzbl (%rbx), %r12d
cmpl $0x2a, %r12d
je 0x68fa4
cmpl $0x2f, %r12d
jne 0x6900f
movq %r14, %rdi
callq 0x690f0
jmp 0x68fb0
movq %r14, %rdi
callq 0x690a6
testb %al, %al
je 0x6900f
movb $0x1, %bpl
cmpb $0x1, 0x10a(%r14)
jne 0x69011
decq %rbx
movq 0xd8(%r14), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x68ff8
movq %rbx, %rsi
callq 0x69121
testb %al, %al
jne 0x68ff8
cmpb $0x2a, %r12b
jne 0x68ff4
movq 0xd0(%r14), %rsi
movq %rbx, %rdi
callq 0x69121
testb %al, %al
jne 0x68ff8
pushq $0x1
popq %r15
movq 0xd0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %ecx
callq 0x69140
jmp 0x69011
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movabsq $0x40000000400000d, %rdx # imm = 0x40000000400000D
cmpq %rax, %rcx
je 0x69060
movzbl (%rcx), %esi
leal -0x30(%rsi), %r8d
cmpb $0xa, %r8b
jb 0x69054
addl $-0x2b, %esi
cmpl $0x3a, %esi
ja 0x69060
btq %rsi, %rdx
jae 0x69060
incq %rcx
movq %rcx, 0xd0(%rdi)
jmp 0x69034
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x69096
movq %rcx, %r8
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x69099
movb -0x1(%rax,%r8), %r9b
cmpb -0x1(%rsi,%r8), %r9b
movq %rdx, %r8
je 0x69081
xorl %eax, %eax
retq
addq %rcx, %rax
movq %rax, 0xd0(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq 0xd0(%rdi), %rcx
incq %rcx
leaq -0x1(%rcx), %rdx
cmpq %rax, %rdx
je 0x690d5
movq %rcx, 0xd0(%rdi)
cmpb $0x2a, -0x1(%rcx)
jne 0x690b4
cmpb $0x2f, (%rcx)
jne 0x690b4
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x690ec
leaq 0x1(%rdx), %rax
movq %rax, 0xd0(%rdi)
cmpb $0x2f, (%rdx)
sete %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x1, %ecx
jne 0x6918a
movq 0xe0(%rdi), %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6a7f8
movq %rsp, %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x6da02
movq %rsp, %rdi
callq 0x35730
jmp 0x691d4
leaq 0xe8(%rdi), %r15
cmpq $0x0, 0xf0(%rdi)
je 0x691aa
leaq 0x9e10(%rip), %rsi      # 0x72fb2
movq %r15, %rdi
callq 0x35c30
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6a7f8
movq %rsp, %rsi
movq %r15, %rdi
callq 0x35c60
movq %rsp, %rdi
callq 0x35730
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35730
jmp 0x69205
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35730
jmp 0x69205
movq %rax, %rdi
callq 0x3a198
jmp 0x69202
movq %rax, %rbx
movq %rbx, %rdi
callq 0x35b50
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x69e24
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x68ce8
movl 0x8(%rsp), %eax
cmpl %ebp, %eax
je 0x6957c
testl %eax, %eax
jne 0x69565
movslq %r15d, %rsi
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %r14
movaps %xmm0, -0x8(%r14)
movaps %xmm0, 0x8(%r14)
movaps %xmm0, 0x18(%r14)
movaps %xmm0, -0x18(%r14)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x69e34
movq %r14, %rdi
callq 0x35730
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::decodeDouble(Json::Reader::Token&)
bool 
Reader::decodeDouble( Token &token )
{
   double value = 0;
   const int bufferSize = 32;
   int count;
   int length = int(token.end_ - token.start_);
   if ( length <= bufferSize )
   {
      Char buffer[bufferSize];
      memcpy( buffer, token.start_, length );
      buffer[length] = 0;
      count = sscanf( buffer, "%lf", &value );
   }
   else
   {
      std::string buffer( token.start_, token.end_ );
      count = sscanf( buffer.c_str(), "%lf", &value );
   }

   if ( count != 1 )
      return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
   currentValue() = value;
   return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %r14
andq $0x0, 0x8(%rsp)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
movq %rdx, %rax
subq %rsi, %rax
cmpl $0x20, %eax
jg 0x69666
movslq %eax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x354c0
movb $0x0, 0x10(%rsp,%rbx)
leaq 0xcc85(%rip), %rsi      # 0x762d8
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x35450
movl %eax, %ebx
jmp 0x6969d
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x6a7f8
movq (%r12), %rdi
leaq 0xcc51(%rip), %rsi      # 0x762d8
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x35450
movl %eax, %ebx
movq %r12, %rdi
callq 0x35730
cmpl $0x1, %ebx
jne 0x696e3
movsd 0x8(%rsp), %xmm0
leaq 0x10(%rsp), %rdi
callq 0x6c6a4
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x696c9
movq 0x48(%r14), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6c95e
leaq 0x10(%rsp), %rdi
callq 0x6c88a
jmp 0x6975a
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x38(%rsp), %rdi
callq 0x6a7f8
leaq 0x9c2b(%rip), %rsi      # 0x73330
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x498a8
leaq 0xcbaa(%rip), %rdx      # 0x762c5
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3ab7a
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x6851c
leaq 0x10(%rsp), %rdi
callq 0x35730
leaq 0x58(%rsp), %rdi
callq 0x35730
leaq 0x38(%rsp), %rdi
callq 0x35730
cmpl $0x1, %ebx
sete %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35730
jmp 0x69797
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6c88a
jmp 0x697ab
movq %rax, %rbx
jmp 0x697ab
movq %rax, %rbx
jmp 0x697a1
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x35730
leaq 0x38(%rsp), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x69912
testb %al, %al
je 0x698cc
movl $0xfffffc00, %eax       # imm = 0xFFFFFC00
andl (%r12), %eax
movb $0x1, %bpl
cmpl $0xd800, %eax           # imm = 0xD800
jne 0x698ce
movq (%r15), %rax
movq %r13, %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
jg 0x69844
leaq 0xcb07(%rip), %rsi      # 0x7631a
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x35280
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6851c
leaq 0x8(%rsp), %rdi
callq 0x35730
jmp 0x698cc
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x5c, (%rax)
jne 0x69899
leaq 0x2(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x75, 0x1(%rax)
jne 0x69899
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x69912
testb %al, %al
je 0x698cc
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 0x698ce
leaq 0xcabe(%rip), %rsi      # 0x7635e
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x35280
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6851c
leaq 0x8(%rsp), %rdi
callq 0x35730
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35730
jmp 0x6990a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35730
jmp 0x6990a
movq %rax, %rdi
callq 0x3a198
jmp 0x69907
movq %rax, %rbx
movq %rbx, %rdi
callq 0x35b50
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
subq %rax, %rcx
cmpq $0x3, %rcx
jg 0x69967
leaq 0xca77(%rip), %rsi      # 0x763ae
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x35280
movq (%r15), %rcx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6851c
leaq 0x10(%rsp), %rdi
callq 0x35730
xorl %eax, %eax
jmp 0x699bd
andl $0x0, (%r8)
incq %rax
xorl %ecx, %ecx
pushq $0x4
popq %rdx
subl $0x1, %edx
jb 0x699bb
movq %rax, (%r15)
movsbl -0x1(%rax), %esi
shll $0x4, %ecx
movl %ecx, (%r8)
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x69995
addl %esi, %ecx
addl $-0x30, %ecx
jmp 0x699b3
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x699a5
addl %esi, %ecx
addl $-0x57, %ecx
jmp 0x699b3
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x699c7
addl %esi, %ecx
addl $-0x37, %ecx
movl %ecx, (%r8)
incq %rax
jmp 0x69973
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xca1d(%rip), %rsi      # 0x763eb
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x35280
movq (%r15), %rcx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6851c
leaq 0x10(%rsp), %rdi
callq 0x35730
jmp 0x69963
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35730
jmp 0x69a2a
jmp 0x69a27
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x35730
jmp 0x69a2a
movq %rax, %rdi
callq 0x3a198
movq %rax, %rbx
movq %rbx, %rdi
callq 0x35b50
// File: /workspace/github_cpp_makefile_star2_O2/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), %r9
andl $0x0, (%rdx)
xorl %eax, %eax
movq %r9, %r8
movq 0xc8(%rdi), %r10
cmpq %rsi, %r8
jae 0x69a7a
cmpq %r10, %r8
je 0x69a7a
movzbl (%r8), %r11d
incq %r8
cmpl $0xa, %r11d
je 0x69a71
cmpl $0xd, %r11d
jne 0x69a48
leaq 0x1(%r8), %r9
cmpb $0xa, (%r8)
cmoveq %r9, %r8
incl %eax
movl %eax, (%rdx)
movq %r8, %r9
jmp 0x69a41
subl %r9d, %esi
incl %esi
movl %esi, (%rcx)
incl (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_reader.cpp
// Function: Json::Reader::getFormatedErrorMessages[abi:cxx11]() const
std::string 
Reader::getFormatedErrorMessages() const
{
   std::string formattedMessage;
   for ( Errors::const_iterator itError = errors_.begin();
         itError != errors_.end();
         ++itError )
   {
      const ErrorInfo &error = *itError;
      formattedMessage += "* " + getLocationLineAndColumn( error.token_.start_ ) + "\n";
      formattedMessage += "  " + error.message_ + "\n";
      if ( error.extra_ )
         formattedMessage += "See " + getLocationLineAndColumn( error.extra_ ) + " for detail.\n";
   }
   return formattedMessage;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x60(%rsi), %r15
movq 0x70(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %r12
leaq 0x18(%rsp), %rbp
leaq 0x38(%rsp), %r13
cmpq 0x80(%r14), %r15
je 0x69c60
movq 0x8(%r15), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x69a84
movq %rbp, %rdi
leaq 0xc8ee(%rip), %rsi      # 0x76441
movq %r12, %rdx
callq 0x498a8
movq %r13, %rdi
movq %rbp, %rsi
leaq 0x944a(%rip), %rdx      # 0x72fb2
callq 0x3ab7a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x35c60
movq %r13, %rdi
callq 0x35730
movq %rbp, %rdi
callq 0x35730
movq %r12, %rdi
callq 0x35730
addq $0x18, %r15
movq %rbp, %rdi
leaq 0xb914(%rip), %rsi      # 0x754b2
movq %r15, %rdx
callq 0x498a8
movq %r13, %rdi
movq %rbp, %rsi
leaq 0x93ff(%rip), %rdx      # 0x72fb2
callq 0x3ab7a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x35c60
movq %r13, %rdi
callq 0x35730
movq %rbp, %rdi
callq 0x35730
movq 0x20(%r15), %rdx
testq %rdx, %rdx
je 0x69c2e
movq %r12, %rdi
movq %r14, %rsi
callq 0x69a84
movq %rbp, %rdi
leaq 0xc853(%rip), %rsi      # 0x76444
movq %r12, %rdx
callq 0x498a8
movq %r13, %rdi
movq %rbp, %rsi
leaq 0xc843(%rip), %rdx      # 0x76449
callq 0x3ab7a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x35c60
movq %r13, %rdi
callq 0x35730
movq %rbp, %rdi
callq 0x35730
movq %r12, %rdi
callq 0x35730
addq $0x28, %r15
cmpq 0x10(%rsp), %r15
jne 0x69b2d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r15
addq $0x8, %rax
movq %rax, 0x8(%rsp)
leaq 0x200(%r15), %rax
movq %rax, 0x10(%rsp)
jmp 0x69b2d
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x35730
jmp 0x69ca2
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x35730
jmp 0x69cc4
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x35730
jmp 0x69cd8
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x35730
jmp 0x69cb1
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x35730
jmp 0x69cf1
jmp 0x69cd0
jmp 0x69cd0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x35730
jmp 0x69cf1
movq %rax, %r14
jmp 0x69cf1
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x35730
jmp 0x69ce7
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x35730
movq %rbx, %rdi
callq 0x35730
movq %r14, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/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 0x67f14
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x68246
testb %al, %al
je 0x69d59
leaq 0x28(%rsp), %rdi
callq 0x43556
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x35310
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x69ae4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35a10
xorl %ebp, %ebp
movq 0x2b264(%rip), %rsi     # 0x94ff0
movq 0x2b1f5(%rip), %rdx     # 0x94f88
movq %rbx, %rdi
callq 0x35af0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x35730
testb %bpl, %bpl
jne 0x69db2
jmp 0x69dbf
movq %rax, %r14
movq %rbx, %rdi
callq 0x35460
jmp 0x69dbf
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x43556
movq %r14, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x356f0
movzbl (%r14), %eax
testl %eax, %eax
je 0x6c3ef
cmpl $0x2f, %eax
jne 0x6c406
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x6c47e
movq %rax, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x35310
movq %rax, %rbx
leaq 0xa1c0(%rip), %rsi      # 0x765d8
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x35280
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x35a10
xorl %ebp, %ebp
movq 0x28bb0(%rip), %rsi     # 0x94ff0
movq 0x28b41(%rip), %rdx     # 0x94f88
movq %rbx, %rdi
callq 0x35af0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x35730
testb %bpl, %bpl
jne 0x6c46e
jmp 0x6c476
movq %rax, %rdi
callq 0x3a198
movq %rax, %r14
movq %rbx, %rdi
callq 0x35460
movq %r14, %rdi
callq 0x35b50
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::duplicateStringValue(char const*, unsigned int)
static inline char *
duplicateStringValue( const char *value, 
                      unsigned int length = unknown )
{
   if ( length == unknown )
      length = (unsigned int)strlen(value);
   char *newString = static_cast<char *>( malloc( length + 1 ) );
   memcpy( newString, value, length );
   newString[length] = 0;
   return newString;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
cmpl $-0x1, %esi
jne 0x6c499
movq %rbx, %rdi
callq 0x352d0
movq %rax, %r14
leal 0x1(%r14), %edi
callq 0x357c0
movq %rax, %r15
movl %r14d, %r14d
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x354c0
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::Value(Json::Value const&)
Value::Value( const Value &other )
   : type_( other.type_ )
   , comments_( 0 )
# ifdef JSON_VALUE_USE_INTERNAL_MAP
   , itemIsUsed_( 0 )
#endif
{
   switch ( type_ )
   {
   case nullValue:
   case intValue:
   case uintValue:
   case realValue:
   case booleanValue:
      value_ = other.value_;
      break;
   case stringValue:
      if ( other.value_.string_ )
      {
         value_.string_ = duplicateStringValue( other.value_.string_ );
         allocated_ = true;
      }
      else
         value_.string_ = 0;
      break;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   case arrayValue:
   case objectValue:
      value_.map_ = new ObjectValues( *other.value_.map_ );
      break;
#else
   case arrayValue:
      value_.array_ = arrayAllocator()->newArrayCopy( *other.value_.array_ );
      break;
   case objectValue:
      value_.map_ = mapAllocator()->newMapCopy( *other.value_.map_ );
      break;
#endif
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   if ( other.comments_ )
   {
      comments_ = new CommentInfo[numberOfCommentPlacement];
      for ( int comment =0; comment < numberOfCommentPlacement; ++comment )
      {
         const CommentInfo &otherComment = other.comments_[comment];
         if ( otherComment.comment_ )
            comments_[comment].setComment( otherComment.comment_ );
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x8(%rsi), %eax
movb %al, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
cmpb $0x7, %al
ja 0x6c7d7
movzbl %al, %eax
pushq $0x2f
popq %rcx
btl %eax, %ecx
jae 0x6c794
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0x6c7d7
movl $0xc0, %ecx
btl %eax, %ecx
jae 0x6c7b9
pushq $0x30
popq %rdi
callq 0x355d0
movq %rax, %r15
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x6e220
movq %r15, (%r14)
jmp 0x6c7d7
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6c7d3
pushq $-0x1
popq %rsi
callq 0x6c47e
movq %rax, (%r14)
orb $0x1, 0x9(%r14)
jmp 0x6c7d7
andq $0x0, (%r14)
cmpq $0x0, 0x10(%rbx)
je 0x6c83c
pushq $0x20
popq %rdi
callq 0x35030
movq %rax, %r15
movq $0x3, (%rax)
leaq 0x8(%rax), %rbp
xorl %r13d, %r13d
movq %rbp, %r12
movq %r12, %rdi
callq 0x6c3be
addq $-0x8, %r13
addq $0x8, %r12
cmpq $-0x18, %r13
jne 0x6c7fa
movq %rbp, 0x10(%r14)
xorl %r15d, %r15d
cmpq $0x18, %r15
je 0x6c83c
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rsi
testq %rsi, %rsi
je 0x6c836
movq 0x10(%r14), %rdi
addq %r15, %rdi
callq 0x6c3cc
addq $0x8, %r15
jmp 0x6c817
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x35570
jmp 0x6c87a
movq %rax, %rbx
testq %r13, %r13
je 0x6c872
negq %r13
leaq (%r15,%r13), %rdi
callq 0x6c3c4
addq $-0x8, %r13
jne 0x6c863
movq %r15, %rdi
callq 0x35770
movq %rbx, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6c8be
movq (%rbx), %r15
testq %r15, %r15
je 0x6c8b4
movq %r15, %rdi
callq 0x6e1ca
movq %r15, %rdi
callq 0x35570
jmp 0x6c8d1
cmpl $0x4, %ecx
jne 0x6c8d1
btl $0x8, %eax
jae 0x6c8d1
movq (%rbx), %rdi
callq 0x356f0
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x6c90d
leaq -0x8(%r15), %rbx
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x6c8fa
shlq $0x3, %r12
leaq (%rbx,%r12), %rdi
callq 0x6c3c4
addq $-0x8, %r12
jne 0x6c8eb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x35770
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x35570
jmp 0x6c94e
movq %rax, %r14
cmpq $0x8, %r12
je 0x6c946
addq $-0x10, %r15
leaq (%r15,%r12), %rdi
callq 0x6c3c4
addq $-0x8, %r12
cmpq $0x8, %r12
jne 0x6c933
movq %rbx, %rdi
callq 0x35770
movq %r14, %rdi
callq 0x35b50
movq %rax, %rdi
callq 0x3a198
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6ca5f
movzwl %ax, %eax
decl %eax
cmpl $0x6, %eax
ja 0x6ca76
leaq 0x9aa2(%rip), %rcx      # 0x764a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rdi
movl 0x28(%rdi), %eax
movq (%rsi), %rsi
subl 0x28(%rsi), %eax
je 0x6e494
shrl $0x1f, %eax
retq
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x6ca5f
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 0x6ca63
andb %cl, %al
retq
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
retq
movq (%rdi), %rax
cmpq (%rsi), %rax
setb %al
retq
testq %rdi, %rdi
je 0x6ca76
pushq %rax
callq 0x35860
shrl $0x1f, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
jne 0x6cb0b
cmpb $0x7, %cl
ja 0x6cb0b
movb $0x1, %al
movzwl %cx, %ecx
movzbl %cl, %ecx
leaq 0x9a05(%rip), %rdx      # 0x764c0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x6cb24
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0x6cb0d
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6cb0b
pushq %rax
callq 0x35860
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
movq (%rdi), %rdi
movq 0x28(%rdi), %rax
movq (%rsi), %rsi
cmpq 0x28(%rsi), %rax
je 0x6e57f
xorl %eax, %eax
retq
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
movb (%rdi), %al
cmpb (%rsi), %al
sete %al
retq