LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: burakbugrul[P]NginxLogParser/NginxParser.cpp
// Function: NginxParser::findCharacter(char*, int, int, char)
inline int NginxParser::findCharacter(char *line, int begin, int length, char character){
	
	for( int i=begin ; i<length ; i++ )
		if( line[i] == character )
			return i;
	
	return length;
}

// Assembly:
movb %r8b, %al
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl %ecx, -0x20(%rsp)
movb %al, -0x21(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x20(%rsp), %eax
jge 0x4f7b
movq -0x18(%rsp), %rax
movslq -0x28(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x21(%rsp), %ecx
cmpl %ecx, %eax
jne 0x4f6c
movl -0x28(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x4f83
jmp 0x4f6e
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x4f41
movl -0x20(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: brianwu02[P]ImageProcessing/sharpen.cpp
// Function: clip(int)
int clip(int a) {
    if (a >= 255) {
        return 255;
    } else if (a <= 0) {
        return 0;
    } else {
        return a;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xff, -0x8(%rbp)
jl 0x1c19
movl $0xff, -0x4(%rbp)
jmp 0x1c2e
cmpl $0x0, -0x8(%rbp)
jg 0x1c28
movl $0x0, -0x4(%rbp)
jmp 0x1c2e
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dekanfrus[P]pThreads/osproj2a.c
// Function: compute_pi(void*)
void *compute_pi( void *s )
{
  unsigned int seed;
  int ii;
  int *hit_pointer;
  int local_hits;
  double rand_no_x;
  double rand_no_y;

  hit_pointer = (int *) s;
  seed = *hit_pointer;
  local_hits = 0;


  for( ii=0; ii < sample_points_per_thread; ii++ )
    {
	  
      rand_no_x = (double) (rand_r( &seed ))/(double)RAND_MAX;
      rand_no_y = (double) (rand_r( &seed ))/(double)RAND_MAX;
      if(((rand_no_x - 0.5) * (rand_no_x - 0.5) +
	  (rand_no_y - 0.5) * (rand_no_y - 0.5)) < 0.25)
	local_hits++;
      seed *= ii;
	  
    }

  *hit_pointer = local_hits;
  pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x34cc(%rip), %eax      # 0x4890
jge 0x1485
leaq -0xc(%rbp), %rdi
callq 0x1070
cvtsi2sd %eax, %xmm0
movsd 0xc49(%rip), %xmm1      # 0x2028
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1070
cvtsi2sd %eax, %xmm0
movsd 0xc2b(%rip), %xmm1      # 0x2028
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
movsd 0xc0d(%rip), %xmm0      # 0x2020
subsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm2
movsd 0xbfc(%rip), %xmm0      # 0x2020
subsd %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
movsd 0xbeb(%rip), %xmm3      # 0x2020
subsd %xmm3, %xmm0
movsd -0x30(%rbp), %xmm3
movsd 0xbda(%rip), %xmm4      # 0x2020
subsd %xmm4, %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xbba(%rip), %xmm0      # 0x2018
ucomisd %xmm1, %xmm0
jbe 0x146d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13bb
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x10a0
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: Context::Context(char*, int)
Context::Context(char *cursor, int length) : start(0), strls(false)
{
  this->origin = cursor;
  this->cursor = cursor;
  this->length = length;
  this->currentState = new OpenDTA();
  this->buffer = new char[INITIAL_BUFFER];
  this->buffer_size = INITIAL_BUFFER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq 0x1d0fe(%rip), %rax     # 0x31ff0
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x14030
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x30(%rbp)
callq 0x14500
jmp 0x14f15
movq -0x38(%rbp), %rdi
movb $0x0, 0xb0(%rdi)
addq $0xc0, %rdi
movq %rdi, -0x58(%rbp)
callq 0x18280
movq -0x38(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x182a0
movq -0x38(%rbp), %rax
movq $0x0, 0x108(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x100(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x110(%rax)
movl $0x8, %edi
callq 0x8430
movq %rax, -0x48(%rbp)
jmp 0x14f82
movq -0x48(%rbp), %rdi
movq $0x0, (%rdi)
callq 0x182c0
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xa8(%rax)
movl $0x400, %edi            # imm = 0x400
callq 0x8030
movq %rax, -0x60(%rbp)
jmp 0x14fb1
movq -0x38(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0xf0(%rax)
movl $0x400, 0xf8(%rax)      # imm = 0x400
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15005
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x18300
movq -0x58(%rbp), %rdi
callq 0x18360
movq -0x30(%rbp), %rdi
callq 0x14570
movq -0x40(%rbp), %rdi
callq 0x140e0
movq -0x20(%rbp), %rdi
callq 0x87c0
nopw (%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: Context::~Context()
Context::~Context()
{
  if (currentState)
    delete currentState;
  
  if (buffer)
    delete buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1cfa5(%rip), %rcx     # 0x31fe0
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0xa8(%rax)
je 0x1506d
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1506b
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x1506d
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x150a0
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1509e
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x8440
jmp 0x150a0
movq -0x10(%rbp), %rdi
addq $0xd8, %rdi
callq 0x18300
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0x18360
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x14570
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x140e0
addq $0x20, %rsp
popq %rbp
retq
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: Context::exportToDB(DatabaseTypes, void*)
int Context::exportToDB(DatabaseTypes db_type, void * params)
{
  Database * db_obj = NULL;

  switch(db_type) 
  {
    case SQLITE:
        db_obj = (Database *)new SQLite();
        break;
  }


  if (db_obj)
  {
      if (db_obj->connect((char*)params))
      {
        /* start writing the database */
        db_obj->write(*this);

        /* finished */
        db_obj->close();
      }

      delete db_obj;
      db_obj = NULL;
  }
  else
  {
    cout << "Couldn't create a database object to export the database"  << endl;
    return 0;
  }
 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %eax
testl %eax, %eax
jne 0x15180
jmp 0x1513c
movl $0x10, %edi
callq 0x8430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x1f8d0
jmp 0x15157
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x15180
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x8440
jmp 0x15200
cmpq $0x0, -0x20(%rbp)
je 0x151d4
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x1519a
jmp 0x151b2
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x151ca
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, -0x20(%rbp)
jmp 0x151fe
movq 0x1dde5(%rip), %rdi     # 0x32fc0
leaq 0xc728(%rip), %rsi      # 0x2190a
callq 0x8420
movq %rax, %rdi
movq 0x1dd87(%rip), %rsi     # 0x32f78
callq 0x8480
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
ud2
movq -0x28(%rbp), %rdi
callq 0x87c0
nopl (%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: Context::advanceData(int)
void Context::advanceData(int c)
{
  int curr_length=0, curr_position = 0;
  char *prev_cursor = cursor;
 
  for (start = cursor; curr_position <= c; cursor++, curr_position++);
 
  curr_length = cursor - prev_cursor;

  if (curr_length > buffer_size)
    resizeBuffer(curr_length);

  memset(buffer, 0, buffer_size);
  strncpy(buffer, start, curr_length);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x100(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x100(%rax), %rcx
movq %rcx, 0x108(%rax)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x15279
jmp 0x15258
movq -0x28(%rbp), %rax
movq 0x100(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x100(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1524e
movq -0x28(%rbp), %rcx
movq 0x100(%rcx), %rax
movq -0x20(%rbp), %rdx
subq %rdx, %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0xf8(%rcx), %eax
jle 0x152a5
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x183c0
movq -0x28(%rbp), %rax
movq 0xf0(%rax), %rdi
movslq 0xf8(%rax), %rdx
xorl %esi, %esi
callq 0x8240
movq -0x28(%rbp), %rax
movq 0xf0(%rax), %rdi
movq 0x108(%rax), %rsi
movslq -0x10(%rbp), %rdx
callq 0x8210
addq $0x30, %rsp
popq %rbp
retq
nop
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: Context::advanceNoState()
void Context::advanceNoState()
{
  int curr_length=0;
  int i = 0;


  for (start = cursor; cursor && (cursor - origin) < length && *cursor != '>'; cursor++);

  if (cursor && *cursor++ == '>')
  {
    curr_length = cursor - start;
        
    if (curr_length > buffer_size)
      resizeBuffer(curr_length);

    memset(buffer, 0, buffer_size);
    strncpy(buffer, start, curr_length);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x100(%rax), %rcx
movq %rcx, 0x108(%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x100(%rcx)
movb %al, -0x19(%rbp)
je 0x15360
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rcx
movq 0xb8(%rax), %rdx
subq %rdx, %rcx
movslq 0x110(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jge 0x15360
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x15369
jmp 0x15383
jmp 0x1536b
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x100(%rax)
jmp 0x15310
movq -0x18(%rbp), %rax
cmpq $0x0, 0x100(%rax)
je 0x15419
movq -0x18(%rbp), %rcx
movq 0x100(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x100(%rcx)
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x15419
movq -0x18(%rbp), %rcx
movq 0x100(%rcx), %rax
movq 0x108(%rcx), %rdx
subq %rdx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xf8(%rcx), %eax
jle 0x153e5
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x183c0
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rdi
movslq 0xf8(%rax), %rdx
xorl %esi, %esi
callq 0x8240
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rdi
movq 0x108(%rax), %rsi
movslq -0xc(%rbp), %rdx
callq 0x8210
addq $0x20, %rsp
popq %rbp
retq
nop
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: Context::advance()
void * Context::advance()
{
  advanceNoState();

  while (currentState && currentState->check(buffer))
  {
      currentState->process(*this);

      if (currentState)
      {
        State * newState = currentState->advanceState();
        delete currentState;
        currentState = newState;
      }
  }
  
  return (void *)(start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x152e0
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xa8(%rcx)
movb %al, -0x19(%rbp)
je 0x154a7
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rdi
movq 0xf0(%rax), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x154b0
jmp 0x15519
movq -0x18(%rbp), %rsi
movq 0xa8(%rsi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x15514
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq 0xa8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x15505
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xa8(%rax)
jmp 0x15479
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenRelease::process(Context&)
bool OpenRelease::process(Context &ctx)
{
  string version = ctx.getChars(3);
 
  switch (strtol(version.c_str(), NULL, 10))
  {
  case 119:
  case 118:
    ctx.hdr.fileRelease = R119;
    break;
  case 117:
    ctx.hdr.fileRelease = R117;
    break;

  default:
    ctx.hdr.fileRelease = R117;
    break;
  }

  ctx.advance(); // CONTENT
  ctx.advance(); // </release>
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x3, %edx
callq 0x184f0
movq -0x50(%rbp), %rdi
callq 0x8190
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x8660
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
subq $0x75, %rax
je 0x156ec
jmp 0x156cf
movq -0x48(%rbp), %rax
addq $-0x76, %rax
subq $0x1, %rax
ja 0x156f9
jmp 0x156df
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
jmp 0x15704
movq -0x10(%rbp), %rax
movl $0x2, 0x60(%rax)
jmp 0x15704
movq -0x10(%rbp), %rax
movl $0x2, 0x60(%rax)
movq -0x10(%rbp), %rdi
callq 0x15460
jmp 0x1570f
movq -0x10(%rbp), %rdi
callq 0x15460
jmp 0x1571a
leaq -0x30(%rbp), %rdi
callq 0x8280
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8280
movq -0x38(%rbp), %rdi
callq 0x87c0
nopl (%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenByteOrder::process(Context&)
bool OpenByteOrder::process(Context &ctx)
{
  string byteOrder = ctx.getChars(3);

  if (!strcasecmp(byteOrder.c_str(), XML_LSF))
    ctx.hdr.fileByteorder = LSF;
  else
    ctx.hdr.fileByteorder = MSF;

  ctx.advance(); // ORDER
  ctx.advance(); // </byteorder>
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x3, %edx
callq 0x184f0
leaq -0x30(%rbp), %rdi
callq 0x8190
movq %rax, %rdi
leaq 0xc17e(%rip), %rsi      # 0x21943
callq 0x84d0
cmpl $0x0, %eax
jne 0x157dc
movq -0x10(%rbp), %rax
movl $0x0, 0x64(%rax)
jmp 0x157e7
movq -0x10(%rbp), %rax
movl $0x1, 0x64(%rax)
movq -0x10(%rbp), %rdi
callq 0x15460
jmp 0x157f2
movq -0x10(%rbp), %rdi
callq 0x15460
jmp 0x157fd
leaq -0x30(%rbp), %rdi
callq 0x8280
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8280
movq -0x38(%rbp), %rdi
callq 0x87c0
nop
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenK::process(Context&)
bool OpenK::process(Context &ctx)
{

  if (ctx.hdr.fileByteorder == LSF)
  {
    char *ctxbuf = (char *)ctx.advance();

   

    switch (ctx.hdr.fileRelease)
    {
    // 4 byte
    case R119:
      if (ctxbuf[2] == '<' && ctxbuf[3] == '/')
        ctx.hdr.variables = GetLSF<uint16_t>(ctxbuf, 2);
      else 
        ctx.hdr.variables = GetLSF<uint32_t>(ctxbuf, 4);
      break;

    // 2 byte
    case R118:
    case R117:
      ctx.hdr.variables = GetLSF<uint16_t>(ctxbuf, 2);
      break;

    default:

      break;
    }
  }
  else
  {
    // MSF not implemented yet
  }

  ctx.advance();

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x15922
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x158b7
jmp 0x158ab
movl -0x1c(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x15904
jmp 0x1591e
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x3c, %eax
jne 0x158eb
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x2f, %eax
jne 0x158eb
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x18620
movzwl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x15902
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x18690
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x15920
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x18620
movzwl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x15920
jmp 0x15920
jmp 0x15924
jmp 0x15924
movq -0x10(%rbp), %rdi
callq 0x15460
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenN::process(Context&)
bool OpenN::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();

  if (ctx.hdr.fileByteorder == LSF)
  {
    switch (ctx.hdr.fileRelease)
    {
    // 8 byte
    case R119:
    case R118:
      ctx.hdr.observations = GetLSF<uint64_t>(ctxbuf, 8);
      break;

    // 4 byte
    case R117:
      ctx.hdr.observations = GetLSF<uint32_t>(ctxbuf, 4);
      break;

    default:
      break;
    }
  }
  else
  {
    // MSF not implemented yet
  }


  ctx.advance();
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x159fd
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
jb 0x159c2
jmp 0x159b8
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x159dd
jmp 0x159f9
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x18740
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x159fb
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x18690
movl %eax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x159fb
jmp 0x159fb
jmp 0x159ff
jmp 0x159ff
movq -0x10(%rbp), %rdi
callq 0x15460
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenLabel::process(Context&)
bool OpenLabel::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();
  int label_count = 0;

  if (ctx.hdr.fileByteorder == LSF)
  {
    switch (ctx.hdr.fileRelease)
    {
    case R119:
    case R118:
      label_count = GetLSF<int16_t>(ctxbuf, 2);
      ctx.hdr.datalabel.assign(&ctxbuf[2], label_count);
      break;

    case R117:
      label_count = GetLSF<int8_t>(ctxbuf, 1);
      ctx.hdr.datalabel.assign(&ctxbuf[1], label_count);
      break;

    default:
      break;
    }
  }
  else
  {
    // not implemented yet
  }

  ctx.advance();

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x15b15
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x2, %eax
jb 0x15aad
jmp 0x15aa3
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x15ade
jmp 0x15b11
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x187f0
cwtl
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x85d0
jmp 0x15b13
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x18860
movsbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x85d0
jmp 0x15b13
jmp 0x15b13
jmp 0x15b17
jmp 0x15b17
movq -0x10(%rbp), %rdi
callq 0x15460
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenTimeStamp::process(Context&)
bool OpenTimeStamp::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();
  int label_count = 0;

  switch (ctx.hdr.fileRelease)
  {

  case R119:
  case R118:
  case R117:
    label_count = GetLSF<int8_t>(ctxbuf, 1);
    ctx.hdr.ts.assign(&ctxbuf[1], label_count);
    break;
  case R115:
  case R114:
  case R113:
  case R112:
    break;
  }

  ctx.advance();
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x3, %eax
jb 0x15bb2
jmp 0x15ba5
movl -0x20(%rbp), %eax
addl $-0x3, %eax
subl $0x4, %eax
jb 0x15be5
jmp 0x15be7
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x18860
movsbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x85d0
jmp 0x15be7
jmp 0x15be7
movq -0x10(%rbp), %rdi
callq 0x15460
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenVarNames::process(Context&)
bool OpenVarNames::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();
  int sz = 0;
  int curr = 0;

  if (ctx.hdr.fileByteorder == LSF)
  {

    while (*ctxbuf != '<')
    {

      switch (ctx.hdr.fileRelease)
      {
      // UTF-8
      case R119:
      case R118:
        sz = strlen(ctxbuf);
        /*wcslen((wchar_t *)ctxbuf);*/
        (ctx.vList.at(curr))->varname.assign(&ctxbuf[0], sz);
        cout <<  (ctx.vList.at(curr))->varname << endl;
        ctxbuf += 129;
        break;
      // ASCII
      case R117:
        sz = strlen(ctxbuf);
        (ctx.vList.at(curr))->varname.assign(&ctxbuf[0], sz);
        ctxbuf += 33;
        break;

      case R115:
      case R114:
      case R113:
      case R112:
        break;
      }

      curr++;
    }
  }
  else
  {
    // not implemented yet
  }

  ctx.advance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x16d48
jmp 0x16c2b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0x16d46
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
jb 0x16c6e
jmp 0x16c4c
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x16cf0
jmp 0x16c5a
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x4, %eax
jb 0x16d36
jmp 0x16d38
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x20(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x85d0
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x20(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rsi
movq 0x1c2f4(%rip), %rdi     # 0x32fc0
callq 0x83d0
movq %rax, %rdi
movq 0x1c29d(%rip), %rsi     # 0x32f78
callq 0x8480
movq -0x18(%rbp), %rax
addq $0x81, %rax
movq %rax, -0x18(%rbp)
jmp 0x16d38
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x20(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x85d0
movq -0x18(%rbp), %rax
addq $0x21, %rax
movq %rax, -0x18(%rbp)
jmp 0x16d38
jmp 0x16d38
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x16c2b
jmp 0x16d4a
jmp 0x16d4a
movq -0x10(%rbp), %rdi
callq 0x15460
ud2
nopw %cs:(%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenFormats::process(Context&)
bool OpenFormats::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();
  int curr = 0, sz = 0;

  if (ctx.hdr.fileByteorder == LSF)
  {

    while (*ctxbuf != '<')
    {

      switch (ctx.hdr.fileRelease)
      {
      // UTF-8
      case R119:
      case R118:
        //sz = wcslen((wchar_t *)ctxbuf);
        sz = strlen((char *)ctxbuf);
        (ctx.vList.at(curr))->format.assign(&ctxbuf[0], sz);
        // cout << (ctx.vList.at(curr))->format << endl;
        ctxbuf += 57;
        break;

      // ASCII
      case R117:
        sz = strlen((char *)ctxbuf);
        (ctx.vList.at(curr))->format.assign(&ctxbuf[0], sz);
        //cout << (ctx.vList.at(curr))->format << endl;
        ctxbuf += 49;
        break;

      case R115:
      case R114:
      case R113:
      case R112:
        break;
      }

      curr++;
    }
  }
  else
  {
    // not implemented yet
  }

  ctx.advance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x16f30
jmp 0x16e4b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0x16f2e
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
jb 0x16e8a
jmp 0x16e6c
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x16ed4
jmp 0x16e76
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x4, %eax
jb 0x16f1e
jmp 0x16f20
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x85d0
movq -0x18(%rbp), %rax
addq $0x39, %rax
movq %rax, -0x18(%rbp)
jmp 0x16f20
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x85d0
movq -0x18(%rbp), %rax
addq $0x31, %rax
movq %rax, -0x18(%rbp)
jmp 0x16f20
jmp 0x16f20
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16e4b
jmp 0x16f32
jmp 0x16f32
movq -0x10(%rbp), %rdi
callq 0x15460
ud2
nopl (%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenValueLabelNames::process(Context&)
bool OpenValueLabelNames::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();
  int curr = 0, sz = 0;

  if (ctx.hdr.fileByteorder == LSF)
  {

    while (*ctxbuf != '<')
    {

      switch (ctx.hdr.fileRelease)
      {
      // UTF-8
      case R119:
      case R118:
        //sz = wcslen((wchar_t *)ctxbuf);
        sz = strlen((char *)ctxbuf);
        (ctx.vList.at(curr))->vallbl.assign(&ctxbuf[0], sz);
        ctxbuf += 129;
        break;

      // ASCII
      case R117:
        sz = strlen((char *)ctxbuf);
        (ctx.vList.at(curr))->vallbl.assign(&ctxbuf[0], sz);
        ctxbuf += 33;
        break;

      case R115:
      case R114:
      case R113:
      case R112:
        break;
      }

      curr++;
    }
  }
  else
  {
    // not implemented yet
  }

  ctx.advance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x170a2
jmp 0x16fbb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
je 0x170a0
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
jb 0x16ffa
jmp 0x16fdc
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x17046
jmp 0x16fe6
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x4, %eax
jb 0x17090
jmp 0x17092
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x85d0
movq -0x18(%rbp), %rax
addq $0x81, %rax
movq %rax, -0x18(%rbp)
jmp 0x17092
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x85d0
movq -0x18(%rbp), %rax
addq $0x21, %rax
movq %rax, -0x18(%rbp)
jmp 0x17092
jmp 0x17092
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16fbb
jmp 0x170a4
jmp 0x170a4
movq -0x10(%rbp), %rdi
callq 0x15460
ud2
nop
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenVariableLabels::process(Context&)
bool OpenVariableLabels::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();
  int curr = 0, sz = 0;

  if (ctx.hdr.fileByteorder == LSF)
  {

    while (*ctxbuf && *ctxbuf != '<')
    {

      switch (ctx.hdr.fileRelease)
      {
      case R119:
      case R118:

        if (ctxbuf[0] != 0)
        {
          //sz = wcslen((wchar_t *)ctxbuf);
          sz = strlen((char *)ctxbuf);
          (ctx.vList.at(curr))->varlbl.assign(&ctxbuf[0], sz);
        }

        ctxbuf += 321;
        break;

      case R117:

        if (ctxbuf[0] != 0)
        {
          sz = strlen((char *)ctxbuf);
          (ctx.vList.at(curr))->varlbl.assign(&ctxbuf[0], sz);
        }

        ctxbuf += 81;
        break;

      default:
        break;
      }

      curr++;
    }
  }
  else
  {
    // not implemented yet
  }

  ctx.advance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x17233
jmp 0x1712b
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x17149
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x17155
jmp 0x17231
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x2, %eax
jb 0x17173
jmp 0x17166
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x171cb
jmp 0x17221
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x171bb
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x85d0
movq -0x18(%rbp), %rax
addq $0x141, %rax            # imm = 0x141
movq %rax, -0x18(%rbp)
jmp 0x17223
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17213
movq -0x18(%rbp), %rdi
callq 0x81c0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x19060
movq %rax, %rdi
callq 0x190a0
movq %rax, %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x85d0
movq -0x18(%rbp), %rax
addq $0x51, %rax
movq %rax, -0x18(%rbp)
jmp 0x17223
jmp 0x17223
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1712b
jmp 0x17235
jmp 0x17235
movq -0x10(%rbp), %rdi
callq 0x15460
ud2
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenCharacteristics::process(Context&)
bool OpenCharacteristics::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.getCursor();

  if (ctxbuf[0] == '<' && ctxbuf[1] == '/')
  {
    setHasCharacteristics(false);
    ctx.advance();
    ctx.advance();
  }
  else
  {
    setHasCharacteristics(true);
    ctx.advanceNoState();
  }
}

// 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 -0x10(%rbp), %rdi
callq 0x19290
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x1732d
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x1732d
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x192b0
movq -0x10(%rbp), %rdi
callq 0x15460
movq -0x10(%rbp), %rdi
callq 0x15460
jmp 0x17344
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x192b0
movq -0x10(%rbp), %rdi
callq 0x152e0
ud2
nopw %cs:(%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenCH::process(Context&)
bool OpenCH::process(Context &ctx)
{
  char *ctxbuf = ctx.getCursor();
  int count = 0;

  if (ctx.hdr.fileByteorder == LSF)
  {

    while (ctxbuf)
    {

      if (ctxbuf[0] == '<' &&
          ctxbuf[1] == '/' &&
          ctxbuf[2] == 'c' &&
          ctxbuf[3] == 'h' &&
          ctxbuf[4] == '>' &&
          ctxbuf[5] == '<')
      {
        ctx.advanceCursor(count);
        ctxbuf = ctx.getCursor();
        return true;
      }

      ctxbuf++;
      count++;
    }
  }
  else
  {
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19290
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x1745b
jmp 0x173c4
cmpq $0x0, -0x18(%rbp)
je 0x17459
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x1743f
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x1743f
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x63, %eax
jne 0x1743f
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x68, %eax
jne 0x1743f
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x3e, %eax
jne 0x1743f
movq -0x18(%rbp), %rax
movsbl 0x5(%rax), %eax
cmpl $0x3c, %eax
jne 0x1743f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15420
movq -0x10(%rbp), %rdi
callq 0x19290
movq %rax, -0x18(%rbp)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x173c4
jmp 0x1745d
jmp 0x1745d
ud2
nop
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: CloseCH::process(Context&)
bool CloseCH::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();

  if (ctxbuf[0] == '<' && ctxbuf[1] == 'c' && ctxbuf[2] == 'h' && ctxbuf[3] == '>')
    setHasCharacteristics(true);
  else
  {
    setHasCharacteristics(false);
    ctx.advance();
  }
}

// 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 -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x17558
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x63, %eax
jne 0x17558
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x68, %eax
jne 0x17558
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x3e, %eax
jne 0x17558
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x19330
jmp 0x1756c
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x19330
movq -0x10(%rbp), %rdi
callq 0x15460
ud2
nop
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenSTRL::process(Context&)
bool OpenSTRL::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();

  if (!ctx.strls)
  {
    cout << "no strls, next" << endl;
    return ctx.advance() && true;
  }
  else
  {
    // not implemented
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15460
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x17b24
movq 0x1b4df(%rip), %rdi     # 0x32fc0
leaq 0x9f2d(%rip), %rsi      # 0x21a15
callq 0x8420
movq %rax, %rdi
movq 0x1b481(%rip), %rsi     # 0x32f78
callq 0x8480
movq -0x18(%rbp), %rdi
callq 0x15460
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
je 0x17b1a
movb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x17b1a
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x17b2a
jmp 0x17b26
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: maplechori[P]stata-reader-writer/State.cpp
// Function: OpenValueLabel::process(Context&)
bool OpenValueLabel::process(Context &ctx)
{
  char *ctxbuf = (char *)ctx.advance();

  if (ctxbuf[0] == '<' && ctxbuf[1] == '/')
    setHasLabels(false);
  else
    setHasLabels(true);
}

// 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 -0x10(%rbp), %rdi
callq 0x15460
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x17c1b
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x17c1b
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x196e0
jmp 0x17c29
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x196e0
ud2
nopl (%rax,%rax)
// File: maplechori[P]stata-reader-writer/./State.h
// Function: Context::getChars[abi:cxx11](int)
string getChars(int count)
  {
    string tmp;
    tmp.assign(cursor, count);
    cursor += count;
    return tmp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x8630
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x100(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x85d0
jmp 0x18539
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %edx
movq 0x100(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x100(%rax)
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x18580
jmp 0x18577
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8280
jmp 0x1858a
movq -0x30(%rbp), %rdi
callq 0x8280
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x87c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: maplechori[P]stata-reader-writer/./StateBitops.h
// Function: unsigned short GetLSF<unsigned short>(char*, int)
T GetLSF(char * ctxbuf, int size)
{
    int i, j;
    T currValue = 0;

    for (i=0, j=0; i < size; i++, j += 8)
        currValue  |= ((ctxbuf[i] << j) & (0xFF << j));
        

    return currValue;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw $0x0, -0x16(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x18688
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
movl $0xff, %eax
shll %cl, %eax
movl -0x1c(%rbp), %ecx
andl %eax, %ecx
movzwl -0x16(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rbp)
jmp 0x1863f
movw -0x16(%rbp), %ax
popq %rbp
retq
nop
// File: maplechori[P]stata-reader-writer/StateBitops.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> GetLSF<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char*, int)
string GetLSF<string>(char * ctxbuf, int size)
{
    string _st;
    char * c = ctxbuf;
    int inner_size = 0;

    while(c && *c && inner_size < size)
    {
        inner_size++;
        c++;
    }

    if (inner_size < size)
        memset(&ctxbuf[inner_size], 0, size - inner_size);

    _st.assign(ctxbuf, size);
    return _st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x8630
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x49(%rbp)
je 0x1f7ec
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x49(%rbp)
je 0x1f7ec
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x1f7f5
jmp 0x1f80c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1f7c6
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1f82f
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movl -0x14(%rbp), %eax
subl -0x24(%rbp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x8240
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x85d0
jmp 0x1f842
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1f86e
jmp 0x1f865
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8280
jmp 0x1f878
movq -0x48(%rbp), %rdi
callq 0x8280
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x87c0
nopw %cs:(%rax,%rax)
// File: maplechori[P]stata-reader-writer/SQLite.cpp
// Function: SQLite::connect(void*)
bool SQLite::connect(void * ptr) {

    char *zErrMsg = 0;
    int rc;
    char * filename = (char *)ptr;
  
    rc = sqlite3_open(filename, &db);
    
    if (rc)
    {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      sqlite3_close(db);
      return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rsi
callq 0x87a0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x20c11
movq -0x38(%rbp), %rax
movq 0x123ef(%rip), %rcx     # 0x32fc8
movq (%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rdi
callq 0x8410
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x1738(%rip), %rsi      # 0x2232f
movb $0x0, %al
callq 0x8670
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8200
movb $0x0, -0x1(%rbp)
jmp 0x20c15
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::FetchDict(char const*)
ChUTF8* RNNet::FetchDict(const char* pathRoot){

    char* path=(char*)calloc(sizeof(char),41);
    strcpy(path,pathRoot);
    strcpy(path+strlen(pathRoot),"DICT");
    
    ChUTF8* ret;
    std::cout<< path<<std::endl;
    FILE* dicfp=fopen(path,"r");
    FILE* dictmp=fopen("dictmp","w");
    ret=fldDic(dicfp,featureNUM);
    prtHash2File(ret,dictmp,featureNUM);
    free(path);
    ccdict=ret;
    return ret;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, %edi
movl $0x29, %esi
callq 0x20b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2120
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2070
movq -0x40(%rbp), %rdi
addq %rax, %rdi
leaq 0x58bf(%rip), %rsi      # 0x8056
callq 0x2120
movq -0x18(%rbp), %rsi
movq 0x8831(%rip), %rdi      # 0xafd8
callq 0x2140
movq %rax, %rdi
movq 0x880a(%rip), %rsi      # 0xafc0
callq 0x2170
movq -0x18(%rbp), %rdi
leaq 0x58aa(%rip), %rsi      # 0x8070
callq 0x2190
movq %rax, -0x28(%rbp)
leaq 0x58a0(%rip), %rdi      # 0x8076
leaq 0x5883(%rip), %rsi      # 0x8060
callq 0x2190
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl 0x30(%rax), %esi
callq 0x6df0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl 0x30(%rax), %edx
callq 0x7030
movq -0x18(%rbp), %rdi
callq 0x21a0
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::_save_var(char const*)
void RNNet::_save_var(const char* pathRoot){
    char* pdic=(char*)calloc(sizeof(char),41);
    char* ppar=(char*)calloc(sizeof(char),41);
    int pathrootlen = strlen(pathRoot);
    strcpy(pdic,pathRoot);
    strcpy(ppar,pathRoot);
    strcpy(pdic+pathrootlen,"DICT");
    strcpy(ppar+pathrootlen,"PARA");
    
    FILE* fp = fopen(pdic,"w");
    prtHash2File(ccdict,fp,featureNUM);
    prtPara(ppar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, %edi
movl $0x29, %esi
callq 0x20b0
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x29, %esi
callq 0x20b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2070
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2120
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2120
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
leaq 0x5370(%rip), %rsi      # 0x8056
callq 0x2120
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
leaq 0x535e(%rip), %rsi      # 0x805b
callq 0x2120
movq -0x18(%rbp), %rdi
leaq 0x5353(%rip), %rsi      # 0x8060
callq 0x2190
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movl 0x30(%rax), %edx
callq 0x7030
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2db0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::Save2txt(char const*)
void RNNet::Save2txt(const char* pathRoot){
    // char* pdic=(char*)calloc(sizeof(char),41);
    // char* ppar=(char*)calloc(sizeof(char),41);
    // int pathrootlen = strlen(pathRoot);
    // strcpy(pdic,pathRoot);
    // strcpy(ppar,pathRoot);
    // //Dictionary/CROSS
    // strcpy(pdic+pathrootlen,"Dictionary/CROSSDICT");
    // strcpy(ppar+pathrootlen,"Dictionary/CROSSPARA");

    // FILE* fp = fopen(pdic,"w");
    // prtHash2File(ccdict,fp,featureNUM);
    // prtPara(ppar);
    char* path=(char*)calloc(sizeof(char),41);
    int pathrootlen = strlen(pathRoot);
    strcpy(path,pathRoot);
    strcpy(path+pathrootlen,"Dictionary/CROSS");
    _save_var(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
movl $0x29, %esi
callq 0x20b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2070
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2120
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
leaq 0x52a5(%rip), %rsi      # 0x803b
callq 0x2120
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c70
addq $0x30, %rsp
popq %rbp
retq
nop
// File: huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::RNNForward_CROSSENTROPY(char const*)
double RNNet::RNNForward_CROSSENTROPY(const char* pathRoot){

    int pathrootlen=strlen(pathRoot);
    char* psen=(char*)calloc(sizeof(char),41);
    strcpy(psen,pathRoot);
    strcpy(psen+pathrootlen,"Material/");
    FreeSen();
    Sentence sentmp=FetchSent(psen);
    free(psen);
    
    while(sentmp){
        _Forward_CROSSENTROPY(sentmp);
        sentmp=sentmp->next;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2070
movl %eax, -0x14(%rbp)
movl $0x1, %edi
movl $0x29, %esi
callq 0x20b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2120
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
leaq 0x4bf5(%rip), %rsi      # 0x80bb
callq 0x2120
movq -0x30(%rbp), %rdi
callq 0x3520
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3050
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x21a0
cmpq $0x0, -0x28(%rbp)
je 0x3510
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x36f0
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x34ee
xorps %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)