LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
callq 0x2050
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x2aaaaaaa, %ecx       # imm = 0x2AAAAAAA
movl $0x44, %eax
cmpl $0x55555555, %ecx       # imm = 0x55555555
jb 0x353a
movl $0x23, %eax
movb %al, (%rbx,%r15)
incq %r15
cmpq $0x14, %r15
jne 0x3517
imull $0x962fc963, 0x8(%r14), %eax # imm = 0x962FC963
addl $0x1b4e81a, %eax        # imm = 0x1B4E81A
rorl %eax
cmpl $0x1b4e81b, %eax        # imm = 0x1B4E81B
jb 0x3571
movaps 0x12bc(%rip), %xmm0     # 0x4820
movups %xmm0, 0x14(%rbx)
movl $0x20202020, 0x24(%rbx) # imm = 0x20202020
jmp 0x35c6
callq 0x2050
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,4), %ecx
negl %ecx
addl %ecx, %eax
addl $0x12, %eax
movl $0x14, %ecx
cmpl %eax, %ecx
movl %ecx, %ecx
jne 0x35b6
movw $0x2a2a, (%rbx,%rcx)    # imm = 0x2A2A
movb $0x2a, 0x2(%rbx,%rcx)
movl $0x3, %edx
jmp 0x35bf
movb $0x20, (%rbx,%rcx)
movl $0x1, %edx
addl %edx, %ecx
cmpl $0x28, %ecx
jb 0x359e
xorl %r14d, %r14d
callq 0x2050
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x2aaaaaaa, %ecx       # imm = 0x2AAAAAAA
movl $0x44, %eax
cmpl $0x55555555, %ecx       # imm = 0x55555555
jb 0x35ec
movl $0x23, %eax
movb %al, 0x28(%rbx,%r14)
incq %r14
cmpq $0x14, %r14
jne 0x35c9
movb $0xa, 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %edi, %edi
je 0x36a7
movl $0x18, %edi
callq 0x2120
leaq 0x367f(%rip), %rcx      # 0x6d08
addq $0x10, %rcx
movq %rcx, (%rax)
movabsq $0x1400000000, %rcx     # imm = 0x1400000000
movq %rcx, 0x8(%rax)
movl $0x28, 0x10(%rax)
jmp 0x36c6
movl $0x10, %edi
callq 0x2120
leaq 0x3610(%rip), %rcx      # 0x6cc8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
imull $0xcccccccd, 0x8(%rdi), %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx       # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x370d
leaq -0x60(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3734
movl 0x8(%r14), %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3878
movl 0x8(%r14), %eax
xorl %ecx, %ecx
cmpl $0x4e20, %eax           # imm = 0x4E20
jg 0x3722
incl %eax
movl %eax, 0x8(%r14)
movl %eax, %ecx
movl %ecx, 0x8(%r14)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2050
andl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x1, %eax
sbbl %ecx, %ecx
orl $0x1, %ecx
movl 0x10(%r14), %eax
addl %ecx, %eax
cmpl $0x3c, %eax
jg 0x3770
addl 0xc(%r14), %ecx
jle 0x3770
movl %ecx, 0xc(%r14)
movl %eax, 0x10(%r14)
movslq 0xc(%r14), %r15
testq %r15, %r15
jle 0x37ab
xorl %r12d, %r12d
callq 0x2050
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x2aaaaaaa, %ecx       # imm = 0x2AAAAAAA
movl $0x44, %eax
cmpl $0x55555555, %ecx       # imm = 0x55555555
jb 0x379f
movl $0x23, %eax
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %r15
jne 0x377c
movslq 0xc(%r14), %rcx
movl 0x10(%r14), %eax
cmpl %eax, %ecx
jge 0x37c7
movb $0x20, (%rbx,%rcx)
incq %rcx
movslq 0x10(%r14), %rax
cmpq %rax, %rcx
jl 0x37b7
cmpl $0x3b, %eax
jg 0x3809
movslq %eax, %r14
incq %r14
callq 0x2050
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x2aaaaaaa, %ecx       # imm = 0x2AAAAAAA
movl $0x44, %eax
cmpl $0x55555555, %ecx       # imm = 0x55555555
jb 0x37f5
movl $0x23, %eax
movb %al, -0x1(%rbx,%r14)
movq %r14, %rax
incq %rax
cmpl $0x3c, %r14d
movq %rax, %r14
jne 0x37d2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
cmovnel %ecx, %esi
movl $0x3c, %r14d
cmovel %ecx, %r14d
subl %esi, %r14d
jle 0x386b
movq %rdx, %rbx
movslq %esi, %rax
addq %rax, %rbx
xorl %r15d, %r15d
callq 0x2050
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x2aaaaaaa, %ecx       # imm = 0x2AAAAAAA
movl $0x44, %eax
cmpl $0x55555555, %ecx       # imm = 0x55555555
jb 0x385f
movl $0x23, %eax
movb %al, (%rbx,%r15)
incq %r15
cmpl %r15d, %r14d
jne 0x383c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x6e9(%rsi), %rax
movl $0x1d, %ecx
movq $-0x3d, %rdi
movb (%rax,%rdi), %r8b
movb %r8b, 0x3d(%rax,%rdi)
incq %rdi
jne 0x388f
leaq -0x1(%rcx), %rdi
addq $-0x3d, %rax
cmpq $0x1, %rcx
movq %rdi, %rcx
ja 0x3888
xorl %eax, %eax
movb (%rdx,%rax), %cl
movb %cl, (%rsi,%rax)
incq %rax
cmpq $0x3d, %rax
jne 0x38b0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
leaq 0xfa4(%rip), %rcx       # 0x4883
movl $0x4, %r14d
movq %rsi, %rdi
movl $0x2, %esi
movl $0x4, %edx
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2270
movl %r15d, %eax
leaq -0x4(,%rax,4), %r12
leaq 0x6ed(%rip), %r15       # 0x4004
xorl %r13d, %r13d
cmpq %r13, %r12
jne 0x396b
movq %rbx, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x20b0
leaq 0xf87(%rip), %rax       # 0x48bc
movslq (%r13,%rax), %rax
leaq 0x33ff(%rip), %rcx      # 0x6d40
movq (%rcx,%rax,8), %r8
movq %rbx, %rdi
movl %r14d, %esi
movl $0x4, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2040
movq %rbx, %rdi
movl $0x40000, %esi          # imm = 0x40000
xorl %edx, %edx
callq 0x21d0
jmp 0x3997
leaq 0xf4a(%rip), %rax       # 0x48bc
movslq (%r13,%rax), %rax
leaq 0x33c2(%rip), %rcx      # 0x6d40
movq (%rcx,%rax,8), %r8
movq %rbx, %rdi
movl %r14d, %esi
movl $0x4, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2040
incl %r14d
addq $0x4, %r13
cmpq $0x4, %r13
je 0x391a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/drofp[P]RoadRun/src/settings_menu.cc
// Function: roadrun::SettingsMenu::PrintMenu()
void SettingsMenu::PrintMenu()
  {
    endwin();
    refresh();
    WINDOW *menu_win;
    int highlight = 1;
    int choice = 0;
    int c;
    initscr();
    clear();
    noecho();
    cbreak();
    int startx = 5;  // (80 - kWidth) / 2;
    int starty = 5;  // (80 - kHeight) / 2;
    menu_win = newwin(kHeight, kWidth, starty, startx);
    keypad(menu_win, TRUE);
    mvprintw(0, 0, "Use up and down arrows to choose, enter to select.");
    refresh();
    RenderOptions(menu_win, highlight);
    int enter_pressed = 0;
    while(!enter_pressed)
    {
      c = wgetch(menu_win);
      switch (c)
      {
      case KEY_UP:
        if(highlight == 1)
            highlight = 2;
          else
            --highlight;
          break;
      case KEY_DOWN:
        if(highlight == 2)
          highlight = 1;
        else
          ++highlight;
        break;
      case 10:
        choice = highlight;
        enter_pressed = 1;
        break;
      default:
        // mvprintw(24, 0, "Charcter pressed is = %3d Hopefully it can be printed as '%c'", c, c);
        refresh();
        break;
      }
      current_choice = settings_item_list[highlight - 1];
      RenderOptions(menu_win, highlight);
    }
    // mvprintw(23, 0, "You chose choice %d with choice string %s\n", choice, choices[choice - 1]);
    clrtoeol();
    refresh();
    endwin();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21b0
callq 0x2240
callq 0x2210
callq 0x2250
callq 0x21a0
callq 0x2070
movl 0x14(%rbx), %esi
movl 0x18(%rbx), %edi
movl $0x5, %edx
movl $0x5, %ecx
callq 0x2150
movq %rax, %r14
movl $0x1, %r15d
movq %rax, %rdi
movl $0x1, %esi
callq 0x2090
leaq 0xbdf(%rip), %rdx       # 0x45fe
xorl %r12d, %r12d
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x21e0
callq 0x2240
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq *0x10(%rax)
leaq 0xe72(%rip), %r13       # 0x48bc
movq %r14, %rdi
callq 0x2080
cmpl $0xa, %eax
je 0x3a80
cmpl $0x102, %eax            # imm = 0x102
je 0x3a70
cmpl $0x103, %eax            # imm = 0x103
jne 0x3a88
xorl %eax, %eax
cmpl $0x1, %r15d
sete %al
jmp 0x3a79
xorl %eax, %eax
cmpl $0x2, %r15d
setne %al
incl %eax
movl %eax, %r15d
jmp 0x3a8d
movl $0x1, %r12d
jmp 0x3a8d
callq 0x2240
leal -0x1(%r15), %eax
movl (%r13,%rax,4), %eax
movl %eax, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq *0x10(%rax)
testl %r12d, %r12d
je 0x3a4a
movq 0x3524(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x2180
callq 0x2240
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rbx
leaq -0x1d0(%rbp), %rdx
movq %rbx, %rdi
callq 0x3090
leaq -0x1d0(%rbp), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x3250
leaq -0x30(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x3e40
leaq -0x30(%rbp), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rbx
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x5b1b(%rip), %rdi      # 0x8fd0
callq 0x31a0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3100
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34f6
callq 0x3160
testq %rbx, %rbx
je 0x3503
movq %rbx, %rdi
callq 0x35ac
movq 0x5aae(%rip), %rsi      # 0x8fb8
leaq -0x1d0(%rbp), %rdi
callq 0x3200
leaq -0x158(%rbp), %rdi
callq 0x3070
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3534
callq 0x3160
xorl %eax, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x3566
movq %rax, %r14
jmp 0x3573
movq %rax, %r14
jmp 0x3592
movq %rax, %r14
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3566
callq 0x3160
testq %rbx, %rbx
je 0x3573
movq %rbx, %rdi
callq 0x35ac
movq 0x5a3e(%rip), %rsi      # 0x8fb8
leaq -0x1d0(%rbp), %rdi
callq 0x3200
leaq -0x158(%rbp), %rdi
callq 0x3070
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35a4
callq 0x3160
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x541c(%rip), %rax      # 0x8a68
movq %rax, (%rdi)
leaq -0x198(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x3250
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x32c0
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x8(%rbx)
movq 0x5938(%rip), %rsi      # 0x8fb8
leaq -0x198(%rbp), %rdi
callq 0x3200
leaq -0x120(%rbp), %rdi
callq 0x3070
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x590a(%rip), %rsi      # 0x8fb8
leaq -0x198(%rbp), %rdi
callq 0x3200
leaq -0x120(%rbp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x2497(%rip), %rsi      # 0x6006
leaq 0x2492(%rip), %rdx      # 0x6008
callq 0x4bc4
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
je 0x3c1c
movl $0x1, %r13d
xorl %r15d, %r15d
leaq -0x70(%rbp), %r12
cmpl $0x1, %r13d
je 0x3bab
movq %rbx, %rdi
leaq 0x2463(%rip), %rsi      # 0x6009
callq 0x32b0
movq 0x8(%r14), %rax
shlq $0x4, %r15
movq (%rax,%r15), %rsi
movq (%rsi), %rax
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4a21
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31c0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x3bef
callq 0x3160
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3c01
callq 0x3160
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
movl %r13d, %r15d
sarq $0x4, %rax
incl %r13d
cmpq %r15, %rax
ja 0x3b96
leaq 0x23e9(%rip), %rsi      # 0x600c
movq %rbx, %rdi
callq 0x32b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c41
jmp 0x3c41
movq %rax, %r14
jmp 0x3c5b
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3c5b
callq 0x3160
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x3c69
callq 0x3160
movq %r14, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x3430
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31b0
movq 0x600e(%rip), %rdi      # 0xafd0
leaq 0x3234(%rip), %rsi      # 0x81fd
movl $0x1c, %edx
callq 0x32f0
movl (%rbx), %esi
movq 0x5ff4(%rip), %rdi      # 0xafd0
callq 0x3400
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31f0
leaq 0x8(%rbx), %r14
movslq (%rbx), %rsi
movq %r14, %rdi
callq 0x53ac
movl (%rbx), %eax
testl %eax, %eax
jle 0x509e
xorl %ecx, %ecx
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rcx, (%rsp)
leaq (%rcx,%rcx,2), %rbp
leaq (,%rbp,8), %rdi
addq (%r14), %rdi
movslq %eax, %rsi
callq 0x542e
cmpl $0x0, (%rbx)
jle 0x508f
xorl %r13d, %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq (%r14), %rax
leaq (%rax,%rbp,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x507f
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5087
movq %r12, %rdx
callq 0x5684
incl %r13d
cmpl (%rbx), %r13d
jl 0x504f
movq (%rsp), %rcx
incq %rcx
movslq (%rbx), %rax
cmpq %rax, %rcx
jl 0x502c
leaq 0x10(%rsp), %rdi
callq 0x3090
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50c8
jmp 0x50c8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r13
movq %r13, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movslq (%rsi), %rsi
incq %rsi
callq 0x57e0
movl $0x0, 0x8(%rsp)
cmpl $0x0, (%r15)
jle 0x5161
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5147
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5152
movq %rbx, %rdi
movq %r12, %rdx
callq 0x588a
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl (%r15), %eax
jl 0x5131
movl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5183
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5190
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x59a2
movq 0x20(%rbx), %rdx
leaq 0x30c3(%rip), %rcx      # 0x825e
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3360
movaps 0x2e5e(%rip), %xmm0     # 0x8010
movups %xmm0, 0x38(%rbx)
movl $0x0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x51cf
jmp 0x51cf
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x51df
callq 0x3290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51ec
callq 0x3290
movq %r15, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::initRandom(int)
void initRandom(int seed = 42) {
        srand(seed/*time(NULL)*/);

        for (uint i = 1 ; i < sequence.size() ; ++i ) {
            // initial and final position are fixed (initial/final node remains 0)

            int idx1 = rand() % (sequence.size()-2) + 1;
            int idx2 = rand() % (sequence.size()-2) + 1;

            int tmp = sequence[idx1];
            sequence[idx1] = sequence[idx2];
            sequence[idx2] = tmp;
        }

        std::cout << "###" << std::endl;
        print(std::cout);
        std::cout << "###" << std::endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %edi
callq 0x32a0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x5, %rax
jb 0x5299
movl $0x2, %ebp
movabsq $0x100000000, %r15      # imm = 0x100000000
callq 0x30c0
cltq
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x2, %rcx
addq $-0x2, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
callq 0x30c0
cltq
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
addq $-0x2, %rsi
xorl %edx, %edx
divq %rsi
shlq $0x20, %r14
addq %r15, %r14
sarq $0x1e, %r14
movl (%rcx,%r14), %eax
shlq $0x20, %rdx
addq %r15, %rdx
sarq $0x1e, %rdx
movl (%rcx,%rdx), %esi
movl %esi, (%rcx,%r14)
movl %eax, (%rcx,%rdx)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movl %ebp, %ecx
sarq $0x2, %rax
incl %ebp
cmpq %rcx, %rax
ja 0x5225
movq 0x5d30(%rip), %r14      # 0xafd0
leaq 0x2fbe(%rip), %r15      # 0x8265
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a76
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x32f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::print(std::ostream&) const
void print(std::ostream& out) const {
        out << std::endl;
        for (uint i = 0; i < sequence.size(); i++ ) {
            out << sequence[i] << " ";
        }
        out << std::endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rdi
addq %rsi, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31f0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x5af3
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x2684(%rip), %r15      # 0x8145
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x3400
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32f0
movl %ebp, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5ac1
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/LocalSearchSolver.cpp
// Function: LocalSearchSolver::swap(TSPSolution&, move const&)
TSPSolution& LocalSearchSolver::swap( TSPSolution& tspSol , const TSPMove& move ) {

    TSPSolution tmpSol(tspSol);

    for (int i = move.from ; i <= move.to ; ++i) {
        tspSol.sequence[i] = tmpSol.sequence[move.to-(i-move.from)];
    }

    return tspSol;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x625a
movslq (%r14), %rax
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jg 0x622d
movq 0x8(%rsp), %rdx
movq (%rbx), %rsi
movq %rax, %rdi
decq %rdi
negl %eax
addl (%r14), %ecx
addl %eax, %ecx
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x4(%rsi,%rdi,4)
movslq 0x4(%r14), %rcx
incq %rdi
decl %eax
cmpq %rcx, %rdi
jl 0x6210
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6240
callq 0x3290
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x624f
callq 0x3290
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/./TSPSolution.h
// Function: TSPSolution::TSPSolution(TSPSolution const&)
TSPSolution( const TSPSolution& tspSol ) {
        sequence.reserve(tspSol.sequence.size());

        for (uint i = 0; i < tspSol.sequence.size(); ++i ) {
            sequence.push_back(tspSol.sequence[i]);
        }

        solveBy = tspSol.solveBy;
        userTime = tspSol.userTime;
        cpuTime = tspSol.cpuTime;
        iterations = tspSol.iterations;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
callq 0x57e0
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x62e3
movl $0x1, %ebp
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x62c4
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x62cc
movq %rbx, %rdi
callq 0x588a
movl %ebp, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x62a8
leaq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x3180
movups 0x38(%r15), %xmm0
movups %xmm0, 0x38(%rbx)
movl 0x48(%r15), %eax
movl %eax, 0x48(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x630a
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x631a
callq 0x3290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6327
callq 0x3290
movq %r15, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/TabuSearchSolver.cpp
// Function: TabuSearchSolver::getSolverName[abi:cxx11]() const
std::string TabuSearchSolver::getSolverName() const {
    char buffer[50];
    sprintf(buffer, "\tTenure: %d, MaxIter: %d", mTabuLength, mMaxIteration);

    std::string tmp = std::string(buffer);

    if (ACmode) {
        if (BestImprovement) {
            return "Tabu Search AC - BI " + tmp;
        } else {
            return "Tabu Search AC - FI " + tmp;
        }
    } else {
        if (BestImprovement) {
            return "Tabu Search - BI " + tmp;
        } else {
            return "Tabu Search - FI " + tmp;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %ecx
leaq 0x1f7c(%rip), %rsi      # 0x8300
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3080
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rdi
callq 0x3140
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d90
leaq 0x1f82(%rip), %rax      # 0x8343
leaq 0x1f8d(%rip), %rcx      # 0x8355
cmpb $0x0, 0x81(%r14)
cmovneq %rax, %rcx
leaq 0x1f3e(%rip), %rax      # 0x8319
leaq 0x1f4c(%rip), %rsi      # 0x832e
cmovneq %rax, %rsi
cmpb $0x0, 0x80(%r14)
cmoveq %rcx, %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x532a
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x640b
callq 0x3290
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x642d
callq 0x3290
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/TabuSearchSolver.cpp
// Function: TabuSearchSolver::swap(TSPSolution&, move const&)
TSPSolution& TabuSearchSolver::swap(TSPSolution& tspSol, const TSPMove& move) {

    TSPSolution tmpSol(tspSol);

    for ( int i = move.from ; i <= move.to ; ++i ) {
        tspSol.sequence[i] = tmpSol.sequence[move.to-(i-move.from)];
    }

    return tspSol;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x625a
movslq (%r14), %rax
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
jg 0x6c09
movq 0x8(%rsp), %rdx
movq (%rbx), %rsi
movq %rax, %rdi
decq %rdi
negl %eax
addl (%r14), %ecx
addl %eax, %ecx
movslq %ecx, %rcx
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x4(%rsi,%rdi,4)
movslq 0x4(%r14), %rcx
incq %rdi
decl %eax
cmpq %rcx, %rdi
jl 0x6bec
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c1c
callq 0x3290
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6c2b
callq 0x3290
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/TabuSearchSolver.cpp
// Function: TabuSearchSolver::isTabuMove(int, int)
bool TabuSearchSolver::isTabuMove(int from, int to) {
    /*std::list<TSPMove>::const_iterator it = mTabuList.begin();

    while (it != mTabuList.end()) {
        if ((*it).from == from && (*it).to == to)
            return true;
        it++;
    }*/


    char buffer[50];
    sprintf(buffer, "%u%u", from, to);
    string moveKey = string(buffer);

    if (mTabuSet.find(moveKey) != mTabuSet.end()) {
        return true;
    }

    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
leaq 0x14f9(%rip), %rsi      # 0x8384
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3080
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x3140
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5d90
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x7460
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6edf
callq 0x3290
addq $0x50, %rbx
cmpq %rbx, %r14
setne %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6f06
callq 0x3290
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/EduBic[P]TSP-MetaheuristicSolvers/./neighborimprovement.h
// Function: BestImprovement::execute(TSP const&, TSPSolution const&, move&)
double execute(const TSP &tsp, const TSPSolution &currSol, TSPMove &move) {
        //cout << endl << endl << "------------- find neighbor --------------";

        // Determine the *move* yielding the best 2-opt neigbor solution
        double bestCostVariation = tsp.infinite;

        // initial and final position are fixed (initial/final node remains 0)
        for ( uint a = 1 ; a < currSol.sequence.size() - 2 ; a++ ) {

            int h = currSol.sequence[a-1];
            int i = currSol.sequence[a];

            for ( uint b = a + 1 ; b < currSol.sequence.size() - 1 ; b++ ) {
                int j = currSol.sequence[b];
                int l = currSol.sequence[b+1];

                // incremental evaluation --> bestCostVariation (instead of best cost)
                double neighCostVariation = - tsp.cost[h][i] - tsp.cost[j][l]
                                            + tsp.cost[h][j] + tsp.cost[i][l];

                //cout << endl << "Move from " << a << " to " << b;
                //cout << "\tNeighbor Variation = " << neighCostVariation << " - BestCostVariation = " << bestCostVariation;

                if ( neighCostVariation < bestCostVariation ) {
                    //cout << "\tSave! Best neighbor found until now";

                    bestCostVariation = neighCostVariation;
                    move.from = a;
                    move.to = b;
                }
            }
        }

        //cout << endl << "-----------------------------" << endl;
        return bestCostVariation;
    }

// Assembly:
movsd 0x20(%rsi), %xmm0
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
leaq -0x2(%rdx), %rdi
cmpq $0x2, %rdi
jb 0x7be9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
decq %rdx
movq 0x8(%rsi), %rsi
movl $0x1, %r9d
movl $0x1, %r11d
movl $0x3, %r8d
movapd 0x79e(%rip), %xmm1      # 0x82f0
movl %r9d, %r10d
leal 0x1(%r10), %r9d
cmpq %r9, %rdx
jbe 0x7bd0
movslq (%rax,%r11,4), %rbx
leal -0x1(%r10), %r11d
movslq (%rax,%r11,4), %r11
leaq (%r11,%r11,2), %r11
movq (%rsi,%r11,8), %r11
movsd (%r11,%rbx,8), %xmm2
xorpd %xmm1, %xmm2
leaq (%rbx,%rbx,2), %rbx
movq (%rsi,%rbx,8), %rbx
movl %r8d, %r14d
movq %r9, %r15
movslq (%rax,%r15,4), %r12
movl %r14d, %r15d
movslq (%rax,%r15,4), %r13
leaq (%r12,%r12,2), %rbp
movq (%rsi,%rbp,8), %rbp
movapd %xmm2, %xmm3
subsd (%rbp,%r13,8), %xmm3
addsd (%r11,%r12,8), %xmm3
addsd (%rbx,%r13,8), %xmm3
ucomisd %xmm3, %xmm0
jbe 0x7bc8
leal -0x1(%r14), %ebp
movl %r10d, (%rcx)
movl %ebp, 0x4(%rcx)
movapd %xmm3, %xmm0
incl %r14d
cmpq %r15, %rdx
ja 0x7b8a
incl %r8d
movq %r9, %r11
cmpq %r9, %rdi
ja 0x7b52
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidNKraemer[P]convex-hull/./cvhull/_Interface.h
// Function: ams562::loadtxt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<ams562::Point2D, std::allocator<ams562::Point2D>>&)
void loadtxt(const std::string &filename, std::vector<Point2D> &p) {
    // check the size, if not zero, make it zero
    if (p.size())
      p.resize(0);

    std::ifstream infile(filename);
    if (infile.is_open()) {
      Point2D temp;
      while (infile >> temp)
        p.push_back(temp);
      infile.close();
    }
    else {

      std::string err = "[Error] Cannot open: " + filename + " to read!";
      throw err;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x2445
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2df4
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x2230
leaq 0xc0(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0x24e7
leaq 0xc(%rsp), %r14
movq $0x0, -0x4(%r14)
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2120
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x68(%rsp,%rax)
jne 0x24c2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2e26
jmp 0x2484
leaq 0x48(%rsp), %rdi
callq 0x2050
leaq 0x48(%rsp), %rdi
callq 0x2070
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1b16(%rip), %rsi      # 0x4004
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x2e4a
leaq 0x1b18(%rip), %rsi      # 0x401a
leaq 0x28(%rsp), %rdi
callq 0x2290
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x252d
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x253a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x256d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
movl $0x20, %edi
callq 0x20f0
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
jne 0x2591
movups (%r14), %xmm0
movups %xmm0, (%rcx)
jmp 0x259d
movq %rdx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x3780(%rip), %rsi      # 0x5d40
movq 0x39f1(%rip), %rdx      # 0x5fb8
movq %rax, %rdi
callq 0x2250
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x260a
movq 0x18(%rsp), %rsi
jmp 0x25f9
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x260a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x260a
jmp 0x2607
jmp 0x2607
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/DavidNKraemer[P]convex-hull/./cvhull/_Interface.h
// Function: ams562::write2txt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<ams562::Point2D, std::allocator<ams562::Point2D>> const&)
void write2txt(const std::string &filename, const std::vector<Point2D> &p) {
    std::ofstream outfile(filename);
    if (outfile.is_open()) {
      for (const auto & pt : p)
        outfile << pt << '\n';
      outfile.close();
    }
    else {
      std::string err = "[Error] Cannot open: " + filename + " to write!";
      throw err;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x22a0
leaq 0xb8(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0x2702
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x26b7
leaq 0x48(%rsp), %rbx
leaq 0x8(%rsp), %r14
movl (%r15), %esi
movq %rbx, %rdi
callq 0x2260
movb $0x2c, 0x8(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
movl 0x4(%r15), %esi
movq %rax, %rdi
callq 0x2260
movb $0xa, 0x8(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x266d
leaq 0x48(%rsp), %rdi
callq 0x21f0
movq 0x3900(%rip), %rax      # 0x5fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x48(%rsp,%rcx)
callq 0x2170
leaq 0x140(%rsp), %rdi
callq 0x20a0
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18fb(%rip), %rsi      # 0x4004
leaq 0x28(%rsp), %rdi
movq %rbx, %rdx
callq 0x2e4a
leaq 0x1907(%rip), %rsi      # 0x4024
leaq 0x28(%rsp), %rdi
callq 0x2290
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2748
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x2755
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2788
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
movl $0x20, %edi
callq 0x20f0
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
jne 0x27ac
movups (%r14), %xmm0
movups %xmm0, (%rcx)
jmp 0x27b8
movq %rdx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x3565(%rip), %rsi      # 0x5d40
movq 0x37d6(%rip), %rdx      # 0x5fb8
movq %rax, %rdi
callq 0x2250
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2825
movq 0x18(%rsp), %rsi
jmp 0x2814
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2825
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x2825
jmp 0x2822
jmp 0x2822
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/include/policies.hpp
// Function: BackupSmartFilled<boost::intrusive::list<Intrusive<32u, (boost::intrusive::link_mode_type)2>, boost::intrusive::constant_time_size<false>>>::make(unsigned long)
inline static std::unique_ptr<Container> make(std::size_t size){
        if(v.size() != size){
            v.clear();
            v.reserve(size);
            for(std::size_t i = 0; i < size; ++i){
                v.push_back({i});
            }
        }

        std::unique_ptr<Container> container(new Container());

        for(std::size_t i = 0; i < size; ++i){
            container->push_back(v[i]);
        }

        return container;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2b675(%rip), %rcx     # 0x35240
movq 0x2b666(%rip), %rax     # 0x35238
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rsi
cmpq %r14, %rsi
je 0x9cb6
cmpq %rax, %rcx
je 0x9c26
vxorps %xmm0, %xmm0, %xmm0
movq %rax, %rdx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x9c16
movq 0x8(%rdx), %rdi
movq %rsi, (%rdi)
movq %rdi, 0x8(%rsi)
vmovups %xmm0, (%rdx)
addq $0x30, %rdx
cmpq %rcx, %rdx
jne 0x9bff
movq %rax, 0x2b61a(%rip)     # 0x35240
leaq 0x2b60b(%rip), %rdi     # 0x35238
movq %r14, %rsi
callq 0x9d38
testq %r14, %r14
je 0x9cb6
leaq 0x10(%rsp), %r13
xorl %ebp, %ebp
leaq 0x2b5f0(%rip), %r15     # 0x35238
movq %rsp, %r12
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movq %rbp, 0x10(%rsp)
movq 0x2b5e0(%rip), %rsi     # 0x35240
cmpq 0x2b5e1(%rip), %rsi     # 0x35248
je 0x9c82
vmovups %xmm0, (%rsi)
vmovups (%r13), %ymm0
vmovups %ymm0, 0x10(%rsi)
addq $0x30, 0x2b5c0(%rip)    # 0x35240
jmp 0x9c90
movq %r15, %rdi
movq %r12, %rdx
vzeroupper
callq 0x9e5e
movq (%rsp), %rax
testq %rax, %rax
je 0x9cae
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
incq %rbp
cmpq %rbp, %r14
jne 0x9c4b
movl $0x10, %edi
vzeroupper
callq 0x21b0
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rax)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rax, (%rbx)
testq %r14, %r14
je 0x9cff
movq (%rbx), %rax
movq 0x2b554(%rip), %rcx     # 0x35238
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rcx, (%rdx)
addq $0x30, %rcx
decq %r14
jne 0x9ce4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x9d2f
movq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movq %rax, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/root.hpp
// Function: root::treeprint(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
virtual void treeprint(std::ostream &dst, std::string indent)const override{
		dst<<indent<<"Root start ["<<'\n';
		if(left != NULL)
		{
		for(int i=0;i<left->size();i++)
		{
			(left->at(i))->treeprint(dst, indent+"  ");
		}
		}
      		dst << indent << "]"<<'\n';
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x9250
movq %rax, %r12
leaq 0x11415(%rip), %rsi     # 0x1d548
movl $0xc, %edx
movq %rax, %rdi
callq 0x9250
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9250
cmpq $0x0, 0x8(%r15)
je 0xc1da
movq 0x8(%r15), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0xc1da
leaq 0x28(%rsp), %r13
xorl %ebx, %ebx
leaq 0x18(%rsp), %r12
movq (%rax,%rbx,8), %rbp
movq %r13, 0x18(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x18f32
movq %r12, %rdi
leaq 0x11bf8(%rip), %rsi     # 0x1dd92
callq 0x93e0
movq (%rbp), %rax
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0xc1c0
callq 0x91b0
incq %rbx
movq 0x8(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
ja 0xc175
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%rsp), %rdi
callq 0x9250
movq %rax, %rbx
leaq 0x11360(%rip), %rsi     # 0x1d555
movl $0x1, %edx
movq %rax, %rdi
callq 0x9250
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9250
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc228
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0xc23a
callq 0x91b0
movq %rbx, %rdi
callq 0x93a0
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/primary_expression/identifier.hpp
// Function: identifier::translate(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) const
virtual void translate(std::ostream &dst,std::string indent, bool &addglobal, std::vector<std::string> &globalvariables)const override{
	dst<<id;
	if(addglobal == true)
		{
			addglobal = false;
			globalvariables.push_back(id);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %rax
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x9250
cmpb $0x1, (%r15)
jne 0xc333
addq $0x8, %r14
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc636
popq %rbx
popq %r14
popq %r15
retq
nop