LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6778f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6815a
cmpl $0xc, (%rbx)
je 0x67777
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6815a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x695e6
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x67802
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 0x67820
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6bf78
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x67bdd
movq 0x48(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6c3fa
leaq 0x8(%rsp), %rdi
callq 0x6c31c
movq 0xc8(%rbx), %rax
movq 0xd0(%rbx), %rcx
cmpq %rax, %rcx
je 0x67c30
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x67c30
btq %rsi, %rdx
jae 0x67c30
incq %rcx
movq %rcx, 0xd0(%rbx)
cmpq %rax, %rcx
jne 0x67c12
movq 0xd0(%rbx), %rax
cmpb $0x5d, (%rax)
jne 0x67c4e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6815a
jmp 0x67d00
xorl %ebp, %ebp
movl $0x200, %r12d           # imm = 0x200
leaq 0x8(%rsp), %r14
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x67c70
movq 0x48(%rbx), %rax
movq -0x8(%rax), %rax
addq %r12, %rax
movq -0x8(%rax), %rdi
movl %ebp, %esi
callq 0x6cf9e
movq %rax, 0x8(%rsp)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x67c9b
movq %rax, (%rcx)
addq $0x8, 0x30(%rbx)
jmp 0x67ca6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69dd4
movq %rbx, %rdi
callq 0x67536
movl %eax, %r15d
movq %rbx, %rdi
callq 0x69d8c
movq %rbx, %rdi
testb %r15b, %r15b
jne 0x67cd5
movl $0x4, %esi
callq 0x68b68
movl $0x1, %eax
jmp 0x67cf1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6815a
movl 0x8(%rsp), %eax
cmpl $0xc, %eax
je 0x67cd2
xorl %ecx, %ecx
cmpl $0x4, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
incl %ebp
testl %eax, %eax
je 0x67c5b
cmpl $0x3, %eax
jne 0x67d04
movb $0x1, %al
jmp 0x67d06
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 0x6c31c
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68818
movl %eax, %ebx
testb %al, %al
je 0x6810b
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6c112
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x680f3
movq 0x48(%r14), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6c3fa
leaq 0x8(%rsp), %rdi
callq 0x6c31c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x6811a
callq 0x27560
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6c31c
jmp 0x68142
movq %rax, %rdi
callq 0x2e1ed
jmp 0x6813f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x68151
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6815a
movl (%r14), %ebp
cmpl %ebx, %ebp
je 0x6843a
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 0x677a2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6843a
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 0x68464
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x684a7
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rcx), %esi
cmpq $0x20, %rsi
ja 0x684a7
btq %rsi, %rdx
jae 0x684a7
incq %rcx
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jne 0x68489
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68519
leaq 0x1(%rdx), %rsi
movq %rsi, 0xd0(%rdi)
movzbl (%rdx), %ecx
cmpl $0x5c, %ecx
je 0x684f7
cmpl $0x22, %ecx
jne 0x6850a
jmp 0x68512
cmpq %rax, %rsi
je 0x6850a
addq $0x2, %rdx
movq %rdx, 0xd0(%rdi)
movq %rdx, %rsi
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0x684dd
cmpb $0x22, %cl
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %r14
cmpq %rax, %r14
je 0x68549
leaq 0x1(%r14), %rcx
movq %rcx, 0xd0(%rbx)
movb (%r14), %r15b
jmp 0x6854c
xorl %r15d, %r15d
cmpb $0x2f, %r15b
je 0x68567
movzbl %r15b, %eax
cmpl $0x2a, %eax
jne 0x68593
movq %rbx, %rdi
callq 0x686c6
movl %eax, %ebp
jmp 0x68595
movq 0xd0(%rbx), %rcx
movb $0x1, %bpl
cmpq %rax, %rcx
je 0x68595
leaq 0x1(%rcx), %rdx
movq %rdx, 0xd0(%rbx)
movzbl (%rcx), %esi
cmpl $0xd, %esi
je 0x68595
movq %rdx, %rcx
cmpl $0xa, %esi
jne 0x6856e
jmp 0x68595
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x6862c
cmpb $0x1, 0x10a(%rbx)
jne 0x6862c
decq %r14
movq 0xd8(%rbx), %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x6861a
cmpq %r14, %rax
setb %dl
jae 0x685dc
movzbl (%rax), %esi
cmpl $0xa, %esi
je 0x685dc
cmpl $0xd, %esi
je 0x685dc
incq %rax
cmpq %r14, %rax
setb %dl
jne 0x685c4
testb $0x1, %dl
jne 0x6861a
cmpb $0x2a, %r15b
jne 0x68615
movq 0xd0(%rbx), %rdx
cmpq %rdx, %r14
setb %al
jae 0x68611
movq %r14, %rsi
movzbl (%rsi), %edi
cmpl $0xa, %edi
je 0x68611
cmpl $0xd, %edi
je 0x68611
incq %rsi
cmpq %rdx, %rsi
setb %al
jne 0x685f9
testb $0x1, %al
jne 0x6861a
movl $0x1, %ecx
movq 0xd0(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68742
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68681
movabsq $0x40000000400000d, %rdx # imm = 0x40000000400000D
movzbl (%rcx), %esi
leal -0x30(%rsi), %r8d
cmpb $0xa, %r8b
jb 0x68672
addl $-0x2b, %esi
cmpl $0x3a, %esi
ja 0x68681
btq %rsi, %rdx
jae 0x68681
incq %rcx
movq %rcx, 0xd0(%rdi)
cmpq %rax, %rcx
jne 0x68657
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x686b6
movq %rcx, %r8
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x686b9
movb -0x1(%rax,%r8), %r9b
cmpb -0x1(%rsi,%r8), %r9b
movq %rdx, %r8
je 0x686a1
xorl %eax, %eax
retq
addq %rcx, %rax
movq %rax, 0xd0(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rax, %rcx
je 0x686ee
incq %rcx
movq %rcx, 0xd0(%rdi)
cmpb $0x2a, -0x1(%rcx)
jne 0x686d4
cmpb $0x2f, (%rcx)
jne 0x686d4
movq 0xd0(%rdi), %rcx
cmpq %rax, %rcx
je 0x6870c
leaq 0x1(%rcx), %rax
movq %rax, 0xd0(%rdi)
cmpb $0x2f, (%rcx)
sete %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6878d
movq 0xe0(%rdi), %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f1b2
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x6d74c
jmp 0x687d9
leaq 0xe8(%rdi), %r15
cmpq $0x0, 0xf0(%rdi)
je 0x687ad
leaq 0xb87d(%rip), %rsi      # 0x74022
movq %r15, %rdi
callq 0x27c10
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f1b2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x27210
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x687e8
callq 0x27560
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x687f6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6880f
callq 0x27560
jmp 0x6880f
jmp 0x6880c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6815a
movl 0x8(%rsp), %eax
cmpl %ebp, %eax
je 0x68bcf
testl %eax, %eax
jne 0x68bb8
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)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x69652
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x68c28
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 0x68c4b
callq 0x27560
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68fd8
testb %al, %al
je 0x68fa1
movl $0xfffffc00, %eax       # imm = 0xFFFFFC00
andl (%r12), %eax
movb $0x1, %bpl
cmpl $0xd800, %eax           # imm = 0xD800
jne 0x68fa3
movq (%r15), %rax
movq %r13, %rcx
subq %rax, %rcx
cmpq $0x5, %rcx
jg 0x68f08
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe48b(%rip), %rsi      # 0x7736a
leaq 0xe4c7(%rip), %rdx      # 0x773ad
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x677a2
jmp 0x68f92
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x5c, (%rax)
jne 0x68f5d
leaq 0x2(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x75, 0x1(%rax)
jne 0x68f5d
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x68fd8
testb %al, %al
je 0x68fa1
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 0x68fa3
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe440(%rip), %rsi      # 0x773ae
leaq 0xe488(%rip), %rdx      # 0x773fd
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movq (%r15), %rcx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x677a2
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x68fa1
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 0x68fb8
jmp 0x68fcc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x68fcf
callq 0x27560
jmp 0x68fcf
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
subq (%rdx), %rcx
cmpq $0x3, %rcx
jg 0x69039
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe3f7(%rip), %rsi      # 0x773fe
leaq 0xe42c(%rip), %rdx      # 0x7743a
movq %rsp, %rdi
callq 0x2f1b2
movq (%r15), %rcx
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x677a2
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x69035
callq 0x27560
xorl %ebp, %ebp
jmp 0x6909e
movl $0x0, (%r8)
movq (%r15), %rax
incq %rax
xorl %ebp, %ebp
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, (%r15)
movsbl -0x1(%rax), %esi
shll $0x4, %ecx
movl %ecx, (%r8)
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x69069
addl %esi, %ecx
addl $-0x30, %ecx
jmp 0x69087
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x69079
addl %esi, %ecx
addl $-0x57, %ecx
jmp 0x69087
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x690b1
addl %esi, %ecx
addl $-0x37, %ecx
movl %ecx, (%r8)
cmpl $0x3, %edx
leal 0x1(%rdx), %esi
setae %bpl
incq %rax
movl %esi, %edx
cmpl $0x4, %esi
jne 0x6904c
andb $0x1, %bpl
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe379(%rip), %rsi      # 0x7743b
leaq 0xe3b4(%rip), %rdx      # 0x7747d
movq %rsp, %rdi
callq 0x2f1b2
movq (%r15), %rcx
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x677a2
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6909e
callq 0x27560
jmp 0x6909e
jmp 0x690f6
jmp 0x69109
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6910c
callq 0x27560
jmp 0x6910c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movl $0x0, (%rdx)
cmpq %rsi, %rax
jae 0x6916b
cmpq 0xc8(%rdi), %rax
je 0x6916b
movq %rax, %r8
leaq 0x1(%rax), %r9
movzbl (%rax), %r10d
cmpl $0xa, %r10d
je 0x69153
cmpl $0xd, %r10d
jne 0x69158
cmpb $0xa, 0x1(%rax)
jne 0x69153
addq $0x2, %rax
movq %rax, %r9
incl (%rdx)
movq %r9, %r8
movq %r9, %rax
cmpq %rsi, %r9
jae 0x6916e
cmpq 0xc8(%rdi), %rax
jne 0x69132
jmp 0x6916e
movq %rax, %r8
subl %r8d, %esi
incl %esi
movl %esi, (%rcx)
incl (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x69114
movl (%r14), %edx
movl (%r15), %ecx
leaq 0xe2d2(%rip), %rsi      # 0x7747e
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 0x2f1b2
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x670a8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x67490
testb %al, %al
je 0x69546
leaq 0x120(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6950b
callq 0x27560
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x69521
callq 0x27560
leaq 0x78(%rsp), %rdi
callq 0x3a64a
leaq 0x28(%rsp), %rdi
callq 0x3a7d6
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 0x691ea
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x26a75(%rip), %rsi     # 0x8fff0
movq 0x269ee(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x695a8
callq 0x27560
jmp 0x695a8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x695cb
movq %rbx, %rdi
callq 0x27470
jmp 0x695cb
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3a7d6
jmp 0x695d5
jmp 0x695dd
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x39cbc
movq %r14, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6bd19
callq 0x27700
movzbl (%r14), %eax
testl %eax, %eax
je 0x6bd26
cmpl $0x2f, %eax
jne 0x6bd62
movq %r14, %rdi
callq 0x272f0
movq %rax, %r15
leal 0x1(%rax), %edi
callq 0x277b0
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 0xb879(%rip), %rsi      # 0x775f8
leaq 0xb88c(%rip), %rdx      # 0x77612
movq %rsp, %rdi
callq 0x2f1b2
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x2424b(%rip), %rsi     # 0x8fff0
movq 0x241c4(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6bdcd
callq 0x27560
jmp 0x6bdcd
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6bdda
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c354
movq (%rbx), %r15
testq %r15, %r15
je 0x6c36c
movq 0x10(%r15), %rsi
movq %r15, %rdi
callq 0x6e03a
movq %r15, %rdi
callq 0x27560
jmp 0x6c36c
cmpl $0x4, %ecx
jne 0x6c36c
btl $0x8, %eax
jae 0x6c36c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6c36c
callq 0x27700
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x6c3a8
leaq -0x8(%r15), %rbx
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x6c395
shlq $0x3, %r12
leaq (%rbx,%r12), %rdi
callq 0x6bcec
addq $-0x8, %r12
jne 0x6c386
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x27760
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x27560
jmp 0x6c3e9
movq %rax, %r14
cmpq $0x8, %r12
je 0x6c3e1
addq $-0x10, %r15
leaq (%r15,%r12), %rdi
callq 0x6bcec
addq $-0x8, %r12
cmpq $0x8, %r12
jne 0x6c3ce
movq %rbx, %rdi
callq 0x27760
movq %r14, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::swap(Json::Value&)
void 
Value::swap( Value &other )
{
   ValueType temp = type_;
   type_ = other.type_;
   other.type_ = temp;
   std::swap( value_, other.value_ );
   int temp2 = allocated_;
   allocated_ = other.allocated_;
   other.allocated_ = temp2;
}

// Assembly:
movb 0x8(%rdi), %al
movb 0x8(%rsi), %cl
movb %cl, 0x8(%rdi)
movb %al, 0x8(%rsi)
movq (%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rax, (%rsi)
movzwl 0x8(%rdi), %eax
movl $0x100, %ecx            # imm = 0x100
movl %eax, %edx
andl %ecx, %edx
movzwl 0x8(%rsi), %r8d
andl %ecx, %r8d
andl $0xfeff, %eax           # imm = 0xFEFF
orl %r8d, %eax
movw %ax, 0x8(%rdi)
movl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
andl 0x8(%rsi), %eax
orl %edx, %eax
movw %ax, 0x8(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c552
movzwl %ax, %eax
decl %eax
cmpl $0x6, %eax
ja 0x6c581
leaq 0xafcc(%rip), %rcx      # 0x774c4
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 0x6c556
shrl $0x1f, %eax
retq
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x6c552
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 0x6c56e
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 0x6e2e9
testq %rdi, %rdi
je 0x6c581
pushq %rax
callq 0x27840
shrl $0x1f, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c5b4
xorl %eax, %eax
retq
cmpb $0x7, %cl
ja 0x6c5b1
movb $0x1, %al
movzwl %cx, %ecx
movzbl %cl, %ecx
leaq 0xaf18(%rip), %rdx      # 0x774e0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x6c63e
movq (%rdi), %rax
movq 0x28(%rax), %rdx
movq (%rsi), %rcx
cmpq 0x28(%rcx), %rdx
jne 0x6c5b1
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
jmp 0x6e3fc
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0x6c5b3
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x6c5b1
pushq %rax
callq 0x27840
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_O1/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 0x6c677
leaq 0xae92(%rip), %rcx      # 0x77500
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xb196(%rip), %rdx      # 0x7781b
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x6c6e2
movzbl (%rsi), %edx
leaq 0x662a(%rip), %rax      # 0x72cc1
leaq 0x6c4a(%rip), %rsi      # 0x732e8
testq %rdx, %rdx
cmovneq %rax, %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
xorq $0x5, %rdx
addq %rsi, %rdx
movq %rbx, %rdi
jmp 0x6c6e2
movq (%rsi), %rax
testq %rax, %rax
leaq 0xb156(%rip), %r14      # 0x7781b
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 0x2f1b2
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 0xaf01(%rip), %rsi      # 0x77613
leaq 0xaf1b(%rip), %rdx      # 0x77634
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x238b4(%rip), %rsi     # 0x8fff0
movq 0x2382d(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c765
callq 0x27560
jmp 0x6c765
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6c772
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6c844
leaq 0xad86(%rip), %rcx      # 0x77520
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
jmp 0x6c846
movzbl (%rdi), %eax
jmp 0x6c846
movsd (%rdi), %xmm0
movapd 0xae21(%rip), %xmm1     # 0x775e0
andpd %xmm0, %xmm1
movsd 0x92ad(%rip), %xmm2     # 0x75a78
ucomisd %xmm1, %xmm2
jb 0x6c8a9
cvttsd2si %xmm0, %rax
jmp 0x6c846
movq (%rdi), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jb 0x6c846
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xae2f(%rip), %rsi      # 0x77635
leaq 0xae4b(%rip), %rdx      # 0x77658
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x237c0(%rip), %rsi     # 0x8fff0
movq 0x23739(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
jmp 0x6c8ff
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 0xae0c(%rip), %rsi      # 0x7767a
leaq 0xae23(%rip), %rdx      # 0x77698
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x23758(%rip), %rsi     # 0x8fff0
movq 0x236d1(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
jmp 0x6c8ff
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xad93(%rip), %rsi      # 0x77659
leaq 0xadac(%rip), %rdx      # 0x77679
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x23700(%rip), %rsi     # 0x8fff0
movq 0x23679(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
jmp 0x6c907
jmp 0x6c907
jmp 0x6c91b
jmp 0x6c91b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c921
callq 0x27560
jmp 0x6c921
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6c92e
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6ca15
leaq 0xabe6(%rip), %rcx      # 0x7753c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
testq %rax, %rax
jns 0x6ca17
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xad11(%rip), %rsi      # 0x77699
leaq 0xad43(%rip), %rdx      # 0x776d2
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x2363e(%rip), %rsi     # 0x8fff0
movq 0x235b7(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
jmp 0x6cad0
movzbl (%rdi), %eax
jmp 0x6ca17
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x6ca7a
movsd 0xac0b(%rip), %xmm1     # 0x775f0
ucomisd %xmm0, %xmm1
jb 0x6ca7a
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x9075(%rip), %xmm0     # 0x75a78
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x6ca17
movq (%rdi), %rax
jmp 0x6ca17
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 0xacb7(%rip), %rsi      # 0x776f6
leaq 0xaccf(%rip), %rdx      # 0x77715
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x23587(%rip), %rsi     # 0x8fff0
movq 0x23500(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
jmp 0x6cad0
movl $0x10, %edi
callq 0x27320
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xac3c(%rip), %rsi      # 0x776d3
leaq 0xac57(%rip), %rdx      # 0x776f5
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x2352f(%rip), %rsi     # 0x8fff0
movq 0x234a8(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
jmp 0x6cad8
jmp 0x6caec
jmp 0x6cad8
jmp 0x6caec
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6caf2
callq 0x27560
jmp 0x6caf2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6caff
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6cb39
leaq 0xaa34(%rip), %rcx      # 0x77558
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq (%rdi), %xmm0
jmp 0x6cb6e
cmpb $0x0, (%rdi)
jne 0x6cb66
xorpd %xmm0, %xmm0
jmp 0x6cb6e
movsd (%rdi), %xmm0
jmp 0x6cb6e
movsd (%rdi), %xmm1
unpcklps 0x9870(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x9878(%rip), %xmm1     # 0x763d0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x6cb6e
movsd 0x74a2(%rip), %xmm0     # 0x74010
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 0xab80(%rip), %rsi      # 0x77716
leaq 0xab9a(%rip), %rdx      # 0x77737
leaq 0x8(%rsp), %rdi
callq 0x2f1b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x279f0
xorl %ebp, %ebp
movq 0x23430(%rip), %rsi     # 0x8fff0
movq 0x233a9(%rip), %rdx     # 0x8ff70
movq %rbx, %rdi
callq 0x27ab0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6cbe9
callq 0x27560
jmp 0x6cbe9
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6cbf6
movq %rbx, %rdi
callq 0x27470
movq %r14, %rdi
callq 0x27b20
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6cc38
leaq 0xa964(%rip), %rcx      # 0x77574
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, (%rdi)
jmp 0x6cc34
movq (%rdi), %rax
cmpq $0x0, 0x28(%rax)
jmp 0x6cc34
movq (%rdi), %rax
testq %rax, %rax
je 0x6cc38
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
// File: /workspace/github_cpp_makefile_star2_O1/zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::resize(unsigned int)
void 
Value::resize( ArrayIndex newSize )
{
   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
   if ( type_ == nullValue )
      *this = Value( arrayValue );
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   ArrayIndex oldSize = size();
   if ( newSize == 0 )
      clear();
   else if ( newSize > oldSize )
      (*this)[ newSize - 1 ];
   else
   {
      for ( ArrayIndex index = newSize; index < oldSize; ++index )
      {
         value_.map_->erase( index );
      }
      assert( size() == newSize );
   }
#else
   value_.array_->resize( newSize );
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x6cf00
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x6, %esi
callq 0x6bf78
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6c3fa
leaq 0x8(%rsp), %rdi
callq 0x6c31c
movq %rbx, %rdi
callq 0x6cdf6
testl %ebp, %ebp
je 0x6cf21
movl %eax, %r14d
cmpl %ebp, %eax
jae 0x6cf2b
decl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6cf9e
jmp 0x6cf64
movq %rbx, %rdi
callq 0x6ce8a
jmp 0x6cf64
jbe 0x6cf64
leaq 0x8(%rsp), %r15
movq (%rbx), %r12
movq %r15, %rdi
movl %ebp, %esi
callq 0x6bde2
movq %r12, %rdi
movq %r15, %rsi
callq 0x6e47c
movq %r12, %rdi
movq %rax, %rsi
callq 0x6e552
movq %r15, %rdi
callq 0x6beb6
incl %ebp
cmpl %ebp, %r14d
jne 0x6cf32
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6c31c
jmp 0x6cf8d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6beb6
movq %rbx, %rdi
callq 0x27b20
movq %rax, %rdi
callq 0x2e1ed
nop