LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetNeckGlobalDirFromSightDelay(int)
AngleDeg WorldStateUpdater::GetNeckGlobalDirFromSightDelay(int sight_delay) {
  Assert(sight_delay >= 0 && sight_delay <= HistoryState::HISTORY_SIZE);

  if (sight_delay == 0) {
    return GetSelf().GetNeckGlobalDir();
  } else {
    sight_delay = Min(sight_delay, int(HistoryState::HISTORY_SIZE));
    double neck_dir = mpWorldState->GetHistory(sight_delay)
                          ->GetTeammate(mSelfUnum)
                          .GetNeckDir();
    return GetSelf().GetBodyDir() + neck_dir;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x55993
cmpl $0xa, %esi
pushq $0xa
popq %rax
cmovll %esi, %eax
movq 0x8(%rbx), %rdi
movl %eax, %esi
callq 0x4c81e
movslq 0x14(%rbx), %rcx
imulq $0x178, %rcx, %rcx      # imm = 0x178
leaq (%rax,%rcx), %rdi
addq $-0x38, %rdi
callq 0xd40e
movslq 0x14(%rbx), %rax
movq 0x8(%rbx), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
addsd -0x20(%rcx,%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movslq 0x14(%rbx), %rax
movq 0x8(%rbx), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
leaq (%rax,%rcx), %rdi
addq $-0xd0, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4bef2
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetSelfVelFromSightDelay(int)
Vector WorldStateUpdater::GetSelfVelFromSightDelay(int sight_delay) {
  Assert(sight_delay >= 0 && sight_delay <= HistoryState::HISTORY_SIZE);

  if (sight_delay == 0) {
    return GetSelf().GetVel();
  } else {
    sight_delay = Min(sight_delay, int(HistoryState::HISTORY_SIZE));
    const PlayerState &player =
        mpWorldState->GetHistory(sight_delay)->GetTeammate(mSelfUnum);
    return player.GetVel()
        .Rotate(-player.GetNeckGlobalDir())
        .Rotate(GetNeckGlobalDirFromSightDelay(sight_delay));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x55a4b
cmpl $0xa, %esi
pushq $0xa
popq %r14
cmovll %esi, %r14d
movq 0x8(%rbx), %rdi
movl %r14d, %esi
callq 0x4c81e
movslq 0x14(%rbx), %rcx
imulq $0x178, %rcx, %rcx      # imm = 0x178
leaq (%rcx,%rax), %rdi
addq $-0xd0, %rdi
leaq (%rcx,%rax), %r15
addq $-0xa0, %r15
callq 0x4bef2
xorps 0x1610(%rip), %xmm0     # 0x57020
leaq -0x28(%rbp), %rsi
movlps %xmm0, (%rsi)
movq %r15, %rdi
callq 0xd02c
leaq -0x38(%rbp), %r15
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5593e
leaq -0x20(%rbp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0xd02c
jmp 0x55a6c
movslq 0x14(%rbx), %rax
movq 0x8(%rbx), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
movsd -0xa0(%rax,%rcx), %xmm0
movsd -0x98(%rax,%rcx), %xmm1
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerParam.h
// Function: PlayerParam::ConvertMarkDist(double)
double ConvertMarkDist(double dist) {
    Assert(dist >= 0);
    int low = 0;
    int middle = 0;
    int high = MARKSIZE;

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

      if (middle >= MARKSIZE || middle < 0) {
        break;
      }

      if (fabs(dist - mMarkChange[middle][0]) < 0.01) {
        return mMarkChange[middle][1];
      }

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

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

// Assembly:
addq $0x37d8, %rdi           # imm = 0x37D8
movl $0x184, %ecx            # imm = 0x184
xorl %r8d, %r8d
pushq $0x2
popq %rsi
movapd 0x155a(%rip), %xmm4     # 0x57010
movsd 0x1c5a(%rip), %xmm1     # 0x57718
cmpl %ecx, %r8d
jg 0x55b10
leal (%rcx,%r8), %eax
cltd
idivl %esi
leal (%rcx,%r8), %edx
addl $0xfffffcf8, %edx       # imm = 0xFFFFFCF8
cmpl $0xfffffcf7, %edx       # imm = 0xFFFFFCF7
jb 0x55b10
movl %eax, %edx
imulq $0x18, %rdx, %rdx
movsd (%rdi,%rdx), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
andpd %xmm4, %xmm3
ucomisd %xmm3, %xmm1
ja 0x55b8a
ucomisd %xmm0, %xmm2
leal 0x1(%rax), %edx
cmoval %r8d, %edx
cmoval %eax, %ecx
movl %edx, %r8d
jmp 0x55abe
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x214d1(%rip), %rdi     # 0x76ff0
leaq 0x5db5(%rip), %rsi      # 0x5b8db
movsd %xmm0, -0x8(%rbp)
callq 0x94b0
leaq 0x563b(%rip), %rsi      # 0x5b172
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movl $0x186, %esi            # imm = 0x186
callq 0x9890
leaq 0x38cc(%rip), %rsi      # 0x5941f
movq %rax, %rdi
callq 0x94b0
leaq 0x5d8e(%rip), %rsi      # 0x5b8f0
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movsd -0x8(%rbp), %xmm0
callq 0x97e0
movq %rax, %rdi
callq 0x99e8
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
addq %rdx, %rdi
movsd 0x8(%rdi), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
movl $0x183, %r8d            # imm = 0x183
xorl %r10d, %r10d
pushq $0x2
popq %r9
cmpl %r8d, %r10d
jg 0x55c18
leal (%r8,%r10), %ecx
movl %ecx, %eax
cltd
idivl %r9d
cmpl $0x306, %ecx            # imm = 0x306
jge 0x55c85
leal 0x1(%rax), %r11d
movslq %eax, %rdx
imulq $0x18, %rdx, %rbx
leaq (%rsi,%rbx), %rdx
movsd (%rsi,%rbx), %xmm3
ucomisd %xmm3, %xmm0
jb 0x55bfc
movslq %r11d, %rbx
imulq $0x18, %rbx, %rbx
movsd (%rsi,%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0x55c8f
incl %ecx
cmpl $0x2, %ecx
jbe 0x55cb1
ucomisd %xmm0, %xmm3
cmoval %r10d, %r11d
cmoval %eax, %r8d
movl %r11d, %r10d
jmp 0x55bb1
movq 0x213d1(%rip), %rdi     # 0x76ff0
leaq 0x5cb5(%rip), %rsi      # 0x5b8db
movapd %xmm0, -0x20(%rbp)
callq 0x94b0
leaq 0x553b(%rip), %rsi      # 0x5b172
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movl $0x1ac, %esi            # imm = 0x1AC
callq 0x9890
leaq 0x37cc(%rip), %rsi      # 0x5941f
movq %rax, %rdi
callq 0x94b0
leaq 0x5c8e(%rip), %rsi      # 0x5b8f0
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movapd -0x20(%rbp), %xmm0
callq 0x97e0
movq %rax, %rdi
callq 0x99e8
xorpd %xmm0, %xmm0
jmp 0x55cb6
movsd 0x5c30(%rdi), %xmm0
jmp 0x55cb6
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd 0x1371(%rip), %xmm3     # 0x57010
andpd %xmm3, %xmm2
subsd %xmm1, %xmm0
andpd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x55cbd
movsd 0x10(%rdx), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
addq %rbx, %rsi
movsd 0x10(%rsi), %xmm0
jmp 0x55cb6
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::AutoUpdate(int, double)
inline void PlayerState::AutoUpdate(int delay_add, double conf_dec_factor) {
  MobileState::AutoUpdate(delay_add, conf_dec_factor);

  mNeckDir.AutoUpdate(delay_add, conf_dec_factor);
  mBodyDir.AutoUpdate(delay_add, conf_dec_factor);
  mArmPoint.AutoUpdate(delay_add, conf_dec_factor);
  mFocusOn.AutoUpdate(delay_add, conf_dec_factor);

  mCollideWithPost = false;
  mCollideWithPlayer = false;
  mCollideWithBall = false;
  mIsKicked = false;
  mIsTired = false;

  if (mTackleBan > 0) {
    mTackleBan -= delay_add;
    mTackleBan = Max(mTackleBan, 0);
  }

  if (mFoulChargedCycle > 0) {
    mFoulChargedCycle -= delay_add;
    mFoulChargedCycle = Max(mFoulChargedCycle, 0);
  }

  if (mCatchBan > 0) {
    mCatchBan -= delay_add;
    mCatchBan = Max(mCatchBan, 0);
  }

  if (mArmPoint.mValue.mExpireBan > 0) {
    mArmPoint.mValue.mExpireBan -= delay_add;
    mArmPoint.mValue.mExpireBan = Max(mArmPoint.mValue.mExpireBan, 0);
  }

  if (mArmPoint.mValue.mMovableBan > 0) {
    mArmPoint.mValue.mMovableBan -= delay_add;
    mArmPoint.mValue.mMovableBan = Max(mArmPoint.mValue.mMovableBan, 0);
  }

  if (GetPosDelay() > delay_add) {
    mIsBodyDirMayChanged = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movl %esi, %r14d
movq %rdi, %rbx
callq 0xde4c
addl %r14d, 0xa0(%rbx)
movsd 0xa8(%rbx), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0xa8(%rbx)
addl %r14d, 0xb8(%rbx)
movsd 0xc0(%rbx), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0xc0(%rbx)
addl %r14d, 0xe8(%rbx)
movsd 0xf0(%rbx), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0xf0(%rbx)
addl %r14d, 0x100(%rbx)
mulsd 0x108(%rbx), %xmm1
movsd %xmm1, 0x108(%rbx)
xorl %eax, %eax
movb %al, 0x122(%rbx)
andw $0x0, 0x120(%rbx)
movb %al, 0x111(%rbx)
movb %al, 0x160(%rbx)
movl 0xc8(%rbx), %ecx
testl %ecx, %ecx
jle 0x55d84
subl %r14d, %ecx
testl %ecx, %ecx
cmovgl %ecx, %eax
movl %eax, 0xc8(%rbx)
movl 0x124(%rbx), %eax
testl %eax, %eax
jle 0x55d9e
subl %r14d, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, 0x124(%rbx)
movl 0xcc(%rbx), %eax
testl %eax, %eax
jle 0x55db8
subl %r14d, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, 0xcc(%rbx)
movl 0xd4(%rbx), %eax
testl %eax, %eax
jle 0x55dd2
subl %r14d, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, 0xd4(%rbx)
movl 0xd0(%rbx), %eax
testl %eax, %eax
jle 0x55dec
subl %r14d, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, 0xd0(%rbx)
cmpl %r14d, 0x18(%rbx)
jle 0x55df9
movb $0x1, 0x174(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/BaseState.h
// Function: MobileState::operator=(MobileState const&)
const MobileState &operator=(const MobileState &v) {
    mVel = v.mVel;
    mDecay = v.mDecay;

    UpdatePos(v.GetPos(), v.GetPosDelay(), v.GetPosConf()); // use old predictor

    mEffectiveSpeedMax = v.mEffectiveSpeedMax;

    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movups 0x30(%rsi), %xmm0
movups 0x40(%rsi), %xmm1
movups %xmm1, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movsd 0x58(%rsi), %xmm0
movsd %xmm0, 0x58(%rdi)
addq $0x8, %rsi
movl 0x18(%rbx), %edx
movsd 0x20(%rbx), %xmm0
callq 0xde1c
movsd 0x60(%rbx), %xmm0
movsd %xmm0, 0x60(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5639e
callq 0x3db2c
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x3f36e
callq 0x38d94
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x39990
callq 0x38d94
cmpb $0x1, 0x31a5(%rax)
jne 0x5630f
pushq $0x30
popq %rdi
callq 0x94d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x17f58
jmp 0x56347
callq 0x38d94
cmpb $0x1, 0x31a6(%rax)
jne 0x56334
movl $0x198, %edi            # imm = 0x198
callq 0x94d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4317c
jmp 0x56347
pushq $0x38
popq %rdi
callq 0x94d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x38510
callq 0x38d94
cmpb $0x1, 0x5c40(%rax)
jne 0x5635f
movq %rbx, %rdi
callq 0x17b32
jmp 0x56367
movq %rbx, %rdi
callq 0x17d12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
pushq $0x38
jmp 0x5638d
movq %rax, %r14
movl $0x198, %esi            # imm = 0x198
jmp 0x5638e
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x94f0
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9c(%rip), %rsi        # 0x56445
pushq $0x2
popq %rdi
callq 0x95b0
cmpq $-0x1, %rax
je 0x5640d
leaq 0x87(%rip), %rsi        # 0x56445
pushq $0x3
popq %rdi
callq 0x95b0
cmpq $-0x1, %rax
je 0x56416
leaq 0x72(%rip), %rsi        # 0x56445
pushq $0xb
popq %rdi
callq 0x95b0
cmpq $-0x1, %rax
je 0x5641f
leaq 0x5d(%rip), %rsi        # 0x56445
pushq $0x4
popq %rdi
callq 0x95b0
cmpq $-0x1, %rax
je 0x56428
leaq 0x48(%rip), %rsi        # 0x56445
pushq $0x8
popq %rdi
callq 0x95b0
cmpq $-0x1, %rax
je 0x56431
popq %rbp
retq
leaq 0x54f4(%rip), %rdi      # 0x5b908
jmp 0x56438
leaq 0x54f2(%rip), %rdi      # 0x5b90f
jmp 0x56438
leaq 0x54f1(%rip), %rdi      # 0x5b917
jmp 0x56438
leaq 0x54f0(%rip), %rdi      # 0x5b91f
jmp 0x56438
leaq 0x54ee(%rip), %rdi      # 0x5b926
callq 0x9410
pushq $0x1
popq %rdi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O2/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       # 0x56445
callq 0x95b0
movq 0x20b8f(%rip), %r14     # 0x76ff0
leaq 0x54c5(%rip), %rsi      # 0x5b92d
movq %r14, %rdi
callq 0x94b0
movq %rax, %rdi
movl %ebx, %esi
callq 0x9890
movq %rax, %rdi
callq 0x99e8
callq 0x564de
leaq 0x54ad(%rip), %rsi      # 0x5b93b
movq %r14, %rdi
callq 0x94b0
movq %rax, %rdi
callq 0x99e8
callq 0x2ca2e
movq %rax, %rdi
callq 0x2cdf0
callq 0x2ca2e
movq %rax, %rdi
callq 0x2cd0e
callq 0x1d7c4
leaq 0x548a(%rip), %rsi      # 0x5b94e
pushq $0x3
popq %rdx
movq %rax, %rdi
callq 0x1da72
pushq $0x64
popq %rdi
callq 0x17eda
xorl %edi, %edi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O2/MarkOates[P]file-downloader/file_downloader.cpp
// Function: FileDownloader::progress_function(void*, double, double, double, double)
int FileDownloader::progress_function(void *ptr, double download_total, double download_now, double upload_total, double upload_now)
{
   FileDownloader::FileHandle &handle = *static_cast<FileDownloader::FileHandle *>(ptr);
   if (download_total == 0) return 0;
   if (handle.abort) return 1;

   handle.status = DOWNLOADING;
   handle.percentage = download_now / download_total;
   handle.download_size = download_total;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x3eca
jnp 0x3ef4
cmpb $0x0, 0x10(%rdi)
je 0x3ed7
movl $0x1, %eax
jmp 0x3ef4
movl $0x1, 0x4(%rdi)
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, 0xc(%rdi)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x70, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1db32(%rip), %rsi     # 0x231d6
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x4140
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5d86
movl %eax, %r14d
leaq -0x48(%rbp), %rdi
callq 0x46b8
testb %r14b, %r14b
je 0x56fb
pushq $0x10
popq %rdi
callq 0x4350
movq %rax, %r14
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4460
movq %r14, %rdi
movq %r12, %rsi
callq 0x5792
jmp 0x5722
movl $0x210, %edi            # imm = 0x210
callq 0x4350
movq %rax, %r14
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4460
movq %r14, %rdi
movq %r12, %rsi
callq 0x5db0
movq %r14, (%rbx)
movq %r12, %rdi
callq 0x46b8
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x574d
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x46b8
jmp 0x5759
jmp 0x5756
movq %rax, %rbx
movq %r14, %rdi
callq 0x4320
jmp 0x5774
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x46b8
jmp 0x5774
movq %rax, %rbx
movq %rbx, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/aalto-speech[P]ftk/util/io.cc
// Function: GZipFileInput::getline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool
GZipFileInput::getline(string &line)
{
    char buffer[GZIP_BUFFER_SIZE];
    char *res = gzgets(gzf, buffer, GZIP_BUFFER_SIZE-1);
    if (res != NULL) {
        strtok(buffer, "\r\n");
        line.assign(buffer);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x100008, %rsp         # imm = 0x100008
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
leaq -0x100020(%rbp), %rsi
movl $0xfffff, %edx          # imm = 0xFFFFF
callq 0x45b0
movq %rax, %r14
testq %rax, %rax
je 0x584f
leaq 0x1d9a5(%rip), %rsi     # 0x231da
leaq -0x100020(%rbp), %r15
movq %r15, %rdi
callq 0x4500
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4640
testq %r14, %r14
setne %al
addq $0x100008, %rsp         # imm = 0x100008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x70, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1d956(%rip), %rsi     # 0x231d6
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x4140
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5dfa
movl %eax, %r14d
leaq -0x48(%rbp), %rdi
callq 0x46b8
testb %r14b, %r14b
je 0x58d7
pushq $0x18
popq %rdi
callq 0x4350
movq %rax, %r14
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4460
movq %r14, %rdi
movq %r12, %rsi
callq 0x5bda
jmp 0x58fe
movl $0x208, %edi            # imm = 0x208
callq 0x4350
movq %rax, %r14
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4460
movq %r14, %rdi
movq %r12, %rsi
callq 0x5a60
movq %r14, (%rbx)
movq %r12, %rdi
callq 0x46b8
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x5929
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x46b8
jmp 0x5935
jmp 0x5932
movq %rax, %rbx
movq %r14, %rdi
callq 0x4320
jmp 0x5950
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x46b8
jmp 0x5950
movq %rax, %rbx
movq %rbx, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5994
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5990
movq (%rdi), %rax
callq *0x48(%rax)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5c63
movq 0x8(%rbx), %rdi
callq 0x4590
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x46c0
movq (%r14), %rdx
movq 0x28(%rbx), %rcx
cmpq %rcx, %rdx
je 0x5edb
cmpb $0x0, (%rdx)
jne 0x5edb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2f0de(%rip), %rax     # 0x34fc0
movq (%rax), %rdi
movq 0x70(%rbx), %rdx
leaq 0x1d35f(%rip), %rsi     # 0x2324f
xorl %eax, %eax
callq 0x4480
pushq $0x1
popq %rdi
callq 0x43c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42c0
movq (%r14), %rax
movq 0x28(%rbx), %rcx
cmpq %rcx, %rax
je 0x5f3c
cmpb $0x0, (%rax)
jne 0x5f3c
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2f07d(%rip), %rax     # 0x34fc0
movq (%rax), %rdi
movq 0x70(%rbx), %rdx
leaq 0x1d2fe(%rip), %rsi     # 0x2324f
xorl %eax, %eax
callq 0x4480
pushq $0x1
popq %rdi
callq 0x43c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42c0
movq (%r14), %rax
movq 0x28(%rbx), %rcx
cmpq %rcx, %rax
je 0x5f98
cmpb $0x0, (%rax)
jne 0x5f98
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2f021(%rip), %rax     # 0x34fc0
movq (%rax), %rdi
movq 0x70(%rbx), %rdx
leaq 0x1d2a2(%rip), %rsi     # 0x2324f
xorl %eax, %eax
callq 0x4480
pushq $0x1
popq %rdi
callq 0x43c0
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq -0xa8(%rbp), %rdi
callq 0x796c
movslq %ebx, %r14
pushq $0x1
popq %r12
leaq -0x58(%rbp), %r13
leaq -0x29(%rbp), %rbx
cmpq %r14, %r12
jge 0x6861
movq (%r15,%r12,8), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x4140
leaq -0xa8(%rbp), %rdi
movq %r13, %rsi
callq 0x8d02
movq %r13, %rdi
callq 0x46b8
incq %r12
jmp 0x6831
movzbl -0x30(%rbp), %edx
leaq -0xa8(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x63c4
leaq -0xa8(%rbp), %rdi
callq 0x7200
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x68a3
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x46b8
jmp 0x68a6
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rcx
callq 0x67f6
leaq 0x1c763(%rip), %rsi     # 0x2303a
leaq -0x30(%rbp), %r14
leaq -0x50(%rbp), %rdx
movq %r14, %rdi
callq 0x4140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x695a
movb 0x4a(%rax), %r14b
leaq -0x30(%rbp), %rdi
callq 0x46b8
cmpb $0x1, %r14b
je 0x6916
movq %rbx, %rdi
callq 0x6b44
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x69ae
movq (%r14), %rdi
movq 0x2e659(%rip), %rax     # 0x34f88
movq (%rax), %rsi
callq 0x4390
movq %r14, %rdi
callq 0x46b8
xorl %edi, %edi
callq 0x43c0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x46b8
movq %rbx, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9096
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
je 0x698d
movslq 0x40(%rax), %rax
imulq $0x90, %rax, %rax
addq 0x20(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2e62c(%rip), %rax     # 0x34fc0
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0x1c9ee(%rip), %rsi     # 0x2338f
xorl %eax, %eax
callq 0x4480
callq 0x41e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::help_string[abi:cxx11]() const
std::string
Config::help_string() const
{
    std::string help;
    help.reserve(1024);
    help.append(usage_line);

    // Iterate options
    for (int i = 0; i < (int)options.size(); i++) {
        const Option& option = options[i];

        help.append("  ");

        // Append short name
        if (option.short_name != 0) {
            help.append("-");
            help.append(1, option.short_name);
        }
        else
            help.append("  ");

        // Append long name
        if (option.long_name != "") {
            if (option.short_name != 0)
                help.append(", ");
            else
                help.append("  ");

            help.append("--");
            help.append(option.long_name);
            help.append(longest_name_length - option.long_name.length(), ' ');
        }
        else if (longest_name_length > 0)
            help.append(longest_name_length + 4, ' ');

        // Append the help text
        help.append("  ");
        help.append(option.help);
        help.append("\n");
    }

    return help;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x400, %esi            # imm = 0x400
callq 0x4510
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4660
movq %r14, -0x30(%rbp)
pushq $0x50
popq %r15
xorl %r14d, %r14d
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r12
movq 0x28(%rax), %rax
subq %r12, %rax
cqto
movl $0x90, %ecx
idivq %rcx
cltq
cmpq %rax, %r14
jge 0x6b1d
movq %rbx, %rdi
leaq 0x1c947(%rip), %rsi     # 0x23367
callq 0x4630
cmpb $0x0, -0x50(%r12,%r15)
je 0x6a4f
movq %rbx, %rdi
leaq 0x1c8e0(%rip), %rsi     # 0x23317
callq 0x4630
movsbl -0x50(%r12,%r15), %edx
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0x4380
jmp 0x6a5e
movq %rbx, %rdi
leaq 0x1c90e(%rip), %rsi     # 0x23367
callq 0x4630
leaq (%r12,%r15), %r13
addq $-0x48, %r13
movq %r13, %rdi
leaq 0x1cab7(%rip), %rsi     # 0x23527
callq 0x704f
testb %al, %al
je 0x6ac5
cmpb $0x0, -0x50(%r12,%r15)
leaq 0x1c8e4(%rip), %rsi     # 0x2336a
leaq 0x1c8da(%rip), %rax     # 0x23367
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x4630
movq %rbx, %rdi
leaq 0x1c847(%rip), %rsi     # 0x232ea
callq 0x4630
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4660
movq -0x30(%rbp), %rax
movslq 0xb0(%rax), %rsi
subq -0x40(%r12,%r15), %rsi
jmp 0x6ad7
movq -0x30(%rbp), %rax
movl 0xb0(%rax), %esi
testl %esi, %esi
jle 0x6ae2
addq $0x4, %rsi
movq %rbx, %rdi
pushq $0x20
popq %rdx
callq 0x4380
movq %rbx, %rdi
leaq 0x1c87b(%rip), %rsi     # 0x23367
callq 0x4630
addq %r15, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4660
movq %rbx, %rdi
leaq 0x1c849(%rip), %rsi     # 0x23352
callq 0x4630
incq %r14
addq $0x90, %r15
jmp 0x69f2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b31
movq %rax, %r14
movq %rbx, %rdi
callq 0x46b8
movq %r14, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %rax
subq %r12, %rax
cqto
movl $0x90, %ecx
idivq %rcx
cltq
cmpq %rax, %r14
jge 0x6c16
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
cmpb $0x0, (%r12,%r15)
je 0x6bb7
leaq -0x48(%rbp), %rdi
leaq 0x1c775(%rip), %rsi     # 0x23316
callq 0x4630
movsbl (%r12,%r15), %edx
leaq -0x48(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x4380
leaq (%r12,%r15), %r13
addq $0x8, %r13
movq %r13, %rdi
leaq 0x1c95e(%rip), %rsi     # 0x23527
callq 0x704f
testb %al, %al
je 0x6bee
leaq -0x48(%rbp), %rdi
leaq 0x1c70c(%rip), %rsi     # 0x232e9
callq 0x4630
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x4660
cmpb $0x1, 0x48(%r12,%r15)
jne 0x6bfe
cmpb $0x0, 0x4a(%r12,%r15)
je 0x6c25
leaq -0x48(%rbp), %rdi
callq 0x46b8
incq %r14
addq $0x90, %r15
jmp 0x6b5e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2e394(%rip), %r14     # 0x34fc0
movq (%r14), %rdi
movq -0x48(%rbp), %rdx
leaq 0x1c71a(%rip), %rsi     # 0x23354
xorl %eax, %eax
callq 0x4480
movq (%r14), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x6da2
jmp 0x6c51
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x46b8
movq %rbx, %rdi
callq 0x45f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0xb0(%rbp), %rdi
xorl %edx, %edx
callq 0x7271
leaq -0x60(%rbp), %r15
leaq -0xb0(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x43d0
movq %r12, %rdi
callq 0x46b8
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
leaq 0x1c680(%rip), %rsi     # 0x23350
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x735a
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
leaq -0x21(%rbp), %rcx
callq 0x74f4
movzbl %r14b, %edx
leaq -0xb0(%rbp), %rsi
movq %rbx, %rdi
callq 0x63c4
leaq -0xb0(%rbp), %rdi
callq 0x7200
leaq -0x40(%rbp), %rdi
callq 0x54b6
leaq -0x60(%rbp), %rdi
callq 0x46b8
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x7200
jmp 0x6d4a
jmp 0x6d47
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x54b6
leaq -0x60(%rbp), %rdi
callq 0x46b8
movq %rbx, %rdi
callq 0x45f0
movq %rax, %rdi
callq 0x4150
movq 0x2e275(%rip), %rdi     # 0x34fe8
leaq 0x1c5bb(%rip), %rsi     # 0x23335
callq 0x4340
movq %rax, %rdi
callq 0x4180
pushq $0x1
popq %rdi
callq 0x43c0
movq %rax, %rbx
callq 0x4560
jmp 0x6d53
movq %rax, %rdi
callq 0x53b8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
addq $0x38, %rdi
movq %rax, %rsi
callq 0x903e
leaq 0x40(%rbx), %rcx
cmpq %rcx, %rax
je 0x6e19
movslq 0x24(%rax), %rax
imulq $0x90, %rax, %rax
addq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2e1a0(%rip), %rax     # 0x34fc0
movq (%rax), %rdi
movzbl -0x9(%rbp), %edx
leaq 0x1c53f(%rip), %rsi     # 0x2336d
xorl %eax, %eax
callq 0x4480
callq 0x41e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7297
movq %r14, %rdi
callq 0x4070
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x1030(%rbp), %r15
pushq $0x1
popq %r12
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x44d0
movq %rax, %r13
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x72dc
movq %r14, %rdi
callq 0x4620
testl %eax, %eax
jne 0x7308
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4060
cmpq $0x1000, %r13           # imm = 0x1000
jae 0x72b2
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x1c0b1(%rip), %rsi     # 0x233cb
movq %rax, %rdi
callq 0x4130
movq 0x2dcc7(%rip), %rsi     # 0x34ff0
movq 0x2dc80(%rip), %rdx     # 0x34fb0
movq %r15, %rdi
callq 0x45c0
jmp 0x7347
movq %rax, %r14
movq %r15, %rdi
callq 0x4290
jmp 0x734a
movq %rax, %r14
movq %rbx, %rdi
callq 0x46b8
movq %r14, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x9194
movq 0x78(%r15), %rcx
cmpl $-0x1, %eax
jne 0x916a
movslq %r12d, %rax
imulq $0x14, %rax, %rax
cvtss2sd 0x4(%rcx,%rax), %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movl 0x8(%rcx,%rax), %r12d
jmp 0x9137
movslq %eax, %rdx
imulq $0x14, %rdx, %rdx
cvtss2sd (%rcx,%rdx), %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
cmpl $-0x1, 0xc(%rcx,%rdx)
jne 0x918b
addq %rdx, %rcx
movl 0x8(%rcx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, -0x1c(%rbp)
movslq %esi, %rcx
movq 0x78(%rdi), %rax
imulq $0x14, %rcx, %rdx
movslq 0xc(%rax,%rdx), %rcx
pushq $-0x1
popq %rbx
cmpq $-0x1, %rcx
je 0x9212
movq %rdi, %r14
addq %rdx, %rax
movslq 0x10(%rax), %r15
movq 0x90(%rdi), %rax
leaq (%rax,%rcx,4), %rdi
leaq (%rax,%r15,4), %rsi
addq $0x4, %rsi
incq %r15
leaq -0x1c(%rbp), %rdx
callq 0xa2e0
movq %rax, %rcx
subq 0x90(%r14), %rcx
movq %rcx, %rdx
shrq $0x2, %rdx
cmpl %edx, %r15d
je 0x9212
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x9212
movq 0xa8(%r14), %rax
shlq $0x1e, %rcx
sarq $0x1e, %rcx
movl (%rax,%rcx), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x9194
movq 0x78(%r15), %rcx
cmpl $-0x1, %eax
jne 0x926a
movslq %r12d, %rax
imulq $0x14, %rax, %rax
movss 0x4(%rcx,%rax), %xmm0
addss (%rbx), %xmm0
movss %xmm0, (%rbx)
movl 0x8(%rcx,%rax), %r12d
jmp 0x9237
movslq %eax, %rdx
imulq $0x14, %rdx, %rdx
movss (%rcx,%rdx), %xmm0
addss (%rbx), %xmm0
movss %xmm0, (%rbx)
cmpl $-0x1, 0xc(%rcx,%rdx)
jne 0x928b
addq %rdx, %rcx
movl 0x8(%rcx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/aalto-speech[P]ftk/util/str.hh
// Function: str::clean(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
inline void clean(std::string &str, const char *chars = " \n\t")
{
    int i;

    // Clean trailing chars
    //
    for (i = str.length(); i > 0; i--)
        if (!strchr(chars, str[i - 1]))
            break;
    str.erase(i);

    // Clean leading chars
    //
    for (i = 0; i < (int)str.length(); i++)
        if (!strchr(chars, str[i]))
            break;
    str.erase(0, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %r12
movq %rdi, -0x30(%rbp)
movq 0x8(%rdi), %r15
movl %r15d, %r13d
movl %r15d, %ebx
sarl $0x1f, %ebx
andl %r15d, %ebx
incl %r15d
testl %r13d, %r13d
jle 0xa06a
movsbl -0x1(%r12,%r13), %esi
decq %r13
movq %r14, %rdi
callq 0x4120
decl %r15d
testq %rax, %rax
jne 0xa04a
jmp 0xa06d
movl %ebx, %r15d
movslq %r15d, %rsi
pushq $-0x1
popq %rdx
movq -0x30(%rbp), %r13
movq %r13, %rdi
callq 0x40c0
movl 0x8(%r13), %r15d
movq (%r13), %r12
xorl %ebx, %ebx
testl %r15d, %r15d
cmovlel %ebx, %r15d
cmpq %rbx, %r15
je 0xa0af
movsbl (%r12,%rbx), %esi
movq %r14, %rdi
callq 0x4120
testq %rax, %rax
je 0xa0ac
incq %rbx
jmp 0xa090
movq %rbx, %r15
movq %r13, %rdi
xorl %esi, %esi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40c0
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
cmpq %rsi, %rcx
jne 0xafa2
sarq $0x2, %rcx
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0xaf7c
movl (%rax,%rsi,4), %edi
movl (%rdx,%rsi,4), %r8d
incl %esi
cmpl %edi, %r8d
je 0xaf62
setg %al
jmp 0xaf99
movq 0x2a065(%rip), %rdi     # 0x34fe8
leaq 0x18616(%rip), %rsi     # 0x235a0
callq 0x4340
movq %rax, %rdi
callq 0x4180
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0x185c8(%rip), %rsi     # 0x2357c
leaq -0x11(%rbp), %rdx
movq %rax, %rdi
callq 0x4140
leaq 0x29d91(%rip), %rsi     # 0x34d58
movq 0x29fd2(%rip), %rdx     # 0x34fa0
movq %rbx, %rdi
callq 0x45c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4290
movq %r14, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbff8
andl $0x0, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb724
movslq 0x11c(%rbx), %rsi
leaq -0x20(%rbp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rdi
callq 0xc03e
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xb701
leaq 0x20(%r15), %rsi
movsd 0x40(%r15), %xmm0
movq %rbx, %rdi
callq 0xb89a
movq %r15, %rdi
callq 0x43b0
movq %rax, %r15
jmp 0xb6dd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb710
jmp 0xb710
movq %rax, %r14
movq %rbx, %rdi
callq 0xc136
movq %r14, %rdi
callq 0x45f0
nop