LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x64(%rsi)
jne 0xaade
movq %rbx, %rdi
callq 0xa876
movl 0x60(%rbx), %ecx
leal -0x1(%rcx), %edx
cmpl $0x2, %edx
jae 0xaac0
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0xbd76
movzwl %ax, %eax
jmp 0xaadb
testl %ecx, %ecx
jne 0xaade
cmpb $0x3c, 0x2(%rax)
jne 0xaad0
cmpb $0x2f, 0x3(%rax)
je 0xaab0
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0xbd9e
movl %eax, 0x10(%rbx)
movq %rbx, %rdi
callq 0xa876
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xa876
cmpl $0x0, 0x64(%rbx)
jne 0xabc8
movq %rax, %r14
cmpl $0x2, 0x60(%rbx)
jae 0xaba8
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xbdf2
leaq 0x40(%rbx), %rdi
addq $0x2, %r14
movswq %ax, %rdx
jmp 0xabc0
jne 0xabc8
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xbe1a
leaq 0x40(%rbx), %rdi
incq %r14
movsbq %al, %rdx
movq %r14, %rsi
callq 0x7420
movq %rbx, %rdi
callq 0xa876
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xa876
cmpl $0x2, 0x60(%rbx)
ja 0xac29
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xbe1a
leaq 0x20(%rbx), %rdi
incq %r14
movsbq %al, %rdx
movq %r14, %rsi
callq 0x7420
movq %rbx, %rdi
callq 0xa876
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xa876
cmpl $0x0, 0x64(%rbx)
jne 0xb29d
movq %rax, %r14
leaq 0xc0(%rbx), %r15
xorl %r12d, %r12d
cmpb $0x3c, (%r14)
je 0xb29d
cmpl $0x2, 0x60(%rbx)
jae 0xb263
movq %r14, %rdi
callq 0x7140
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xc114
movq %rax, %rdi
callq 0xc136
movslq %r13d, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x7420
movq %r15, %rdi
movq %r12, %rsi
callq 0xc114
movq %rax, %rdi
callq 0xc136
movq 0xcd76(%rip), %rdi      # 0x17fc0
movq %rax, %rsi
callq 0x72c0
movq %rax, %rdi
callq 0x7160
addq $0x81, %r14
jmp 0xb295
jne 0xb295
movq %r14, %rdi
callq 0x7140
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xc114
movq %rax, %rdi
callq 0xc136
movslq %r13d, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x7420
addq $0x21, %r14
incq %r12
jmp 0xb1f4
movq %rbx, %rdi
callq 0xa876
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xa876
cmpl $0x0, 0x64(%rbx)
jne 0xb4ee
movq %rax, %r14
leaq 0xc0(%rbx), %r15
xorl %r12d, %r12d
movzbl (%r14), %eax
testl %eax, %eax
je 0xb4ee
cmpl $0x3c, %eax
je 0xb4ee
cmpl $0x2, 0x60(%rbx)
jae 0xb4b3
testb %al, %al
je 0xb4aa
movq %r14, %rdi
callq 0x7140
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xc114
movq %rax, %rdi
callq 0xc136
leaq 0x68(%rax), %rdi
movslq %r13d, %rdx
movq %r14, %rsi
callq 0x7420
addq $0x141, %r14            # imm = 0x141
jmp 0xb4e6
jne 0xb4e6
movq %r14, %rdi
callq 0x7140
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xc114
movq %rax, %rdi
callq 0xc136
leaq 0x68(%rax), %rdi
movslq %r13d, %rdx
movq %r14, %rsi
callq 0x7420
addq $0x51, %r14
incq %r12
jmp 0xb462
movq %rbx, %rdi
callq 0xa876
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x100(%rsi), %rax
cmpb $0x3c, (%rax)
jne 0xb557
cmpb $0x2f, 0x1(%rax)
jne 0xb557
movb $0x0, 0x8(%rdi)
movq %rbx, %rdi
callq 0xa876
movq %rbx, %rdi
callq 0xa876
movb $0x1, 0x8(%rdi)
movq %rbx, %rdi
callq 0xa7aa
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xa876
cmpb $0x3c, (%rax)
jne 0xb61a
cmpb $0x63, 0x1(%rax)
movb $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0xa876
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xa876
cmpb $0x0, 0xb0(%rbx)
je 0xb924
xorl %eax, %eax
jmp 0xb94d
movq 0xc695(%rip), %rdi      # 0x17fc0
leaq 0x3e36(%rip), %rsi      # 0xf768
callq 0x7300
movq %rax, %rdi
callq 0x7160
movq %rbx, %rdi
callq 0xa876
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: OpenValueLabel::advanceState()
State *OpenValueLabel::advanceState()
{
  if (getHasLabels())
    return new OpenInnerValueLabel();
  else
    return new CloseValueLabel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x8(%rdi)
jne 0xb975
pushq $0x10
popq %rdi
callq 0x7310
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0xbf05(%rip), %rcx      # 0x17878
jmp 0xb984
pushq $0x8
popq %rdi
callq 0x7310
leaq 0xbea4(%rip), %rcx      # 0x17828
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/maplechori[P]stata-reader-writer/State.cpp
// Function: OpenInnerValueLabel::advanceState()
State *OpenInnerValueLabel::advanceState()
{
  if (getHasMoreLabels())
    return new OpenInnerValueLabel();
  else
    return new CloseValueLabel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x8(%rdi)
jne 0xb9cb
pushq $0x10
popq %rdi
callq 0x7310
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0xbeaf(%rip), %rcx      # 0x17878
jmp 0xb9da
pushq $0x8
popq %rdi
callq 0x7310
leaq 0xbe4e(%rip), %rcx      # 0x17828
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x100(%rsi), %rsi
movslq %edx, %r15
movq %r15, %rdx
callq 0x7420
addq %r15, 0x100(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7150
movq %r14, %rdi
callq 0x75b0
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
shlq $0x3, %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
je 0xbd9c
movzbl (%rdi), %edx
shll %cl, %edx
orl %edx, %eax
addq $0x8, %rcx
incq %rdi
jmp 0xbd87
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl %r14d, %eax
negl %eax
xorl %ecx, %ecx
movq %r14, %rdx
addq %rcx, %rdx
je 0xdbcf
cmpb $0x0, (%rdx)
je 0xdbcd
cmpl %r15d, %ecx
jge 0xdbcd
incq %rcx
jmp 0xdbb6
movl %ecx, %eax
movl %r15d, %ecx
subl %eax, %ecx
jle 0xdbe5
movl %eax, %edi
addq %r14, %rdi
movslq %ecx, %rdx
xorl %esi, %esi
callq 0x71d0
movslq %r15d, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7420
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7150
movq %r14, %rdi
callq 0x75b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x7590
movl %eax, %r14d
testl %eax, %eax
jne 0xe4b4
testl %r14d, %r14d
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x9b0d(%rip), %rax      # 0x17fc8
movq (%rax), %r15
movq (%rbx), %rdi
callq 0x72f0
leaq 0x1a72(%rip), %rsi      # 0xff3f
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x74a0
movq (%rbx), %rdi
callq 0x7180
jmp 0xe4a3
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x29
popq %rsi
callq 0x20c0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movq %r15, %rdi
callq 0x2070
movl $0x54434944, (%r14,%rax) # imm = 0x54434944
movb $0x0, 0x4(%r14,%rax)
movq 0x6939(%rip), %rdi      # 0x8fd8
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
leaq 0x39be(%rip), %rsi      # 0x6074
movq %r14, %rdi
callq 0x21a0
movq %rax, %r15
leaq 0x39b2(%rip), %rdi      # 0x607a
leaq 0x3995(%rip), %rsi      # 0x6064
callq 0x21a0
movq %rax, %r12
movl 0x30(%rbx), %esi
movq %r15, %rdi
callq 0x4aef
movq %rax, %r15
movl 0x30(%rbx), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4cbc
movq %r14, %rdi
callq 0x21b0
movq %r15, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %r14
pushq $0x29
popq %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x20c0
movq %rax, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0x20c0
movq %rax, %r14
movq %r12, %rdi
callq 0x2070
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %r14, %rdi
movq %r12, %rsi
callq 0x2130
movslq %r13d, %rax
xorl %ecx, %ecx
movb %cl, 0x4(%r15,%rax)
movl $0x54434944, (%r15,%rax) # imm = 0x54434944
movb %cl, 0x4(%r14,%rax)
movl $0x41524150, (%r14,%rax) # imm = 0x41524150
leaq 0x358d(%rip), %rsi      # 0x6064
movq %r15, %rdi
callq 0x21a0
movq (%rbx), %rdi
movl 0x30(%rbx), %edx
movq %rax, %rsi
callq 0x4cbc
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b64
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x29
popq %rsi
callq 0x20c0
movq %rax, %r15
movq %rbx, %rdi
callq 0x2070
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2130
movslq %r12d, %rax
movups 0x34fa(%rip), %xmm0     # 0x603f
movups %xmm0, (%r15,%rax)
movb $0x0, 0x10(%r15,%rax)
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a58
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2070
movq %rax, %r15
pushq $0x1
popq %rdi
pushq $0x29
popq %rsi
callq 0x20c0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movslq %r15d, %rax
movabsq $0x6c6169726574614d, %rcx # imm = 0x6C6169726574614D
movq %rcx, (%r12,%rax)
movw $0x2f, 0x8(%r12,%rax)
movq %rbx, %rdi
callq 0x30cc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d48
movq %rax, %r14
movq %r12, %rdi
callq 0x21b0
testq %r14, %r14
je 0x30c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31f2
movq 0x70(%r14), %r14
jmp 0x30aa
xorps %xmm0, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::FreeSen()
int RNNet::FreeSen(){
    if(sent==NULL) return 0;
    Sentence tmp;
    int i,j;
    while(sent){
        tmp = sent;
        sent=sent->next;
        free(tmp->schar);
        for(i=0;i<tmp->tlen;++i){
            free(tmp->inVec[i]);
            free(tmp->hidLay[i]);
            free(tmp->outLay[i]);
            free(tmp->kLayer[i]);
            free(tmp->energy[i]);
            free(tmp->DLDh[i]);
            free(tmp->DLDo[i]);
            free(tmp->DLDx[i]);
        }
        free(tmp->inVec);
        free(tmp->hidLay);
        free(tmp->kLayer);
        free(tmp->outLay);
        free(tmp->energy);
        free(tmp->eng);
        free(tmp->stdAns);
        free(tmp->DLDh);
        free(tmp->DLDo);
        free(tmp->DLDx);
        free(tmp);
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x78(%rdi), %r15
testq %r15, %r15
je 0x31e4
movq %rdi, %r14
pushq $0x1
popq %rbx
testq %r15, %r15
je 0x31e6
movq 0x70(%r15), %rax
movq %rax, 0x78(%r14)
movq 0x8(%r15), %rdi
callq 0x21b0
xorl %r12d, %r12d
movslq 0x10(%r15), %rax
movq 0x18(%r15), %rdi
cmpq %rax, %r12
jge 0x317d
movq (%rdi,%r12,8), %rdi
callq 0x21b0
movq 0x20(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x21b0
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x21b0
movq 0x28(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x21b0
movq 0x38(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x21b0
movq 0x60(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x21b0
movq 0x58(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x21b0
movq 0x68(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x21b0
incq %r12
jmp 0x3107
callq 0x21b0
movq 0x20(%r15), %rdi
callq 0x21b0
movq 0x28(%r15), %rdi
callq 0x21b0
movq 0x30(%r15), %rdi
callq 0x21b0
movq 0x38(%r15), %rdi
callq 0x21b0
movq 0x40(%r15), %rdi
callq 0x21b0
movq 0x48(%r15), %rdi
callq 0x21b0
movq 0x60(%r15), %rdi
callq 0x21b0
movq 0x58(%r15), %rdi
callq 0x21b0
movq 0x68(%r15), %rdi
callq 0x21b0
movq %r15, %rdi
callq 0x21b0
movq 0x78(%r14), %r15
jmp 0x30ea
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::RNNForward_CROSSENTROPY_Nthread(char const*, int)
double RNNet::RNNForward_CROSSENTROPY_Nthread(const char* pathRoot,int Nthread){
    
    char* psen=(char*)calloc(sizeof(char),41);
    int pathrootlen=strlen(pathRoot);   
    strcpy(psen,pathRoot);
    strcpy(psen+pathrootlen,"Material/");
    FreeSen();
    Sentence sentmp=FetchSent(psen);
    free(psen);
    flag = totnum-1;
    
    std::thread th[Nthread];
    int n;
   
    for(n=0;n<Nthread;++n){
        th[n]=std::thread(_Forward_CROSSENTROPY_SingleTask,\
            this,&sentmp,n);
    }
    for(n=0;n<Nthread;++n)
        th[n].join();
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x29
popq %rsi
callq 0x20c0
movq %rax, %r12
movq %r14, %rdi
callq 0x2070
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x2130
movslq %r13d, %rax
movabsq $0x6c6169726574614d, %rcx # imm = 0x6C6169726574614D
movq %rcx, (%r12,%rax)
movw $0x2f, 0x8(%r12,%rax)
movq %r15, %rdi
callq 0x30cc
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d48
movq %rax, -0x50(%rbp)
movq %r12, %rdi
callq 0x21b0
movq %rsp, -0x38(%rbp)
movq 0x50(%r15), %rax
decq %rax
movq %r15, %r12
movq %rax, 0x48(%r15)
movl %ebx, %r15d
movq %rsp, %r14
leaq 0xf(,%r15,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testl %ebx, %ebx
je 0x35af
leaq (,%r15,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x20b0
xorl %eax, %eax
leaq -0x58(%rbp), %r13
movl %eax, -0x2c(%rbp)
cmpl %ebx, %eax
jge 0x3602
movq %r12, -0x48(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %r13, %rdi
leaq 0xa4(%rip), %rsi        # 0x3676
leaq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x4616
movslq -0x2c(%rbp), %rax
leaq (%r14,%rax,8), %rdi
movq %r13, %rsi
callq 0x46aa
movq %r13, %rdi
callq 0x46c8
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x35b5
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
cmpl %ebx, %eax
jge 0x361d
cltq
leaq (%r14,%rax,8), %rdi
callq 0x2220
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x3604
testl %ebx, %ebx
je 0x3638
addq $-0x8, %r14
shlq $0x3, %r15
leaq (%r14,%r15), %rdi
callq 0x46c8
addq $-0x8, %r15
jne 0x3629
movq -0x38(%rbp), %rsp
xorps %xmm0, %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3650
movq %rax, %r12
testl %ebx, %ebx
je 0x366e
addq $-0x8, %r14
shlq $0x3, %r15
leaq (%r14,%r15), %rdi
callq 0x46c8
addq $-0x8, %r15
jne 0x365f
movq %r12, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::_Forward_CROSSENTROPY_SingleTask(RNNet*, sentence**, int)
double RNNet::_Forward_CROSSENTROPY_SingleTask(RNNet* rnn,Sentence* sen,int n){
    Sentence tsen = *sen;
    long num = tsen->num;
    std::mutex g_mutex;
    while( rnn->flag > -1){
        g_mutex.lock();
        num = rnn->flag;
        //printf("%ld\n",num);
        rnn->flag--;
        g_mutex.unlock();
        tsen = gonext(tsen,num);
        if(tsen!=NULL){
            //std::cout<<tsen->schar<<std::endl;
            rnn->_Forward_CROSSENTROPY(tsen);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
andq $0x0, 0x20(%r14)
cmpq $0x0, 0x48(%rbx)
js 0x36e4
movq %r14, %rdi
callq 0x47d8
movq 0x48(%rbx), %r12
leaq -0x1(%r12), %rax
movq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0x20e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x442e
movq %rax, %r15
testq %rax, %rax
je 0x36a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31f2
jmp 0x36a0
xorps %xmm0, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::_Backward_CROSSENTROPY_SingleTask(RNNet*, sentence**, int)
void RNNet::_Backward_CROSSENTROPY_SingleTask(RNNet* rnn,Sentence* sen,int n){
    Sentence tsen = *sen;
    std::mutex g_mutex;
    long num = tsen->num;
    while(rnn->flag > -1){
        g_mutex.lock();
        num = rnn->flag;
        //printf("%ld\n",num);
        rnn->flag--;
        g_mutex.unlock();
        tsen = gonext(tsen,num);
        if(tsen!=NULL){
            rnn->_Backward_CROSSENTROPY(tsen);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
andq $0x0, 0x20(%r14)
cmpq $0x0, 0x48(%rbx)
js 0x439c
movq %r14, %rdi
callq 0x47d8
movq 0x48(%rbx), %r12
leaq -0x1(%r12), %rax
movq %rax, 0x48(%rbx)
movq %r14, %rdi
callq 0x20e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x442e
movq %rax, %r15
testq %rax, %rax
je 0x4358
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38c0
jmp 0x4358
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::softmax_add(sentence*, double*, int)
void RNNet::softmax_add(Sentence sen,double* src,int t){
    double normal=0.0;
    int i;
    for(i=0;i<EMOTIONNUM;++i)
        normal+=exp(src[i]);
    
    for(i=0;i<EMOTIONNUM;++i){
        sen->energy[t][i]=exp(src[i])/normal;
     //   std::cout<<sen->energy[t][i]<<std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r14
xorpd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorl %r12d, %r12d
cmpq $0x7, %r12
je 0x43f2
movsd (%rbx,%r12,8), %xmm0
callq 0x2240
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
incq %r12
jmp 0x43ce
movslq %r15d, %r15
xorl %r12d, %r12d
cmpq $0x7, %r12
je 0x4421
movsd (%rbx,%r12,8), %xmm0
callq 0x2240
divsd -0x28(%rbp), %xmm0
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0x43f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: gonext(sentence*, long)
Sentence gonext(Sentence sen,long target){
    Sentence ret=sen;
    if(target < 0) return NULL;
    while(ret->num>target){
        ret = ret->next;
    }
    return ret;
}

// Assembly:
testq %rsi, %rsi
js 0x4447
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
cmpq %rsi, (%rax)
jle 0x4445
movq 0x70(%rax), %rax
jmp 0x443a
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::FreeAll()
void RNNet::FreeAll(){
    FreeSen();
    if(ccdict!=NULL) hashFree(ccdict);
    int i,j;
    for(i=0;i<EMOTIONNUM;++i){
        free(k2out[i]);
        free(DLDk2out[i]);
    }
    for(i=0;i<hidlayerNUM;++i){
        free(in2hid[i]);
        free(ro2h[i]);
        free(rh2h[i]);
        free(DLDro2h[i]);
        free(DLDrh2h[i]);
        free(DLDin2hid[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x30cc
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4466
callq 0x4d7c
xorl %r14d, %r14d
cmpq $0x7, %r14
je 0x448e
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
movq 0x60(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
incq %r14
jmp 0x4469
xorl %r14d, %r14d
movslq 0x34(%rbx), %rax
cmpq %rax, %r14
jge 0x44ed
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
movq 0x70(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x21b0
incq %r14
jmp 0x4491
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/RNNet.cpp
// Function: RNNet::prtSent(char const*)
void RNNet::prtSent(const char* path){
    Sentence tmp=sent;

    FILE* fp = fopen(path,"w");
    int i,j;

    while(tmp){
        fprintf(fp,"{\n");
        fprintf(fp,"%s %d\ninVec:{\n",tmp->schar,tmp->tlen);
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<featureNUM;++j)
        //         fprintf(fp,"%f ",tmp->inVec[i][j]);
        //     fprintf(fp,"\n");
        // }
        // fprintf(fp,"}\nhidLay:{\n");
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<hidlayerNUM;++j)
        //         fprintf(fp,"%f ",tmp->hidLay[i][j]);
        //     fprintf(fp,"\n");
        // }
        // fprintf(fp,"}\nkLayer:{\n");
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<hidlayerNUM;++j)
        //         fprintf(fp,"%f ",tmp->kLayer[i][j]);
        //     fprintf(fp,"\n");
        // }
        // fprintf(fp,"}\noutLay:{\n");
        // for(i=0;i<tmp->tlen;++i){
        //     for(j=0;j<EMOTIONNUM;++j)
        //         fprintf(fp,"%f ",tmp->outLay[i][j]);
        //     fprintf(fp,"\n");
        // }
        fprintf(fp,"}\neng:{\n");
        for(j=0;j<EMOTIONNUM;++j)
            fprintf(fp,"%f ",tmp->eng[j]);
        fprintf(fp,"\n}\nstdAns:{\n");
        for(j=0;j<EMOTIONNUM;++j)
            fprintf(fp,"%f ",tmp->stdAns[j]);
        fprintf(fp,"\n}\nloss:%f\n\n",tmp->loss);
        tmp=tmp->next;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq 0x78(%rdi), %r14
leaq 0x1b56(%rip), %rsi      # 0x6064
movq %rax, %rdi
callq 0x21a0
movq %rax, %rbx
pushq $0x1
popq %r12
leaq 0x1bbd(%rip), %r13      # 0x60e1
testq %r14, %r14
je 0x45ef
leaq 0x1ba1(%rip), %rdi      # 0x60d5
pushq $0x2
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2260
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
movq %rbx, %rdi
leaq 0x1b75(%rip), %rsi      # 0x60c9
xorl %eax, %eax
callq 0x21e0
leaq 0x1b76(%rip), %rdi      # 0x60d8
pushq $0x8
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2260
xorl %r15d, %r15d
cmpq $0x7, %r15
je 0x4595
movq 0x40(%r14), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x21e0
incq %r15
jmp 0x4573
leaq 0x1b49(%rip), %rdi      # 0x60e5
pushq $0xc
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2260
xorl %r15d, %r15d
cmpq $0x7, %r15
je 0x45cf
movq 0x48(%r14), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x21e0
incq %r15
jmp 0x45ad
movsd 0x50(%r14), %xmm0
movq %rbx, %rdi
leaq 0x1b13(%rip), %rsi      # 0x60f2
movb $0x1, %al
callq 0x21e0
movq 0x70(%r14), %r14
jmp 0x4524
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/debugRNNet.cpp
// Function: main
int main(void){
    RNNet rnn(256,32,"../");
    const char *pa = "../";
    rnn.RNNForward_CROSSENTROPY_Nthread("../",2);    
    rnn.prtSent("SENTN");
    rnn.RNNBackward_CROSSENTROPY_Nthread(0.1,2);
    for(int n=0;n<0;++n){
        std::cout << "n: "<< n <<std::endl;
        rnn.RNNForward_CROSSENTROPY_Nthread("../",2);
        rnn.RNNBackward_CROSSENTROPY_Nthread(0.1,2);
        //rnn.prtSent("SENTN");
    }
    rnn.RNNForward_CROSSENTROPY_Nthread("../",2);
    rnn.prtSent("TSENT");
    //rnn.Save2txt("../");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x192f(%rip), %rbx      # 0x61b8
leaq -0x98(%rbp), %r14
pushq $0x20
popq %rdx
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
callq 0x240c
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34fa
leaq 0x1904(%rip), %rsi      # 0x61bc
leaq -0x98(%rbp), %rdi
callq 0x44f2
leaq -0x98(%rbp), %rdi
movsd 0x18dd(%rip), %xmm0     # 0x61b0
pushq $0x2
popq %rsi
callq 0x4062
leaq 0x18d6(%rip), %rsi      # 0x61b8
leaq -0x98(%rbp), %rdi
pushq $0x2
popq %rdx
callq 0x34fa
leaq 0x18ca(%rip), %rsi      # 0x61c2
leaq -0x98(%rbp), %rdi
callq 0x44f2
leaq -0x98(%rbp), %rdi
callq 0x4936
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x4936
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: fapdDic(_IO_FILE*, _IO_FILE*, _IO_FILE*, int)
void fapdDic(FILE* infp,FILE* srcfp,FILE* outfp,int dim){
	char* tmp  =(char*)calloc(sizeof(char),421);  
	char* sta=tmp;
	int lenTmp,i;

    ChUTF8* hash=fldDic(srcfp,dim);
	ChUTF8 NewS;
    while(fscanf(infp,"%s\n",sta)!=-1){
		tmp=sta;
        while(tmp[0]!='\0'){
            lenTmp=retLenUTF8(tmp);
           if(!hIscontain(hash,tmp,lenTmp)){
                NewS = (ChUTF8)malloc(sizeof(struct chUTF8));
                NewS->schar=(char*)malloc(sizeof(char)*(lenTmp+1));
                memcpy(NewS->schar,tmp,lenTmp);
                NewS->schar[lenTmp]='\0';
//std::cout<<tmp<<":"<<lenTmp<<":"<<NewS->schar<<std::endl;
                NewS->vecftr=(double*)malloc(sizeof(double)*dim);
                for(i=0;i<dim;++i){
                    NewS->vecftr[i]=(rand()%101-50)/50.0;
                }
            
                hashput(hash,NewS);
           }
					
            tmp+=lenTmp;
        }
		memset(sta,'\0',421*sizeof(char));
    }
	
    prtHash2File(hash,outfp,dim);
    fflush(outfp);
    hashFree(hash);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r14d
movq %rdx, -0x40(%rbp)
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
pushq $0x1
popq %rdi
movl $0x1a5, %esi            # imm = 0x1A5
callq 0x20c0
movq %rax, %r13
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4aef
movq %rax, %rbx
movslq %r14d, %rax
leaq (,%rax,8), %rcx
movq %rcx, -0x58(%rbp)
testl %eax, %eax
movl $0x0, %r12d
movl %r14d, -0x2c(%rbp)
cmovgl %r14d, %r12d
pushq $0x65
popq %r15
movq %rbx, -0x60(%rbp)
movq %r13, -0x48(%rbp)
movq -0x50(%rbp), %rdi
leaq 0x16ab(%rip), %rsi      # 0x6076
movq %r13, %rdx
xorl %eax, %eax
callq 0x2250
cmpl $-0x1, %eax
jne 0x4a99
jmp 0x4abc
movq %r13, %rdi
callq 0x5257
movl %eax, %r14d
movq %rbx, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x4c41
movq %r13, %rcx
movslq %r14d, %r13
testb %al, %al
movq %rcx, -0x38(%rbp)
jne 0x4a8f
pushq $0x18
popq %rdi
callq 0x21d0
movq %rax, %r14
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x21d0
movq %rax, %rbx
movq %rax, (%r14)
movq %rax, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
callq 0x2100
movq %r13, -0x68(%rbp)
movb $0x0, (%rbx,%r13)
movq -0x58(%rbp), %rdi
callq 0x21d0
movq %rax, 0x8(%r14)
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x4a7c
callq 0x2040
cltd
idivl %r15d
addl $-0x32, %edx
cvtsi2sd %edx, %xmm0
divsd 0x175a(%rip), %xmm0     # 0x61c8
movq 0x8(%r14), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
jmp 0x4a51
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c94
movq -0x68(%rbp), %r13
movq -0x38(%rbp), %rax
addq %r13, %rax
movq %rax, %r13
cmpb $0x0, (%r13)
jne 0x49e3
movl $0x1a5, %edx            # imm = 0x1A5
movq -0x48(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x20b0
jmp 0x49c0
movq %rbx, %rdi
movq %rbx, %r14
movq -0x40(%rbp), %rbx
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0x4cbc
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4d7c
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: fldDic(_IO_FILE*, int)
ChUTF8* fldDic(FILE* fp,int dim){
    ChUTF8* ret = tabCreate();
    char* tmp=(char*)calloc(sizeof(char),7);
    fscanf(fp,"%s\n",tmp);
    std::cout<<tmp<<std::endl;
    int lenTmp,i;
    double dtmp;
    while(fscanf(fp,"%s ",tmp)!=-1){
        lenTmp=retLenUTF8(tmp);
        //std::cout<<tmp<<std::endl;
        ChUTF8 NewS = (ChUTF8)malloc(sizeof(struct chUTF8));
        NewS->schar=(char*)malloc(sizeof(char)*(lenTmp+1));
        memcpy(NewS->schar,tmp,lenTmp);
        NewS->schar[lenTmp]='\0';
        NewS->vecftr=(double*)malloc(sizeof(double)*dim);
        for(i=0;i<dim;++i){
            fscanf(fp,"#%lf#",&dtmp);
            NewS->vecftr[i]=dtmp;
        }
        fgetc(fp);
        hashput(ret,NewS);
        memset(tmp,'\0',7*sizeof(char));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x5295
movq %rax, -0x30(%rbp)
pushq $0x1
popq %rdi
pushq $0x7
popq %rsi
callq 0x20c0
movq %rax, %r13
leaq 0x1552(%rip), %rsi      # 0x6076
xorl %r12d, %r12d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2250
movq 0x449d(%rip), %rdi      # 0x8fd8
movq %r13, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movslq %r14d, %r15
leaq (,%r15,8), %rax
movq %rax, -0x40(%rbp)
testl %r15d, %r15d
cmovlel %r12d, %r15d
leaq -0x50(%rbp), %r14
movq %r13, -0x38(%rbp)
movq %rbx, %rdi
leaq 0x1678(%rip), %rsi      # 0x61eb
movq %r13, %rdx
xorl %eax, %eax
callq 0x2250
cmpl $-0x1, %eax
je 0x4c2e
movq %r13, %rdi
callq 0x5257
movl %eax, %r13d
pushq $0x18
popq %rdi
callq 0x21d0
movq %rax, %r12
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x21d0
movq %rax, -0x48(%rbp)
movq %rax, (%r12)
movslq %r13d, %r13
movq %rax, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
callq 0x2100
movq -0x48(%rbp), %rax
movb $0x0, (%rax,%r13)
movq -0x40(%rbp), %rdi
callq 0x21d0
movq %rax, 0x8(%r12)
xorl %r13d, %r13d
movq %rbx, %rdi
cmpq %r13, %r15
je 0x4c0a
leaq 0x14a8(%rip), %rsi      # 0x6093
movq %r14, %rdx
xorl %eax, %eax
callq 0x2250
movsd -0x50(%rbp), %xmm0
movq 0x8(%r12), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x4bdc
callq 0x2210
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x4c94
movq -0x38(%rbp), %r13
andl $0x0, 0x3(%r13)
andl $0x0, (%r13)
jmp 0x4b69
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hIscontain(chUTF8**, char*, int)
bool hIscontain(ChUTF8* tab,char* src,int len){

    int offset=hFuncUTF8(src);
    ChUTF8 tmp = tab[offset];
    while(tmp){
        if(strncmp(tmp->schar,src,len)==0)
            return true;
        tmp=tmp->next;
    }

    return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x52ae
cltq
leaq (%r15,%rax,8), %rcx
movslq %r14d, %r14
movq (%rcx), %r15
testq %r15, %r15
je 0x4c83
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2090
leaq 0x10(%r15), %rcx
testl %eax, %eax
jne 0x4c65
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hashput(chUTF8**, chUTF8*)
void hashput(ChUTF8* tab,ChUTF8 unit){

    int offset;
    offset=hFuncUTF8(unit->schar);
    unit->next=tab[offset];
    tab[offset]=unit;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x52ae
cltq
movq (%r14,%rax,8), %rcx
movq %rcx, 0x10(%rbx)
movq %rbx, (%r14,%rax,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: prtHash2File(chUTF8**, _IO_FILE*, int)
void prtHash2File(ChUTF8* tab,FILE* fp,int dim){

    //default size 32*64*64
    int i,j;
    ChUTF8 tmp;
    fprintf(fp,"Standard_Dict_Form");
    for(i=0;i<32*64*64;++i){
        tmp=tab[i];
        while(tmp){
            fprintf(fp,"\n");
            fprintf(fp,"%s ",tmp->schar);
            for(j=0;j<dim;++j)
                fprintf(fp,"#%lf#",tmp->vecftr[j]);
            tmp=tmp->next;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq 0x14fb(%rip), %rdi      # 0x61d8
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x2260
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x139a(%rip), %r15      # 0x6093
xorl %ecx, %ecx
cmpq $0x20000, %rcx          # imm = 0x20000
je 0x4d6d
movq -0x30(%rbp), %rax
movq %rcx, -0x38(%rbp)
leaq (%rax,%rcx,8), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x4d64
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x21c0
movq (%r12), %rdx
movq %r14, %rdi
leaq 0x14b9(%rip), %rsi      # 0x61eb
xorl %eax, %eax
callq 0x21e0
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x4d5e
movq 0x8(%r12), %rax
movsd (%rax,%r13,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x21e0
incq %r13
jmp 0x4d3c
addq $0x10, %r12
jmp 0x4d10
movq -0x38(%rbp), %rcx
incq %rcx
jmp 0x4cfb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hashFree(chUTF8**)
void hashFree(ChUTF8* tab){

    int i;
    ChUTF8 tmp;

    for(i=0;i<32*64*64;++i){
        while(tab[i]){
            tmp=tab[i];
            tab[i]=tab[i]->next;
            free(tmp->schar);
            free(tmp->vecftr);
            free(tmp);
        }
    }
    free(tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x20000, %r15          # imm = 0x20000
je 0x4dc6
movq (%rbx,%r15,8), %r14
testq %r14, %r14
je 0x4dc1
movq 0x10(%r14), %rax
movq %rax, (%rbx,%r15,8)
movq (%r14), %rdi
callq 0x21b0
movq 0x8(%r14), %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x21b0
jmp 0x4d95
incq %r15
jmp 0x4d8c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: fcrtDic(_IO_FILE*, _IO_FILE*, int)
void fcrtDic(FILE* infp,FILE* outfp,int dim){
    

    char* tmp=(char*)calloc(sizeof(char),421);
    int lenTmp,i;
	char* sta=tmp;
    ChUTF8* hash = tabCreate();

    while(fscanf(infp,"%s\n",sta)!=-1){
		tmp=sta;
        while(tmp[0]!='\0'){
            lenTmp=retLenUTF8(tmp);
            if(!hIscontain(hash,tmp,lenTmp)){
                ChUTF8 NewS = (ChUTF8)malloc(sizeof(struct chUTF8));
            
                NewS->schar=(char*)malloc(sizeof(char)*(lenTmp+1));
                memcpy(NewS->schar,tmp,lenTmp);
                NewS->schar[lenTmp]='\0';

                NewS->vecftr=(double*)malloc(sizeof(double)*dim);
                for(i=0;i<dim;++i){
                    NewS->vecftr[i]=(rand()%101-50)/50.0;
                }
            
                hashput(hash,NewS);
            }
            tmp+=lenTmp;
        }
        memset(sta,'\0',421*sizeof(char));
    }
    
   
    
    prtHash2File(hash,outfp,dim);
    fflush(outfp);
    
    hashFree(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movq %rsi, -0x40(%rbp)
movq %rdi, -0x50(%rbp)
pushq $0x1
popq %rdi
movl $0x1a5, %esi            # imm = 0x1A5
callq 0x20c0
movq %rax, %r14
callq 0x5295
movslq %ebx, %rcx
leaq (,%rcx,8), %rdx
movq %rdx, -0x58(%rbp)
testl %ecx, %ecx
movl $0x0, %r12d
movl %ebx, -0x2c(%rbp)
cmovgl %ebx, %r12d
movq %rax, %rbx
pushq $0x65
popq %r15
movq %rax, -0x60(%rbp)
movq %r14, -0x48(%rbp)
movq -0x50(%rbp), %rdi
leaq 0x1236(%rip), %rsi      # 0x6076
movq %r14, %rdx
xorl %eax, %eax
callq 0x2250
cmpl $-0x1, %eax
je 0x4f34
movq %r14, %r13
cmpb $0x0, (%r13)
je 0x4f1c
movq %r13, %rdi
callq 0x5257
movl %eax, %r14d
movq %rbx, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x4c41
movq %r13, %rcx
movslq %r14d, %r13
testb %al, %al
movq %rcx, -0x38(%rbp)
jne 0x4f0d
pushq $0x18
popq %rdi
callq 0x21d0
movq %rax, %r14
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x21d0
movq %rax, %rbx
movq %rax, (%r14)
movq %rax, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
callq 0x2100
movq %r13, -0x68(%rbp)
movb $0x0, (%rbx,%r13)
movq -0x58(%rbp), %rdi
callq 0x21d0
movq %rax, 0x8(%r14)
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x4efa
callq 0x2040
cltd
idivl %r15d
addl $-0x32, %edx
cvtsi2sd %edx, %xmm0
divsd 0x12dc(%rip), %xmm0     # 0x61c8
movq 0x8(%r14), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
jmp 0x4ecf
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c94
movq -0x68(%rbp), %r13
movq -0x38(%rbp), %rax
addq %r13, %rax
movq %rax, %r13
jmp 0x4e56
movl $0x1a5, %edx            # imm = 0x1A5
movq -0x48(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x20b0
jmp 0x4e35
movq %rbx, %rdi
movq %rbx, %r14
movq -0x40(%rbp), %rbx
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0x4cbc
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4d7c
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: hashget(chUTF8**, char*)
ChUTF8 hashget(ChUTF8* tab,char* src){

    int offset=hFuncUTF8(src);
    int len=retLenUTF8(src);
    ChUTF8 tmp = tab[offset];
    while(tmp){
        if(strncmp(tmp->schar,src,len)==0)
            return tmp;
        tmp=tmp->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x52ae
movl %eax, %r15d
movq %rbx, %rdi
callq 0x5257
movslq %r15d, %rcx
leaq (%r14,%rcx,8), %r14
movslq %eax, %r15
movq (%r14), %r14
testq %r14, %r14
je 0x4fb4
movq (%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2090
testl %eax, %eax
je 0x4fb4
addq $0x10, %r14
jmp 0x4f94
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huiwenliuge[P]EmoAnaer/src/DictCreate.cpp
// Function: strLenUTF8(char*)
int strLenUTF8(char* str){
    int ret=0;
    char* point;
    point = str;
    while(*str!='\0'){
        str+=retLenUTF8(str);
        ++ret;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
cmpb $0x0, (%r14)
je 0x4fe5
movq %r14, %rdi
callq 0x5257
cltq
addq %rax, %r14
incl %ebx
jmp 0x4fce
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq