LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetClosestPlayerToBall()
Unum WorldStateUpdater::GetClosestPlayerToBall() {
  double min_dist = 20000;
  int min_index = 0;
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (GetTeammate(i).IsAlive()) {
      if ((GetTeammate(i).GetPos() - Ball().GetPos()).Mod() < min_dist) {
        min_dist = (GetTeammate(i).GetPos() - Ball().GetPos()).Mod();
        min_index = i;
      }
    }
    if (GetOpponent(i).IsAlive()) {
      if ((GetOpponent(i).GetPos() - Ball().GetPos()).Mod() < min_dist) {
        min_dist = (GetOpponent(i).GetPos() - Ball().GetPos()).Mod();
        min_index = -i;
      }
    }
  }

  return min_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd 0x9769(%rip), %xmm0     # 0xc57a8
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
cmpl $0xb, -0x18(%rbp)
jg 0xbc21e
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd640
movq %rax, %rdi
callq 0x23f20
testb $0x1, %al
jne 0xbc079
jmp 0xbc134
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd640
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x60(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x104e0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xbc132
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd640
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x60(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x104e0
movsd %xmm0, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xbc134
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
callq 0x23f20
testb $0x1, %al
jne 0xbc151
jmp 0xbc20e
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x60(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x104e0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xbc20c
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x60(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x104e0
movsd %xmm0, -0x10(%rbp)
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xbc20e
jmp 0xbc210
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbc052
movl -0x14(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.h
// Function: WorldStateUpdater::WorldStateUpdater(Observer*, WorldState*)
WorldStateUpdater(Observer *observer, WorldState *world_state)
      : mpObserver(observer), mpWorldState(world_state),
        mSelfSide(mpObserver ? mpObserver->OurSide() : '?'),
        mSelfUnum(mpObserver ? mpObserver->SelfUnum() : 0) {
    mBallConf = 1;
    mPlayerConf = 1;
    mSightDelay = 0;
    mIsHearBallPos = false;
    mIsHearBallVel = false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0xbc57f
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x6e5b0
movb (%rax), %al
movb %al, -0x29(%rbp)
jmp 0xbc586
movb $0x3f, %al
movb %al, -0x29(%rbp)
jmp 0xbc586
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb -0x29(%rbp), %dl
movb %dl, (%rcx)
movq %rax, %rcx
addq $0x14, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0xbc5b7
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x11dd0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xbc5be
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xbc5be
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %edx
movl %edx, (%rcx)
movsd 0x4a3d(%rip), %xmm0     # 0xc1010
movsd %xmm0, 0x20(%rax)
movsd 0x4a30(%rip), %xmm0     # 0xc1010
movsd %xmm0, 0x18(%rax)
movl $0x0, 0x28(%rax)
movb $0x0, 0x35(%rax)
movb $0x0, 0x36(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerParam.h
// Function: PlayerParam::ConvertAngle(double)
double ConvertAngle(double angle) {
    if (angle > 0) {
      angle += 0.5;
    } else if (angle < 0) {
      angle -= 0.5;
    }

    return angle;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xbcf8f
movsd 0x409d(%rip), %xmm0     # 0xc1020
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0xbcfb1
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xbcfaf
movsd -0x10(%rbp), %xmm0
movsd 0x407a(%rip), %xmm1     # 0xc1020
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0xbcfb1
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerParam.h
// Function: PlayerParam::ConvertSightDist(double)
double ConvertSightDist(double dist) {
    Assert(dist >= 0);
    int low = 0;
    int middle = 0;
    int high = SIGHTSIZE;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x3e, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0xbd311
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
cmpl $0x3e, -0x20(%rbp)
jge 0xbd277
cmpl $0x0, -0x20(%rbp)
jge 0xbd27c
jmp 0xbd311
movq -0x30(%rbp), %rax
movsd -0x18(%rbp), %xmm1
addq $0x3208, %rax           # imm = 0x3208
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
subsd (%rax), %xmm1
movaps 0x3dbf(%rip), %xmm0     # 0xc1060
pand %xmm0, %xmm1
movsd 0x4423(%rip), %xmm0     # 0xc16d0
ucomisd %xmm1, %xmm0
jbe 0xbd2d7
movq -0x30(%rbp), %rax
addq $0x3208, %rax           # imm = 0x3208
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbd386
movq -0x30(%rbp), %rax
movsd -0x18(%rbp), %xmm1
addq $0x3208, %rax           # imm = 0x3208
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xbd303
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xbd30c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbd24e
jmp 0xbd313
movq 0x40cd6(%rip), %rdi     # 0xfdff0
leaq 0x86fa(%rip), %rsi      # 0xc5a1b
callq 0xa5a0
movq %rax, %rdi
leaq 0x7f21(%rip), %rsi      # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x143, %esi            # imm = 0x143
callq 0xaa40
movq %rax, %rdi
leaq 0x6213(%rip), %rsi      # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x86d5(%rip), %rsi      # 0xc5a30
callq 0xa5a0
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0xab60
movq %rax, %rdi
movq 0x40c39(%rip), %rsi     # 0xfdfb0
callq 0xa630
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xbd3f5
movq -0x28(%rbp), %rdi
callq 0xbcea0
movq %rax, %rdi
callq 0xa95b0
movsd %xmm0, -0x8(%rbp)
jmp 0xbd45d
movl $0xa, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13150
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xab550
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x14, %rsi
callq 0x12520
movq %rax, %rdi
callq 0x118d0
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
callq 0xbcea0
movq %rax, %rdi
callq 0x11170
movsd (%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xbd532
movq -0x50(%rbp), %rdi
callq 0xbcea0
movq %rax, %rdi
callq 0x10a80
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbd5e3
movl $0xa, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13150
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xab550
movq -0x50(%rbp), %rsi
movq %rax, %rdi
addq $0x14, %rsi
callq 0x12520
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10a80
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa95b0
movq -0x58(%rbp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x11110
movq -0x50(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
movl -0x1c(%rbp), %esi
callq 0xbd3c0
movsd %xmm0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11110
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x184, -0x24(%rbp)     # imm = 0x184
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0xbdc54
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
cmpl $0x184, -0x20(%rbp)     # imm = 0x184
jge 0xbdbba
cmpl $0x0, -0x20(%rbp)
jge 0xbdbbf
jmp 0xbdc54
movq -0x30(%rbp), %rax
movsd -0x18(%rbp), %xmm1
addq $0x37d8, %rax           # imm = 0x37D8
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
subsd (%rax), %xmm1
movaps 0x347c(%rip), %xmm0     # 0xc1060
pand %xmm0, %xmm1
movsd 0x3ae0(%rip), %xmm0     # 0xc16d0
ucomisd %xmm1, %xmm0
jbe 0xbdc1a
movq -0x30(%rbp), %rax
addq $0x37d8, %rax           # imm = 0x37D8
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbdcc9
movq -0x30(%rbp), %rax
movsd -0x18(%rbp), %xmm1
addq $0x37d8, %rax           # imm = 0x37D8
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xbdc46
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xbdc4f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbdb8e
jmp 0xbdc56
movq 0x40393(%rip), %rdi     # 0xfdff0
leaq 0x7db7(%rip), %rsi      # 0xc5a1b
callq 0xa5a0
movq %rax, %rdi
leaq 0x75de(%rip), %rsi      # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x186, %esi            # imm = 0x186
callq 0xaa40
movq %rax, %rdi
leaq 0x58d0(%rip), %rsi      # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x7d92(%rip), %rsi      # 0xc5a30
callq 0xa5a0
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0xab60
movq %rax, %rdi
movq 0x402f6(%rip), %rsi     # 0xfdfb0
callq 0xa630
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x40(%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0x48(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movsd 0x58(%rcx), %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ddd0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d930
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x142f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x60(%rcx), %xmm0
movsd %xmm0, 0x60(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xbfe80
callq 0x855e0
movq %rax, %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x88040
callq 0x798a0
movq %rax, %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x7a9b0
movq $0x0, -0x18(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x10de0
testb $0x1, (%rax)
je 0xbfd94
movl $0x30, %edi
callq 0xa5c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x28ac0
jmp 0xbfd68
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbfe2d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x30, %esi
callq 0xa5e0
jmp 0xbfe73
callq 0x798a0
movq %rax, %rdi
callq 0x12080
testb $0x1, (%rax)
je 0xbfdea
movl $0x198, %edi            # imm = 0x198
callq 0xa5c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x92ca0
jmp 0xbfdc1
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbfe2b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x198, %esi            # imm = 0x198
callq 0xa5e0
jmp 0xbfe73
movl $0x38, %edi
callq 0xa5c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x78ab0
jmp 0xbfe05
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbfe2b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x38, %esi
callq 0xa5e0
jmp 0xbfe73
jmp 0xbfe2d
callq 0x798a0
movq %rax, %rdi
callq 0x12140
testb $0x1, (%rax)
je 0xbfe4a
movq -0x18(%rbp), %rdi
callq 0x28260
jmp 0xbfe53
movq -0x18(%rbp), %rdi
callq 0x28560
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xbfe6b
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: 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
movl $0x2, %edi
leaq 0x100(%rip), %rsi       # 0xbff90
callq 0xa720
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0xbfeb7
leaq 0x5ba0(%rip), %rdi      # 0xc5a48
callq 0xa4c0
movl $0x1, %edi
callq 0xa740
movl $0x3, %edi
leaq 0xcd(%rip), %rsi        # 0xbff90
callq 0xa720
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0xbfeea
leaq 0x5b74(%rip), %rdi      # 0xc5a4f
callq 0xa4c0
movl $0x1, %edi
callq 0xa740
movl $0xb, %edi
leaq 0x9a(%rip), %rsi        # 0xbff90
callq 0xa720
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0xbff1d
leaq 0x5b49(%rip), %rdi      # 0xc5a57
callq 0xa4c0
movl $0x1, %edi
callq 0xa740
movl $0x4, %edi
leaq 0x67(%rip), %rsi        # 0xbff90
callq 0xa720
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0xbff50
leaq 0x5b1e(%rip), %rdi      # 0xc5a5f
callq 0xa4c0
movl $0x1, %edi
callq 0xa740
movl $0x8, %edi
leaq 0x34(%rip), %rsi        # 0xbff90
callq 0xa720
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0xbff83
leaq 0x5af2(%rip), %rdi      # 0xc5a66
callq 0xa4c0
movl $0x1, %edi
callq 0xa740
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0x15(%rip), %rsi       # 0xbff90
callq 0xa720
movq 0x3e03f(%rip), %rdi     # 0xfdff0
leaq 0x5ab5(%rip), %rsi      # 0xc5a6d
callq 0xa5a0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0xaa40
movq %rax, %rdi
movq 0x3dfde(%rip), %rsi     # 0xfdfb0
callq 0xa630
callq 0xc0050
movq 0x3e00d(%rip), %rdi     # 0xfdff0
leaq 0x5a91(%rip), %rsi      # 0xc5a7b
callq 0xa5a0
movq %rax, %rdi
movq 0x3dfb7(%rip), %rsi     # 0xfdfb0
callq 0xa630
callq 0x5add0
movq %rax, %rdi
callq 0x5b410
callq 0x5add0
movq %rax, %rdi
callq 0x5b310
callq 0x33ef0
movq %rax, %rdi
leaq 0x5a67(%rip), %rsi      # 0xc5a8e
movl $0x3, %edx
callq 0x34320
movl $0x64, %edi
callq 0x28840
xorl %edi, %edi
callq 0xa740
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x45fd
jp 0x45fd
movl $0x0, -0x4(%rbp)
jmp 0x464b
movq -0x38(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x4610
movl $0x1, -0x4(%rbp)
jmp 0x464b
movq -0x38(%rbp), %rax
movl $0x1, 0x4(%rax)
movsd -0x20(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, 0xc(%rax)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: 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
subq $0xd0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x46f0
movq -0xa0(%rbp), %rdx
leaq 0x5ebf3(%rip), %rsi     # 0x661d6
leaq -0x30(%rbp), %rdi
callq 0x4550
jmp 0x75ee
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x8370
movb %al, -0xb1(%rbp)
jmp 0x760d
leaq -0x30(%rbp), %rdi
callq 0x4828
leaq -0x31(%rbp), %rdi
callq 0x4420
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x762e
jmp 0x76f7
movl $0x10, %edi
callq 0x43d0
movq -0xb0(%rbp), %rsi
movq %rax, -0xc0(%rbp)
movb $0x1, -0x69(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x41a0
jmp 0x7655
movq -0xc0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x77f0
jmp 0x7667
movq -0xa8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movb $0x0, -0x69(%rbp)
movq %rcx, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x4828
jmp 0x779e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x76ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4828
leaq -0x31(%rbp), %rdi
callq 0x4420
jmp 0x77a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x76de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4828
testb $0x1, -0x69(%rbp)
jne 0x76e6
jmp 0x76f2
movq -0xc0(%rbp), %rdi
callq 0x43a0
jmp 0x77a7
movl $0x210, %edi            # imm = 0x210
callq 0x43d0
movq -0xb0(%rbp), %rsi
movq %rax, -0xc8(%rbp)
movb $0x1, -0x91(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x41a0
jmp 0x7724
movq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x8410
jmp 0x7739
movq -0xa8(%rbp), %rax
movq -0xc8(%rbp), %rcx
movb $0x0, -0x91(%rbp)
movq %rcx, (%rax)
leaq -0x90(%rbp), %rdi
callq 0x4828
jmp 0x779e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4828
testb $0x1, -0x91(%rbp)
jne 0x7790
jmp 0x779c
movq -0xc8(%rbp), %rdi
callq 0x43a0
jmp 0x77a7
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46e0
// File: 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
subq $0x100030, %rsp         # imm = 0x100030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x100020(%rbp), %rsi
movl $0xfffff, %edx          # imm = 0xFFFFF
callq 0x46a0
movq %rax, -0x100028(%rbp)
cmpq $0x0, -0x100028(%rbp)
je 0x7946
leaq -0x100020(%rbp), %rdi
leaq 0x5e8af(%rip), %rsi     # 0x661da
callq 0x4610
movq -0x18(%rbp), %rdi
leaq -0x100020(%rbp), %rsi
callq 0x47a0
movb $0x1, -0x1(%rbp)
jmp 0x794a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100030, %rsp         # imm = 0x100030
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x46f0
movq -0xa0(%rbp), %rdx
leaq 0x5e833(%rip), %rsi     # 0x661d6
leaq -0x30(%rbp), %rdi
callq 0x4550
jmp 0x79ae
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x84e0
movb %al, -0xb1(%rbp)
jmp 0x79cd
leaq -0x30(%rbp), %rdi
callq 0x4828
leaq -0x31(%rbp), %rdi
callq 0x4420
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x79ee
jmp 0x7ab7
movl $0x18, %edi
callq 0x43d0
movq -0xb0(%rbp), %rsi
movq %rax, -0xc0(%rbp)
movb $0x1, -0x69(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x41a0
jmp 0x7a15
movq -0xc0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x8050
jmp 0x7a27
movq -0xa8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movb $0x0, -0x69(%rbp)
movq %rcx, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x4828
jmp 0x7b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7a6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4828
leaq -0x31(%rbp), %rdi
callq 0x4420
jmp 0x7b67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7a9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4828
testb $0x1, -0x69(%rbp)
jne 0x7aa6
jmp 0x7ab2
movq -0xc0(%rbp), %rdi
callq 0x43a0
jmp 0x7b67
movl $0x208, %edi            # imm = 0x208
callq 0x43d0
movq -0xb0(%rbp), %rsi
movq %rax, -0xc8(%rbp)
movb $0x1, -0x91(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x41a0
jmp 0x7ae4
movq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x7d70
jmp 0x7af9
movq -0xa8(%rbp), %rax
movq -0xc8(%rbp), %rcx
movb $0x0, -0x91(%rbp)
movq %rcx, (%rax)
leaq -0x90(%rbp), %rdi
callq 0x4828
jmp 0x7b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7b45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4828
testb $0x1, -0x91(%rbp)
jne 0x7b50
jmp 0x7b5c
movq -0xc8(%rbp), %rdi
callq 0x43a0
jmp 0x7b67
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46e0
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x7bec
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7be1
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x10(%rax)
je 0x8183
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4680
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
callq 0x4190
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x4830
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x4190
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x871e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x876d
movq -0x28(%rbp), %rdi
movq 0x8b897(%rip), %rax     # 0x93fc0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
addq $0x70, %rdi
callq 0x4190
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x4190
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x5daf3(%rip), %rsi     # 0x6624f
movb $0x0, %al
callq 0x4580
movl $0x1, %edi
callq 0x4470
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
callq 0x4190
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4320
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x4190
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x87db
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x882a
movq -0x28(%rbp), %rdi
movq 0x8b7da(%rip), %rax     # 0x93fc0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
addq $0x70, %rdi
callq 0x4190
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x4190
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x5da36(%rip), %rsi     # 0x6624f
movb $0x0, %al
callq 0x4580
movl $0x1, %edi
callq 0x4470
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
callq 0x4190
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4320
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x4190
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x889b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x88ea
movq -0x28(%rbp), %rdi
movq 0x8b71a(%rip), %rax     # 0x93fc0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
addq $0x70, %rdi
callq 0x4190
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x4190
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x5d976(%rip), %rsi     # 0x6624f
movb $0x0, %al
callq 0x4580
movl $0x1, %edi
callq 0x4470
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xad30
movl $0x1, -0x74(%rbp)
movl -0x74(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x97de
movq -0x18(%rbp), %rax
movslq -0x74(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xc8(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x46f0
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x4550
jmp 0x9766
leaq -0x70(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xad50
jmp 0x9778
leaq -0x98(%rbp), %rdi
callq 0x4828
leaq -0x99(%rbp), %rdi
callq 0x4420
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x9718
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x97d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4828
leaq -0x99(%rbp), %rdi
callq 0x4420
jmp 0x981b
movq -0xb8(%rbp), %rdi
movzbl -0x19(%rbp), %edx
andl $0x1, %edx
leaq -0x70(%rbp), %rsi
callq 0x8f90
jmp 0x97f7
leaq -0x70(%rbp), %rdi
callq 0xad80
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xad80
movq -0xa8(%rbp), %rdi
callq 0x46e0
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x96e0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x46f0
movq -0x78(%rbp), %rdx
leaq 0x5c7c3(%rip), %rsi     # 0x6603a
leaq -0x38(%rbp), %rdi
callq 0x4550
jmp 0x9882
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9970
movq %rax, -0x88(%rbp)
jmp 0x9898
movq -0x88(%rbp), %rax
movb 0x4a(%rax), %al
movb %al, -0x89(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4828
leaq -0x39(%rbp), %rdi
callq 0x4420
movb -0x89(%rbp), %al
testb $0x1, %al
je 0x9951
movq -0x80(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x9a20
movq -0x98(%rbp), %rdi
callq 0x4190
movq %rax, %rdi
movq 0x8a68e(%rip), %rax     # 0x93f80
movq (%rax), %rsi
callq 0x4440
jmp 0x98fc
leaq -0x70(%rbp), %rdi
callq 0x4828
xorl %edi, %edi
callq 0x4470
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x992f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4828
leaq -0x39(%rbp), %rdi
callq 0x4420
jmp 0x9963
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4828
jmp 0x9963
movq -0x80(%rbp), %rdi
callq 0x9c70
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x68, %rdi
callq 0xb4c0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x68, %rdi
callq 0xb520
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb4f0
testb $0x1, %al
jne 0x99bd
jmp 0x99ee
movq -0x30(%rbp), %rdi
movq 0x8a5f8(%rip), %rax     # 0x93fc0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x4190
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x5c9ad(%rip), %rsi     # 0x6638f
movb $0x0, %al
callq 0x4580
callq 0x4220
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb550
movq -0x40(%rbp), %rdi
movslq 0x20(%rax), %rsi
callq 0xb3f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x54(%rbp)
addq $0x20, %rdi
callq 0xa5f0
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x9dd8
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0xb3f0
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4560
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x9d1b
leaq 0x5c639(%rip), %rsi     # 0x66316
leaq -0x38(%rbp), %rdi
callq 0x4790
jmp 0x9ce8
movq -0x18(%rbp), %rax
movsbl (%rax), %edx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x4410
jmp 0x9cff
jmp 0x9d1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4828
jmp 0x9dde
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x5c7cd(%rip), %rsi     # 0x664f7
callq 0xa700
movb %al, -0x55(%rbp)
jmp 0x9d34
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x9d3d
jmp 0x9d64
leaq 0x5c5a5(%rip), %rsi     # 0x662e9
leaq -0x38(%rbp), %rdi
callq 0x4790
jmp 0x9d4f
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x47c0
jmp 0x9d62
jmp 0x9d64
movq -0x18(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x9dc1
movq -0x18(%rbp), %rax
testb $0x1, 0x4a(%rax)
jne 0x9dc1
movq 0x8a241(%rip), %rax     # 0x93fc0
movq %rax, -0x60(%rbp)
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4190
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0x5c5b3(%rip), %rsi     # 0x66354
xorl %eax, %eax
callq 0x4580
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x9ff0
jmp 0x9dbf
jmp 0x9dc1
leaq -0x38(%rbp), %rdi
callq 0x4828
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9c8b
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x46e0
nopw (%rax,%rax)
// File: 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
subq $0x110, %rsp            # imm = 0x110
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4560
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
xorl %edx, %edx
callq 0xadf0
jmp 0x9e2f
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4480
leaq -0x58(%rbp), %rdi
callq 0x4828
jmp 0x9eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4180
movq 0x8a185(%rip), %rdi     # 0x93fe8
leaq 0x5c4cb(%rip), %rsi     # 0x66335
callq 0x43c0
movq %rax, -0xf8(%rbp)
jmp 0x9e78
movq -0xf8(%rbp), %rdi
movq 0x8a112(%rip), %rsi     # 0x93f98
callq 0x4400
jmp 0x9e8d
movl $0x1, %edi
callq 0x4470
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x4660
jmp 0x9eaa
jmp 0x9fd5
leaq -0x80(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xa160
movq -0x100(%rbp), %rcx
leaq 0x5c483(%rip), %rsi     # 0x66350
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
callq 0xafa0
jmp 0x9edd
leaq -0x80(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xb2f0
movq -0x110(%rbp), %rdi
movq %rax, -0xd8(%rbp)
callq 0xb320
movq %rax, -0xe0(%rbp)
leaq -0xe1(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xb350
movq -0x108(%rbp), %rcx
movq -0xd8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
callq 0xb370
jmp 0x9f3d
leaq -0xe1(%rbp), %rdi
callq 0x6c40
movq -0xf0(%rbp), %rdi
movzbl -0x11(%rbp), %edx
andl $0x1, %edx
leaq -0xd0(%rbp), %rsi
callq 0x8f90
jmp 0x9f65
leaq -0xd0(%rbp), %rdi
callq 0xad80
leaq -0x80(%rbp), %rdi
callq 0x6970
leaq -0x38(%rbp), %rdi
callq 0x4828
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x9fcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xe1(%rbp), %rdi
callq 0x6c40
jmp 0x9fcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xad80
leaq -0x80(%rbp), %rdi
callq 0x6970
leaq -0x38(%rbp), %rdi
callq 0x4828
movq -0x60(%rbp), %rdi
callq 0x46e0
movq %rax, %rdi
callq 0x6210
nop
// File: 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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x38, %rdi
leaq -0x9(%rbp), %rsi
callq 0xb410
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x38, %rdi
callq 0xb470
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb440
testb $0x1, %al
jne 0xa0af
jmp 0xa0d0
movq 0x89f0a(%rip), %rax     # 0x93fc0
movq (%rax), %rdi
movzbl -0x9(%rbp), %edx
leaq 0x5c2a9(%rip), %rsi     # 0x6636d
movb $0x0, %al
callq 0x4580
callq 0x4220
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb4a0
movq -0x30(%rbp), %rdi
movslq 0x4(%rax), %rsi
callq 0xb3f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x1060, %rsp           # imm = 0x1060
movq %rdi, -0x1050(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1048(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0xae2a
movq -0x10(%rbp), %rdi
callq 0x4090
movq -0x1050(%rbp), %rdi
movq $0x1000, -0x20(%rbp)    # imm = 0x1000
movb $0x0, -0x1021(%rbp)
movb $0x0, -0x1022(%rbp)
callq 0x4560
movb -0x1021(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xae5d
jmp 0xaf4d
movq -0x10(%rbp), %rcx
leaq -0x1020(%rbp), %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x45d0
movq %rax, -0x1058(%rbp)
jmp 0xae80
movq -0x1058(%rbp), %rax
movq %rax, -0x1030(%rbp)
cmpq $0x1000, -0x1030(%rbp) # imm = 0x1000
jae 0xaf2c
movq -0x10(%rbp), %rdi
callq 0x4760
cmpl $0x0, %eax
je 0xaf25
movl $0x10, %edi
callq 0x41e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1060(%rbp)
leaq 0x5b500(%rip), %rsi     # 0x663cb
callq 0x4170
jmp 0xaed2
movq -0x1060(%rbp), %rdi
movq 0x89110(%rip), %rsi     # 0x93ff0
movq 0x890c9(%rip), %rdx     # 0x93fb0
callq 0x46b0
jmp 0xaf91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1038(%rbp)
movl %eax, -0x103c(%rbp)
jmp 0xaf79
movq -0x1060(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1038(%rbp)
movl %eax, -0x103c(%rbp)
callq 0x42f0
jmp 0xaf79
movb $0x1, -0x1021(%rbp)
movq -0x1050(%rbp), %rdi
movq -0x1030(%rbp), %rdx
leaq -0x1020(%rbp), %rsi
callq 0x4080
jmp 0xaf48
jmp 0xae4c
movb $0x1, -0x1022(%rbp)
testb $0x1, -0x1022(%rbp)
jne 0xaf69
movq -0x1050(%rbp), %rdi
callq 0x4828
movq -0x1048(%rbp), %rax
addq $0x1060, %rsp           # imm = 0x1060
popq %rbp
retq
movq -0x1050(%rbp), %rdi
callq 0x4828
movq -0x1038(%rbp), %rdi
callq 0x46e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)