LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::InitKeywords()
void inTec_Zone::InitKeywords()
{
   // add TecPlot keywords with default values
// keywords["T"] = "";
   keywords["ZONETYPE"] = "ORDERED";
// keywords["I"] = "";
// keywords["J"] = "";
// keywords["K"] = "";
// keywords["NODES"] = "";
// keywords["ELEMENTS"] = "";
// keywords["FACES"] = "";
// keywords["TOTALNUMFACENODES"] = "";
// keywords["NUMCONNECTEDBOUNDARYFACES"] = "";
// keywords["TOTALNUMBOUNDARYCONNECTIONS"] = "";
// keywords["FACENEIGBORMODE"] = "LOCALONETOONE";
// keywords["FACENEIGHBORCONNECTIONS"] = "";
   keywords["DT"] = "SINGLE";
   keywords["DATAPACKING"] = "BLOCK";
   keywords["VARLOCATION"] = "(NODAL)";
// keywords["VARSHARELIST"] = "";
// keywords["NV"] = "";
// keywords["CONNECTIVITYSHAREZONE"] = "";
// keywords["STRANDID"] = "";
// keywords["SOLUTIONTIME"] = "";
// keywords["PARENTZONE"] = "";
// keywords["PASSIVEVARLIST"] = "";
// keywords["AUXDATA"] = "";
// keywords[""] = "";

   // keywords from the old format
// keywords["E"] = "";
// keywords["N"] = "";
// keywords["ET"] = "";

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x88b0(%rip), %rsi      # 0xe294
leaq 0x88b1(%rip), %rdx      # 0xe29c
leaq 0x8(%rsp), %rdi
callq 0x5110
addq $0xe8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a0
movq 0x8(%rax), %rdx
leaq 0x8878(%rip), %rcx      # 0xe28c
movl $0x7, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5580
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5a3b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5380
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x885a(%rip), %rsi      # 0xe2a4
leaq 0x8855(%rip), %rdx      # 0xe2a6
callq 0x5110
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a0
movq 0x8(%rax), %rdx
leaq 0x882f(%rip), %rcx      # 0xe29d
movl $0x6, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5580
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5a95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5380
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x8809(%rip), %rsi      # 0xe2ad
leaq 0x880d(%rip), %rdx      # 0xe2b8
callq 0x5110
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a0
movq 0x8(%rax), %rdx
leaq 0x87df(%rip), %rcx      # 0xe2a7
movl $0x5, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5580
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5aef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5380
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x87c3(%rip), %rsi      # 0xe2c1
leaq 0x87c7(%rip), %rdx      # 0xe2cc
callq 0x5110
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56a0
movq 0x8(%rax), %rdx
leaq 0x8797(%rip), %rcx      # 0xe2b9
movl $0x7, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5580
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5b49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5380
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x5b57
jmp 0x5b57
jmp 0x5b57
movq %rax, %rbx
jmp 0x5b7c
jmp 0x5b62
jmp 0x5b62
jmp 0x5b62
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5b7c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5380
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::~inTec_Zone()
inTec_Zone::~inTec_Zone()
{
#ifdef _DEBUG_
   printf(" i Zone object deconstructed\n");
#endif

   clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd43d(%rip), %rax      # 0x12fe0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x9460(%rip), %rdi      # 0xf011
callq 0x5570
movq %rbx, %rdi
callq 0x56c0
leaq 0xe8(%rbx), %rdi
callq 0x52f0
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x5be5
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x5380
addq $0x58, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x5170
movq %rax, %rdi
callq 0xbe6d
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::NotifyDataPositionInFile(long)
int inTec_Zone::NotifyDataPositionInFile( long ipos_data_ )
{
   // reject reseting of position if it is already set
   if( ipos_data != 0 ) {
      return(1);
   } else {   // this is for when a zone is created but not read from a file
      ipos_data = ipos_data_;
#ifdef _DEBUG_
      printf(" --- Zone's data position at: %ld \n", ipos_data );
#endif
      return(0);
   }
}

// Assembly:
pushq %rbx
movl $0x1, %ebx
cmpq $0x0, 0xd8(%rdi)
jne 0x5ed3
movq %rsi, 0xd8(%rdi)
leaq 0x8403(%rip), %rdi      # 0xe2cd
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x5060
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::SetState_Reading()
int inTec_Zone::SetState_Reading( void )
{
   if( istate != 0 ) {
      // this is an error code that implies prior setting of the state
      return(1);
   }

   // use whatever keywords hava been collected to manage the internal state
   int iret = ManageInternals();
   if( iret == 0 ) {
      istate = 1;
      return(0);
   } else {
      // this is an error code that should imply an inconsistency
      return(2);
   }
}

// Assembly:
movl $0x1, %eax
cmpl $0x0, 0x8(%rdi)
je 0x5ee4
retq
pushq %rbx
movq %rdi, %rbx
callq 0x54a0
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x5f01
movl $0x1, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::HandleKeyword_T(char const*)
int inTec_Zone::HandleKeyword_T( const char *string )
{
   // make a duplicate buffer
   size_t is=0;
   while( string[is] != '\0' && string[is] != '\n' ) ++is;
   char *buf = (char *) malloc(is*sizeof(char));
   if( buf == NULL ) return(-1);

   memcpy( buf, string, is );
   tkey = buf;

   return(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x749a
cmpl $0xa, %eax
je 0x749a
incq %r15
jmp 0x7487
movq %r15, %rdi
callq 0x54e0
testq %rax, %rax
je 0x74c0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x52e0
movq %r12, 0x10(%rbx)
xorl %eax, %eax
jmp 0x74c5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::HandleKeyword_ET(char const*)
int inTec_Zone::HandleKeyword_ET( const char *string )
{
   size_t is=0;
   while( string[is] != '\0' && string[is] != '\n' ) ++is;

   // default is to place a number so that it is know ET was set
   iold_et = 999;

   if( is == 5 ) {
      if( strncasecmp( string, "BRICK", 5 ) == 0 ) iold_et = FEBRICK;
   }

   if( is == 8 ) {
      if( strncasecmp( string, "TRIANGLE", 8 ) == 0 ) iold_et = FETRIANGLE;
   }

   if( is == 11 ) {
      if( strncasecmp( string, "TETRAHEDRON", 11 ) == 0 )
         iold_et = FETETRAHEDRON;
   }

   if( is == 13 ) {
      if( strncasecmp( string, "QUADRILATERAL", 13 ) == 0 )
         iold_et = FEQUADRILATERAL;
   }

   return(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movzbl (%rsi,%rax), %ecx
testl %ecx, %ecx
je 0x74ea
cmpl $0xa, %ecx
je 0x74ea
incq %rax
jmp 0x74d8
movl $0x3e7, 0xc0(%rbx)      # imm = 0x3E7
addq $-0x5, %rax
cmpq $0x8, %rax
ja 0x759e
leaq 0x6bcb(%rip), %rcx      # 0xe0d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7236(%rip), %rax      # 0xe74f
movl $0x5, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5490
testl %eax, %eax
jne 0x759e
movl $0x6, %eax
jmp 0x7598
leaq 0x7248(%rip), %rax      # 0xe783
movl $0xb, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5490
testl %eax, %eax
jne 0x759e
movl $0x5, %eax
jmp 0x7598
leaq 0x720e(%rip), %rax      # 0xe76b
movl $0x8, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5490
testl %eax, %eax
jne 0x759e
movl $0x2, %eax
jmp 0x7598
leaq 0x7212(%rip), %rax      # 0xe791
movl $0xd, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5490
testl %eax, %eax
jne 0x759e
movl $0x3, %eax
movl %eax, 0xc0(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::HandleKeyword_Datapacking(char const*)
int inTec_Zone::HandleKeyword_Datapacking( const char *string )
{
#ifdef _DEBUG_
   printf(" i Inside HandleKeyword_Datapacking() \n");
#endif
   int iret=1;

   size_t is=0;
   while( string[is] != '\0' && string[is] != '\n' ) ++is;
   if( is < 5 ) return(1);

   if( strncasecmp( string, "POINT", 5 ) == 0 ) {
#ifdef _DEBUG_
      printf(" --- Data is in POINT format \n");
#endif
      idatapack = 1;
      iret = 0;
   } else if( strncasecmp( string, "BLOCK", 5 ) == 0 ) {
#ifdef _DEBUG_
      printf("   --- Data is in BLOCK format \n");
#endif
      idatapack = 2;
      iret = 0;
   } else {
#ifdef _DEBUG_
      printf(" i Unrecognized datapacking format: \"%s\" \n", string );
      iret = 2;
#endif
   }

#ifdef _DEBUG_
   printf(" i Exiting HandleKeyword_Datapacking() \n");
#endif
   return( iret );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x76f5(%rip), %rdi      # 0xf2cc
callq 0x5570
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
testl %ecx, %ecx
je 0x7bf1
cmpl $0xa, %ecx
je 0x7bf1
incq %rax
jmp 0x7bde
movl $0x1, %ebp
cmpq $0x5, %rax
jb 0x7c7a
leaq 0x6b19(%rip), %rsi      # 0xe71c
movl $0x5, %edx
movq %r14, %rdi
callq 0x5490
testl %eax, %eax
je 0x7c44
leaq 0x668c(%rip), %rsi      # 0xe2a7
movl $0x5, %edx
movq %r14, %rdi
callq 0x5490
testl %eax, %eax
je 0x7c59
leaq 0x6aef(%rip), %rdi      # 0xe722
movq %r14, %rsi
xorl %eax, %eax
callq 0x5060
movl $0x2, %ebp
jmp 0x7c6e
leaq 0x76c8(%rip), %rdi      # 0xf313
callq 0x5570
movl $0x1, 0x1c(%rbx)
jmp 0x7c6c
leaq 0x7693(%rip), %rdi      # 0xf2f3
callq 0x5570
movl $0x2, 0x1c(%rbx)
xorl %ebp, %ebp
leaq 0x76bc(%rip), %rdi      # 0xf331
callq 0x5570
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::GetElementNodes(unsigned long, int&, unsigned long*)
int inTec_Zone::GetElementNodes( unsigned long n,
                                 int & ik, unsigned long *icon_ )
{
   long off,k;


   if( ietype == FELINESEG ) {
      ik = 2;
   } else if( ietype == FETRIANGLE ) {
      ik = 3;
   } else if( ietype == FETETRAHEDRON ) {
      ik = 4;
   } else if( ietype == FEQUADRILATERAL ) {
      ik = 4;
   } else if( ietype == FEBRICK ) {
      ik = 8;
   } else {
      return(1);
   }

   off = ik*(n - 1);

   for(k=0;k<ik;++k) {
      icon_[k] = icon[off + k];
   }

   return(0);
}

// Assembly:
movl 0x18(%rdi), %r8d
decl %r8d
movl $0x1, %eax
cmpl $0x5, %r8d
ja 0xa816
movl $0x37, %r9d
btl %r8d, %r9d
jae 0xa816
movl %r8d, %eax
leaq 0x3996(%rip), %r8       # 0xe174
movl (%r8,%rax,4), %r9d
leaq 0x39a7(%rip), %r8       # 0xe190
movq (%r8,%rax,8), %r8
movl %r9d, (%rdx)
decq %rsi
imulq %r8, %rsi
shlq $0x3, %rsi
addq 0xa0(%rdi), %rsi
xorl %eax, %eax
xorl %edx, %edx
movq (%rsi,%rdx,8), %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r8
jne 0xa806
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::GetNumIndices(int) const
unsigned long inTec_Zone::GetNumIndices( int idir ) const
{
   if( idir == 1 ) {
      return im;
   } else if( idir == 2 ) {
      return jm;
   } else if( idir == 3 ) {
      return km;
   } else {
      return 0;
   }
}

// Assembly:
cmpl $0x3, %esi
je 0xa835
cmpl $0x2, %esi
je 0xa830
cmpl $0x1, %esi
jne 0xa83a
movq 0x30(%rdi), %rax
retq
movq 0x38(%rdi), %rax
retq
movq 0x40(%rdi), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::inTec_File(char*)
inTec_File::inTec_File( char *fname_ )
{
#ifdef _DEBUG_
   printf("File object instantiated \"%s\" \n", fname_ );
#endif

   memset( name, '\0', 256 );
   sprintf( name, "%s", fname_ );
   fp = NULL;
   istate = 0;
   nline = 0;
   iline = 0;
   ipos = 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8735(%rip), %rax      # 0x12fc8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x138(%rdi), %rax
xorl %r12d, %r12d
movl %r12d, 0x138(%rdi)
movq %r12, 0x140(%rdi)
movq %rax, 0x148(%rdi)
movq %rax, 0x150(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rdi)
movups %xmm0, 0x168(%rdi)
movups %xmm0, 0x178(%rdi)
movq %r12, 0x188(%rdi)
leaq 0x430f(%rip), %rdi      # 0xebf5
xorl %eax, %eax
callq 0x5060
leaq 0xc(%rbx), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x51e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x5310
movl %r12d, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x110(%rbx)
movups %xmm0, 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::OpenRead()
int inTec_File::OpenRead()
{
#ifdef _DEBUG_
   printf(" i Opening file object \"%s\" \n", name );
#endif

   if( istate != 0 ) {
      printf(" e File object is not in the right state (%d)\n", istate);
      return(1);
   }

   fp = fopen( name, "r" );
   if( fp == NULL ) {
      printf(" e Could not open file \"%s\"\n", name );
      return(2);
   }

   istate = 1;
   iline = 0;

   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xc(%rdi), %rbx
leaq 0x4181(%rip), %rdi      # 0xed2b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5060
movl 0x8(%r14), %esi
testl %esi, %esi
je 0xabd1
leaq 0x4186(%rip), %rdi      # 0xed49
xorl %eax, %eax
callq 0x5060
movl $0x1, %eax
jmp 0xac19
leaq 0x41a0(%rip), %rsi      # 0xed78
movq %rbx, %rdi
callq 0x5410
movq %rax, 0x110(%r14)
testq %rax, %rax
je 0xac03
movl $0x1, 0x8(%r14)
movq $0x0, 0x120(%r14)
xorl %eax, %eax
jmp 0xac19
leaq 0x4170(%rip), %rdi      # 0xed7a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5060
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::Close()
int inTec_File::Close()
{
#ifdef _DEBUG_
   printf(" i Closing file object \"%s\" \n", name );
#endif

   if( istate == 0 || istate == 1000 ) {
      return(0);
   }

   fclose( fp );

   istate = 1000;
   iline = 0;
   ipos = 0;

   return(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
leaq 0x4166(%rip), %rdi      # 0xed97
xorl %eax, %eax
callq 0x5060
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xac63
cmpl $0x3e8, %eax            # imm = 0x3E8
je 0xac63
movq 0x110(%rbx), %rdi
callq 0x5360
movl $0x3e8, 0x8(%rbx)       # imm = 0x3E8
xorps %xmm0, %xmm0
movups %xmm0, 0x120(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::Parse()
int inTec_File::Parse()
{
#ifdef _DEBUG_
   printf(" i Parsing file \"%s\" \n", name );
#endif

   if( istate != 1 ) {
      printf(" e File not in a reading state\n");
      return(1);
   }

   int iret = ParseLoop();

   if( iret != 0 ) {
      return(2);
   }

   return(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
leaq 0x4132(%rip), %rdi      # 0xedb5
xorl %eax, %eax
callq 0x5060
cmpl $0x1, 0x8(%rbx)
jne 0xac9c
movq %rbx, %rdi
callq 0x5690
addl %eax, %eax
jmp 0xacad
leaq 0x4b55(%rip), %rdi      # 0xf7f8
callq 0x5570
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::IdentifyComponent(char*)
int inTec_File::IdentifyComponent( char *buf )
{
#ifdef _DEBUG2_
   printf(" i Inside \"IdentifyComponent()\" \n");
#endif

   if( buf == NULL ) return(-1);
#ifdef _DEBUG3_
   printf("BUF: -->|%s", buf );
#endif

   size_t isize=0;
   while( buf[isize] != '\n' && buf[isize] != '\0' ) ++isize;
#ifdef _DEBUG3_
   printf(" i Size of buffer: %d \n", (int) isize);
#endif

   if( buf[0] == '\n' ) return(0);

   if( buf[0] == '#' ) return( Comment );

   if( isize >= 9 ) {
      if( strncasecmp( "VARIABLES", buf, 9 ) == 0 ) return( Variables );

   }

   if( isize >= 8 ) {
      if( strncasecmp( "FILETYPE", buf, 8 ) == 0 ) return( Filetype );
      if( strncasecmp( "GEOMETRY", buf, 8 ) == 0 ) return( Geometry );
   }

   if( isize >= 5 ) {
      if( strncasecmp( "TITLE", buf, 5 ) == 0 ) return( Title );
   }

   if( isize >= 4 ) {
      if( strncasecmp( "ZONE", buf, 4 ) == 0 ) return( Zone );
      if( strncasecmp( "TEXT", buf, 4 ) == 0 ) return( Text );
   }




   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xaf96
movq %rsi, %r14
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
testl %ecx, %ecx
je 0xaf7f
cmpl $0xa, %ecx
je 0xaf7f
incq %rax
jmp 0xaf6c
movzbl (%r14), %ecx
xorl %ebx, %ebx
cmpl $0xa, %ecx
je 0xaf9b
cmpl $0x23, %ecx
jne 0xafa5
movl $0x64, %ebx
jmp 0xaf9b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpq $0x9, %rax
jb 0xafca
leaq 0x3e47(%rip), %rdi      # 0xedf9
movl $0x9, %edx
movq %r14, %rsi
callq 0x5490
testl %eax, %eax
jne 0xafd0
movl $0xd, %ebx
jmp 0xaf9b
cmpq $0x8, %rax
jne 0xb007
leaq 0x3e2c(%rip), %rdi      # 0xee03
movl $0x8, %edx
movq %r14, %rsi
callq 0x5490
testl %eax, %eax
je 0xb02f
leaq 0x3e1d(%rip), %rdi      # 0xee0c
movl $0x8, %edx
movq %r14, %rsi
callq 0x5490
testl %eax, %eax
jne 0xb00d
movl $0x29, %ebx
jmp 0xaf9b
cmpq $0x5, %rax
jb 0xb039
leaq 0x3e01(%rip), %rdi      # 0xee15
movl $0x5, %edx
movq %r14, %rsi
callq 0x5490
testl %eax, %eax
jne 0xb043
movl $0xb, %ebx
jmp 0xaf9b
movl $0xc, %ebx
jmp 0xaf9b
cmpq $0x4, %rax
jne 0xaf9b
leaq 0x3593(%rip), %rdi      # 0xe5dd
movl $0x4, %edx
movq %r14, %rsi
callq 0x5490
testl %eax, %eax
je 0xb081
leaq 0x3db9(%rip), %rdi      # 0xee1b
movl $0x4, %edx
movq %r14, %rsi
callq 0x5490
testl %eax, %eax
jne 0xaf9b
movl $0x1f, %ebx
jmp 0xaf9b
movl $0x15, %ebx
jmp 0xaf9b
nop
// File: /workspace/github_cpp_makefile_star2_O3/nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_File::ParseComponent_Header(int, char*)
int inTec_File::ParseComponent_Header( int iop, char *buf )
{
#ifdef _DEBUG_
   if( iop == 1 ) printf(" i Inside \"ParseComponent_Header(Title)\" \n");
   if( iop == 2 ) printf(" i Inside \"ParseComponent_Header(Filetype)\" \n");
   if( iop == 3 ) printf(" i Inside \"ParseComponent_Header(Variables)\" \n");
#endif

   switch( iop ) {
    case(1):   // title

#ifdef _DEBUG_
      printf(" i Parsing header \"title\" line \n");
#endif

    break;
    case(2):   // filetype

#ifdef _DEBUG_
      printf(" i Parsing header \"filetype\" line \n");
#endif

    break;
    case(3):   // variables

#ifdef _DEBUG_
      printf(" i Parsing header \"variables\" line \n");
#endif
      return( ParseComponent_HeaderVariables( buf ) );

    break;

    default:
      printf(" e Error parsing header component\n");
      return(1);
   }

   return(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %esi
je 0xb0d0
cmpl $0x2, %esi
je 0xb0b4
cmpl $0x1, %esi
jne 0xb100
leaq 0x4771(%rip), %rdi      # 0xf817
callq 0x5570
leaq 0x4831(%rip), %rdi      # 0xf8e3
jmp 0xb0c7
leaq 0x4786(%rip), %rdi      # 0xf841
callq 0x5570
leaq 0x47f9(%rip), %rdi      # 0xf8c0
callq 0x5570
xorl %eax, %eax
jmp 0xb111
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4791(%rip), %rdi      # 0xf86e
callq 0x5570
leaq 0x47b3(%rip), %rdi      # 0xf89c
callq 0x5570
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54f0
leaq 0x47fc(%rip), %rdi      # 0xf903
callq 0x5570
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelvinabrokwa[P]bottleneck/./CBottleneckDistance.cpp
// Function: CBottleneckDistance::DFS(int)
bool CBottleneckDistance::DFS(int v)
{
    if (v < 0)
        return true;

    // for every adjacent vertex u of v
    for (unsigned int i = 0; i < Connections[v].size(); ++i) {
        int u = Connections[v][i];
        if (Layers[Pair[u] + 1] == Layers[v + 1] + 1) {
            if (DFS( Pair[u])) {
                Pair[u] = v;
                Pair[v] = u;
                return true;
            }
        }
    }

    Layers[v + 1] = -1;

    return false;
}

// Assembly:
movb $0x1, %al
testl %esi, %esi
js 0x1a64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
movq 0x88(%rdi), %rax
leaq (%r15,%r15,2), %r12
movq (%rax,%r12,8), %rcx
cmpq %rcx, 0x8(%rax,%r12,8)
je 0x1a35
movl $0x1, %r13d
xorl %edx, %edx
movl (%rcx,%rdx,4), %ecx
movslq %ecx, %rbx
movq 0x70(%r14), %rcx
movq 0xa0(%r14), %rdx
movslq (%rcx,%rbx,4), %rsi
movl 0x4(%rdx,%r15,4), %ecx
incl %ecx
cmpl %ecx, 0x4(%rdx,%rsi,4)
jne 0x1a1a
movq %r14, %rdi
callq 0x19aa
testb %al, %al
jne 0x1a49
movq 0x88(%r14), %rax
movl %r13d, %edx
movq (%rax,%r12,8), %rcx
movq 0x8(%rax,%r12,8), %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
incl %r13d
cmpq %rdx, %rsi
ja 0x19e5
movq 0xa0(%r14), %rax
movl $0xffffffff, 0x4(%rax,%r15,4) # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x1a56
movq 0x70(%r14), %rax
movl %ebp, (%rax,%rbx,4)
movl %ebx, (%rax,%r15,4)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelvinabrokwa[P]bottleneck/./CBottleneckDistance.cpp
// Function: CBottleneckDistance::Hopcroft_Karp(unsigned int&)
void CBottleneckDistance::Hopcroft_Karp(unsigned int &matching)
{
    while (BFS() == true)
        for (unsigned int vertex = 0; vertex < Max_Size; ++vertex) {
            if (Pair[ vertex ] == -1) {
                if (DFS(vertex)) {
                    ++matching;
                }
            }
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a66
testb %al, %al
je 0x1ca9
cmpl $0x0, 0x50(%r14)
je 0x1ca4
xorl %r15d, %r15d
movq 0x70(%r14), %rax
cmpl $-0x1, (%rax,%r15,4)
jne 0x1c98
movq %r14, %rdi
movl %r15d, %esi
callq 0x19aa
testb %al, %al
je 0x1c98
incl (%rbx)
incq %r15
movl 0x50(%r14), %eax
cmpq %rax, %r15
jb 0x1c7c
movq %r14, %rdi
jmp 0x1c69
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/kelvinabrokwa[P]bottleneck/bottleneckDist.cpp
// Function: main
int main(int argc, char* argv[])
{
    // must pass in two args, one for each persdia file, so #argc = 1 + 2
    // may also want to pass in max_gen later
    if (argc < 3 || argc > 4) {
        cout
            << endl
            << "Must pass in filename1 and filename2"
            << endl
            << "to find the distance between diagrams."
            << endl;
        return -1;
    }

    // file names
    char* file1 = argv[1];
    char* file2 = argv[2];

    CBottleneckDistance d;

    double max_gen = 1;

    // compute the distance between persistence diagrams
    double distance = d.Distance(file1, file2, max_gen);

    cout << distance << endl;

    return 0;
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
addl $-0x5, %edi
cmpl $-0x3, %edi
ja 0x1fcc
movq 0x50b9(%rip), %rbx      # 0x6fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
movq %rax, %rbx
leaq 0x219b(%rip), %rsi      # 0x40eb
movl $0x24, %edx
movq %rax, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
movq %rax, %rbx
leaq 0x2182(%rip), %rsi      # 0x4110
movl $0x26, %edx
movq %rax, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x206b
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
leaq 0x4dbd(%rip), %rcx      # 0x6d98
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
movw $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movups %xmm0, 0x88(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0xa8(%rdi)
movsd 0x1ff7(%rip), %xmm0     # 0x4018
movq %rax, %rsi
callq 0x1eac
movq 0x4fa8(%rip), %rdi      # 0x6fd8
callq 0x1160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10d0
leaq 0x8(%rsp), %rdi
callq 0x1432
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1432
movq %rbx, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/app/genipafolio/genipafolio.cpp
// Function: solverThread(void*)
void* solverThread(void* solver) {
	int res = ipasir_solve(solver);
	printf("c [genipafolio] solver stopped, res = %d\n", res);
	if (res != 0) {
		result = res;
	}
	return NULL;
}

// Assembly:
pushq %rbx
callq 0x20bb
movl %eax, %ebx
leaq 0xe6aa(%rip), %rdi      # 0x10004
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
testl %ebx, %ebx
je 0x196d
movl %ebx, 0x157df(%rip)     # 0x1714c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ostafen[P]Fast-Insertion-Sort/src/test.cpp
// Function: compare(int*, int*, int)
bool compare(int *A, int *B, int size)
{
    for (int i = 0; i < size; i++)
    {
        if (A[i] != B[i])
        {
            return false;
        }
    }
    return true;
}

// Assembly:
testl %edx, %edx
jle 0x235a
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x235d
movl %edx, %eax
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x2353
movl (%rdi,%rcx,4), %r8d
leaq 0x1(%rcx), %rdx
cmpl (%rsi,%rcx,4), %r8d
je 0x233d
cmpq %rax, %rcx
setae %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/menu.cpp
// Function: string2int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int string2int( const std::string& a )
{
    // Convert a string representation of a number into a floating point value.
    // Throws an int if the string contains anything but whitespace and a valid
    // numeric representation.
    //
    int result;
    std::string s( a );

    // Get rid of any trailing whitespace
    s.erase( s.find_last_not_of( " \f\n\r\t\v" ) + 1 );

    // Read it into the target type
    std::istringstream ss( s );
    ss >> result;

    // Check to see that there is nothing left over
    if (!ss.eof())
        throw 1;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x3b18
leaq 0x17be(%rip), %rsi      # 0x51a9
movl $0x6, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x2290
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x3a99
leaq -0x38(%rbp), %rsi
movq %rax, 0x8(%rsi)
movq (%rsi), %rcx
movb $0x0, (%rcx,%rax)
leaq -0x1b8(%rbp), %rdi
movl $0x8, %edx
callq 0x22c0
leaq -0x1b8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x20c0
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x198(%rbp,%rax)
je 0x3ab1
movl -0x14(%rbp), %ebx
movq 0x356a(%rip), %rsi      # 0x6fc8
leaq -0x1b8(%rbp), %rdi
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x2060
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a8b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1724(%rip), %rdi      # 0x51c4
leaq 0x1709(%rip), %rsi      # 0x51b0
movq %rax, %rdx
xorl %eax, %eax
callq 0x2250
movl $0x4, %edi
callq 0x20a0
movl $0x1, (%rax)
movq 0x34e0(%rip), %rsi      # 0x6fa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x22d0
jmp 0x3ad4
movq %rax, %rbx
jmp 0x3afb
movq %rax, %rbx
movq 0x34e5(%rip), %rsi      # 0x6fc8
leaq -0x1b8(%rbp), %rdi
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x2060
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3b10
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/myPtrace.cpp
// Function: attach(int)
int attach(pid_t pid)
{
    int status;
    if(ptrace(PTRACE_ATTACH, pid, NULL, NULL))
    {
        perror("PTRACE_ATTACH");
        return 1;
    }
    std::cout << "attached to " << pid << std::endl << "wait for child" << std::endl;
    wait(&status);
    std::cout << "Status: " << status << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r15d
xorl %ebx, %ebx
movl $0x10, %edi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
testq %rax, %rax
jne 0x3cd3
movq 0x33e6(%rip), %r14      # 0x6fd0
leaq 0x1618(%rip), %rsi      # 0x5209
movl $0xc, %edx
movq %r14, %rdi
callq 0x21e0
movq %r14, %rdi
movl %r15d, %esi
callq 0x22e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %rax, %r15
leaq 0x15d9(%rip), %rsi      # 0x5216
movl $0xe, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq -0x1c(%rbp), %r15
movq %r15, %rdi
callq 0x2220
leaq 0x15a1(%rip), %rsi      # 0x5225
movl $0x8, %edx
movq %r14, %rdi
callq 0x21e0
movl (%r15), %esi
movq %r14, %rdi
callq 0x22e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1521(%rip), %rdi      # 0x51fb
callq 0x2140
movl $0x1, %ebx
jmp 0x3cc6
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/myPtrace.cpp
// Function: detach(int)
int detach(pid_t pid)
{
    if(ptrace(PTRACE_DETACH, pid, NULL, NULL))
    {
        perror("PTRACE_DETACH");
        return 1;
    }
    std::cout << "detached from " << pid << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
xorl %ebx, %ebx
movl $0x11, %edi
movl %r14d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
testq %rax, %rax
jne 0x3d6a
movq 0x32bc(%rip), %r15      # 0x6fd0
leaq 0x1521(%rip), %rsi      # 0x523c
movl $0xe, %edx
movq %r15, %rdi
callq 0x21e0
movq %r15, %rdi
movl %r14d, %esi
callq 0x22e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14bd(%rip), %rdi      # 0x522e
callq 0x2140
movl $0x1, %ebx
jmp 0x3d5d
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/myPtrace.cpp
// Function: peek(int, unsigned long, long&)
int peek(pid_t pid, unsigned long addr, long &buffer)
{
    errno = 0;
    if(((buffer = ptrace(PTRACE_PEEKDATA, pid, (void *)addr, NULL)) == -1) && errno)
    {
        perror("PTRACE_PEEKDATA");
        if(ptrace(PTRACE_DETACH, pid, NULL, NULL))
            perror("PTRACE_DETACH");
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebx
callq 0x2040
movq %rax, %r15
movl $0x0, (%rax)
xorl %r14d, %r14d
movl $0x2, %edi
movl %ebx, %esi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
movq %rax, (%r12)
cmpq $-0x1, %rax
jne 0x3dc7
cmpl $0x0, (%r15)
jne 0x3dd9
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x146b(%rip), %rdi      # 0x524b
callq 0x2140
movl $0x11, %edi
movl %ebx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
movl $0x1, %r14d
testq %rax, %rax
je 0x3dc7
leaq 0x1425(%rip), %rdi      # 0x522e
callq 0x2140
jmp 0x3dc7
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/myPtrace.cpp
// Function: poke(int, unsigned long, long)
int poke(pid_t pid, unsigned long addr, long buffer)
{
    errno = 0;
    if (ptrace(PTRACE_POKEDATA, pid, (void *)addr, buffer) == -1 && errno)
    {
        perror("PTRACE_POKE");
        return 1;
    }
    std::cout << "successfully wrote " << buffer << " to " << std::hex << "0x" << addr << std::dec << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r13d
callq 0x2040
movq %rax, %r12
movl $0x0, (%rax)
xorl %ebx, %ebx
movl $0x5, %edi
movl %r13d, %esi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2150
cmpq $-0x1, %rax
jne 0x3e5d
cmpl $0x0, (%r12)
jne 0x3f1f
movq 0x316c(%rip), %r12      # 0x6fd0
leaq 0x13fc(%rip), %rsi      # 0x5267
movl $0x13, %edx
movq %r12, %rdi
callq 0x21e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %r15
leaq 0x1384(%rip), %rsi      # 0x5211
movl $0x4, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
leaq 0x13c3(%rip), %rsi      # 0x527b
movl $0x2, %edx
movq %r15, %rdi
callq 0x21e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x20d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1335(%rip), %rdi      # 0x525b
callq 0x2140
movl $0x1, %ebx
jmp 0x3f0e
nop
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/print.cpp
// Function: printHelp()
void printHelp() {
    std::cout << "MemCrawl options: " << std::endl;
    std::cout << "help:\t\tprints this help screen" << std::endl;
    std::cout << "list:\t\tprints a list of all entries" << std::endl;
    std::cout << "update:\t\tupdates all entries" << std::endl;
    std::cout << "ulist:\t\tupdates and lists all entries" << std::endl;
    std::cout << "info:\t\tprints info about scan regions" << std::endl;
    std::cout << "set <number>:\tsets all entries to <number>" << std::endl;
    std::cout << "reset:\t\tresets all entries" << std::endl;
    std::cout << "pid:\t\tchange to pid" << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2ee2(%rip), %rbx      # 0x6fd0
leaq 0x11a4(%rip), %rsi      # 0x5299
movl $0x12, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x117c(%rip), %rsi      # 0x52ac
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x1160(%rip), %rsi      # 0x52cb
movl $0x23, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x1149(%rip), %rsi      # 0x52ef
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x112b(%rip), %rsi      # 0x530c
movl $0x25, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x1116(%rip), %rsi      # 0x5332
movl $0x25, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x1101(%rip), %rsi      # 0x5358
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10f1(%rip), %rsi      # 0x5383
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10d1(%rip), %rsi      # 0x539e
movl $0x13, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/scan.cpp
// Function: scanIntInit(std::vector<scanRegion, std::allocator<scanRegion>>, std::vector<scanResult, std::allocator<scanResult>>&, int, int)
int scanIntInit(std::vector<scanRegion> regions, std::vector<scanResult> &results, pid_t pid, int scanValue)
{
    unsigned long startAddr = 0, endAddr = 0;
    long buffer = 0;

    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<regions.size(); x++)
    {
        scanResult result;
        startAddr = regions[x].startRegion;
        endAddr = regions[x].endRegion;

        while (startAddr < endAddr)
        {

            if (peek(pid, startAddr, buffer) != 0)
            {
                return 1;
            }
            if (buffer == scanValue)
            {
                result.addr = startAddr;
                result.value = buffer;
                results.push_back(result);
            }
            startAddr += sizeof(unsigned long);

         }

    }


    detach(pid);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r14d
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
movq $0x0, -0x38(%rbp)
movl %edx, %edi
callq 0x3bb8
movl $0x1, %ecx
testl %eax, %eax
jne 0x43ff
movl %r14d, -0x2c(%rbp)
movq (%r15), %rax
movq %r15, -0x40(%rbp)
movq 0x8(%r15), %rcx
cmpq %rax, %rcx
je 0x43ef
movslq -0x2c(%rbp), %r15
xorl %edx, %edx
xorl %edi, %edi
shlq $0x4, %rdx
movq (%rax,%rdx), %r13
movq 0x8(%rax,%rdx), %r14
cmpq %r14, %r13
jae 0x43d7
movq %rdi, -0x48(%rbp)
movl %ebx, %edi
movq %r13, %rsi
leaq -0x38(%rbp), %rdx
callq 0x3d7d
testl %eax, %eax
jne 0x43fa
cmpq %r15, -0x38(%rbp)
jne 0x43bf
movq %r13, -0x58(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x50(%rbp)
movq 0x8(%r12), %rsi
cmpq 0x10(%r12), %rsi
je 0x43b3
movups -0x58(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%r12)
jmp 0x43bf
movq %r12, %rdi
leaq -0x58(%rbp), %rdx
callq 0x4740
addq $0x8, %r13
cmpq %r14, %r13
jb 0x4376
movq -0x40(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq -0x48(%rbp), %rdi
incl %edi
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
movq %rdi, %rdx
cmpq %rdi, %rsi
ja 0x4360
movl %ebx, %edi
callq 0x3ce6
xorl %ecx, %ecx
jmp 0x43ff
movl $0x1, %ecx
movl %ecx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/scan.cpp
// Function: scanIntResults(std::vector<scanResult, std::allocator<scanResult>>&, int, int)
int scanIntResults(std::vector<scanResult> &results, pid_t pid, int scanValue)
{
    long buffer = 0;
    scanResult result;
    std::vector<scanResult> newResults;

    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<results.size(); x++)
    {
        if (peek(pid, results[x].addr, buffer) != 0)
        {
            return 1;
        }
        if (buffer == scanValue)
        {
            result.addr = results[x].addr;
            result.value = buffer;
            newResults.push_back(result);
        }

    }

    results = newResults;
    detach(pid);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, -0x2c(%rbp)
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, -0x58(%rbp)
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movl %esi, %edi
callq 0x3bb8
movl $0x1, %r12d
testl %eax, %eax
jne 0x44e9
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x44cb
movslq -0x2c(%rbp), %r13
xorl %r15d, %r15d
shlq $0x4, %r15
movq (%rax,%r15), %rsi
movl %ebx, %edi
leaq -0x58(%rbp), %rdx
callq 0x3d7d
testl %eax, %eax
jne 0x44e3
cmpq %r13, -0x58(%rbp)
jne 0x44b2
movq (%r14), %rax
movq (%rax,%r15), %rax
movq %rax, -0x68(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x44a5
movups -0x68(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, -0x48(%rbp)
jmp 0x44b2
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x4740
movl %r12d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
incl %r12d
cmpq %r15, %rcx
ja 0x445f
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x4652
xorl %r12d, %r12d
movl %ebx, %edi
callq 0x3ce6
jmp 0x44e9
movl $0x1, %r12d
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x44fe
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x21c0
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4512
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x452a
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/scan.cpp
// Function: updateIntResults(std::vector<scanResult, std::allocator<scanResult>>&, int)
int updateIntResults(std::vector<scanResult> &results, pid_t pid)
{
    long buffer = 0;

    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<results.size(); x++)
    {
        if (peek(pid, results[x].addr, buffer) != 0)
        {
            return 1;
        }
        else {
            results[x].value = buffer;
        }
    }

    detach(pid);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq $0x0, -0x30(%rbp)
movl %esi, %edi
callq 0x3bb8
movl $0x1, %ecx
testl %eax, %eax
jne 0x45ba
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x45aa
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
movl $0x1, %r15d
shlq $0x4, %r13
movq (%rax,%r13), %rsi
movl %ebx, %edi
movq %r12, %rdx
callq 0x3d7d
testl %eax, %eax
jne 0x45b5
movl -0x30(%rbp), %ecx
movq (%r14), %rax
movl %ecx, 0x8(%rax,%r13)
movl %r15d, %r13d
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
incl %r15d
cmpq %r13, %rcx
ja 0x4573
movl %ebx, %edi
callq 0x3ce6
xorl %ecx, %ecx
jmp 0x45ba
movl $0x1, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/illmat[P]MemCrawl/scan.cpp
// Function: setInt(std::vector<scanResult, std::allocator<scanResult>>&, int, int)
int setInt(std::vector<scanResult> &results, pid_t pid, int value)
{
    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<results.size(); x++)
    {
        if (poke(pid, results[x].addr, value) != 0)
        {
            return 1;
        }
    }

    detach(pid);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x3bb8
movl $0x1, %r15d
testl %eax, %eax
jne 0x463f
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x4635
movslq %r12d, %r12
xorl %ecx, %ecx
movl $0x1, %r13d
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movl %ebx, %edi
movq %r12, %rdx
callq 0x3e10
testl %eax, %eax
jne 0x463f
movl %r13d, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
incl %r13d
cmpq %rcx, %rdx
ja 0x4606
movl %ebx, %edi
callq 0x3ce6
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/danfai[P]dboc/stringtokenizer.cpp
// Function: StringTokenizer::getString[abi:cxx11]()
std::string StringTokenizer::getString()
{
    if (this->end)
        throw InvalidLineException();
    if (line[pos] == ' ') { ++pos;
        return ""; }
    int oldpos = pos;
    for(; line[pos] != '\0'; ++pos) {
        if (line[pos] == ' ') {
            ++pos;
            std::string b = line.substr(oldpos, pos-oldpos-1);
            return b;
        }
    }
    this->end = true;
    return line.substr(oldpos);
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x24(%rsi)
jne 0x2b0f
movq %rdi, %rbx
movl 0x20(%rsi), %eax
movq (%rsi), %rcx
movb (%rcx,%rax), %r9b
cmpb $0x20, %r9b
jne 0x2abe
incl %eax
movl %eax, 0x20(%rsi)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x262a(%rip), %rdx      # 0x50db
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x29c2
jmp 0x2b0a
movslq %eax, %rdx
leal 0x1(%rdx), %r8d
xorl %edi, %edi
testb %r9b, %r9b
je 0x2af4
movzbl %r9b, %r9d
cmpl $0x20, %r9d
je 0x2ae6
leal (%r8,%rdi), %r9d
movl %r9d, 0x20(%rsi)
movb (%rcx,%r9), %r9b
incl %edi
jmp 0x2ac7
addl %edi, %eax
incl %eax
movl %eax, 0x20(%rsi)
movl %edi, %ecx
movq %rbx, %rdi
jmp 0x2b05
movl $0x1, 0x24(%rsi)
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x21f0
movq %rbx, %rax
popq %rbx
retq
movl $0x8, %edi
callq 0x2110
leaq 0x5230(%rip), %rcx      # 0x7d50
movq %rcx, (%rax)
leaq 0x51fe(%rip), %rsi      # 0x7d28
movq 0x54a7(%rip), %rdx      # 0x7fd8
movq %rax, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/danfai[P]dboc/parser.cpp
// Function: Parser::Parser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Parser::Parser(std::string inFile)
{
    std::ifstream in(inFile);

    std::string line;
    while(std::getline(in, line)) {
        if(line.size() > 0)
            parseLine(line);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22c0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x30(%rsp), %rbp
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2cbb
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x2c47
movq %rbp, 0x20(%rsp)
movq (%rsp), %rsi
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2b5a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d42
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c47
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x2c47
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2cd1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x40(%rsp), %rdi
callq 0x2080
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2d31
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d11
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x2d11
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d27
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x40(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2888
movq %r14, %rdi
callq 0x22f0
nop