LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::PlayGame()
void Game::PlayGame()
{
  this->map_generator = MapGeneratorFactory::create(curr_difficulty);
  PrintPrepScreen();
  while (playing)
  {
    key = wgetch(game_win);
    playing = key == 'q' ? false : true;

    UpdatePlayerLoc();
    PrintGameFrame();
    PrintInfoFrame();
    napms(1);
  }

  UpdateHighScore();

  wrefresh(game_win);
  wrefresh(info_win);
  wclear(game_win);
  wclear(info_win);
  wrefresh(game_win);
  wrefresh(info_win);
  PrintEndScreen();
  endwin();
  delete map_generator;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x760(%rax), %edi
callq 0x5350
movq -0x10(%rbp), %rdi
movq %rax, 0x768(%rdi)
callq 0x2790
movq -0x10(%rbp), %rax
testb $0x1, 0x770(%rax)
je 0x26fb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2090
movq -0x10(%rbp), %rdi
movl %eax, 0x780(%rdi)
movl 0x780(%rdi), %eax
subl $0x71, %eax
setne %al
negb %al
andb $0x1, %al
movb %al, 0x770(%rdi)
callq 0x2860
movq -0x10(%rbp), %rdi
callq 0x28d0
movq -0x10(%rbp), %rdi
callq 0x2970
movl $0x1, %edi
callq 0x20e0
jmp 0x269f
movq -0x10(%rbp), %rdi
callq 0x2a30
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x21b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2150
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x21b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21b0
movq -0x10(%rbp), %rdi
callq 0x2b10
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x768(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2780
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::PrintPrepScreen()
void Game::PrintPrepScreen()
{
  char* mode;
  const char* kStartArt = R"ronmak(
   / __ \___  ____ _____/ __  __   / /_____     / __ \____  ____ _____/ _______  ______  / /
  / /_/ / _ \/ __ `/ __  / / / /  / __/ __ \   / /_/ / __ \/ __ `/ __  / ___/ / / / __ \/ /
 / _, _/  __/ /_/ / /_/ / /_/ /  / /_/ /_/ /  / _, _/ /_/ / /_/ / /_/ / /  / /_/ / / / /_/
/_/ |_|\___/\__,_/\__,_/\__, /   \__/\____/  /_/ |_|\____/\__,_/\__,_/_/   \__,_/_/ /_(_)
                       /____/
              )ronmak";
if(curr_difficulty == SettingsItem::kRegular)
{

  mode = R"ronmak(
    ______                    __  ___          __
   / ________ ________  __   /  |/  ____  ____/ ___
  / __/ / __ `/ ___/ / / /  / /|_/ / __ \/ __  / _ \
 / /___/ /_/ (__  / /_/ /  / /  / / /_/ / /_/ /  __/
/_____/\__,_/____/\__, /  /_/  /_/\____/\__,_/\___/
                 /____/
              )ronmak";
}
else
{
  mode = R"ronmak(
    __  __               __   __  ___          __
   / / / ____ __________/ /  /  |/  ____  ____/ ___
  / /_/ / __ `/ ___/ __  /  / /|_/ / __ \/ __  / _ \
 / __  / /_/ / /  / /_/ /  / /  / / /_/ / /_/ /  __/
/_/ /_/\__,_/_/   \__,_/  /_/  /_/\____/\__,_/\___/
              )ronmak";
}

  mvwprintw(art_win, 0, 0, "%s", kStartArt);
  mvwprintw(art_win, 10, 0, "%s", mode);
  wrefresh(art_win);
  napms(2000);
  wmove(art_win, 0, 0);
  wclrtobot(art_win);
  wrefresh(art_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x3fe4(%rip), %rcx      # 0x678f
movq %rcx, -0x18(%rbp)
cmpl $0x0, 0x760(%rax)
jne 0x27c5
leaq 0x416c(%rip), %rax      # 0x692b
movq %rax, -0x10(%rbp)
jmp 0x27d0
leaq 0x428b(%rip), %rax      # 0x6a57
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %r8
xorl %edx, %edx
leaq 0x3f64(%rip), %rcx      # 0x6749
movl %edx, %esi
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %r8
movl $0xa, %esi
xorl %edx, %edx
leaq 0x3f41(%rip), %rcx      # 0x6749
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21b0
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x20e0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2180
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21e0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::UpdatePlayerLoc()
void Game::UpdatePlayerLoc()
{
  UpdatePlayerDeltas();

  if (player_locx + player_deltax >= kMenuWidth
      || player_locx + player_deltax < 0)
    player_deltax = 0;

  player_locx += player_deltax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2c50
movq -0x10(%rbp), %rcx
movl 0x778(%rcx), %eax
addl 0x77c(%rcx), %eax
cmpl $0x3d, %eax
jge 0x28a3
movq -0x10(%rbp), %rcx
movl 0x778(%rcx), %eax
addl 0x77c(%rcx), %eax
cmpl $0x0, %eax
jge 0x28b1
movq -0x10(%rbp), %rax
movl $0x0, 0x77c(%rax)
movq -0x10(%rbp), %rax
movl 0x77c(%rax), %ecx
addl 0x778(%rax), %ecx
movl %ecx, 0x778(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::PrintGameFrame()
void Game::PrintGameFrame()
{
  wclear(game_win);

  mvwprintw(game_win, 0, 0, "%s", map_generator->GenerateMap(game_map));
  mvwprintw(game_win, player_locy, player_locx, "%c", player_icon);

  CheckCollision();

  wrefresh(game_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x2150
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
movq %rax, -0x18(%rbp)
movq 0x768(%rsi), %rdi
addq $0x18, %rsi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movq %rax, %r8
xorl %edx, %edx
leaq 0x3e32(%rip), %rcx      # 0x6749
movl %edx, %esi
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl 0x774(%rax), %esi
movl 0x778(%rax), %edx
movsbl 0x771(%rax), %r8d
leaq 0x3e0a(%rip), %rcx      # 0x674c
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2bb0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::PrintInfoFrame()
void Game::PrintInfoFrame()
{
  wclear(info_win);

  UpdateScore();
  mvwprintw(info_win, 0, 0, "player loc x is %d", player_locx);
  mvwprintw(info_win, 1, 0, "High score: %d", curr_high_score);
  mvwprintw(info_win, 2, 0, "Score: %d", curr_score);
  mvwprintw(info_win, 3, 0, "Press 'q' at any time to quit");

  wrefresh(info_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x2150
movq -0x10(%rbp), %rdi
callq 0x2c00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x778(%rax), %r8d
xorl %edx, %edx
leaq 0x3da1(%rip), %rcx      # 0x674f
movl %edx, %esi
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x788(%rax), %r8d
movl $0x1, %esi
xorl %edx, %edx
leaq 0x3d8e(%rip), %rcx      # 0x6762
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x78c(%rax), %r8d
movl $0x2, %esi
xorl %edx, %edx
leaq 0x4527(%rip), %rcx      # 0x6f1f
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3, %esi
xorl %edx, %edx
leaq 0x3d5c(%rip), %rcx      # 0x6771
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::UpdateHighScore()
void Game::UpdateHighScore()
{
  if (curr_score > curr_high_score)
    difficulty_map->operator[](curr_difficulty) = curr_score;


  *prev_score = curr_score;

  wclear(info_win);
  mvwprintw(info_win, 7, 0, "high score: %d", curr_high_score);
  mvwprintw(info_win, 8, 0, "difficulty_map difficulty: %d", difficulty_map->at(curr_difficulty));

  wrefresh(info_win);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x78c(%rcx), %eax
cmpl 0x788(%rcx), %eax
jle 0x2a77
movq -0x10(%rbp), %rsi
movl 0x78c(%rsi), %eax
movl %eax, -0x14(%rbp)
movq 0x790(%rsi), %rdi
addq $0x760, %rsi            # imm = 0x760
callq 0x2d40
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x78c(%rax), %edx
movq 0x798(%rax), %rcx
movl %edx, (%rcx)
movq 0x8(%rax), %rdi
callq 0x2150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x788(%rax), %r8d
movl $0x7, %esi
xorl %edx, %edx
leaq 0x41f9(%rip), %rcx      # 0x6ca9
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rsi
movq 0x8(%rsi), %rax
movq %rax, -0x20(%rbp)
movq 0x790(%rsi), %rdi
addq $0x760, %rsi            # imm = 0x760
callq 0x2e20
movq -0x20(%rbp), %rdi
movl (%rax), %r8d
movl $0x8, %esi
xorl %edx, %edx
leaq 0x41cd(%rip), %rcx      # 0x6cb8
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::PrintEndScreen()
void Game::PrintEndScreen()
{

  const char* kEndArt = R"ronmak(
   ______                        ____                  __
  / ________ _____ ___  ___     / __ \_   _____  _____/ /
 / / __/ __ `/ __ `__ \/ _ \   / / / | | / / _ \/ ___/ /
/ /_/ / /_/ / / / / / /  __/  / /_/ /| |/ /  __/ /  /_/
\____/\__,_/_/ /_/ /_/\___/   \____/ |___/\___/_/  (_)
              )ronmak";
  mvwprintw(art_win, 0, 0, "%s", kEndArt);
  mvwprintw(art_win, 10, 0, "Your score was %d", curr_score);
  wrefresh(art_win);
  napms(2000);
  wclrtobot(art_win);
  wrefresh(art_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x4040(%rip), %rcx      # 0x6b6b
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %r8
xorl %edx, %edx
leaq 0x3c09(%rip), %rcx      # 0x6749
movl %edx, %esi
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl 0x78c(%rax), %r8d
movl $0xa, %esi
xorl %edx, %edx
leaq 0x4131(%rip), %rcx      # 0x6c97
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21b0
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x20e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::UpdateScore()
void Game::UpdateScore()
{
  score_timer++;

  if (score_timer == kScoreTickCnt)
  {
    curr_score++;
    score_timer = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x784(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x784(%rax)
cmpl $0x64, 0x784(%rax)
jne 0x2c45
movq -0x10(%rbp), %rax
movl 0x78c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x78c(%rax)
movl $0x0, 0x784(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: drofp[P]RoadRun/src/game.cc
// Function: roadrun::Game::UpdatePlayerDeltas()
void Game::UpdatePlayerDeltas()
{
  if (curr_difficulty == SettingsItem::kRegular)
  {
    if (key == KEY_LEFT)
      player_deltax -= kDeltaEasy;
    else if (key == KEY_RIGHT)
      player_deltax += kDeltaEasy;
    else
      player_deltax = 0;
  }
  else if (curr_difficulty == SettingsItem::kLudicrous)
  {
    if (key == KEY_LEFT)
      player_deltax -= kDeltaHard;
    else if (key == KEY_RIGHT)
      player_deltax += kDeltaHard;
    else
      player_deltax = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x760(%rax)
jne 0x2cc5
movq -0x10(%rbp), %rax
cmpl $0x104, 0x780(%rax)     # imm = 0x104
jne 0x2c8e
movq -0x10(%rbp), %rax
movl 0x77c(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x77c(%rax)
jmp 0x2cc3
movq -0x10(%rbp), %rax
cmpl $0x105, 0x780(%rax)     # imm = 0x105
jne 0x2cb3
movq -0x10(%rbp), %rax
movl 0x77c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x77c(%rax)
jmp 0x2cc1
movq -0x10(%rbp), %rax
movl $0x0, 0x77c(%rax)
jmp 0x2cc3
jmp 0x2d30
movq -0x10(%rbp), %rax
cmpl $0x1, 0x760(%rax)
jne 0x2d2e
movq -0x10(%rbp), %rax
cmpl $0x104, 0x780(%rax)     # imm = 0x104
jne 0x2cf7
movq -0x10(%rbp), %rax
movl 0x77c(%rax), %ecx
subl $0x3, %ecx
movl %ecx, 0x77c(%rax)
jmp 0x2d2c
movq -0x10(%rbp), %rax
cmpl $0x105, 0x780(%rax)     # imm = 0x105
jne 0x2d1c
movq -0x10(%rbp), %rax
movl 0x77c(%rax), %ecx
addl $0x3, %ecx
movl %ecx, 0x77c(%rax)
jmp 0x2d2a
movq -0x10(%rbp), %rax
movl $0x0, 0x77c(%rax)
jmp 0x2d2c
jmp 0x2d2e
jmp 0x2d30
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: drofp[P]RoadRun/src/game_environment.cc
// Function: roadrun::GameEnvironment::GameEnvironment()
GameEnvironment::GameEnvironment()
  {
    difficulty_to_high_score[SettingsItem::kRegular] = 0;
    difficulty_to_high_score[SettingsItem::kLudicrous] = 0;

    difficulty = SettingsItem::kRegular;
    main_menu = new MainMenu(difficulty_to_high_score, prev_score);
    settings_menu = new SettingsMenu(kMenuWidth, kMenuHeight);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
callq 0x4370
movq -0x30(%rbp), %rdi
movl $0x0, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x4390
movq %rax, -0x28(%rbp)
jmp 0x40db
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rdi
movl $0x1, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x4390
movq %rax, -0x40(%rbp)
jmp 0x4103
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movl $0x0, (%rcx)
movl $0x0, (%rax)
movl $0x28, %edi
callq 0x2140
movq %rax, -0x48(%rbp)
jmp 0x4127
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rdx, %rsi
addq $0x20, %rsi
addq $0x50, %rdx
callq 0x4470
jmp 0x4141
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x20, %edi
callq 0x2140
movq %rax, -0x50(%rbp)
jmp 0x415d
movq -0x50(%rbp), %rdi
movl $0x3d, %esi
movl $0x1e, %edx
callq 0x44c0
jmp 0x4172
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x41c8
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x2160
jmp 0x41c8
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x2160
movq -0x30(%rbp), %rdi
callq 0x4510
movq -0x18(%rbp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: drofp[P]RoadRun/src/game_environment.cc
// Function: roadrun::GameEnvironment::PlayGame()
int GameEnvironment::PlayGame()
  {
    while(1)
    {
      main_menu->PrintMenu();
      roadrun::MenuItem menu_choice = main_menu->GetUserChoice();

      if(menu_choice == roadrun::MenuItem::kChooseDifficulty)
      {
        settings_menu->PrintMenu();
        difficulty = settings_menu->GetUserChoice();
      }
      else if (menu_choice == roadrun::MenuItem::kStartGame)
      {
        game = new Game(kMenuWidth, kMenuHeight, '^', difficulty,
                        difficulty_to_high_score, prev_score);
        game->PlayGame();

        delete game;

      }
      else
      {
        break;
      }
    }
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x42b0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x4353
cmpl $0x0, -0xc(%rbp)
jne 0x434f
movl $0x7a0, %edi            # imm = 0x7A0
callq 0x2140
movq -0x28(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl (%rcx), %r8d
movq %rcx, %r9
addq $0x20, %r9
addq $0x50, %rcx
movq %rsp, %rax
movq %rcx, (%rax)
movl $0x3d, %esi
movl $0x1e, %edx
movl $0x5e, %ecx
callq 0x24e0
jmp 0x42fc
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
callq 0x2670
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4331
movq -0x38(%rbp), %rdi
movl $0x7a0, %esi            # imm = 0x7A0
callq 0x2160
jmp 0x4351
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x7a0, %esi            # imm = 0x7A0
callq 0x2160
jmp 0x4360
jmp 0x4358
jmp 0x4353
jmp 0x4264
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2280
nopl (%rax)
// File: drofp[P]RoadRun/src/main.cc
// Function: main
int main()
{
  roadrun::GameEnvironment *game_environment = new roadrun::GameEnvironment();
  game_environment->PlayGame();

  delete game_environment;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x58, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x40a0
jmp 0x4c5a
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4250
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4c90
movq -0x30(%rbp), %rdi
callq 0x41e0
movq -0x30(%rbp), %rdi
movl $0x58, %esi
callq 0x2160
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x58, %esi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x2280
nopl (%rax,%rax)
// File: drofp[P]RoadRun/src/main_menu.cc
// Function: roadrun::MainMenu::RenderOptions(_win_st*, int)
void MainMenu::RenderOptions(WINDOW *menu_win, int highlight)
  {
    mvwprintw(menu_win, 2, 4, "Main Menu");
    char *choices[] = {
        "Play Game",
        "Options",
        "Exit",
    };
    int x, y, i;
    x = y = 4;
    box(menu_win, 0,0);
    for(i = 0; i < num_menu_items; i++) {
      if(highlight == i + 1)
      {
        wattron(menu_win, A_REVERSE);
        mvwprintw(menu_win, y, x, "%s", MenuItemToString(choices, menu_item_list[i]));
        wattroff(menu_win, A_REVERSE);
      }
      else
      {
        mvwprintw(menu_win, y, x, "%s", MenuItemToString(choices, menu_item_list[i]));
      }
      ++y;
    }
    wrefresh(menu_win);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
leaq 0x203a(%rip), %rcx      # 0x6d22
movb $0x0, %al
callq 0x2040
movq 0x4f6a(%rip), %rax      # 0x9c60
movq %rax, -0x30(%rbp)
movq 0x4f67(%rip), %rax      # 0x9c68
movq %rax, -0x28(%rbp)
movq 0x4f64(%rip), %rax      # 0x9c70
movq %rax, -0x20(%rbp)
movl $0x4, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2290
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x4e12
movl -0x14(%rbp), %eax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4db5
movq -0x10(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x20c0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rcx
leaq 0x21be(%rip), %rax      # 0x6f3c
movl (%rax,%rcx,4), %esi
callq 0x5110
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x40(%rbp), %edx
movq %rax, %r8
leaq 0x19af(%rip), %rcx      # 0x6749
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x21f0
jmp 0x4dfb
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rcx
leaq 0x2164(%rip), %rax      # 0x6f3c
movl (%rax,%rcx,4), %esi
callq 0x5110
movq -0x60(%rbp), %rdi
movl -0x58(%rbp), %esi
movl -0x54(%rbp), %edx
movq %rax, %r8
leaq 0x1955(%rip), %rcx      # 0x6749
movb $0x0, %al
callq 0x2040
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4d32
movq -0x10(%rbp), %rdi
callq 0x21b0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drofp[P]RoadRun/src/map_generator_easy.cc
// Function: roadrun::MapGeneratorEasy::GenerateMap(char*)
const char* MapGeneratorEasy::GenerateMap(char* game_map)
{
  // Create new line to be inserted at top of game_map
  char new_line[kMenuWidth];
  if (ticks % kMillisPerFrameEasy == 0)
  {
    GenerateNewLine(new_line);
    MapUpdater::MoveLinesDown(ticks, game_map, new_line);
  }

  ticks = ticks > kMaxTickCnt ? 0 : ++ticks;

  return game_map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x8(%rax), %eax
movl $0x4b, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5179
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x51c0
movq -0x58(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x56a0
movq -0x58(%rbp), %rax
cmpl $0x4e20, 0x8(%rax)      # imm = 0x4E20
jle 0x518d
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x519d
movq -0x58(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drofp[P]RoadRun/src/map_generator_easy.cc
// Function: roadrun::MapGeneratorEasy::GenerateNewLine(char*)
void MapGeneratorEasy::GenerateNewLine(char* new_line)
{
  // Generate left wall
  GenerateWall(roadrun::WallSide::kLeft, new_line);

  // Generate rocks with delay
  if (ticks % kMillisPerRock == 0)
  {
    int i = (kMenuWidth - 1) / 3;
    int index = rand() % 20 + 18;
    while (i < 2 * (kMenuWidth - 1) / 3)
    {
      if (i == index)
      {
        /* 39 is max right, 20 is max left. we are
        getting a random place to put some rocks */
        new_line[i] = (char)'*';
        new_line[i + 1] = (char)'*';
        new_line[i + 2] = (char)'*';
        i += 3;
      }
      else
      {
        new_line[i] = (char)' ';
        i++;
      }
    }
  }
  else
  {
    for (int i = (kMenuWidth - 1) / 3; i < 2 * (kMenuWidth - 1) / 3; i++)
    {
      new_line[i] = (char)' ';
    }
  }

  // Generate right wall
  GenerateWall(roadrun::WallSide::kRight, new_line);

  new_line[kMenuWidth - 1] = '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x52c0
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x96, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5271
movl $0x14, -0x14(%rbp)
callq 0x2050
movl $0x14, %ecx
cltd
idivl %ecx
addl $0x12, %edx
movl %edx, -0x18(%rbp)
cmpl $0x28, -0x14(%rbp)
jge 0x526f
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x5258
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x2a, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x2a, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb $0x2a, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x14(%rbp)
jmp 0x526d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5211
jmp 0x5297
movl $0x14, -0x1c(%rbp)
cmpl $0x28, -0x1c(%rbp)
jge 0x5295
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5278
jmp 0x5297
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x52c0
movq -0x10(%rbp), %rax
movb $0xa, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drofp[P]RoadRun/src/map_generator_easy.cc
// Function: roadrun::MapGeneratorEasy::GenerateWall(roadrun::WallSide, char*)
void MapGeneratorEasy::GenerateWall(roadrun::WallSide wall_side,
                                    char* new_line)
{
  int lower_limit, upper_limit;
  if (wall_side == roadrun::WallSide::kLeft)
  {
    lower_limit = 0;
    upper_limit = (kMenuWidth - 1) / 3;
  }
  else
  {
    lower_limit = 2 * (kMenuWidth - 1) / 3;
    upper_limit = kMenuWidth - 1;
  }

  for (int i = lower_limit; i < upper_limit; i++)
  {
    if (rand() % 3 == 0)
      new_line[i] = (char)'D';
    else
      new_line[i] = (char)'#';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x52e9
movl $0x0, -0x1c(%rbp)
movl $0x14, -0x20(%rbp)
jmp 0x52f7
movl $0x28, -0x1c(%rbp)
movl $0x3c, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x533e
callq 0x2050
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5325
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x44, (%rax,%rcx)
jmp 0x5331
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x23, (%rax,%rcx)
jmp 0x5333
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x52fd
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: drofp[P]RoadRun/src/map_generator_factory.cc
// Function: roadrun::MapGeneratorFactory::create(roadrun::SettingsItem)
MapGenerator* MapGeneratorFactory::create(SettingsItem difficulty)
{
  if (difficulty == SettingsItem::kRegular)
   return new MapGeneratorEasy();
  else if (difficulty == SettingsItem::kLudicrous)
    return new MapGeneratorHard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x53a2
movl $0x10, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x5400
jmp 0x537c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53ed
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x2160
jmp 0x53f7
cmpl $0x1, -0xc(%rbp)
jne 0x53e9
movl $0x18, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x5440
jmp 0x53c3
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53ed
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x2160
jmp 0x53f7
jmp 0x53eb
ud2
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2280
// File: drofp[P]RoadRun/src/map_generator_hard.cc
// Function: roadrun::MapGeneratorHard::GenerateMap(char*)
const char* MapGeneratorHard::GenerateMap(char* game_map)
{
  // Create new line to be inserted at top of game_map
  char new_line[kMenuWidth];
  if (ticks % kMillisPerFrameHard == 0)
  {
    GenerateNewLine(new_line);
    MapUpdater::MoveLinesDown(ticks, game_map, new_line);
  }

  ticks = ticks > kMaxTickCnt ? 0 : ++ticks;

  return game_map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x8(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x54f9
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5540
movq -0x58(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x56a0
movq -0x58(%rbp), %rax
cmpl $0x4e20, 0x8(%rax)      # imm = 0x4E20
jle 0x550d
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x551d
movq -0x58(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drofp[P]RoadRun/src/map_generator_hard.cc
// Function: roadrun::MapGeneratorHard::GenerateNewLine(char*)
void MapGeneratorHard::GenerateNewLine(char* new_line)
{
  int wall_shift = rand() % 2 == 0 ? -1 : 1;

  if (split_location_right + wall_shift < kMenuWidth
      && split_location_left + wall_shift > 0)
  {
    split_location_left += wall_shift;
    split_location_right += wall_shift;
  }

  GenerateWall(roadrun::WallSide::kLeft, new_line, split_location_left);

  for (int i = split_location_left; i < split_location_right; i++)
    new_line[i] = (char)' ';

  GenerateWall(roadrun::WallSide::kRight, new_line, split_location_right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2050
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movl %edx, %esi
movl $0x1, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x0, %esi
cmovel %edx, %ecx
movl %ecx, -0x14(%rbp)
movl 0x10(%rax), %eax
addl -0x14(%rbp), %eax
cmpl $0x3d, %eax
jge 0x55ae
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x14(%rbp), %eax
cmpl $0x0, %eax
jle 0x55ae
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl 0xc(%rdi), %ecx
xorl %esi, %esi
callq 0x5610
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x55ed
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x55ca
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl 0x10(%rdi), %ecx
movl $0x1, %esi
callq 0x5610
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drofp[P]RoadRun/src/map_generator_hard.cc
// Function: roadrun::MapGeneratorHard::GenerateWall(roadrun::WallSide, char*, int)
void MapGeneratorHard::GenerateWall(roadrun::WallSide wall_side,
                                    char* new_line,
                                    int wall_edge)
{
  int lower_limit, upper_limit;
  if (wall_side == roadrun::WallSide::kLeft)
  {
    lower_limit = 0;
    upper_limit = wall_edge;
  }
  else
  {
    lower_limit = wall_edge;
    upper_limit = kMenuWidth - 1;
  }

  for (int i = lower_limit; i < upper_limit; i++)
  {
    if (rand() % 3 == 0)
      new_line[i] = (char)'D';
    else
      new_line[i] = (char)'#';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x563b
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x5648
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x3c, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x568f
callq 0x2050
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5676
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x44, (%rax,%rcx)
jmp 0x5682
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x23, (%rax,%rcx)
jmp 0x5684
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x564e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: drofp[P]RoadRun/src/map_updater.cc
// Function: roadrun::MapUpdater::MoveLinesDown(int, char*, char*)
void MapUpdater::MoveLinesDown(int ticks, char* game_map, char* new_line)
{
  for (int j = kMenuHeight - 1; j > 0; j--) {
    for (int i = 0; i < kMenuWidth; i++) {
      game_map[(j * kMenuWidth) + i] = game_map[((j - 1) * (kMenuWidth)) + i];
    }
  }

  // Write the new line to the 0th line of game_map
  for (int i = 0; i < kMenuWidth; i++)
  {
    game_map[i] = new_line[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1d, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x5708
movl $0x0, -0x20(%rbp)
cmpl $0x3d, -0x20(%rbp)
jge 0x56fb
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
imull $0x3d, %ecx, %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
imull $0x3d, -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x56c3
jmp 0x56fd
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x56b6
movl $0x0, -0x24(%rbp)
cmpl $0x3d, -0x24(%rbp)
jge 0x5736
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x570f
popq %rbp
retq
nopl (%rax,%rax)
// File: drofp[P]RoadRun/src/settings_menu.cc
// Function: roadrun::SettingsMenu::RenderOptions(_win_st*, int)
void SettingsMenu::RenderOptions(WINDOW *menu_win, int highlight)
  {
    mvwprintw(menu_win, 2, 4, "Choose a Difficulty");
    char *choices[] = {
        "Regular Mode",
        "Ludicrous Mode",
        "Ron Mak",
    };
    int x, y, i;
    x = y = 4;
    box(menu_win, 0,0);
    for(i = 0; i < num_settings_items; i++) {
      if(highlight == i + 1)
      {
        wattron(menu_win, A_REVERSE);
        mvwprintw(menu_win, y, x, "%s",
                  SettingToString(choices, settings_item_list[i]));
        wattroff(menu_win, A_REVERSE);
      }
      else
      {
        mvwprintw(menu_win, y, x, "%s",
                  SettingToString(choices, settings_item_list[i]));
      }
      ++y;
    }
  wrefresh(menu_win);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
leaq 0x1847(%rip), %rcx      # 0x6faf
movb $0x0, %al
callq 0x2040
movq 0x45ca(%rip), %rax      # 0x9d40
movq %rax, -0x30(%rbp)
movq 0x45c7(%rip), %rax      # 0x9d48
movq %rax, -0x28(%rbp)
movq 0x45c4(%rip), %rax      # 0x9d50
movq %rax, -0x20(%rbp)
movl $0x4, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2290
movl $0x0, -0x3c(%rbp)
cmpl $0x2, -0x3c(%rbp)
jge 0x5892
movl -0x14(%rbp), %eax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5835
movq -0x10(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x20c0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rcx
leaq 0x17ea(%rip), %rax      # 0x6fe8
movl (%rax,%rcx,4), %esi
callq 0x5a50
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x40(%rbp), %edx
movq %rax, %r8
leaq 0xf2f(%rip), %rcx       # 0x6749
movb $0x0, %al
callq 0x2040
movq -0x10(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %eax, %eax
movl %eax, %edx
callq 0x21f0
jmp 0x587b
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rcx
leaq 0x1790(%rip), %rax      # 0x6fe8
movl (%rax,%rcx,4), %esi
callq 0x5a50
movq -0x60(%rbp), %rdi
movl -0x58(%rbp), %esi
movl -0x54(%rbp), %edx
movq %rax, %r8
leaq 0xed5(%rip), %rcx       # 0x6749
movb $0x0, %al
callq 0x2040
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x57b2
movq -0x10(%rbp), %rdi
callq 0x21b0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ajuc[P]c--_lisp_sexp_parser/test_parse.cpp
// Function: main
int main(int argc, char* argv[]) {
	std::string tmp(argv[1]);
	std::istringstream input(tmp);
	const std::shared_ptr<const AjucLispParser::Expression> e = AjucLispParser::parse(input);
	std::cout << e->toString() << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x218(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x3330
movq -0x218(%rbp), %rsi
movq -0x210(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3250
jmp 0x3541
leaq -0x31(%rbp), %rdi
callq 0x3200
leaq -0x1c8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x32e0
jmp 0x3561
leaq -0x1e8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x46a0
jmp 0x3576
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x220(%rbp)
leaq -0x1e8(%rbp), %rsi
movq %rsi, -0x228(%rbp)
callq 0x36c0
movq -0x228(%rbp), %rdi
callq 0x36f0
movq -0x220(%rbp), %rdi
callq 0x3710
movq %rax, %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x208(%rbp), %rdi
callq *%rax
jmp 0x35c4
movq 0xfa05(%rip), %rdi      # 0x12fd0
leaq -0x208(%rbp), %rsi
callq 0x3170
movq %rax, -0x230(%rbp)
jmp 0x35e0
movq -0x230(%rbp), %rdi
movq 0xf9ca(%rip), %rsi      # 0x12fb8
callq 0x31e0
jmp 0x35f5
leaq -0x208(%rbp), %rdi
callq 0x3110
movl $0x0, -0x4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x3730
leaq -0x1c8(%rbp), %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0x3110
movl -0x4(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3200
jmp 0x36af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x36a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x369a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x368e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3110
leaq -0x1d8(%rbp), %rdi
callq 0x3730
leaq -0x1c8(%rbp), %rdi
callq 0x30e0
leaq -0x30(%rbp), %rdi
callq 0x3110
movq -0x40(%rbp), %rdi
callq 0x3320
nopl (%rax,%rax)
// File: ajuc[P]c--_lisp_sexp_parser/lispparser.cpp
// Function: AjucLispParser::Float::Float(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Float::Float(const std::string& text) {
	std::istringstream ss(text);
	float f;
	ss >> f;
	(this->_value) = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x3a10
movq -0x1a8(%rbp), %rax
leaq 0xefdf(%rip), %rcx      # 0x12a60
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movl $0x8, %edx
callq 0x32e0
jmp 0x3a9b
leaq -0x190(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3050
jmp 0x3ab0
movq -0x1a8(%rbp), %rax
movss -0x1a0(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
leaq -0x190(%rbp), %rdi
callq 0x30e0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x3b0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x30e0
movq -0x1a8(%rbp), %rdi
callq 0x3a30
movq -0x198(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: ajuc[P]c--_lisp_sexp_parser/lispparser.cpp
// Function: AjucLispParser::List::toString[abi:cxx11]() const
const std::string List::toString() const {
	std::string result("( ");
	for (unsigned int i=0; i<elements.size(); i++) {
		if (i>0) {
			result += ", ";
		}
		result = result + elements[i]->toString();
	}
	result += " )";
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3330
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x7e2d(%rip), %rsi      # 0xc006
callq 0x3250
jmp 0x41e0
leaq -0x12(%rbp), %rdi
callq 0x3200
movl $0x0, -0x28(%rbp)
movq -0x80(%rbp), %rdi
movl -0x28(%rbp), %eax
movq %rax, -0x90(%rbp)
addq $0x8, %rdi
callq 0x58d0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x42e2
cmpl $0x0, -0x28(%rbp)
jbe 0x425f
movq -0x78(%rbp), %rdi
leaq 0x7dde(%rip), %rsi      # 0xc009
callq 0x3190
jmp 0x4232
jmp 0x425f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3200
jmp 0x4320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4317
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x5970
movq %rax, %rdi
callq 0x5990
movq %rax, %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0x428b
movq -0x78(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x58f0
jmp 0x429e
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3230
leaq -0x48(%rbp), %rdi
callq 0x3110
leaq -0x68(%rbp), %rdi
callq 0x3110
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x41f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3110
jmp 0x4317
movq -0x78(%rbp), %rdi
leaq 0x7d1f(%rip), %rsi      # 0xc00c
callq 0x3190
jmp 0x42f4
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4307
movq -0x78(%rbp), %rdi
callq 0x3110
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3110
movq -0x20(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: BenLangmead[P]bowtie/./random_source.h
// Function: RandomSource::nextU64()
uint64_t nextU64() {
		assert(inited_);
		uint64_t first = nextU32();
		first = first << 32;
		uint64_t second = nextU32();
		return first | second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x483c0
movq -0x20(%rbp), %rdi
movl %eax, %eax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x10(%rbp)
callq 0x483c0
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
orq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: EduBic[P]TSP-MetaheuristicSolvers/solversexecutor.cpp
// Function: SolversExecutor::printInitSolutions() const
void SolversExecutor::printInitSolutions() const {
    for (vector<TSPSolution*>::const_iterator it = mInitSolutions.begin(); it != mInitSolutions.end(); ++it) {
        cout << endl << (*it)->solveBy << endl;
        cout << "(value : " << (*it)->evaluateObjectiveFunction(mTspInstance) << ")\n";
        cout << "sec. (user time) " << (*it)->userTime << endl;
        cout << "sec. (CPU time) " << (*it)->cpuTime << endl;
        cout << "Max iterations " << (*it)->iterations << endl;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x60, %rdi
callq 0x5d00
movq %rax, 0x38(%rsp)
movq 0x28(%rsp), %rdi
addq $0x60, %rdi
callq 0x5d70
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5d30
testb $0x1, %al
jne 0x498c
jmp 0x4aee
movq 0xf63d(%rip), %rdi      # 0x13fd0
movq 0xf616(%rip), %rsi      # 0x13fb0
callq 0x32b0
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5da0
movq (%rsp), %rdi
movq (%rax), %rsi
addq $0x18, %rsi
callq 0x3240
movq %rax, %rdi
movq 0xf5e9(%rip), %rsi      # 0x13fb0
callq 0x32b0
movq 0xf5fd(%rip), %rdi      # 0x13fd0
leaq 0x9735(%rip), %rsi      # 0xe10f
callq 0x3280
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5da0
movq 0x28(%rsp), %rsi
movq (%rax), %rdi
addq $0x8, %rsi
callq 0x5bf0
movq 0x8(%rsp), %rdi
callq 0x3460
movq %rax, %rdi
leaq 0x973c(%rip), %rsi      # 0xe14f
callq 0x3280
movq 0xf5b1(%rip), %rdi      # 0x13fd0
leaq 0x96f6(%rip), %rsi      # 0xe11c
callq 0x3280
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5da0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movsd 0x38(%rax), %xmm0
callq 0x3460
movq %rax, %rdi
movq 0xf55a(%rip), %rsi      # 0x13fb0
callq 0x32b0
movq 0xf56e(%rip), %rdi      # 0x13fd0
leaq 0x96c5(%rip), %rsi      # 0xe12e
callq 0x3280
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5da0
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movsd 0x40(%rax), %xmm0
callq 0x3460
movq %rax, %rdi
movq 0xf517(%rip), %rsi      # 0x13fb0
callq 0x32b0
movq 0xf52b(%rip), %rdi      # 0x13fd0
leaq 0x9693(%rip), %rsi      # 0xe13f
callq 0x3280
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5da0
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movl 0x48(%rax), %esi
callq 0x3300
movq %rax, %rdi
movq 0xf4d6(%rip), %rsi      # 0x13fb0
callq 0x32b0
leaq 0x38(%rsp), %rdi
callq 0x5db0
jmp 0x4961
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: EduBic[P]TSP-MetaheuristicSolvers/./TSP.h
// Function: TSP::readFromFile(char const*)
void readFromFile(const char* filename) {
        std::ifstream in(filename);

        in >> n;
        std::cout << "read from file, num nodes = " << n << std::endl;

        cost.resize(n);
        for (int i = 0; i < n; i++) {

            cost[i].reserve(n);

            for (int j = 0; j < n; j++) {
                double c;
                in >> c;
                cost[i].push_back(c);
            }
        }

        in.close();
    }

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x248(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x8, %edx
callq 0x3450
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x31a0
jmp 0x5301
movq 0xecc8(%rip), %rdi      # 0x13fd0
leaq 0x8ee6(%rip), %rsi      # 0xe1f5
callq 0x3280
movq %rax, 0x8(%rsp)
jmp 0x531b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0x3410
movq %rax, (%rsp)
jmp 0x5332
movq (%rsp), %rdi
movq 0xec73(%rip), %rsi      # 0x13fb0
callq 0x32b0
jmp 0x5344
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq (%rax), %rsi
callq 0x6010
jmp 0x535a
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl (%rcx), %eax
jge 0x541b
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movslq 0x30(%rsp), %rsi
callq 0x60b0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
callq 0x60d0
jmp 0x5398
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl (%rcx), %eax
jge 0x5409
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3220
jmp 0x53be
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movslq 0x30(%rsp), %rsi
callq 0x60b0
movq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x61e0
jmp 0x53e0
jmp 0x53e2
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x53a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x5439
jmp 0x540b
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x5362
leaq 0x40(%rsp), %rdi
callq 0x3090
jmp 0x5427
leaq 0x40(%rsp), %rdi
callq 0x30b0
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x38(%rsp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::TSPSolution(TSP const&)
TSPSolution( const TSP& tsp ) {

        sequence.reserve(tsp.n + 1);

        for ( int i = 0; i < tsp.n ; ++i ) {
            sequence.push_back(i);
        }

        sequence.push_back(0);

        solveBy = "Random";
        userTime = -1.0;
        cpuTime = -1.0;
        iterations = 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x7950
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x10(%rsp)
callq 0x3330
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movl (%rax), %eax
incl %eax
movslq %eax, %rsi
callq 0x7960
jmp 0x5580
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x55d9
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7a70
jmp 0x55a6
jmp 0x55a8
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x5588
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x31b0
movq 0x18(%rsp), %rdi
callq 0x7b10
jmp 0x5634
movq 0x8(%rsp), %rdi
movl $0x0, 0x24(%rsp)
leaq 0x24(%rsp), %rsi
callq 0x7ae0
jmp 0x55f2
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x8c54(%rip), %rsi      # 0xe256
callq 0x3310
jmp 0x5609
movq 0x8(%rsp), %rax
movsd 0x89fa(%rip), %xmm0     # 0xe010
movsd %xmm0, 0x38(%rax)
movsd 0x89ed(%rip), %xmm0     # 0xe010
movsd %xmm0, 0x40(%rax)
movl $0x0, 0x48(%rax)
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3420
nop