LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerParam.h
// Function: PlayerParam::GetEpsInMark(double)
double GetEpsInMark(double dist) {
    Assert(dist >= 0);
    int low = 0;
    int middle = 0;
    int high = MARKSIZE - 1;

    while (low <= high) {
      middle = (low + high) / 2;

      if (middle + 1 >= MARKSIZE) {
        return mMarkChange[MARKSIZE - 1][2];
      }

      if (dist >= mMarkChange[middle][0] &&
          dist <= mMarkChange[middle + 1][0]) {
        if (fabs(dist - mMarkChange[middle][0]) <
            fabs(dist - mMarkChange[middle + 1][0])) {
          return mMarkChange[middle][2];
        } else {
          return mMarkChange[middle + 1][2];
        }
      }

      if (middle == 0) {
        return mMarkChange[middle][2];
      }

      if (dist < mMarkChange[middle][0]) {
        high = middle;
      } else {
        low = middle + 1;
      }
    }

    PRINT_ERROR("can not find this dist " << dist);
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x37d8(%rdi), %rax
xorl %ecx, %ecx
movl $0x183, %edx            # imm = 0x183
leal (%rdx,%rcx), %r9d
cmpl $0x306, %r9d            # imm = 0x306
jge 0x67cff
movl %r9d, %esi
shrl $0x1f, %esi
addl %r9d, %esi
sarl %esi
leal 0x1(%rsi), %r10d
movslq %esi, %r8
leaq (%r8,%r8,2), %r8
leaq (%rax,%r8,8), %r8
movsd (%r8), %xmm3
ucomisd %xmm3, %xmm0
jb 0x67c38
movslq %r10d, %r11
leaq (%r11,%r11,2), %r11
movsd (%rax,%r11,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0x67d09
incl %r9d
cmpl $0x2, %r9d
jbe 0x67d2b
ucomisd %xmm0, %xmm3
ja 0x67c50
movl %r10d, %ecx
movl %edx, %esi
movl %esi, %edx
cmpl %esi, %ecx
jle 0x67beb
movq 0x1c393(%rip), %rbx     # 0x83ff0
leaq 0x5c97(%rip), %rsi      # 0x6d8fb
movl $0x14, %edx
movq %rbx, %rdi
movapd %xmm0, -0x20(%rbp)
callq 0x9560
leaq 0x5515(%rip), %rsi      # 0x6d192
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x1ac, %esi            # imm = 0x1AC
callq 0x9880
movq %rax, %rbx
leaq 0x37b6(%rip), %rsi      # 0x6b457
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x5c5b(%rip), %rsi      # 0x6d910
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movapd -0x20(%rbp), %xmm0
callq 0x97d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
xorpd %xmm0, %xmm0
jmp 0x67d31
movsd 0x5c30(%rdi), %xmm0
jmp 0x67d31
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd 0x12f7(%rip), %xmm3     # 0x69010
andpd %xmm3, %xmm2
subsd %xmm1, %xmm0
andpd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x67d38
movsd 0x10(%r8), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq (%rax,%r11,8), %rax
movsd 0x10(%rax), %xmm0
jmp 0x67d31
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/main.cpp
// Function: main
int main(int argc, char *argv[]) {
  RegisterSignalHandler();

  ServerParam::instance().init(argc, argv);
  PlayerParam::instance().init(argc, argv);

  Client *client = 0;

  if (PlayerParam::instance().isCoach()) {
    client = new Coach;
  } else if (PlayerParam::instance().isTrainer()) {
    client = new Trainer;
  } else {
    client = new Player;
  }

  if (PlayerParam::instance().DynamicDebugMode()) {
    client->RunDynamicDebug(); // 进入动态调试模式
  } else {
    client->RunNormal(); // 进入正常比赛模式
  }

  delete client;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
callq 0x68343
callq 0x49360
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x4aba6
callq 0x43dce
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x44bc8
callq 0x43dce
cmpb $0x1, 0x31a5(%rax)
jne 0x682ad
movl $0x30, %edi
callq 0x94c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1bfdc
jmp 0x682e7
callq 0x43dce
cmpb $0x1, 0x31a6(%rax)
jne 0x682d2
movl $0x198, %edi            # imm = 0x198
callq 0x94c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4f3b0
jmp 0x682e7
movl $0x38, %edi
callq 0x94c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x434b0
callq 0x43dce
cmpb $0x1, 0x5c40(%rax)
jne 0x682ff
movq %rbx, %rdi
callq 0x1bb4e
jmp 0x68307
movq %rbx, %rdi
callq 0x1bd6a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x38, %esi
jmp 0x68333
movq %rax, %r14
movl $0x198, %esi            # imm = 0x198
jmp 0x68333
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x94e0
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/main.cpp
// Function: RegisterSignalHandler()
void RegisterSignalHandler() {
#ifndef WIN32
  if (signal(SIGINT, signal_catcher) == SIG_ERR) //中断
    perror("SIGINT"), exit(1);
  if (signal(SIGQUIT, signal_catcher) == SIG_ERR) //退出
    perror("SIGQUIT"), exit(1);
  //	if(signal(SIGABRT, signal_catcher) == SIG_ERR)
  ////不能注册SIGABRT，否则调用 abort 时，会产生死循环 		perror("SIGABRT"),
  //exit(1);
  if (signal(SIGSEGV, signal_catcher) == SIG_ERR) //段错误
    perror("SIGSEGV"), exit(1);
  if (signal(SIGILL, signal_catcher) == SIG_ERR) //非法指令
    perror("SIGILL"), exit(1);
  if (signal(SIGFPE, signal_catcher) == SIG_ERR) //浮点异常
    perror("SIGFPE"), exit(1);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x87(%rip), %rsi        # 0x683d5
movl $0x2, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x683bc
leaq 0x70(%rip), %rsi        # 0x683d5
movl $0x3, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x683c1
leaq 0x59(%rip), %rsi        # 0x683d5
movl $0xb, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x683c6
leaq 0x42(%rip), %rsi        # 0x683d5
movl $0x4, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x683cb
leaq 0x2b(%rip), %rsi        # 0x683d5
movl $0x8, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x683d0
popq %rbp
retq
callq 0xa587
callq 0xa56f
callq 0xa557
callq 0xa53f
callq 0xa527
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/main.cpp
// Function: (anonymous namespace)::signal_catcher(int)
void signal_catcher(int sig) {
#ifndef WIN32
  signal(sig, signal_catcher);

  std::cerr << "catch signal " << sig << std::endl;

  create_dump(); //先产生coredump

  std::cerr << "exiting safely now" << std::endl;

  Logger::instance().LogSight();
  Logger::instance().SetFlushCond(); // set flush cond and let the logger thread
                                     // flush the logs to file.
  DynamicDebug::instance().AddMessage("---Aborted", MT_Send);

  WaitFor(100); // wait logger thread to finish flushing

  exit(0); //这里会调用静态对象的析构函数
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq -0x10(%rip), %rsi       # 0x683d5
callq 0x95b0
movq 0x1bbff(%rip), %r14     # 0x83ff0
leaq 0x5555(%rip), %rsi      # 0x6d94d
movq %r14, %rdi
callq 0x94a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x9880
movq %rax, %rdi
callq 0x9240
callq 0x68472
leaq 0x553d(%rip), %rsi      # 0x6d95b
movq %r14, %rdi
callq 0x94a0
movq %rax, %rdi
callq 0x9240
callq 0x34c60
movq %rax, %rdi
callq 0x35042
callq 0x34c60
movq %rax, %rdi
callq 0x34f60
callq 0x22cde
leaq 0x551a(%rip), %rsi      # 0x6d96e
movq %rax, %rdi
movl $0x3, %edx
callq 0x23068
movl $0x64, %edi
callq 0x68486
xorl %edi, %edi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/io.cc
// Function: SimpleFileInput::SimpleFileInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SimpleFileInput::SimpleFileInput(string filename)
{
    if (ends_with(filename, ".gz"))
    {
#ifndef NO_ZLIB
        infs = new GZipFileInput(filename);
#else
        cerr << "No ZLIB support" << endl;
        exit(1);
#endif
    }
    else
        infs = new IFStreamInput(filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x2018e(%rip), %rsi     # 0x261fe
leaq 0x2018a(%rip), %rdx     # 0x26201
leaq -0x40(%rbp), %rdi
callq 0x5fac
movq 0x8(%r14), %rsi
movq -0x38(%rbp), %rdx
subq %rdx, %rsi
jae 0x6092
xorl %r12d, %r12d
jmp 0x60a4
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
callq 0x4470
testl %eax, %eax
sete %r12b
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x60b2
callq 0x4350
testb %r12b, %r12b
je 0x6107
movl $0x10, %edi
callq 0x4390
movq %rax, %r15
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x5f0e
leaq 0x2dae9(%rip), %rax     # 0x33bd0
movq %rax, (%r15)
movq -0x80(%rbp), %rdi
leaq 0x203ef(%rip), %rsi     # 0x264e4
callq 0x4500
movq %rax, 0x8(%r15)
movq %r15, (%rbx)
movq -0x80(%rbp), %rdi
jmp 0x6143
movl $0x210, %edi            # imm = 0x210
callq 0x4390
movq %rax, %r15
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x5f0e
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x68aa
movq %r15, (%rbx)
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x614d
callq 0x4350
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x616a
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x617b
callq 0x4350
jmp 0x617b
jmp 0x6178
movq %rax, %rbx
movq %r15, %rdi
callq 0x4350
jmp 0x6196
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
jne 0x617e
jmp 0x6196
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/io.cc
// Function: SimpleFileOutput::SimpleFileOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SimpleFileOutput::SimpleFileOutput(string filename)
{
    if (ends_with(filename, ".gz"))
    {
#ifndef NO_ZLIB
        outfs = new GZipFileOutput(filename);
#else
        cerr << "No ZLIB support" << endl;
        exit(1);
#endif
    }
    else
        outfs = new OFStream(filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ff3c(%rip), %rsi     # 0x261fe
leaq 0x1ff38(%rip), %rdx     # 0x26201
leaq -0x40(%rbp), %rdi
callq 0x5fac
movq 0x8(%r14), %rsi
movq -0x38(%rbp), %rdx
subq %rdx, %rsi
jae 0x62e4
xorl %r12d, %r12d
jmp 0x62f6
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
callq 0x4470
testl %eax, %eax
sete %r12b
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x6304
callq 0x4350
testb %r12b, %r12b
je 0x635e
movl $0x18, %edi
callq 0x4390
movq %rax, %r15
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x5f0e
leaq 0x2d91f(%rip), %rax     # 0x33c58
movq %rax, (%r15)
movq -0x80(%rbp), %rdi
leaq 0x1febe(%rip), %rsi     # 0x26205
callq 0x4500
movq %rax, 0x8(%r15)
movb $0x1, 0x10(%r15)
movq %r15, (%rbx)
movq -0x80(%rbp), %rdi
jmp 0x639a
movl $0x208, %edi            # imm = 0x208
callq 0x4390
movq %rax, %r15
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x5f0e
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x6526
movq %r15, (%rbx)
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x63a4
callq 0x4350
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x63c1
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x63d2
callq 0x4350
jmp 0x63d2
jmp 0x63cf
movq %rax, %rbx
movq %r15, %rdi
callq 0x4350
jmp 0x63ed
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
jne 0x63d5
jmp 0x63ed
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/io.cc
// Function: SimpleFileOutput::close()
void
SimpleFileOutput::close()
{
    if (outfs) {
        outfs->close();
        delete outfs;
        outfs = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x645b
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6454
movq (%rdi), %rax
callq *0x48(%rax)
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/io.cc
// Function: GZipFileOutput::close()
void
GZipFileOutput::close()
{
    if (file_open) {
         gzclose(gzf);
         gzf = NULL;
    }
    file_open = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x6786
movq 0x8(%rbx), %rdi
callq 0x45e0
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Option::get_int() const
int
Option::get_int() const
{
    char *endptr;
    int return_value = strtol(value.c_str(), &endptr, 10);
    if (endptr == value.c_str() || *endptr != 0) {
        fprintf(stderr, "invalid value for option %s: %s\n", name.c_str(),
                value.c_str());
        exit(1);
    }
    return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0x44b0
movq (%r14), %rcx
movq 0x28(%rbx), %rsi
cmpq %rsi, %rcx
je 0x69d9
cmpb $0x0, (%rcx)
jne 0x69d9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x4710
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Option::get_float() const
float
Option::get_float() const
{
    char *endptr;
    double return_value = strtod(value.c_str(), &endptr);
    if (endptr == value.c_str() || *endptr != 0) {
        fprintf(stderr, "invalid value for option %s: %s\n", name.c_str(),
                value.c_str());
        exit(1);
    }
    return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x42d0
movq (%r14), %rax
movq 0x28(%rbx), %rsi
cmpq %rsi, %rax
je 0x6a1e
cmpb $0x0, (%rax)
jne 0x6a1e
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x473e
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Option::get_double() const
double
Option::get_double() const
{
    char *endptr;
    double return_value = strtod(value.c_str(), &endptr);
    if (endptr == value.c_str() || *endptr != 0) {
        fprintf(stderr, "invalid value for option %s: %s\n", name.c_str(),
                value.c_str());
        exit(1);
    }
    return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x42d0
movq (%r14), %rax
movq 0x28(%rbx), %rsi
cmpq %rsi, %rax
je 0x6a5e
cmpb $0x0, (%rax)
jne 0x6a5e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x476c
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::parse(int, char**, bool)
void
Config::parse(int argc, char *argv[], bool override)
{
    std::deque<std::string> argument_queue;
    for (int arg_index = 1; arg_index < argc; arg_index++)
        argument_queue.push_back(argv[arg_index]);
    parse_aux(argument_queue, override);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, -0x30(%rbp)
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x86cc
cmpl $0x2, %ebx
jl 0x74be
movl %ebx, %r14d
movl $0x1, %r13d
leaq -0x58(%rbp), %r12
leaq -0xb0(%rbp), %rbx
movq (%r15,%r13,8), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x4150
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9adc
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x74b6
callq 0x4350
incq %r13
cmpq %r13, %r14
jne 0x7489
movzbl -0x30(%rbp), %edx
leaq -0xb0(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x6eda
leaq -0xb0(%rbp), %rdi
callq 0x7fac
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74f2
movq %rax, %rbx
jmp 0x750c
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x750c
callq 0x4350
leaq -0xb0(%rbp), %rdi
callq 0x7fac
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::default_parse(int, char**)
void
Config::default_parse(int argc, char *argv[])
{
    parse(argc, argv);

    if ((*this)["help"].specified) {
        fputs(help_string().c_str(), stdout);
        exit(0);
    }
    check_required();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x1, %ecx
callq 0x742c
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1eaef(%rip), %rsi     # 0x26038
leaq 0x1eaec(%rip), %rdx     # 0x2603c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x5fac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75da
movb 0x4a(%rax), %r14b
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x7579
callq 0x4350
testb %r14b, %r14b
jne 0x7591
movq %rbx, %rdi
callq 0x77de
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7616
movq (%r14), %rdi
movq 0x2c9d6(%rip), %rax     # 0x33f80
movq (%rax), %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x4708
xorl %edi, %edi
callq 0x4420
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x75d2
callq 0x4350
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
const Option&
Config::operator[](std::string long_name) const
{
    LongMap::const_iterator it = long_map.find(long_name);
    if (it == long_map.end()) {
        fprintf(stderr, "Config::get(): unknown option %s\n", long_name.c_str());
        abort();
    }
    return options[it->second];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x68, %rdi
callq 0x9dcc
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
je 0x760e
movslq 0x40(%rax), %rax
leaq (%rax,%rax,8), %rax
shlq $0x4, %rax
addq 0x20(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x48aa
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::check_required() const
void
Config::check_required() const
{
    for (int i = 0; i < (int)options.size(); i++) {
        const Option &option = options[i];
        std::string option_name;
        if (option.short_name != 0) {
            option_name.append(" -");
            option_name.append(1, option.short_name);
        }
        if (option.long_name != "") {
            option_name.append(" --");
            option_name.append(option.long_name);
        }
        if (option.required && !option.specified) {
            fprintf(stderr, "option%s required\n", option_name.c_str());
            print_help(stderr, 1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %rax
subq %r14, %rax
shrq $0x4, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
testl %eax, %eax
jle 0x78e0
movq %rdi, %rbx
xorl %r13d, %r13d
leaq -0x48(%rbp), %r12
xorl %r15d, %r15d
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
cmpb $0x0, (%r14,%r13)
je 0x785b
movq %r12, %rdi
leaq 0x1eb00(%rip), %rsi     # 0x2633e
callq 0x46b0
movsbl (%r14,%r13), %r8d
movq -0x40(%rbp), %rsi
movl $0x1, %ecx
movq %r12, %rdi
xorl %edx, %edx
callq 0x4690
leaq (%r14,%r13), %rdi
addq $0x8, %rdi
leaq 0x1ed2d(%rip), %rsi     # 0x26597
callq 0x40f0
testl %eax, %eax
je 0x7894
movq %r12, %rdi
leaq 0x1ea94(%rip), %rsi     # 0x26311
callq 0x46b0
movq 0x8(%r14,%r13), %rsi
movq 0x10(%r14,%r13), %rdx
movq %r12, %rdi
callq 0x4100
cmpb $0x1, 0x48(%r14,%r13)
jne 0x78a4
cmpb $0x0, 0x4a(%r14,%r13)
je 0x78ef
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x78b6
callq 0x4350
incq %r15
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %rax
subq %r14, %rax
shrq $0x4, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
cltq
addq $0x90, %r13
cmpq %rax, %r15
jl 0x7819
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2c6d2(%rip), %r14     # 0x33fc8
movq (%r14), %rdi
movq -0x48(%rbp), %rdx
leaq 0x1ea78(%rip), %rsi     # 0x2637c
xorl %eax, %eax
callq 0x44d0
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x7ac2
jmp 0x791d
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x7932
callq 0x4350
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::read(_IO_FILE*, bool)
void
Config::read(FILE *file, bool override)
{
    // Read and split the file in fields
    std::string text;
    try {
        text = str::read_file(file);
    } catch (...) {
        std::cerr << "could not read config file" << std::endl;
        exit(1);
    }
    std::vector<std::string> fields;
    str::split_with_quotes(&text, " \t\n", true, &fields);

    // Prepare for parsing
    std::deque<std::string> argument_queue(fields.begin(), fields.end());
    parse_aux(argument_queue, override);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0xb0(%rbp), %rdi
xorl %edx, %edx
callq 0x7ffa
leaq -0x60(%rbp), %rdi
leaq -0xb0(%rbp), %r15
movq %r15, %rsi
callq 0x4430
movq (%r15), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0x799e
callq 0x4350
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x1e9c1(%rip), %rsi     # 0x26378
leaq -0x60(%rbp), %rdi
movl $0x1, %edx
callq 0x80eb
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x40(%rdi)
callq 0x9c3e
movzbl %r14b, %edx
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x6eda
leaq -0xb0(%rbp), %rdi
callq 0x7fac
leaq -0x40(%rbp), %rdi
callq 0x5d4e
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x7a25
callq 0x4350
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x7fac
jmp 0x7a5a
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x99ac
jmp 0x7a5a
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5d4e
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x7a71
callq 0x4350
movq %rbx, %rdi
callq 0x4650
movq %rax, %rdi
callq 0x4160
movq 0x2c560(%rip), %rdi     # 0x33fe8
leaq 0x1e8ce(%rip), %rsi     # 0x2635d
movl $0x1a, %edx
callq 0x4400
movq 0x2c548(%rip), %rdi     # 0x33fe8
callq 0x4180
movl $0x1, %edi
callq 0x4420
movq %rax, %rbx
callq 0x45c0
jmp 0x7a63
movq %rax, %rdi
callq 0x5c6c
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::operator[](unsigned char) const
const Option&
Config::operator[](unsigned char short_name) const
{
    ShortMap::const_iterator it = short_map.find(short_name);
    if (it == short_map.end()) {
        fprintf(stderr, "Config::get(): unknown option %c\n", short_name);
        abort();
    }
    return options[it->second];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x7b48
leaq 0x40(%rdi), %rdx
movq %rdx, %rax
xorl %r8d, %r8d
cmpb %sil, 0x20(%rcx)
setb %r8b
cmovaeq %rcx, %rax
movq 0x10(%rcx,%r8,8), %rcx
testq %rcx, %rcx
jne 0x7b12
cmpq %rdx, %rax
je 0x7b48
cmpb %sil, 0x20(%rax)
ja 0x7b48
movslq 0x24(%rax), %rax
leaq (%rax,%rax,8), %rax
shlq $0x4, %rax
addq 0x20(%rdi), %rax
popq %rbp
retq
movzbl %sil, %edi
callq 0x48d1
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/str.hh
// Function: str::read_file[abi:cxx11](_IO_FILE*, bool)
inline std::string
read_file(FILE *file = stdin, bool rewind = false)
{
    if (rewind)
        ::rewind(file);

    const size_t buf_size = 4096;
    char buf[buf_size];
    bool end = false;
    std::string str;
    while (!end) {
        size_t ret = fread(buf, 1, buf_size, file);
        if (ret < buf_size) {
            if (ferror(file))
                throw std::runtime_error("str::read_file() read error");
            end = true;
        }
        str.append(buf, ret);
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x8020
movq %r14, %rdi
callq 0x4080
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x1030(%rbp), %r15
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %r14, %rcx
callq 0x4520
movq %rax, %r12
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x8066
movq %r14, %rdi
callq 0x46a0
testl %eax, %eax
jne 0x8092
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4070
cmpq $0x1000, %r12           # imm = 0x1000
jae 0x803a
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4190
movq %rax, %r15
leaq 0x1e34d(%rip), %rsi     # 0x263f3
movq %rax, %rdi
callq 0x4140
movq 0x2bf3b(%rip), %rsi     # 0x33ff0
movq 0x2befc(%rip), %rdx     # 0x33fb8
movq %r15, %rdi
callq 0x4610
jmp 0x80d3
movq %rax, %r14
movq %r15, %rdi
callq 0x42b0
jmp 0x80d6
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x80e3
callq 0x4350
movq %r14, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/Ngram.cc
// Function: Ngram::score(int, int, double&)
int
Ngram::score(int node_idx, int word, double &score)
{
    while (true) {
        int tmp = find_node(node_idx, word);
        if (tmp != -1) {
            node_idx = tmp;
            score += nodes[node_idx].prob;
            if (nodes[node_idx].first_arc == -1)
                return nodes[node_idx].backoff_node;
            else
                return node_idx;
        }
        else {
            score += nodes[node_idx].backoff_prob;
            node_idx = nodes[node_idx].backoff_node;
        }
    }

    throw string("Problem in assigning an n-gram score.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
callq 0x9f1c
cmpl $-0x1, %eax
je 0x9e9a
movq 0x78(%r14), %r13
movsd (%rbx), %xmm1
jmp 0x9edd
movsd (%rbx), %xmm1
movq 0x78(%r14), %r13
movslq %r12d, %rax
leaq (%rax,%rax,4), %rax
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r13,%rax,4), %xmm0
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd %xmm1, (%rbx)
movl 0x8(%r13,%rax,4), %r12d
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x9f1c
movsd -0x30(%rbp), %xmm1
cmpl $-0x1, %eax
je 0x9ea2
movslq %eax, %rcx
leaq (%rcx,%rcx,4), %rcx
xorps %xmm0, %xmm0
cvtss2sd (%r13,%rcx,4), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
cmpl $-0x1, 0xc(%r13,%rcx,4)
jne 0x9f0c
leaq (,%rcx,4), %rax
addq %r13, %rax
movl 0x8(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/Ngram.cc
// Function: Ngram::find_node(int, int)
int
Ngram::find_node(int node_idx, int word)
{
    int first_arc = nodes[node_idx].first_arc;
    if (first_arc == -1) return -1;
    int last_arc = nodes[node_idx].last_arc+1;

    auto lower_b=lower_bound(arc_words.begin()+first_arc, arc_words.begin()+last_arc, word);
    int arc_idx = lower_b-arc_words.begin();
    if (arc_idx == last_arc || *lower_b != word) return -1;
    return arc_target_nodes[arc_idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
movq 0x78(%rdi), %rcx
leaq (%rax,%rax,4), %rsi
movslq 0xc(%rcx,%rsi,4), %r10
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $-0x1, %r10
je 0x9fad
leaq (%rcx,%rsi,4), %rcx
movslq 0x10(%rcx), %rcx
incq %rcx
movq 0x90(%rdi), %r8
leaq (%r8,%r10,4), %rsi
movq %rcx, %r9
subq %r10, %r9
jle 0x9f84
movq %r9, %r10
shrq %r10
movq %r10, %r11
notq %r11
addq %r9, %r11
leaq (%rsi,%r10,4), %r9
addq $0x4, %r9
cmpl %edx, -0x4(%r9)
cmovlq %r9, %rsi
cmovgeq %r10, %r11
movq %r11, %r9
testq %r11, %r11
jg 0x9f59
movq %rsi, %r9
subq %r8, %r9
movq %r9, %r8
shrq $0x2, %r8
cmpl %r8d, %ecx
je 0x9fad
cmpl %edx, (%rsi)
jne 0x9fad
movq 0xa8(%rdi), %rax
shlq $0x1e, %r9
sarq $0x1e, %r9
movl (%rax,%r9), %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/Ngram.cc
// Function: Ngram::score(int, int, float&)
int
Ngram::score(int node_idx, int word, float &score)
{
    while (true) {
        int tmp = find_node(node_idx, word);
        if (tmp != -1) {
            node_idx = tmp;
            score += nodes[node_idx].prob;
            if (nodes[node_idx].first_arc == -1)
                return nodes[node_idx].backoff_node;
            else
                return node_idx;
        }
        else {
            score += nodes[node_idx].backoff_prob;
            node_idx = nodes[node_idx].backoff_node;
        }
    }

    throw string("Problem in assigning an n-gram score.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
callq 0x9f1c
cmpl $-0x1, %eax
je 0x9fde
movq 0x78(%r14), %r13
movss (%rbx), %xmm0
jmp 0xa01a
movss (%rbx), %xmm0
movq 0x78(%r14), %r13
movslq %r12d, %rax
leaq (%rax,%rax,4), %rax
addss 0x4(%r13,%rax,4), %xmm0
movss %xmm0, -0x2c(%rbp)
movss %xmm0, (%rbx)
movl 0x8(%r13,%rax,4), %r12d
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x9f1c
movss -0x2c(%rbp), %xmm0
cmpl $-0x1, %eax
je 0x9fe6
movslq %eax, %rcx
leaq (%rcx,%rcx,4), %rcx
addss (%r13,%rcx,4), %xmm0
movss %xmm0, (%rbx)
cmpl $-0x1, 0xc(%r13,%rcx,4)
jne 0xa042
leaq (,%rcx,4), %rax
addq %r13, %rax
movl 0x8(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/util/Ngram.hh
// Function: Ngram::NgramInfo::operator<(Ngram::NgramInfo const&) const
bool operator<(const NgramInfo &ngri) const
        {
            if (ngram.size() != ngri.ngram.size())
                throw std::string("Comparing ngrams of different order");
            for (unsigned int i=0; i<ngram.size(); i++)
                if (ngram[i] < ngri.ngram[i]) return true;
                else if (ngri.ngram[i] < ngram[i]) return false;
            std::cerr << "Warning, comparing same n-grams" << std::endl;
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq %rdi, %rcx
subq %rax, %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
cmpq %rsi, %rcx
jne 0xbe6c
cmpq %rax, %rdi
je 0xbe1e
sarq $0x2, %rcx
movl $0x1, %esi
xorl %edi, %edi
movl (%rax,%rdi,4), %r8d
movl (%rdx,%rdi,4), %edi
cmpl %r8d, %edi
jne 0xbe64
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0xbe09
movq 0x281c3(%rip), %rbx     # 0x33fe8
leaq 0x1a7e4(%rip), %rsi     # 0x26610
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x4400
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4260
xorl %eax, %eax
jmp 0xbe67
setg %al
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x4190
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x1a765(%rip), %rsi     # 0x265ec
leaq 0x1a781(%rip), %rdx     # 0x2660f
movq %rbx, %rdi
callq 0x5fac
leaq 0x27eb3(%rip), %rsi     # 0x33d50
movq 0x280fc(%rip), %rdx     # 0x33fa0
movq %rbx, %rdi
callq 0x4610
movq %rax, %r14
movq %rbx, %rdi
callq 0x42b0
movq %r14, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::StringSet(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&)
StringSet::StringSet(const std::map<std::string, flt_type> &vocab)
{
    max_factor_length = 0;
    learn_map(vocab);
    root_node.arcs.resize(character_count, nullptr);
    for (auto it = vocab.cbegin(); it !=vocab.cend(); ++it)
        add(it->first, it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0xd31c
movl $0x0, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc84a
movslq 0x11c(%rbx), %rsi
leaq -0x20(%rbp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rdi
callq 0xd366
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xc822
leaq 0x20(%r15), %rsi
movsd 0x40(%r15), %xmm0
movq %rbx, %rdi
callq 0xca5c
movq %r15, %rdi
callq 0x4410
movq %rax, %r15
cmpq %r14, %rax
jne 0xc800
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc831
jmp 0xc831
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc841
callq 0x4350
movq %r14, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void
StringSet::add(const string &factor, flt_type cost)
{
    Node *node = &root_node;
    int i=0;
    for (; i < (int)factor.length()-1; i++)
        node = insert(factor[i], "" , 0.0, node);
    insert(factor[i], factor, cost, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, -0x40(%rbp)
movq %rsi, %rdx
movq %rdi, %r14
cmpl $0x2, 0x8(%rsi)
movq %rdi, -0x38(%rbp)
jl 0xcaec
leaq -0x50(%rbp), %r13
xorl %r12d, %r12d
movq %rdx, %r15
movq (%rdx), %rax
movsbl (%rax,%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r13, -0x60(%rbp)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
leaq 0x19aee(%rip), %rdx     # 0x26597
movq %rdx, %rsi
callq 0x5fac
xorps %xmm0, %xmm0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xcbe6
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0xcad7
callq 0x4350
incq %r12
movq %r15, %rdx
movl 0x8(%r15), %eax
decl %eax
cltq
cmpq %rax, %r12
jl 0xca89
jmp 0xcaef
xorl %r12d, %r12d
movq (%rdx), %rax
movsbl (%rax,%r12), %esi
movq -0x38(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
movq %r14, %rcx
callq 0xcbe6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0xcb28
callq 0x4350
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::clear(StringSet::Node*)
void
StringSet::clear(Node *node)
{
    for (auto ait = node->arcs.begin(); ait != node->arcs.end(); ++ait) {
        if (*ait != nullptr) {
            clear((*ait)->target_node);
            delete (*ait)->target_node;
            delete *ait;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r12
movq 0x8(%rsi), %rax
cmpq %rax, %r12
je 0xcbdc
movq %rsi, %rbx
movq %rdi, %r14
movq (%r12), %rcx
testq %rcx, %rcx
je 0xcbd3
movq 0x28(%rcx), %rsi
movq %r14, %rdi
callq 0xcb58
movq (%r12), %rax
movq 0x28(%rax), %r15
testq %r15, %r15
je 0xcba4
movq (%r15), %rdi
testq %rdi, %rdi
je 0xcba4
callq 0x4350
movq %r15, %rdi
callq 0x4350
movq (%r12), %r15
testq %r15, %r15
je 0xcbc7
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0xcbc7
callq 0x4350
movq %r15, %rdi
callq 0x4350
movq 0x8(%rbx), %rax
addq $0x8, %r12
cmpq %rax, %r12
jne 0xcb75
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::insert(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, StringSet::Node*)
StringSet::Node*
StringSet::insert(char letter,
                  const string &factor,
                  flt_type cost,
                  StringSet::Node *node)
{
    // Find a possible existing arc with the letter
    Arc *arc = find_arc(letter, node);

    // No existing arc: create a new arc
    if (arc == nullptr) {
        Node *new_node = new Node();
        unsigned int remapped = remap_char(letter); // unsigned char!
        if (node->arcs.size() < remapped+1) node->arcs.resize(remapped+1, nullptr);
        arc = new Arc(letter, factor, new_node, cost);
        node->arcs[remapped] = arc;
    }

    // Update the existing arc if factor was set
    else if (factor.length() > 0) {
        if (arc->factor.length() == 0) arc->factor = factor;
        arc->cost = cost;
    }

    // Maintain the length of the longest factor
    if ((int)factor.length() > max_factor_length)
        max_factor_length = factor.length();

    return arc->target_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movl %esi, %r13d
movq %rdi, %rbx
movzbl %r13b, %r14d
movzbl 0x1c(%rdi,%r14), %eax
movq (%rcx), %rcx
movq 0x8(%r15), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
cmpq %rax, %rsi
jbe 0xcc62
movq (%rcx,%rax,8), %r12
testq %r12, %r12
je 0xcc62
cmpq $0x0, 0x8(%rdx)
je 0xcd36
cmpq $0x0, 0x10(%r12)
jne 0xcc56
leaq 0x8(%r12), %rdi
movq %rdx, %rsi
movq %rdx, %r14
movsd %xmm0, -0x30(%rbp)
callq 0x41c0
movsd -0x30(%rbp), %xmm0
movq %r14, %rdx
movsd %xmm0, 0x30(%r12)
jmp 0xcd36
movsd %xmm0, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movl $0x18, %edi
callq 0x4390
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
callq 0xd31c
movq %r12, -0x40(%rbp)
movzbl 0x1c(%rbx,%r14), %r14d
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0xccb3
leaq 0x1(%r14), %rsi
leaq -0x68(%rbp), %rdx
movq $0x0, (%rdx)
movq %r15, %rdi
callq 0xd366
movl $0x38, %edi
callq 0x4390
movq %rax, %r12
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x5f0e
movb %r13b, (%r12)
leaq 0x8(%r12), %rdi
movq %r12, %rax
addq $0x18, %rax
movq %rax, 0x8(%r12)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
callq 0x5f0e
movq -0x40(%rbp), %rax
movq %rax, 0x28(%r12)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x30(%r12)
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0xcd2b
callq 0x4350
movq (%r15), %rax
movq %r12, (%rax,%r14,8)
movq -0x38(%rbp), %rdx
movl 0x8(%rdx), %eax
cmpl %eax, 0x18(%rbx)
jge 0xcd41
movl %eax, 0x18(%rbx)
movq 0x28(%r12), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0xcd71
callq 0x4350
jmp 0xcd71
jmp 0xcd6e
movq %rax, %rbx
movq %r12, %rdi
callq 0x4350
movq %rbx, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::includes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool
StringSet::includes(const string &factor) const
{
    const StringSet::Node *node = &root_node;
    StringSet::Arc *arc = nullptr;
    for (unsigned int i=0; i<factor.length(); i++) {
        arc = find_arc(factor[i], node);
        if (arc == nullptr) return false;
        node = arc->target_node;
    }
    if (arc->factor.length() == 0) return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movl $0x1, %edx
xorl %r8d, %r8d
movq %rdi, %rsi
movzbl (%rax,%r8), %r8d
movzbl 0x1c(%rdi,%r8), %r8d
movq (%rsi), %r9
movq 0x8(%rsi), %rsi
subq %r9, %rsi
sarq $0x3, %rsi
cmpq %r8, %rsi
jbe 0xce17
movq (%r9,%r8,8), %r9
testq %r9, %r9
je 0xce17
movq 0x28(%r9), %rsi
movl %edx, %r8d
incl %edx
cmpq %r8, %rcx
ja 0xcdd8
cmpq $0x0, 0x10(%r9)
setne %al
jmp 0xce19
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::get_score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
flt_type
StringSet::get_score(const string &factor) const
{
    const StringSet::Node *node = &root_node;
    StringSet::Arc *arc = nullptr;
    for (unsigned int i=0; i<factor.length(); i++) {
        arc = find_arc(factor[i], node);
        if (arc == nullptr) throw string("could not find factor");
        node = arc->target_node;
    }
    if (arc->factor.length() == 0) throw string("could not find factor");
    return arc->cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xce70
movq (%rsi), %rcx
movl $0x1, %edx
xorl %r9d, %r9d
movq %rdi, %r8
movzbl (%rcx,%r9), %esi
movzbl 0x1c(%rdi,%rsi), %esi
movq (%r8), %r9
movq 0x8(%r8), %r8
subq %r9, %r8
sarq $0x3, %r8
cmpq %rsi, %r8
jbe 0xce83
movq (%r9,%rsi,8), %rsi
testq %rsi, %rsi
je 0xce83
movq 0x28(%rsi), %r8
movl %edx, %r9d
incl %edx
cmpq %r9, %rax
ja 0xce3a
jmp 0xce72
xorl %esi, %esi
cmpq $0x0, 0x10(%rsi)
je 0xcec3
movsd 0x30(%rsi), %xmm0
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x4190
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x197c8(%rip), %rsi     # 0x26666
leaq 0x197d6(%rip), %rdx     # 0x2667b
movq %rbx, %rdi
callq 0x5fac
leaq 0x26e9c(%rip), %rsi     # 0x33d50
movq 0x270e5(%rip), %rdx     # 0x33fa0
movq %rbx, %rdi
callq 0x4610
movl $0x20, %edi
callq 0x4190
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x19788(%rip), %rsi     # 0x26666
leaq 0x19796(%rip), %rdx     # 0x2667b
movq %rbx, %rdi
callq 0x5fac
jmp 0xcead
jmp 0xcef1
movq %rax, %r14
movq %rbx, %rdi
callq 0x42b0
movq %r14, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
flt_type
StringSet::remove(const string &factor)
{
    StringSet::Node *node = &root_node;
    StringSet::Arc *arc = nullptr;

    for (unsigned int i=0; i<factor.length(); i++) {
        arc = find_arc(factor[i], node);
        if (arc == nullptr) throw string("could not remove factor");
        node = arc->target_node;
    }
    arc->factor.clear();
    flt_type cost = arc->cost;
    arc->cost = 0.0;
    return cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movl $0x1, %edx
xorl %r9d, %r9d
movq %rdi, %r8
movzbl (%rax,%r9), %esi
movzbl 0x1c(%rdi,%rsi), %esi
movq (%r8), %r9
movq 0x8(%r8), %r8
subq %r9, %r8
sarq $0x3, %r8
cmpq %rsi, %r8
jbe 0xcf6c
movq (%r9,%rsi,8), %rsi
testq %rsi, %rsi
je 0xcf6c
movq 0x28(%rsi), %r8
movl %edx, %r9d
incl %edx
cmpq %r9, %rcx
ja 0xcf1d
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq 0x8(%rsi), %rcx
movb $0x0, (%rcx)
movsd 0x30(%rsi), %xmm0
movq %rax, 0x30(%rsi)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x4190
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x196f5(%rip), %rsi     # 0x2667c
leaq 0x19705(%rip), %rdx     # 0x26693
movq %rbx, %rdi
callq 0x5fac
leaq 0x26db3(%rip), %rsi     # 0x33d50
movq 0x26ffc(%rip), %rdx     # 0x33fa0
movq %rbx, %rdi
callq 0x4610
movq %rax, %r14
movq %rbx, %rdi
callq 0x42b0
movq %r14, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::collect_arcs(std::vector<StringSet::Arc*, std::allocator<StringSet::Arc*>>&)
void
StringSet::collect_arcs(vector<Arc*> &arcs)
{
    vector<Node*> nodes_to_process;
    nodes_to_process.push_back(&root_node);

    while (nodes_to_process.size() > 0) {
        Node *node = nodes_to_process.back();
        nodes_to_process.pop_back();

        for (auto ait = node->arcs.begin(); ait != node->arcs.end(); ++ait) {
            if (*ait == nullptr) continue;
            arcs.push_back(*ait);
            nodes_to_process.push_back((*ait)->target_node);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x48(%rbp), %rdx
movq %rdi, (%rdx)
movq %rax, %rdi
xorl %esi, %esi
callq 0xd6c8
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
cmpq %rdi, %rax
je 0xd260
leaq -0x40(%rbp), %r14
movq -0x8(%rax), %r12
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
movq (%r12), %r15
cmpq 0x8(%r12), %r15
je 0xd25b
movq (%r15), %rax
testq %rax, %rax
je 0xd248
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xd217
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0xd222
movq %rbx, %rdi
movq %r15, %rdx
callq 0xd802
movq (%r15), %rdx
addq $0x28, %rdx
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0xd240
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, -0x38(%rbp)
jmp 0xd248
movq %r14, %rdi
callq 0xd8d8
addq $0x8, %r15
cmpq 0x8(%r12), %r15
jne 0xd1fb
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
cmpq %rdi, %rax
jne 0xd1e4
testq %rdi, %rdi
je 0xd26a
callq 0x4350
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd279
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xd28a
callq 0x4350
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O3/aalto-speech[P]ftk/src/StringSet.cc
// Function: StringSet::string_count()
unsigned int
StringSet::string_count()
{
    vector<Arc*> arcs;
    collect_arcs(arcs);

    unsigned int count = 0;
    for (auto ait = arcs.begin(); ait != arcs.end(); ++ait) {
        if (*ait == nullptr) continue;
        if ((*ait)->factor.length() > 0) count++;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0xd19a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0xd2dd
movq %rdi, %rcx
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xd2d4
cmpq $0x1, 0x10(%rdx)
sbbl $-0x1, %ebx
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0xd2c4
testq %rdi, %rdi
je 0xd2e7
callq 0x4350
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xd301
callq 0x4350
movq %rbx, %rdi
callq 0x4650