LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::HandleKeyword_Varsharelist(char const*)
int inTec_Zone::HandleKeyword_Varsharelist( const char *string )
{
#ifdef _DEBUG_
   printf(" i Inside HandleKeyword_Varsharelist() \n");
#endif
   int iret=1;

   // 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);

   // shift passed spaces
   memcpy( buf, string, is );
   char *s = buf;
   while( s[0] == ' ' ) s++;
   is = 0;
   while( s[is] != '\0' && s[is] != '\n' ) ++is;

////// need to make this later
#ifdef _DEBUG_
   printf(" --- Temporarily ignoring this keyword\n");
#endif
iret=0;

   // drop the buffer
   free( buf );

#ifdef _DEBUG_
   printf(" i Exiting HandleKeyword_Varsharelist() (return %d) \n",iret);
#endif
   return( iret );
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0xf219(%rip), %rdi      # 0x2898e
movb $0x0, %al
callq 0x13070
movl $0x1, 0x2c(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x197be
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x197c8
jmp 0x197d8
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1978d
movq 0x20(%rsp), %rdi
shlq $0x0, %rdi
callq 0x145f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x19800
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x198c9
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x13c70
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1983b
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1981e
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xe(%rsp)
je 0x19875
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x1987f
jmp 0x1988f
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x19844
leaq 0xf121(%rip), %rdi      # 0x289b7
movb $0x0, %al
callq 0x13070
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
callq 0x14380
movl 0x2c(%rsp), %esi
leaq 0xf125(%rip), %rdi      # 0x289df
movb $0x0, %al
callq 0x13070
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x40(%rsp)
cmpl $0x1, 0x18(%rax)
jne 0x1e2a1
movq -0x20(%rsp), %rax
movl $0x2, (%rax)
jmp 0x1e313
movq -0x40(%rsp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x1e2b9
movq -0x20(%rsp), %rax
movl $0x3, (%rax)
jmp 0x1e311
movq -0x40(%rsp), %rax
cmpl $0x5, 0x18(%rax)
jne 0x1e2d1
movq -0x20(%rsp), %rax
movl $0x4, (%rax)
jmp 0x1e30f
movq -0x40(%rsp), %rax
cmpl $0x3, 0x18(%rax)
jne 0x1e2e9
movq -0x20(%rsp), %rax
movl $0x4, (%rax)
jmp 0x1e30d
movq -0x40(%rsp), %rax
cmpl $0x6, 0x18(%rax)
jne 0x1e301
movq -0x20(%rsp), %rax
movl $0x8, (%rax)
jmp 0x1e30b
movl $0x1, -0x4(%rsp)
jmp 0x1e388
jmp 0x1e30d
jmp 0x1e30f
jmp 0x1e311
jmp 0x1e313
movq -0x20(%rsp), %rax
movslq (%rax), %rax
movq -0x18(%rsp), %rcx
subq $0x1, %rcx
imulq %rcx, %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq -0x20(%rsp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jge 0x1e380
movq -0x40(%rsp), %rax
movq 0xa0(%rax), %rax
movq -0x30(%rsp), %rcx
addq -0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rsp), %rax
movq -0x38(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x1e336
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x1, -0x14(%rsp)
jne 0x1e3ca
movq -0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1e401
cmpl $0x2, -0x14(%rsp)
jne 0x1e3e1
movq -0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1e401
cmpl $0x3, -0x14(%rsp)
jne 0x1e3f8
movq -0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1e401
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: nompelis[P]INTecplotLib/intecplot.cpp
// Function: inTec_Zone::GetVariablePtr(int) const
const double* inTec_Zone::GetVariablePtr( int ivar_ ) const
{
   if( ivar_ > (int) (var_vec.size()) ) {
      return NULL;
   } else {
      const double* tmp = var_vec[ ivar_ ];
      return  tmp;
   }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x88, %rdi
callq 0x13920
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jle 0x1e471
movq $0x0, 0x30(%rsp)
jmp 0x1e499
movq 0x8(%rsp), %rdi
addq $0x88, %rdi
movslq 0x24(%rsp), %rsi
callq 0x14900
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x11ab9(%rip), %rax     # 0x2ffc8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x130, %rdi            # imm = 0x130
movq %rdi, 0x8(%rsp)
callq 0x14910
movq 0x18(%rsp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq %rdi, 0x10(%rsp)
callq 0x14d80
movq 0x18(%rsp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, 0x20(%rsp)
callq 0x134b0
movq 0x38(%rsp), %rsi
leaq 0xac0a(%rip), %rdi      # 0x29169
xorl %eax, %eax
callq 0x13070
jmp 0x1e568
movq 0x18(%rsp), %rdi
addq $0xc, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x13770
movq 0x18(%rsp), %rdi
addq $0xc, %rdi
movq 0x38(%rsp), %rdx
leaq 0xae2b(%rip), %rsi      # 0x293bd
movb $0x0, %al
callq 0x13190
movq 0x18(%rsp), %rax
movq $0x0, 0x110(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x118(%rax)
movq $0x0, 0x120(%rax)
movq $0x0, 0x128(%rax)
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x13440
movq 0x10(%rsp), %rdi
callq 0x13a40
movq 0x8(%rsp), %rdi
callq 0x14280
movq 0x30(%rsp), %rdi
callq 0x14d20
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq %rsi, (%rsp)
addq $0xc, %rsi
leaq 0xa91b(%rip), %rdi      # 0x292b8
movb $0x0, %al
callq 0x13070
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x1e9cd
movq (%rsp), %rax
movl 0x8(%rax), %esi
leaq 0xa91a(%rip), %rdi      # 0x292d6
movb $0x0, %al
callq 0x13070
movl $0x1, 0x14(%rsp)
jmp 0x1ea37
movq (%rsp), %rdi
addq $0xc, %rdi
leaq 0xa929(%rip), %rsi      # 0x29305
callq 0x14320
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x110(%rax)
cmpq $0x0, 0x110(%rax)
jne 0x1ea19
movq (%rsp), %rsi
addq $0xc, %rsi
leaq 0xa8ff(%rip), %rdi      # 0x29307
movb $0x0, %al
callq 0x13070
movl $0x2, 0x14(%rsp)
jmp 0x1ea37
movq (%rsp), %rax
movl $0x1, 0x8(%rax)
movq $0x0, 0x120(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq %rsi, (%rsp)
addq $0xc, %rsi
leaq 0xa8c7(%rip), %rdi      # 0x29324
movb $0x0, %al
callq 0x13070
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x1ea7b
movq (%rsp), %rax
cmpl $0x3e8, 0x8(%rax)       # imm = 0x3E8
jne 0x1ea85
movl $0x0, 0x14(%rsp)
jmp 0x1eabe
movq (%rsp), %rax
movq 0x110(%rax), %rdi
callq 0x13f90
movq (%rsp), %rax
movl $0x3e8, 0x8(%rax)       # imm = 0x3E8
movq $0x0, 0x120(%rax)
movq $0x0, 0x128(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0xc, %rsi
leaq 0xa824(%rip), %rdi      # 0x29342
movb $0x0, %al
callq 0x13070
movq 0x8(%rsp), %rax
cmpl $0x1, 0x8(%rax)
je 0x1eb48
leaq 0xa822(%rip), %rdi      # 0x29359
movb $0x0, %al
callq 0x13070
movl $0x1, 0x24(%rsp)
jmp 0x1eb6f
movq 0x8(%rsp), %rdi
callq 0x14e50
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x1eb67
movl $0x2, 0x24(%rsp)
jmp 0x1eb6f
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1eec3
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1f062
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0x7(%rsp)
je 0x1eefd
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1ef07
jmp 0x1ef17
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1eecc
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1ef31
movl $0x0, 0x24(%rsp)
jmp 0x1f062
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x1ef4b
movl $0x64, 0x24(%rsp)
jmp 0x1f062
cmpq $0x9, 0x8(%rsp)
jb 0x1ef7d
movq 0x10(%rsp), %rsi
leaq 0xa535(%rip), %rdi      # 0x29494
movl $0x9, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x1ef7b
movl $0xd, 0x24(%rsp)
jmp 0x1f062
jmp 0x1ef7d
cmpq $0x8, 0x8(%rsp)
jb 0x1efd7
movq 0x10(%rsp), %rsi
leaq 0xa50d(%rip), %rdi      # 0x2949e
movl $0x8, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x1efad
movl $0xc, 0x24(%rsp)
jmp 0x1f062
movq 0x10(%rsp), %rsi
leaq 0xa4ee(%rip), %rdi      # 0x294a7
movl $0x8, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x1efd5
movl $0x29, 0x24(%rsp)
jmp 0x1f062
jmp 0x1efd7
cmpq $0x5, 0x8(%rsp)
jb 0x1f006
movq 0x10(%rsp), %rsi
leaq 0xa4c5(%rip), %rdi      # 0x294b0
movl $0x5, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x1f004
movl $0xb, 0x24(%rsp)
jmp 0x1f062
jmp 0x1f006
cmpq $0x4, 0x8(%rsp)
jb 0x1f05a
movq 0x10(%rsp), %rsi
leaq 0x94da(%rip), %rdi      # 0x284f4
movl $0x4, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x1f033
movl $0x15, 0x24(%rsp)
jmp 0x1f062
movq 0x10(%rsp), %rsi
leaq 0xa477(%rip), %rdi      # 0x294b6
movl $0x4, %edx
callq 0x144c0
cmpl $0x0, %eax
jne 0x1f058
movl $0x1f, 0x24(%rsp)
jmp 0x1f062
jmp 0x1f05a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x24(%rsp)
jne 0x1f0a1
leaq 0xa421(%rip), %rdi      # 0x294bb
movb $0x0, %al
callq 0x13070
cmpl $0x2, 0x24(%rsp)
jne 0x1f0b6
leaq 0xa437(%rip), %rdi      # 0x294e6
movb $0x0, %al
callq 0x13070
cmpl $0x3, 0x24(%rsp)
jne 0x1f0cb
leaq 0xa450(%rip), %rdi      # 0x29514
movb $0x0, %al
callq 0x13070
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x1f0f0
jmp 0x1f0da
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x1f100
jmp 0x1f0e5
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x1f110
jmp 0x1f133
leaq 0xa44c(%rip), %rdi      # 0x29543
movb $0x0, %al
callq 0x13070
jmp 0x1f14b
leaq 0xa45d(%rip), %rdi      # 0x29564
movb $0x0, %al
callq 0x13070
jmp 0x1f14b
leaq 0xa471(%rip), %rdi      # 0x29588
movb $0x0, %al
callq 0x13070
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x14640
movl %eax, 0x34(%rsp)
jmp 0x1f153
leaq 0xa473(%rip), %rdi      # 0x295ad
movb $0x0, %al
callq 0x13070
movl $0x1, 0x34(%rsp)
jmp 0x1f153
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: kelvinabrokwa[P]bottleneck/./CBottleneckDistance.cpp
// Function: CBottleneckDistance::InfDistanceOfTwoGenerators(Generator, Generator)
double CBottleneckDistance::InfDistanceOfTwoGenerators(Generator gen1, Generator gen2)
{
    double birth_diff = fabs(gen1.birth - gen2.birth);
    double death_diff = fabs(gen1.death - gen2.death);

    if (birth_diff > death_diff)
        return 0; // birth_diff;

    return 0; // death_diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movaps 0x88a3(%rip), %xmm1     # 0xa020
pand %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movaps 0x8889(%rip), %xmm1     # 0xa020
pand %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x17b6
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x17be
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1d76
movb $0x1, -0x1(%rbp)
jmp 0x1ec7
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
addq $0x88, %rdi
movslq -0x14(%rbp), %rsi
callq 0x2d50
movq %rax, %rdi
callq 0x2d70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1ea4
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
movslq -0x14(%rbp), %rsi
callq 0x2d50
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2d90
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq %rdi, %rax
addq $0xa0, %rax
movq %rax, -0x40(%rbp)
addq $0x70, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2d90
movq -0x40(%rbp), %rdi
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2d90
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
addq $0xa0, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2d90
movq %rax, %rcx
movl -0x34(%rbp), %eax
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1e94
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2d90
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0x1d50
testb $0x1, %al
jne 0x1e54
jmp 0x1e92
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
addq $0x70, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2d90
movl -0x48(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x70, %rdi
movslq -0x14(%rbp), %rsi
callq 0x2d90
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1ec7
jmp 0x1e94
jmp 0x1e96
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d7d
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2d90
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ee0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2273
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x50(%rcx), %eax
jae 0x2271
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2d90
cmpl $-0x1, (%rax)
jne 0x2264
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1d50
testb $0x1, %al
jne 0x2257
jmp 0x2262
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2264
jmp 0x2266
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2222
jmp 0x2208
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jl 0x2645
cmpl $0x4, -0x8(%rbp)
jle 0x26a0
movq 0xd98c(%rip), %rdi      # 0xffd8
movq 0xd975(%rip), %rsi      # 0xffc8
callq 0x1110
movq %rax, %rdi
leaq 0x7a59(%rip), %rsi      # 0xa0bb
callq 0x10e0
movq %rax, %rdi
movq 0xd957(%rip), %rsi      # 0xffc8
callq 0x1110
movq %rax, %rdi
leaq 0x7a60(%rip), %rsi      # 0xa0e0
callq 0x10e0
movq %rax, %rdi
movq 0xd939(%rip), %rsi      # 0xffc8
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2779
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1390
movq -0x108(%rbp), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movsd -0xe0(%rbp), %xmm0
callq 0x2530
movsd %xmm0, -0x100(%rbp)
jmp 0x2702
movsd -0x100(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
movsd -0xe8(%rbp), %xmm0
movq 0xd8b7(%rip), %rdi      # 0xffd8
callq 0x1190
movq %rax, -0x110(%rbp)
jmp 0x272f
movq -0x110(%rbp), %rdi
movq 0xd88b(%rip), %rsi      # 0xffc8
callq 0x1110
jmp 0x2744
movl $0x0, -0x4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1420
jmp 0x2779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1420
jmp 0x2785
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xf0(%rbp), %rdi
callq 0x1160
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c50
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x1aa52(%rip), %rdi     # 0x1d004
movb $0x0, %al
callq 0x2030
cmpl $0x0, -0xc(%rbp)
je 0x25c8
movl -0xc(%rbp), %eax
movl %eax, 0x22ba4(%rip)     # 0x2516c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x24d9
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x24cc
movb $0x0, -0x1(%rbp)
jmp 0x24dd
jmp 0x24ce
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x24a6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x30f0
movq -0x1d0(%rbp), %rdi
leaq 0x2348(%rip), %rsi      # 0x91a9
movq $-0x1, %rdx
movq %rdx, -0x1c8(%rbp)
callq 0x3410
movq -0x1d0(%rbp), %rdi
movq -0x1c8(%rbp), %rdx
movq %rax, %rsi
incq %rsi
callq 0x3070
jmp 0x6e8f
leaq -0x1c0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x33b0
jmp 0x6ea6
leaq -0x1c0(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x3140
jmp 0x6eb8
movq -0x1c0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1c0(%rbp,%rax), %rdi
callq 0x3430
movb %al, -0x1d1(%rbp)
jmp 0x6ed8
movb -0x1d1(%rbp), %al
testb $0x1, %al
jne 0x6f31
jmp 0x6ee4
movl $0x4, %edi
callq 0x3120
movq %rax, %rdi
movl $0x1, (%rdi)
movq 0x60b2(%rip), %rsi      # 0xcfb0
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
jmp 0x6f70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6f5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3110
jmp 0x6f5e
movl -0xc(%rbp), %eax
movl %eax, -0x1d8(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3110
leaq -0x30(%rbp), %rdi
callq 0x3150
movl -0x1d8(%rbp), %eax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0x38(%rbp), %rdi
callq 0x33e0
// File: 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
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl $0x10, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
movb $0x0, %al
callq 0x31e0
cmpq $0x0, %rax
je 0x6faf
leaq 0x2212(%rip), %rdi      # 0x91b0
callq 0x31c0
movl $0x1, -0x4(%rbp)
jmp 0x7037
movq 0x601a(%rip), %rdi      # 0xcfd0
leaq 0x2201(%rip), %rsi      # 0x91be
callq 0x3230
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x33d0
movq %rax, %rdi
movq 0x5fe9(%rip), %rsi      # 0xcfc0
callq 0x3280
movq %rax, %rdi
leaq 0x21e5(%rip), %rsi      # 0x91cb
callq 0x3230
movq %rax, %rdi
movq 0x5fcb(%rip), %rsi      # 0xcfc0
callq 0x3280
leaq -0xc(%rbp), %rdi
callq 0x3310
movq 0x5fc6(%rip), %rdi      # 0xcfd0
leaq 0x21c9(%rip), %rsi      # 0x91da
callq 0x3230
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x33d0
movq %rax, %rdi
movq 0x5f95(%rip), %rsi      # 0xcfc0
callq 0x3280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl $0x11, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
movb $0x0, %al
callq 0x31e0
cmpq $0x0, %rax
je 0x707c
leaq 0x2175(%rip), %rdi      # 0x91e3
callq 0x31c0
movl $0x1, -0x4(%rbp)
jmp 0x70b0
movq 0x5f4d(%rip), %rdi      # 0xcfd0
leaq 0x2167(%rip), %rsi      # 0x91f1
callq 0x3230
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x33d0
movq %rax, %rdi
movq 0x5f1c(%rip), %rsi      # 0xcfc0
callq 0x3280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3040
movl $0x0, (%rax)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x31e0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $-0x1, %rax
jne 0x7149
callq 0x3040
cmpl $0x0, (%rax)
je 0x7149
leaq 0x20ed(%rip), %rdi      # 0x9200
callq 0x31c0
movl -0x8(%rbp), %esi
movl $0x11, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
movb $0x0, %al
callq 0x31e0
cmpq $0x0, %rax
je 0x7140
leaq 0x20a8(%rip), %rdi      # 0x91e3
callq 0x31c0
movl $0x1, -0x4(%rbp)
jmp 0x7150
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3040
movl $0x0, (%rax)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x5, %edi
movb $0x0, %al
callq 0x31e0
cmpq $-0x1, %rax
jne 0x71ba
callq 0x3040
cmpl $0x0, (%rax)
je 0x71ba
leaq 0x2064(%rip), %rdi      # 0x9210
callq 0x31c0
movl $0x1, -0x4(%rbp)
jmp 0x7237
movq 0x5e0f(%rip), %rdi      # 0xcfd0
leaq 0x2054(%rip), %rsi      # 0x921c
callq 0x3230
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3420
movq %rax, %rdi
leaq 0x1fe3(%rip), %rsi      # 0x91c6
callq 0x3230
movq %rax, %rdi
leaq -0x2312(%rip), %rsi     # 0x4ee0
callq 0x30b0
movq %rax, %rdi
leaq 0x202f(%rip), %rsi      # 0x9230
callq 0x3230
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3080
movq %rax, %rdi
leaq -0x230c(%rip), %rsi     # 0x4f10
callq 0x30b0
movq %rax, %rdi
movq 0x5d95(%rip), %rsi      # 0xcfc0
callq 0x3280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq 0x5c25(%rip), %rdi      # 0xcfd0
leaq 0x1e9c(%rip), %rsi      # 0x924e
callq 0x3230
movq %rax, %rdi
movq 0x5bff(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5c03(%rip), %rdi      # 0xcfd0
leaq 0x1e8d(%rip), %rsi      # 0x9261
callq 0x3230
movq %rax, %rdi
movq 0x5bdd(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5be1(%rip), %rdi      # 0xcfd0
leaq 0x1e8a(%rip), %rsi      # 0x9280
callq 0x3230
movq %rax, %rdi
movq 0x5bbb(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5bbf(%rip), %rdi      # 0xcfd0
leaq 0x1e8c(%rip), %rsi      # 0x92a4
callq 0x3230
movq %rax, %rdi
movq 0x5b99(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5b9d(%rip), %rdi      # 0xcfd0
leaq 0x1e87(%rip), %rsi      # 0x92c1
callq 0x3230
movq %rax, %rdi
movq 0x5b77(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5b7b(%rip), %rdi      # 0xcfd0
leaq 0x1e8b(%rip), %rsi      # 0x92e7
callq 0x3230
movq %rax, %rdi
movq 0x5b55(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5b59(%rip), %rdi      # 0xcfd0
leaq 0x1e8f(%rip), %rsi      # 0x930d
callq 0x3230
movq %rax, %rdi
movq 0x5b33(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5b37(%rip), %rdi      # 0xcfd0
leaq 0x1e98(%rip), %rsi      # 0x9338
callq 0x3230
movq %rax, %rdi
movq 0x5b11(%rip), %rsi      # 0xcfc0
callq 0x3280
movq 0x5b15(%rip), %rdi      # 0xcfd0
leaq 0x1e91(%rip), %rsi      # 0x9353
callq 0x3230
movq %rax, %rdi
movq 0x5aef(%rip), %rsi      # 0xcfc0
callq 0x3280
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x1c(%rbp), %edi
callq 0x6f70
cmpl $0x0, %eax
je 0x754b
movl $0x1, -0x4(%rbp)
jmp 0x761b
movl $0x0, -0x3c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x3c(%rbp), %eax
movq %rax, -0x60(%rbp)
callq 0x57f0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x760c
movq -0x58(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x7910
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x7910
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x75fc
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x70c0
cmpl $0x0, %eax
je 0x75c5
movl $0x1, -0x4(%rbp)
jmp 0x761b
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jne 0x75ee
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7930
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x759d
jmp 0x75fe
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7552
movl -0x1c(%rbp), %edi
callq 0x7040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4a30
movl -0x14(%rbp), %edi
callq 0x6f70
movl %eax, -0x60(%rbp)
jmp 0x7660
movl -0x60(%rbp), %eax
cmpl $0x0, %eax
je 0x7695
movl $0x1, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x776c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4dc0
jmp 0x777e
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b00
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x7745
movl -0x14(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x74e0
movl -0x70(%rbp), %edi
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x70c0
movl %eax, -0x6c(%rbp)
jmp 0x76e4
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
je 0x76fc
movl $0x1, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x776c
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0x7735
movq -0x10(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x74e0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7930
jmp 0x7733
jmp 0x7735
jmp 0x7737
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x769c
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x79a0
jmp 0x7754
movl -0x14(%rbp), %edi
callq 0x7040
jmp 0x775e
movl $0x0, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4dc0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x6f70
cmpl $0x0, %eax
je 0x77c0
movl $0x1, -0x4(%rbp)
jmp 0x784b
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b00
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x783c
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x74e0
movl -0x34(%rbp), %edi
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x70c0
cmpl $0x0, %eax
je 0x7814
movl $0x1, -0x4(%rbp)
jmp 0x784b
movq -0x20(%rbp), %rax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x74e0
movl -0x38(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x7831
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x77c7
movl -0x14(%rbp), %edi
callq 0x7040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x6f70
cmpl $0x0, %eax
je 0x7888
movl $0x1, -0x4(%rbp)
jmp 0x78f8
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b00
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x78e9
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x74e0
movl -0x2c(%rbp), %edi
movq (%rax), %rsi
movslq -0x18(%rbp), %rdx
callq 0x7160
cmpl $0x0, %eax
je 0x78dc
movl $0x1, -0x4(%rbp)
jmp 0x78f8
jmp 0x78de
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x788f
movl -0x14(%rbp), %edi
callq 0x7040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: danfai[P]dboc/main.cpp
// Function: printHelp()
void printHelp() {
    std::cout
        << "Usage: dboc -o <OUTFILE> <INFILE>" << std::endl
        << "Parameter:" << std::endl
        << "  -o <OUTFILE> Specifies the file, where we should output the source code" << std::endl
        << "  <INFILE> Specifies the input file" << std::endl;
    /**
     * accept dboc -d <DIRECTORY> <SOURCE> ...
     * DIRECTORY is target directory
     * SOURCE is the source file, where each source file will be compiled to `basedir SOURCE`/dbo_`filename SOURCE`.cpp
     **/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xaa0d(%rip), %rdi      # 0xdfb8
leaq 0x5a52(%rip), %rsi      # 0x9004
callq 0x3210
movq %rax, %rdi
movq 0xa9c7(%rip), %rsi      # 0xdf88
callq 0x3270
movq %rax, %rdi
leaq 0x5a56(%rip), %rsi      # 0x9026
callq 0x3210
movq %rax, %rdi
movq 0xa9a9(%rip), %rsi      # 0xdf88
callq 0x3270
movq %rax, %rdi
leaq 0x5a43(%rip), %rsi      # 0x9031
callq 0x3210
movq %rax, %rdi
movq 0xa98b(%rip), %rsi      # 0xdf88
callq 0x3270
movq %rax, %rdi
leaq 0x5a6f(%rip), %rsi      # 0x907b
callq 0x3210
movq %rax, %rdi
movq 0xa96d(%rip), %rsi      # 0xdf88
callq 0x3270
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x24(%rax)
je 0x4326
movl $0x8, %edi
callq 0x3120
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3140
movq -0x50(%rbp), %rdi
callq 0x4450
movq -0x50(%rbp), %rdi
leaq 0x9a16(%rip), %rsi      # 0xdd30
leaq 0x16f(%rip), %rdx       # 0x4490
callq 0x3390
movq -0x38(%rbp), %rdi
movl 0x20(%rdi), %eax
movl %eax, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4393
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
incl %ecx
movl %ecx, 0x20(%rax)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x33d0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x4d77(%rip), %rsi      # 0x90db
callq 0x39b0
jmp 0x436b
leaq -0x11(%rbp), %rdi
callq 0x3290
jmp 0x4439
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x3290
jmp 0x4443
movq -0x38(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movl 0x20(%rdi), %eax
movl %eax, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x441a
movq -0x38(%rbp), %rdi
movl 0x20(%rdi), %eax
movl %eax, %esi
callq 0x3450
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4409
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl 0x20(%rsi), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsi)
movb $0x0, -0x29(%rbp)
movslq -0x28(%rbp), %rdx
movl 0x20(%rsi), %eax
subl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
callq 0x3250
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x4407
movq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x4439
jmp 0x440b
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x439d
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl $0x1, 0x24(%rsi)
movslq -0x28(%rbp), %rdx
movq $-0x1, %rcx
callq 0x3250
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33b0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rsi, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x280(%rbp)
movq %rdi, %rax
movq %rax, -0x278(%rbp)
callq 0x54f0
movq -0x270(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3370
jmp 0x456e
leaq -0x248(%rbp), %rdi
callq 0x3310
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3070
movq %rax, -0x288(%rbp)
jmp 0x4596
movq -0x288(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32f0
movb %al, -0x289(%rbp)
jmp 0x45b4
movb -0x289(%rbp), %al
testb $0x1, %al
jne 0x45c3
jmp 0x465e
leaq -0x248(%rbp), %rdi
callq 0x31a0
cmpq $0x0, %rax
jbe 0x4659
leaq -0x268(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3100
jmp 0x45ee
movq -0x278(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x46b0
jmp 0x4603
leaq -0x268(%rbp), %rdi
callq 0x3180
jmp 0x4659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x4697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x467f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x3180
jmp 0x467f
jmp 0x457a
leaq -0x248(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x248(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
movq -0x280(%rbp), %rdi
callq 0x3a80
movq -0x220(%rbp), %rdi
callq 0x33b0
nop