LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpl $0x1, 0xac(%rsp)
jne 0x118879
movq 0x40(%rsp), %rax
movq 0xe0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x86da0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x88(%rsp), %rdi
callq 0x11a670
jmp 0x1187fc
movq 0x20(%rsp), %rdi
movl 0xac(%rsp), %edx
leaq 0x88(%rsp), %rsi
callq 0x124830
jmp 0x118817
leaq 0x88(%rsp), %rdi
callq 0x86f68
jmp 0x118826
leaq 0x87(%rsp), %rdi
callq 0x867b0
jmp 0x118952
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x118867
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x86f68
jmp 0x118865
jmp 0x118867
leaq 0x87(%rsp), %rdi
callq 0x867b0
jmp 0x11895a
movq 0x40(%rsp), %rdi
addq $0xe8, %rdi
callq 0x86c90
testb $0x1, %al
jne 0x1188a6
movq 0x40(%rsp), %rdi
addq $0xe8, %rdi
leaq 0x17f51(%rip), %rsi     # 0x1307f2
callq 0x866c0
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x86da0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0x11a670
jmp 0x1188ea
movq 0x40(%rsp), %rdi
addq $0xe8, %rdi
leaq 0x50(%rsp), %rsi
callq 0x86910
jmp 0x118902
leaq 0x50(%rsp), %rdi
callq 0x86f68
jmp 0x11890e
leaq 0x4f(%rsp), %rdi
callq 0x867b0
jmp 0x118952
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x118946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x86f68
jmp 0x118944
jmp 0x118946
leaq 0x4f(%rsp), %rdi
callq 0x867b0
jmp 0x11895a
addq $0xc8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movq 0xf0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
addq $0x50, %rdi
callq 0x11a770
movl %eax, 0xe8(%rsp)
movq 0x38(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x117f80
testb $0x1, %al
jne 0x118f8a
movq 0x38(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x20(%rsp)
movslq 0xe8(%rsp), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x11a6f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x11a790
jmp 0x118f53
leaq 0x90(%rsp), %rdi
callq 0xa8db0
jmp 0x118f8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xa8db0
jmp 0x118f85
jmp 0x11903a
movl 0xd0(%rsp), %eax
cmpl 0xec(%rsp), %eax
je 0x118fa4
cmpl $0x0, 0xd0(%rsp)
jne 0x118fa6
jmp 0x118fab
jmp 0x118ed3
movq 0x38(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x8(%rsp)
movslq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11a6f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x11a790
jmp 0x119002
leaq 0x40(%rsp), %rdi
callq 0xa8db0
xorl %eax, %eax
andb $0x1, %al
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xa8db0
jmp 0x119038
jmp 0x11903a
movq 0x88(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nop
// File: 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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x40(%rsp)
movq 0xc0(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movq -0x28(%rsp), %rcx
xorl %eax, %eax
cmpq -0x10(%rsp), %rcx
movb %al, -0x41(%rsp)
jae 0x119e99
movq -0x40(%rsp), %rcx
movq -0x28(%rsp), %rax
cmpq 0xc8(%rcx), %rax
setne %al
movb %al, -0x41(%rsp)
movb -0x41(%rsp), %al
testb $0x1, %al
jne 0x119ea3
jmp 0x119f1e
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rsp)
movb (%rax), %al
movb %al, -0x31(%rsp)
movsbl -0x31(%rsp), %eax
cmpl $0xd, %eax
jne 0x119ef7
movq -0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x119edf
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x119f19
movsbl -0x31(%rsp), %eax
cmpl $0xa, %eax
jne 0x119f17
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x119f19
jmp 0x119e6f
movq -0x10(%rsp), %rax
movq -0x30(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
addl $0x1, %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
leaq 0x7c(%rsp), %rdx
leaq 0x78(%rsp), %rcx
callq 0x119e30
movl 0x7c(%rsp), %edx
movl 0x78(%rsp), %ecx
leaq 0x1a940(%rip), %rsi     # 0x1348ea
xorl %eax, %eax
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x86130
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x86da0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x86a00
jmp 0x119fe0
leaq 0x3f(%rsp), %rdi
callq 0x867b0
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x867b0
movq 0x30(%rsp), %rdi
callq 0x86d80
nopl (%rax)
// File: 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:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1163d0
movq 0x10(%rsp), %rdi
movq 0x170(%rsp), %rsi
movq 0x168(%rsp), %rdx
movl $0x1, %ecx
callq 0x1169c0
movb %al, 0x1e(%rsp)
jmp 0x11a47b
movb 0x1e(%rsp), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x11a539
movb $0x1, 0x1f(%rsp)
movl $0x10, %edi
callq 0x863c0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x11a020
jmp 0x11a4b5
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x86c20
jmp 0x11a4c6
movq 0x8(%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0x4ab19(%rip), %rsi     # 0x164ff0
movq 0x4aaaa(%rip), %rdx     # 0x164f88
callq 0x86d20
jmp 0x11a57b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x11a55b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x11a524
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x86f68
jmp 0x11a522
jmp 0x11a524
testb $0x1, 0x1f(%rsp)
jne 0x11a52d
jmp 0x11a537
movq 0x8(%rsp), %rdi
callq 0x86550
jmp 0x11a55b
movq 0x170(%rsp), %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0xa7880
movq (%rsp), %rax
addq $0x178, %rsp            # imm = 0x178
retq
leaq 0x58(%rsp), %rdi
callq 0xa7880
jmp 0x11a567
jmp 0x11a569
movq 0x48(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
je 0x120e5b
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x120e10
movq 0x58(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x120f33
movq 0x58(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x120f33
movb $0x1, 0x23(%rsp)
movl $0x10, %edi
callq 0x863c0
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x86da0
movq 0x10(%rsp), %rdx
leaq 0x13bdc(%rip), %rsi     # 0x134a88
leaq 0x38(%rsp), %rdi
callq 0x86a00
jmp 0x120eb8
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x86c20
jmp 0x120ec9
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x44116(%rip), %rsi     # 0x164ff0
movq 0x440a7(%rip), %rdx     # 0x164f88
callq 0x86d20
jmp 0x120f64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x120f14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x86f68
jmp 0x120f12
jmp 0x120f14
leaq 0x37(%rsp), %rdi
callq 0x867b0
testb $0x1, 0x23(%rsp)
jne 0x120f27
jmp 0x120f31
movq 0x8(%rsp), %rdi
callq 0x86550
jmp 0x120f52
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x120f70
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x120f92
movq 0x10(%rsp), %rdi
callq 0x86360
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x86990
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x865e0
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::Value(Json::ValueType)
Value::Value( ValueType type )
   : type_( type )
   , allocated_( 0 )
   , comments_( 0 )
# ifdef JSON_VALUE_USE_INTERNAL_MAP
   , itemIsUsed_( 0 )
#endif
{
   switch ( type )
   {
   case nullValue:
      break;
   case intValue:
   case uintValue:
      value_.int_ = 0;
      break;
   case realValue:
      value_.real_ = 0.0;
      break;
   case stringValue:
      value_.string_ = 0;
      break;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   case arrayValue:
   case objectValue:
      value_.map_ = new ObjectValues();
      break;
#else
   case arrayValue:
      value_.array_ = arrayAllocator()->newArray();
      break;
   case objectValue:
      value_.map_ = mapAllocator()->newMap();
      break;
#endif
   case booleanValue:
      value_.bool_ = false;
      break;
   default:
      JSON_ASSERT_UNREACHABLE;
   }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x2c(%rsp), %cl
movb %cl, 0x8(%rax)
movb 0x9(%rax), %cl
andb $-0x2, %cl
movb %cl, 0x9(%rax)
movq $0x0, 0x10(%rax)
movl 0x2c(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x7, %rax
ja 0x1213af
movq 0x10(%rsp), %rax
leaq 0x13612(%rip), %rcx     # 0x134940
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x1213b1
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x1213b1
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1213b1
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x1213b1
movl $0x30, %edi
callq 0x86720
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x125930
jmp 0x12137e
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
jmp 0x1213b1
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0x1213b6
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0x1213b1
jmp 0x1213b1
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x40(%rsp)
subw $0x4, %ax
jb 0x12199a
jmp 0x121976
movl 0x40(%rsp), %eax
subl $0x4, %eax
je 0x12199c
jmp 0x121981
movl 0x40(%rsp), %eax
subl $0x5, %eax
je 0x12199a
jmp 0x12198c
movl 0x40(%rsp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x1219c2
jmp 0x121a0a
jmp 0x121a0c
movq 0x38(%rsp), %rax
movw 0x8(%rax), %ax
shlw $0x7, %ax
sarw $0xf, %ax
cwtl
cmpl $0x0, %eax
je 0x1219c0
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x120e10
jmp 0x121a0c
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x1219eb
movq 0x30(%rsp), %rdi
callq 0x125980
jmp 0x1219e1
movq 0x30(%rsp), %rdi
callq 0x866a0
jmp 0x121a0c
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x866a0
jmp 0x121ae6
jmp 0x121a0c
movq 0x38(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x121ae1
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x121a8c
movq 0x28(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x18(%rsp)
movq -0x8(%rcx), %rdx
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x20(%rsp)
je 0x121a82
movq 0x20(%rsp), %rdi
addq $-0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x120de0
jmp 0x121a6e
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x20(%rsp)
jne 0x121a59
movq 0x18(%rsp), %rdi
callq 0x86930
jmp 0x121ae1
movq 0x28(%rsp), %rcx
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
cmpq %rax, %rcx
movq %rax, 0x8(%rsp)
je 0x121ad5
movq 0x8(%rsp), %rdi
addq $-0x8, %rdi
movq %rdi, (%rsp)
callq 0x120de0
jmp 0x121ac2
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x8(%rsp)
jne 0x121aae
movq 0x18(%rsp), %rdi
callq 0x86930
jmp 0x121ae6
addq $0x58, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movw 0x8(%rdi), %ax
andw $0xff, %ax
movzwl %ax, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
movw %ax, %cx
movw 0x8(%rdi), %ax
andw $0xff, %cx
andw $0xff00, %ax            # imm = 0xFF00
orw %cx, %ax
movw %ax, 0x8(%rdi)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, 0x8(%rax)
movq 0x18(%rsp), %rsi
callq 0x125990
movq 0x8(%rsp), %rax
movw 0x8(%rax), %cx
shlw $0x7, %cx
sarw $0xf, %cx
movswl %cx, %ecx
movl %ecx, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movw 0x8(%rcx), %cx
shlw $0x7, %cx
sarw $0xf, %cx
movswl %cx, %ecx
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, 0x8(%rax)
movl 0x10(%rsp), %ecx
movq 0x18(%rsp), %rax
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, 0x28(%rsp)
subw $0x7, %ax
ja 0x122d22
movq 0x28(%rsp), %rax
leaq 0x11dfb(%rip), %rcx     # 0x134a00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x122d79
movq 0x20(%rsp), %rax
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x122d79
movq 0x20(%rsp), %rax
movq (%rax), %xmm0
movaps 0x108ef(%rip), %xmm1    # 0x133530
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x108f3(%rip), %xmm1    # 0x133540
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x122d79
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x122d79
movq 0x20(%rsp), %rax
movb (%rax), %al
movsd 0xdb46(%rip), %xmm0     # 0x1307d0
xorps %xmm1, %xmm1
movsd %xmm1, 0x10(%rsp)
testb $0x1, %al
movsd %xmm0, 0x18(%rsp)
jne 0x122ca9
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x122d79
movb $0x1, 0x33(%rsp)
movl $0x10, %edi
callq 0x863c0
movq %rax, (%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x86da0
movq 0x8(%rsp), %rdx
leaq 0x11ebe(%rip), %rsi     # 0x134ba6
leaq 0x48(%rsp), %rdi
callq 0x86a00
jmp 0x122cf4
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x86c20
jmp 0x122d04
movq (%rsp), %rdi
movb $0x0, 0x33(%rsp)
movq 0x422dc(%rip), %rsi     # 0x164ff0
movq 0x4226d(%rip), %rdx     # 0x164f88
callq 0x86d20
jmp 0x122d96
jmp 0x122d24
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
jmp 0x122d79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x122d5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x86f68
jmp 0x122d59
jmp 0x122d5b
leaq 0x47(%rsp), %rdi
callq 0x867b0
testb $0x1, 0x33(%rsp)
jne 0x122d6e
jmp 0x122d77
movq (%rsp), %rdi
callq 0x86550
jmp 0x122d84
movsd 0x70(%rsp), %xmm0
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, 0x10(%rsp)
subw $0x7, %ax
ja 0x122e7c
movq 0x10(%rsp), %rax
leaq 0x11c4b(%rip), %rcx     # 0x134a20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, 0x27(%rsp)
jmp 0x122e83
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x122e83
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x122e83
movq 0x8(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x122e83
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, 0x7(%rsp)
je 0x122e54
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x122e83
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1259d0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x122e83
jmp 0x122e7e
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::size() const
ArrayIndex 
Value::size() const
{
   switch ( type_ )
   {
   case nullValue:
   case intValue:
   case uintValue:
   case realValue:
   case booleanValue:
   case stringValue:
      return 0;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   case arrayValue:  // size of the array is highest index + 1
      if ( !value_.map_->empty() )
      {
         ObjectValues::const_iterator itLast = value_.map_->end();
         --itLast;
         return (*itLast).first.index()+1;
      }
      return 0;
   case objectValue:
      return ArrayIndex( value_.map_->size() );
#else
   case arrayValue:
      return Int( value_.array_->size() );
   case objectValue:
      return Int( value_.map_->size() );
#endif
   default:
      JSON_ASSERT_UNREACHABLE;
   }
   return 0; // unreachable;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x14(%rsp)
subw $0x6, %ax
jb 0x12323c
jmp 0x123226
movl 0x14(%rsp), %eax
subl $0x6, %eax
je 0x123246
jmp 0x123231
movl 0x14(%rsp), %eax
subl $0x7, %eax
je 0x1232a7
jmp 0x1232ba
movl $0x0, 0x34(%rsp)
jmp 0x1232c4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x125a40
testb $0x1, %al
jne 0x12329d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x125a60
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x125a90
leaq 0x20(%rsp), %rdi
callq 0x125ab0
leaq 0x20(%rsp), %rdi
callq 0x125ae0
movq %rax, %rdi
callq 0x120b60
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1232c4
movl $0x0, 0x34(%rsp)
jmp 0x1232c4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1259d0
movl %eax, 0x34(%rsp)
jmp 0x1232c4
jmp 0x1232bc
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::empty() const
bool 
Value::empty() const
{
   if ( isNull() || isArray() || isObject() )
      return size() == 0u;
   else
      return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x123330
testb $0x1, %al
jne 0x123307
movq (%rsp), %rdi
callq 0x123350
testb $0x1, %al
jne 0x123307
movq (%rsp), %rdi
callq 0x1233a0
testb $0x1, %al
jne 0x123307
jmp 0x12331e
movq (%rsp), %rdi
callq 0x123200
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x123323
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x1234c7
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x6, %esi
callq 0x1212e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x121b00
jmp 0x12349c
leaq 0x50(%rsp), %rdi
callq 0x121950
jmp 0x1234c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x121950
jmp 0x1234c2
jmp 0x123587
movq 0x20(%rsp), %rdi
callq 0x123200
movl %eax, 0x40(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0x1234eb
movq 0x20(%rsp), %rdi
callq 0x123410
jmp 0x123582
movl 0x6c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jbe 0x123508
movq 0x20(%rsp), %rdi
movl 0x6c(%rsp), %esi
subl $0x1, %esi
callq 0x1235a0
jmp 0x123580
movl 0x6c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x12357e
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %esi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x120fd0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x125b10
jmp 0x12354b
leaq 0x28(%rsp), %rdi
callq 0x121100
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x123510
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x121100
jmp 0x12357c
jmp 0x123587
jmp 0x123580
jmp 0x123582
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::operator[](unsigned int) const
const Value &
Value::operator[]( ArrayIndex index ) const
{
   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
   if ( type_ == nullValue )
      return null;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   CZString key( index );
   ObjectValues::const_iterator it = value_.map_->find( key );
   if ( it == value_.map_->end() )
      return null;
   return (*it).second;
#else
   Value *value = value_.array_->find( index );
   return value ? *value : null;
#endif
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x123887
leaq 0x42fee(%rip), %rax     # 0x166868
movq %rax, 0x90(%rsp)
jmp 0x12398a
movl 0x84(%rsp), %esi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x120fd0
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rsi
movq (%rax), %rdi
callq 0x125c90
movq %rax, 0x28(%rsp)
jmp 0x1238b6
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x125a90
jmp 0x1238d1
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x125a60
movq %rax, 0x18(%rsp)
jmp 0x1238e5
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x125a90
jmp 0x123900
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x125cc0
movb %al, 0x17(%rsp)
jmp 0x123915
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x12391f
jmp 0x123952
leaq 0x42f42(%rip), %rax     # 0x166868
movq %rax, 0x90(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x12397c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x121100
jmp 0x123988
leaq 0x68(%rsp), %rdi
callq 0x125ae0
movq %rax, 0x8(%rsp)
jmp 0x123963
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x90(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x121100
jmp 0x12398a
jmp 0x12399a
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::operator[](char const*) const
const Value &
Value::operator[]( const char *key ) const
{
   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
   if ( type_ == nullValue )
      return null;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   CZString actualKey( key, CZString::noDuplication );
   ObjectValues::const_iterator it = value_.map_->find( actualKey );
   if ( it == value_.map_->end() )
      return null;
   return (*it).second;
#else
   const Value *value = value_.map_->find( key );
   return value ? *value : null;
#endif
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x123db8
leaq 0x42abd(%rip), %rax     # 0x166868
movq %rax, 0x90(%rsp)
jmp 0x123ebe
movq 0x80(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
xorl %edx, %edx
callq 0x120ff0
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rsi
movq (%rax), %rdi
callq 0x125c90
movq %rax, 0x28(%rsp)
jmp 0x123dea
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x125a90
jmp 0x123e05
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x125a60
movq %rax, 0x18(%rsp)
jmp 0x123e19
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x125a90
jmp 0x123e34
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x125cc0
movb %al, 0x17(%rsp)
jmp 0x123e49
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x123e53
jmp 0x123e86
leaq 0x42a0e(%rip), %rax     # 0x166868
movq %rax, 0x90(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x123eb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x121100
jmp 0x123ebc
leaq 0x68(%rsp), %rdi
callq 0x125ae0
movq %rax, 0x8(%rsp)
jmp 0x123e97
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x90(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x121100
jmp 0x123ebe
jmp 0x123ece
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Value::removeMember(char const*)
Value
Value::removeMember( const char* key )
{
   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
   if ( type_ == nullValue )
      return null;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
   CZString actualKey( key, CZString::noDuplication );
   ObjectValues::iterator it = value_.map_->find( actualKey );
   if ( it == value_.map_->end() )
      return null;
   Value old(it->second);
   value_.map_->erase(it);
   return old;
#else
   Value *value = value_.map_->find( key );
   if (value){
      Value old(*value);
      value_.map_.remove( key );
      return old;
   } else {
      return null;
   }
#endif
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x12412f
movq 0x28(%rsp), %rdi
leaq 0x42743(%rip), %rsi     # 0x166868
callq 0x1216e0
jmp 0x12427e
movq 0x80(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %edx, %edx
callq 0x120ff0
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rsi
movq (%rax), %rdi
callq 0x125c90
movq %rax, 0x20(%rsp)
jmp 0x124161
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq (%rax), %rdi
callq 0x125a60
movq %rax, 0x10(%rsp)
jmp 0x12417f
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x125860
movb %al, 0xf(%rsp)
jmp 0x12419e
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1241a8
jmp 0x1241db
movq 0x28(%rsp), %rdi
leaq 0x426b4(%rip), %rsi     # 0x166868
callq 0x1216e0
jmp 0x1241bb
movl $0x1, 0x4c(%rsp)
jmp 0x124264
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x124270
movb $0x0, 0x4b(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1257c0
movq %rax, (%rsp)
jmp 0x1241f0
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
addq $0x10, %rsi
callq 0x1216e0
jmp 0x124204
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
callq 0x125cf0
jmp 0x124222
movb $0x1, 0x4b(%rsp)
movl $0x1, 0x4c(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x124260
jmp 0x124252
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x121950
jmp 0x124262
movq 0x28(%rsp), %rdi
callq 0x121950
jmp 0x12425e
jmp 0x124260
jmp 0x124264
jmp 0x124270
leaq 0x70(%rsp), %rdi
callq 0x121100
jmp 0x12427e
leaq 0x70(%rsp), %rdi
callq 0x121100
jmp 0x12427c
jmp 0x12428b
movq 0x30(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Path::Path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&)
Path::Path( const std::string &path,
            const PathArgument &a1,
            const PathArgument &a2,
            const PathArgument &a3,
            const PathArgument &a4,
            const PathArgument &a5 )
{
   InArgs in;
   in.push_back( &a1 );
   in.push_back( &a2 );
   in.push_back( &a3 );
   in.push_back( &a4 );
   in.push_back( &a5 );
   makePath( path, in );
}

// Assembly:
subq $0x98, %rsp
movq 0xa0(%rsp), %rax
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x125e70
leaq 0x50(%rsp), %rdi
callq 0x125e80
jmp 0x124e1c
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x125e90
jmp 0x124e3a
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x125e90
jmp 0x124e55
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x125e90
jmp 0x124e70
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x125e90
jmp 0x124e8b
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x125e90
jmp 0x124ea9
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x124f30
jmp 0x124ec2
leaq 0x50(%rsp), %rdi
callq 0x125f00
jmp 0x124ece
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x124f02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x125f00
jmp 0x124f00
jmp 0x124f02
movq 0x8(%rsp), %rdi
callq 0x125f80
jmp 0x124f0e
jmp 0x124f10
movq 0x48(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Path::resolve(Json::Value const&) const
const Value &
Path::resolve( const Value &root ) const
{
   const Value *node = &root;
   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
   {
      const PathArgument &arg = *it;
      if ( arg.kind_ == PathArgument::kindIndex )
      {
         if ( !node->isArray()  ||  node->isValidIndex( arg.index_ ) )
         {
            // Error: unable to resolve path (array value expected at position...
         }
         node = &((*node)[arg.index_]);
      }
      else if ( arg.kind_ == PathArgument::kindKey )
      {
         if ( !node->isObject() )
         {
            // Error: unable to resolve path (object value expected at position...)
         }
         node = &((*node)[arg.key_]);
         if ( node == &Value::null )
         {
            // Error: unable to resolve path (object has no member named '' at position...)
         }
      }
   }
   return *node;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x126130
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
callq 0x1261a0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x126160
testb $0x1, %al
jne 0x1254a1
jmp 0x125552
leaq 0x18(%rsp), %rdi
callq 0x1261d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x1254fe
movq 0x20(%rsp), %rdi
callq 0x123350
testb $0x1, %al
jne 0x1254cb
jmp 0x1254e3
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x123d30
testb $0x1, %al
jne 0x1254e3
jmp 0x1254e5
jmp 0x1254e5
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x123840
movq %rax, 0x20(%rsp)
jmp 0x125541
movq 0x8(%rsp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x12553f
movq 0x20(%rsp), %rdi
callq 0x1233a0
testb $0x1, %al
jne 0x125519
jmp 0x125519
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x123f20
movq %rax, 0x20(%rsp)
leaq 0x41334(%rip), %rax     # 0x166868
cmpq %rax, 0x20(%rsp)
jne 0x12553d
jmp 0x12553d
jmp 0x12553f
jmp 0x125541
jmp 0x125543
leaq 0x18(%rsp), %rdi
callq 0x1261e0
jmp 0x12547b
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Path::resolve(Json::Value const&, Json::Value const&) const
Value 
Path::resolve( const Value &root, 
               const Value &defaultValue ) const
{
   const Value *node = &root;
   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
   {
      const PathArgument &arg = *it;
      if ( arg.kind_ == PathArgument::kindIndex )
      {
         if ( !node->isArray()  ||  node->isValidIndex( arg.index_ ) )
            return defaultValue;
         node = &((*node)[arg.index_]);
      }
      else if ( arg.kind_ == PathArgument::kindKey )
      {
         if ( !node->isObject() )
            return defaultValue;
         node = &((*node)[arg.key_]);
         if ( node == &Value::null )
            return defaultValue;
      }
   }
   return *node;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x126130
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1261a0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x126160
testb $0x1, %al
jne 0x1255c9
jmp 0x1256a7
leaq 0x28(%rsp), %rdi
callq 0x1261d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x125637
movq 0x30(%rsp), %rdi
callq 0x123350
testb $0x1, %al
jne 0x1255f3
jmp 0x12560b
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x123d30
testb $0x1, %al
jne 0x12560b
jmp 0x12561e
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1216e0
jmp 0x1256b5
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x123840
movq %rax, 0x30(%rsp)
jmp 0x125696
movq 0x18(%rsp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x125694
movq 0x30(%rsp), %rdi
callq 0x1233a0
testb $0x1, %al
jne 0x125660
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1216e0
jmp 0x1256b5
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x123f20
movq %rax, 0x30(%rsp)
leaq 0x411ed(%rip), %rax     # 0x166868
cmpq %rax, 0x30(%rsp)
jne 0x125692
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1216e0
jmp 0x1256b5
jmp 0x125694
jmp 0x125696
jmp 0x125698
leaq 0x28(%rsp), %rdi
callq 0x1261e0
jmp 0x1255a2
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1216e0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_value.cpp
// Function: Json::Path::make(Json::Value&) const
Value &
Path::make( Value &root ) const
{
   Value *node = &root;
   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
   {
      const PathArgument &arg = *it;
      if ( arg.kind_ == PathArgument::kindIndex )
      {
         if ( !node->isArray() )
         {
            // Error: node is not an array at position ...
         }
         node = &((*node)[arg.index_]);
      }
      else if ( arg.kind_ == PathArgument::kindKey )
      {
         if ( !node->isObject() )
         {
            // Error: node is not an object at position...
         }
         node = &((*node)[arg.key_]);
      }
   }
   return *node;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x126130
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
callq 0x1261a0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x126160
testb $0x1, %al
jne 0x125711
jmp 0x125796
leaq 0x18(%rsp), %rdi
callq 0x1261d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x125754
movq 0x20(%rsp), %rdi
callq 0x123350
testb $0x1, %al
jne 0x12573b
jmp 0x12573b
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x1235a0
movq %rax, 0x20(%rsp)
jmp 0x125785
movq 0x8(%rsp), %rax
cmpl $0x2, 0x24(%rax)
jne 0x125783
movq 0x20(%rsp), %rdi
callq 0x1233a0
testb $0x1, %al
jne 0x12576f
jmp 0x12576f
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x123ee0
movq %rax, 0x20(%rsp)
jmp 0x125785
jmp 0x125787
leaq 0x18(%rsp), %rdi
callq 0x1261e0
jmp 0x1256eb
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::valueToString[abi:cxx11](long long)
std::string valueToString( Int value )
{
   UIntToStringBuffer buffer;
   char *current = buffer + sizeof(buffer);
   bool isNegative = value < 0;
   if ( isNegative )
      value = -value;
   uintToString( UInt(value), current );
   if ( isNegative )
      *--current = '-';
   assert( current >= buffer );
   return current;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x40(%rsp), %rax
addq $0x19, %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x68(%rsp)
setl %al
andb $0x1, %al
movb %al, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
je 0x129ecb
xorl %eax, %eax
subq 0x68(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x129f60
testb $0x1, 0x37(%rsp)
je 0x129ef6
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rsp)
movb $0x2d, -0x1(%rax)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x36(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x86da0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x86a00
jmp 0x129f23
leaq 0x36(%rsp), %rdi
callq 0x867b0
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x36(%rsp), %rdi
callq 0x867b0
movq 0x28(%rsp), %rdi
callq 0x86d80
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_tool.h
// Function: Json::uintToString(unsigned long long, char*&)
static inline void 
uintToString( UInt value, 
              char *&current )
{
   *--current = 0;
   do
   {
      *--current = char(value % 10) + '0';
      value /= 10;
   }
   while ( value != 0 );
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, -0x1(%rax)
movq -0x8(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movb %dl, %al
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x10(%rsp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $-0x1, %rsi
movq %rsi, (%rdx)
movb %cl, -0x1(%rax)
movq -0x8(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0x129f80
retq
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::valueToString[abi:cxx11](unsigned long long)
std::string valueToString( UInt value )
{
   UIntToStringBuffer buffer;
   char *current = buffer + sizeof(buffer);
   uintToString( value, current );
   assert( current >= buffer );
   return current;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x59(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x129f60
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x86da0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x86a00
jmp 0x12a032
leaq 0x37(%rsp), %rdi
callq 0x867b0
movq (%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x867b0
movq 0x28(%rsp), %rdi
callq 0x86d80
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/third_party/jsoncpp/json_writer.cpp
// Function: Json::containsControlCharacter(char const*)
static bool containsControlCharacter( const char* str )
{
   while ( *str ) 
   {
      if ( isControlCharacter( *(str++) ) )
         return true;
   }
   return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x12a8cb
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movsbl (%rax), %edi
callq 0x12a8e0
testb $0x1, %al
jne 0x12a8c2
jmp 0x12a8c9
movb $0x1, 0x17(%rsp)
jmp 0x12a8d0
jmp 0x12a899
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)