LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Nakade.cpp
// Function: Enqueue(nakade_queue_t*, int)
static void
Enqueue( nakade_queue_t *nq, int pos )
{
  nq->pos[nq->tail++] = pos;
  if (nq->tail >= NAKADE_QUEUE_SIZE) {
    nq->tail = 0;
  }
  if (nq->tail == nq->head) {
    std::cerr << "queue  overflow" << std::endl;
  }
}

// Assembly:
movslq 0x7c(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x7c(%rdi)
movl %esi, (%rdi,%rax,4)
movl 0x7c(%rdi), %eax
cmpl $0x1e, %eax
jl 0x4007b
andl $0x0, 0x7c(%rdi)
xorl %eax, %eax
cmpl 0x78(%rdi), %eax
jne 0x4009d
pushq %rax
movq 0x20f68(%rip), %rdi     # 0x60ff0
leaq 0x7e41(%rip), %rsi      # 0x47ed0
callq 0x63c0
movq %rax, %rdi
popq %rax
jmp 0x6190
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/UctFeature.cpp
// Function: CheckCaptureAfterKoForTree(game_info_t const*, int, unsigned int*)
void
CheckCaptureAfterKoForTree( const game_info_t *game, const int color, unsigned int *tactical_features )
{
  const string_t *string = game->string;
  const char *board = game->board;
  const int *string_id = game->string_id;
  const int other = GetOppositeColor(color);
  const int previous_move_2 = game->record[game->moves - 2].pos;
  int id, lib, neighbor4[4];
  GetNeighbor4(neighbor4, previous_move_2);

  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == other) {
      id = string_id[neighbor4[i]];
      if (string[id].libs == 1) {
        lib = string[id].lib[0];
        CompareSwapFeature(tactical_features, lib, UCT_CAPTURE_INDEX, UCT_CAPTURE_AFTER_KO);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x9620(%rdi), %r15
movslq 0x43b0(%rdi), %rax
shlq $0x4, %rax
movl -0x1c(%rax,%rdi), %esi
movq %rsp, %rdi
callq 0x3b128
xorl %eax, %eax
cmpq $0x4, %rax
je 0x41494
movslq (%rsp,%rax,4), %rcx
movsbl 0x43f8(%r14,%rcx), %edx
xorl %ebp, %edx
cmpl $0x3, %edx
jne 0x4148f
movslq 0x95720(%r14,%rcx,4), %rcx
imulq $0x7c8, %rcx, %rcx      # imm = 0x7C8
cmpl $0x1, 0x4(%r15,%rcx)
jne 0x4148f
addq %r15, %rcx
movswq 0x8(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
cmpl $0x6, (%rbx,%rcx)
ja 0x4148f
movl $0x7, (%rbx,%rcx)
incq %rax
jmp 0x41445
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/UctFeature.cpp
// Function: CheckCaptureForTree(game_info_t const*, int, int, unsigned int*)
void
CheckCaptureForTree( const game_info_t *game, const int color, const int pos, unsigned int *tactical_features )
{
  const char *board = game->board;
  const int other = GetOppositeColor(color);
  const string_t *string = game->string;
  const int *string_id = game->string_id;
  int neighbor, id;
  int neighbor4[4];
  bool check;

  GetNeighbor4(neighbor4, pos);

  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == other) {
      if (string[string_id[neighbor4[i]]].libs == 1) {
        check = false;
        id = string_id[neighbor4[i]];
        neighbor = string[id].neighbor[0];
        while (neighbor != NEIGHBOR_END) {
          if (string[neighbor].libs == 1) {
            check = true;
            break;
          }
          neighbor = string[id].neighbor[neighbor];
        }
        if (check) {
          CompareSwapFeature(tactical_features, pos, UCT_CAPTURE_INDEX, UCT_SEMEAI_CAPTURE);
          return;
        } else {
          CompareSwapFeature(tactical_features, pos, UCT_CAPTURE_INDEX, UCT_CAPTURE);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x9620(%rdi), %r12
movq %rsp, %rdi
movl %edx, %esi
callq 0x3b128
imull $0x7, %r15d, %eax
cltq
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x41767
movslq (%rsp,%rcx,4), %rdx
movsbl 0x43f8(%r14,%rdx), %esi
xorl %ebp, %esi
cmpl $0x3, %esi
jne 0x41755
movslq 0x95720(%r14,%rdx,4), %rdx
imulq $0x7c8, %rdx, %rdx      # imm = 0x7C8
cmpl $0x1, 0x4(%r12,%rdx)
jne 0x41755
addq %r12, %rdx
addq $0x57c, %rdx            # imm = 0x57C
movq %rdx, %rsi
movswq (%rsi), %rsi
cmpq $0x11f, %rsi            # imm = 0x11F
je 0x41748
imulq $0x7c8, %rsi, %rdi      # imm = 0x7C8
cmpl $0x1, 0x4(%r12,%rdi)
je 0x4175a
leaq (%rdx,%rsi,2), %rsi
jmp 0x41726
cmpl $0x3, (%rbx,%rax,4)
ja 0x41755
movl $0x4, (%rbx,%rax,4)
incq %rcx
jmp 0x416e8
cmpl $0x4, (%rbx,%rax,4)
ja 0x41767
movl $0x5, (%rbx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/UctFeature.cpp
// Function: CheckAtariForTree(game_info_t const*, int, int, unsigned int*)
void
CheckAtariForTree( const game_info_t *game, const int color, const int pos, unsigned int *tactical_features )
{
  const char *board = game->board;
  const int other = GetOppositeColor(color);
  const string_t *string = game->string;
  const int *string_id = game->string_id;
  int id, neighbor4[4];

  GetNeighbor4(neighbor4, pos);

  for (int i = 0; i < 4; i++) {
    if (board[neighbor4[i]] == other) {
      id = string_id[neighbor4[i]];
      if (string[id].libs == 2) {
        CompareSwapFeature(tactical_features, pos, UCT_ATARI_INDEX, UCT_ATARI);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x9620(%rdi), %r12
movq %rsp, %rdi
movl %edx, %esi
callq 0x3b128
imull $0x7, %r15d, %eax
cltq
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x417e9
movslq (%rsp,%rcx,4), %rdx
movsbl 0x43f8(%r14,%rdx), %esi
xorl %ebp, %esi
cmpl $0x3, %esi
jne 0x417e4
movslq 0x95720(%r14,%rdx,4), %rdx
imulq $0x7c8, %rdx, %rdx      # imm = 0x7C8
cmpl $0x2, 0x4(%r12,%rdx)
jne 0x417e4
cmpl $0x0, 0x8(%rbx,%rax,4)
jne 0x417e4
movl $0x1, 0x8(%rbx,%rax,4)
incq %rcx
jmp 0x417a4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/UctFeature.cpp
// Function: CheckKoRecaptureForTree(game_info_t const*, int, unsigned int*)
void
CheckKoRecaptureForTree( const game_info_t *game, const int color, unsigned int *tactical_features )
{
  const string_t *string = game->string;
  const char *board = game->board;
  const int *string_id = game->string_id;
  const int pm3 = game->record[game->moves - 3].pos;
  const int other = GetOppositeColor(color);

  if (board[pm3] == other) {
    const int id = string_id[pm3];
    if (string[id].libs == 1) {
      const int lib = string[id].lib[0];
      CompareSwapFeature(tactical_features, lib, UCT_CAPTURE_INDEX, UCT_KO_RECAPTURE);
    }
  }
}

// Assembly:
movslq 0x43b0(%rdi), %rax
shlq $0x4, %rax
movslq -0x2c(%rax,%rdi), %rax
movsbl 0x43f8(%rdi,%rax), %ecx
xorl %esi, %ecx
cmpl $0x3, %ecx
jne 0x4187a
movslq 0x95720(%rdi,%rax,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x9624(%rdi,%rax)
jne 0x4187a
addq %rdi, %rax
addq $0x9620, %rax           # imm = 0x9620
movswq 0x8(%rax), %rax
imulq $0x1c, %rax, %rax
cmpl $0x5, (%rdx,%rax)
ja 0x4187a
movl $0x6, (%rdx,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Semeai.cpp
// Function: IsCapturableAtari(game_info_t const*, int, int, int)
bool
IsCapturableAtari( const game_info_t *game, const int pos, const int color, const int opponent_pos )
{
  const int other = GetOppositeColor(color);

  if (!IsLegal(game, pos, color)) {
    return false;
  }

  std::unique_ptr<search_game_info_t> search_game(new search_game_info_t(game));
  search_game_info_t *capturable_game = search_game.get();

  // とりあえず石を置く
  PutStoneForSearch(capturable_game, pos, color);

  const string_t *string = capturable_game->string;
  const int *string_id = capturable_game->string_id;
  const int id = string_id[opponent_pos];

  // 周囲に取り返せる石があれば安全
  int neighbor = string[id].neighbor[0];
  while (neighbor != NEIGHBOR_END) {
    if (string[neighbor].libs == 1) {
      return false;
    }
    neighbor = string[id].neighbor[neighbor];
  }

  if (!IsLegalForSearch(capturable_game, string[string_id[opponent_pos]].lib[0], other)) {
    return true;
  }
  // 逃げるつもりでダメに打つ
  PutStoneForSearch(capturable_game, string[string_id[opponent_pos]].lib[0], other);

  // 逃げても呼吸点が1つなら捕獲可能と判定
  if (string[string_id[opponent_pos]].libs == 1) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r12
callq 0x3bc4c
testb %al, %al
je 0x41a4c
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x63e0
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x392bc
movq %r14, 0x8(%rsp)
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x394df
xorl $0x3, %ebx
movslq %ebp, %r15
movslq 0x956f0(%r14,%r15,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
leaq (%r14,%rax), %rdx
addq $0x9b6c, %rdx           # imm = 0x9B6C
movq %r14, %r12
addq $0x95f0, %r12           # imm = 0x95F0
leaq (%r12,%rax), %rcx
movswq (%rdx), %rdx
cmpq $0x11f, %rdx            # imm = 0x11F
je 0x41a50
imulq $0x7c8, %rdx, %rsi      # imm = 0x7C8
cmpl $0x1, 0x4(%r12,%rsi)
je 0x41aa1
leaq (%rcx,%rdx,2), %rdx
addq $0x57c, %rdx            # imm = 0x57C
jmp 0x41a23
xorl %ebp, %ebp
jmp 0x41aad
movswl 0x8(%r12,%rax), %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x3940e
movb $0x1, %bpl
testb %al, %al
je 0x41aa3
movslq 0x956f0(%r14,%r15,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movswl 0x8(%r12,%rax), %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x394df
movslq 0x956f0(%r14,%r15,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x4(%r12,%rax)
sete %bpl
jmp 0x41aa3
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x42c32
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41abe
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x42c32
jmp 0x41add
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x63f0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Semeai.cpp
// Function: CheckOiotoshi(game_info_t const*, int, int, int)
int
CheckOiotoshi( const game_info_t *game, const int pos, const int color, const int opponent_pos )
{
  const int other = GetOppositeColor(color);
  int num = -1;

  if (!IsLegal(game, pos, color)) {
    return -1;
  }

  std::unique_ptr<search_game_info_t> search_game(new search_game_info_t(game));
  search_game_info_t *oiotoshi_game = search_game.get();
  
  PutStoneForSearch(oiotoshi_game, pos, color);

  const string_t *string = oiotoshi_game->string;
  const int *string_id = oiotoshi_game->string_id;
  const int id = string_id[opponent_pos];

  int neighbor = string[id].neighbor[0];
  while (neighbor != NEIGHBOR_END) {
    if (string[neighbor].libs == 1) {
      return -1;
    }
    neighbor = string[id].neighbor[neighbor];
  }

  if (!IsLegalForSearch(oiotoshi_game, string[string_id[opponent_pos]].lib[0], other)) {
    return -1;
  }
  PutStoneForSearch(oiotoshi_game, string[string_id[opponent_pos]].lib[0], other);

  if (string[string_id[opponent_pos]].libs == 1) {
    num = string[string_id[opponent_pos]].size;
  }

  return num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r12
callq 0x3bc4c
testb %al, %al
je 0x41b8c
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x63e0
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0x392bc
movq %r14, 0x8(%rsp)
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x394df
xorl $0x3, %ebx
movslq %ebp, %r12
movslq 0x956f0(%r14,%r12,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
leaq (%r14,%rax), %rdx
addq $0x9b6c, %rdx           # imm = 0x9B6C
movq %r14, %r15
addq $0x95f0, %r15           # imm = 0x95F0
pushq $-0x1
popq %rbp
leaq (%r15,%rax), %rcx
movswq (%rdx), %rdx
cmpq $0x11f, %rdx            # imm = 0x11F
je 0x41b91
imulq $0x7c8, %rdx, %rsi      # imm = 0x7C8
cmpl $0x1, 0x4(%r15,%rsi)
je 0x41be5
leaq (%rcx,%rdx,2), %rdx
addq $0x57c, %rdx            # imm = 0x57C
jmp 0x41b63
pushq $-0x1
popq %rbp
jmp 0x41bef
movswl 0x8(%r15,%rax), %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x3940e
testb %al, %al
je 0x41be5
movslq 0x956f0(%r14,%r12,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movswl 0x8(%r15,%rax), %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x394df
movslq 0x956f0(%r14,%r12,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x4(%r15,%rax)
jne 0x41be5
addq %rax, %r15
movl 0x7c0(%r15), %ebp
leaq 0x8(%rsp), %rdi
callq 0x42c32
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41c00
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x42c32
jmp 0x41c1f
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x63f0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Semeai.cpp
// Function: CapturableCandidate(game_info_t const*, int)
int
CapturableCandidate( const game_info_t *game, const int id )
{
  const string_t *string = game->string;
  int neighbor = string[id].neighbor[0];
  bool flag = false;
  int capturable_pos = -1;

  // 隣接する呼吸点が1つの敵連が1つだけの時, 候補を返す
  while (neighbor != NEIGHBOR_END) {
    if (string[neighbor].libs == 1) {
      if (string[neighbor].size >= 2) {
        return -1;
      } else {
        if (flag) {
          return -1;
        }
        capturable_pos = string[neighbor].lib[0];
        flag = true;
      }
    }
    neighbor = string[id].neighbor[neighbor];
  }

  return capturable_pos;
}

// Assembly:
movslq %esi, %rax
imulq $0x7c8, %rax, %rcx      # imm = 0x7C8
leaq (%rdi,%rcx), %r8
addq $0x9b9c, %r8            # imm = 0x9B9C
addq $0x9620, %rdi           # imm = 0x9620
pushq $-0x1
popq %rdx
xorl %esi, %esi
addq %rdi, %rcx
movl %edx, %eax
movswq (%r8), %r8
cmpq $0x11f, %r8             # imm = 0x11F
je 0x41c95
imulq $0x7c8, %r8, %r9        # imm = 0x7C8
cmpl $0x1, 0x4(%rdi,%r9)
jne 0x41c86
addq %rdi, %r9
cmpl $0x2, 0x7c0(%r9)
setge %al
orb %sil, %al
testb $0x1, %al
jne 0x41c93
movswl 0x8(%r9), %eax
movb $0x1, %sil
leaq (%rcx,%r8,2), %r8
addq $0x57c, %r8             # imm = 0x57C
jmp 0x41c4d
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Semeai.cpp
// Function: IsDeadlyExtension(game_info_t const*, int, int)
bool
IsDeadlyExtension( const game_info_t *game, const int color, const int id )
{
  const int other = GetOppositeColor(color);
  int pos = game->string[id].lib[0];

  if (nb4_empty[Pat3(game->pat, pos)] == 0 &&
      IsSuicide(game, game->string, other, pos)) {
    return true;
  }

  std::unique_ptr<search_game_info_t> search_game_data(new search_game_info_t(game));
  search_game_info_t *search_game = search_game_data.get();

  PutStoneForSearch(search_game, pos, other);

  if (search_game->string[search_game->string_id[pos]].libs == 1) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl $0x3, %ebx
movslq %edx, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movswl 0x9628(%rdi,%rax), %ebp
addq $0x4748, %rdi           # imm = 0x4748
movl %ebp, %esi
callq 0x37bc6
movl %eax, %eax
leaq 0x1aae8a12(%rip), %rcx  # 0x1ab2a6e0
cmpb $0x0, (%rcx,%rax)
jne 0x41cee
leaq 0x9620(%r14), %rsi
movq %r14, %rdi
movl %ebx, %edx
movl %ebp, %ecx
callq 0x3be24
movb $0x1, %r15b
testb %al, %al
jne 0x41d3d
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x63e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x392bc
movq %r15, (%rsp)
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x394df
movslq %ebp, %rax
movslq 0x956f0(%r15,%rax,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x95f4(%r15,%rax)
sete %r15b
movq %rsp, %rdi
callq 0x42c32
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x42c32
jmp 0x41d68
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r15, %rdi
callq 0x63f0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Semeai.cpp
// Function: IsSelfAtariCapture(game_info_t const*, int, int, int)
bool
IsSelfAtariCapture( const game_info_t *game, const int pos, const int color, const int id )
{
  if (!IsLegal(game, pos, color)) {
    return false;
  }

  std::unique_ptr<search_game_info_t> search_game(new search_game_info_t(game));
  search_game_info_t *capture_game = search_game.get();

  PutStoneForSearch(capture_game, pos, color);

  const string_t *string = capture_game->string;
  const int *string_id = capture_game->string_id;
  const int string_pos = game->string[id].origin;

  if (string[string_id[string_pos]].libs == 1) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
callq 0x3bc4c
testb %al, %al
je 0x41df2
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x63e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x392bc
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x394df
movslq %ebx, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movslq 0x9ddc(%r14,%rax), %rax
movslq 0x956f0(%r15,%rax,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x95f4(%r15,%rax)
sete %bl
leaq 0x8(%rsp), %rdi
callq 0x42c32
jmp 0x41df4
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x42c32
jmp 0x41e22
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r15, %rdi
callq 0x63f0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Semeai.cpp
// Function: CheckLibertyState(game_info_t const*, int, int, int)
int
CheckLibertyState( const game_info_t *game, const int pos, const int color, const int id )
{
  const int string_pos = game->string[id].origin;
  const int libs = game->string[id].libs;

  if (!IsLegal(game, pos, color)) {
    return L_DECREASE;
  }

  std::unique_ptr<search_game_info_t> search_game(new search_game_info_t(game));
  search_game_info_t *liberty_game = search_game.get();

  PutStoneForSearch(liberty_game, pos, color);

  const string_t *string = liberty_game->string;
  const int *string_id = liberty_game->string_id;
  const int new_libs = string[string_id[string_pos]].libs;

  if (new_libs > libs + 1) {
    return L_INCREASE;
  } else if (new_libs > libs) {
    return L_EVEN;
  } else {
    return L_DECREASE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movslq %ecx, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movslq 0x9ddc(%rdi,%rax), %r13
movl 0x9624(%rdi,%rax), %r12d
callq 0x3bc4c
xorl %r14d, %r14d
testb %al, %al
je 0x41ec0
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x63e0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x392bc
movq %r14, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x394df
movslq 0x956f0(%r14,%r13,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movl 0x95f4(%r14,%rax), %eax
leal 0x1(%r12), %ecx
xorl %edx, %edx
cmpl %r12d, %eax
setg %dl
cmpl %ecx, %eax
pushq $0x2
popq %r14
cmovlel %edx, %r14d
movq %rsp, %rdi
callq 0x42c32
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x42c32
jmp 0x41eef
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x63f0
movq %rbx, %rdi
callq 0x6740
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Semeai.cpp
// Function: IsAlreadyCaptured(game_info_t const*, int, int*, int)
bool 
IsAlreadyCaptured( const game_info_t *game, const int id, int player_id[], int player_ids )
{
  const string_t *string = game->string;
  const int *string_id = game->string_id;
  int lib1, lib2;
  bool checked;
  int neighbor4[4];
  int i, j;

  if (string[id].libs == 1) {
    return true;
  } else if (string[id].libs == 2) {
    lib1 = string[id].lib[0];
    lib2 = string[id].lib[lib1];

    GetNeighbor4(neighbor4, lib1);
    checked = false;
    for (i = 0; i < 4; i++) {
      for (j = 0; j < player_ids; j++) {
        if (player_id[j] == string_id[neighbor4[i]]) {
          checked = true;
          player_id[j] = 0;
        }
      }
    }
    if (checked == false) return false;

    GetNeighbor4(neighbor4, lib2);
    checked = false;
    for (i = 0; i < 4; i++) {
      for (j = 0; j < player_ids; j++) {
        if (player_id[j] == string_id[neighbor4[i]]) {
          checked = true;
          player_id[j] = 0;
        }
      }
    }
    if (checked == false) return false;

    for (i = 0; i < player_ids; i++) {
      if (player_id[i] != 0) {
        return false;
      }
    }

    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movslq %esi, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movl 0x9624(%rdi,%rax), %ecx
cmpl $0x1, %ecx
je 0x4270e
cmpl $0x2, %ecx
jne 0x42717
movq %rdx, %r14
movq %rdi, %r15
addq %rdi, %rax
addq $0x9620, %rax           # imm = 0x9620
movswq 0x8(%rax), %rsi
movswl 0x8(%rax,%rsi,2), %ebp
movq %rsp, %rdi
callq 0x3b128
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
xorl %ecx, %ecx
cmpq $0x4, %rax
je 0x426cb
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x426c6
movl (%r14,%rdx,4), %esi
movslq (%rsp,%rax,4), %rdi
cmpl 0x95720(%r15,%rdi,4), %esi
jne 0x426c1
andl $0x0, (%r14,%rdx,4)
movb $0x1, %cl
incq %rdx
jmp 0x426a3
incq %rax
jmp 0x4269b
testb $0x1, %cl
je 0x42717
movq %rsp, %rdi
movl %ebp, %esi
callq 0x3b128
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x4, %rax
je 0x42712
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x42709
movl (%r14,%rdx,4), %esi
movslq (%rsp,%rax,4), %rdi
cmpl 0x95720(%r15,%rdi,4), %esi
jne 0x42704
andl $0x0, (%r14,%rdx,4)
movb $0x1, %cl
incq %rdx
jmp 0x426e6
incq %rax
jmp 0x426de
movb $0x1, %al
jmp 0x42719
testb $0x1, %cl
jne 0x42724
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
cmpq %rcx, %rbx
sete %al
je 0x42719
cmpl $0x0, (%r14,%rcx,4)
leaq 0x1(%rcx), %rcx
je 0x42726
jmp 0x42719
// File: /workspace/github_cpp_makefile_star2_O2/kobanium[P]Ray/src/feature/Ladder.cpp
// Function: CheckLadderExtension(game_info_t const*, int, int)
bool
CheckLadderExtension( const game_info_t *game, const int color, const int pos )
{
  const char *board = game->board;
  const string_t *string = game->string;
  const int *string_id = game->string_id;

  if (board[pos] != color){
    return false;
  }

  const int id = string_id[pos];
  const int ladder = string[id].lib[0];

  if (string[id].libs == 1 &&
      IsLegal(game, ladder, color)) {
    std::unique_ptr<search_game_info_t> search_game(new search_game_info_t(game));
    search_game_info_t *ladder_game = search_game.get();
    PutStoneForSearch(ladder_game, ladder, color);
    if (IsLadderCaptured(0, ladder_game, ladder, GetOppositeColor(color)) == DEAD) {
      return true;
    } 
  }

  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %edx, %rax
movsbl 0x43f8(%rdi,%rax), %ecx
cmpl %esi, %ecx
jne 0x43153
movq %rdi, %r15
movslq 0x95720(%rdi,%rax,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x9624(%rdi,%rax)
jne 0x43153
movl %esi, %ebx
movswl 0x9628(%r15,%rax), %ebp
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x3bc4c
testb %al, %al
je 0x43153
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x63e0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x392bc
movq %r14, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x394df
xorl $0x3, %ebx
xorl %edi, %edi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x42ea4
movl %eax, %ebx
movq %rsp, %rdi
callq 0x42c32
movb $0x1, %al
testb %bl, %bl
je 0x43155
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x63f0
jmp 0x4317d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x42c32
movq %rbx, %rdi
callq 0x6740
nop
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/request.cpp
// Function: REST::Request::Request(int, sockaddr_storage)
Request::Request(int client, struct sockaddr_storage client_addr) : handle(client), addr(client_addr) {
  time = std::chrono::high_resolution_clock::now();

  // TODO config
  struct timeval tv {
    .tv_sec = 30,
    .tv_usec = 0
  };

  // set timeout for reading
  setsockopt(handle, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x18(%rdi), %rax
leaq 0x30(%rdi), %rcx
leaq 0x60(%rdi), %r8
leaq 0x98(%rdi), %rdx
vxorps %xmm0, %xmm0, %xmm0
movl $0x9, (%rdi)
movq %rdi, %rbx
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
andl $0x0, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
andl $0x0, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
movq %r8, 0x70(%rdi)
movq %r8, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
movq %rdx, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
movb %al, 0x98(%rdi)
andq $0x0, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
vmovups %xmm0, 0xb8(%rdi)
movl %esi, 0xc8(%rdi)
vmovups 0x20(%rsp), %zmm0
vmovups 0x60(%rsp), %zmm1
vmovups %zmm1, 0x110(%rdi)
vmovups %zmm0, 0xd0(%rdi)
vzeroupper
callq 0x30130
vmovups 0x161a7(%rip), %xmm0    # 0x4a0e0
movq %rax, 0xc0(%rbx)
movq %rsp, %rcx
vmovaps %xmm0, (%rcx)
movl 0xc8(%rbx), %edi
pushq $0x1
popq %rsi
pushq $0x14
popq %rdx
pushq $0x10
popq %r8
callq 0x33570
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/request.cpp
// Function: REST::Request::parse_query_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Request::parse_query_string(std::string &query) {
  query.erase(query.find_last_not_of(" \n\r\t")+1);
  std::istringstream query_stream(query);
  std::string pair;
  while (std::getline(query_stream, pair, '&')) {
    std::string name, value;
    size_t value_position = pair.find("=");

    name = pair.substr(0, value_position);
    if (value_position != std::string::npos)
      value = pair.substr(value_position+1, pair.size() - value_position-1);

    parameters[Utils::uri_decode(name)] = Utils::uri_decode(value);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x15a4c(%rip), %rsi     # 0x4a132
pushq $-0x1
popq %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x33610
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x304c0
leaq 0xa8(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x33290
leaq 0x58(%rsp), %rax
addq $0x58, %r15
leaq 0x88(%rsp), %r13
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r12
leaq 0x68(%rsp), %rbp
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %r15, (%rsp)
leaq 0x48(%rsp), %r15
movb $0x0, (%rax)
leaq 0xa8(%rsp), %rdi
movq %r15, %rsi
pushq $0x26
popq %rdx
callq 0x33710
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x34857
leaq 0x38(%rsp), %rax
leaq 0x18(%rsp), %rsi
xorl %ecx, %ecx
movq %r15, %rdi
xorl %edx, %edx
movq %rsi, 0x8(%rsp)
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x18180(%rip), %rsi     # 0x4c91f
movb %cl, 0x38(%rsp)
movb %cl, 0x18(%rsp)
callq 0x33aa0
movq %rax, %rbx
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x31ea0
movq %r14, %rdi
movq %r13, %rsi
callq 0x32380
movq %r13, %rdi
callq 0x33b38
cmpq $-0x1, %rbx
je 0x34805
leaq 0x1(%rbx), %rdx
notq %rbx
addq 0x50(%rsp), %rbx
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x31ea0
movq %r12, %rdi
movq %r13, %rsi
callq 0x32380
movq %r13, %rdi
callq 0x33b38
movq %r13, %rdi
movq %r12, %rsi
callq 0x332f0
movq %rbp, %rdi
movq %r14, %rsi
callq 0x332f0
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x33820
movq %rax, %rdi
movq %r13, %rsi
callq 0x32380
movq %rbp, %rdi
callq 0x33b38
movq %r13, %rdi
callq 0x33b38
movq %r12, %rdi
callq 0x33b38
movq %r14, %rdi
callq 0x33b38
jmp 0x3474c
leaq 0x48(%rsp), %rdi
callq 0x33b38
leaq 0xa8(%rsp), %rdi
callq 0x30be0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x348a5
leaq 0x68(%rsp), %rdi
movq %rax, %rbx
callq 0x33b38
jmp 0x34894
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x33b38
jmp 0x348a8
jmp 0x348a5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x33b38
leaq 0x28(%rsp), %rdi
callq 0x33b38
leaq 0x48(%rsp), %rdi
callq 0x33b38
leaq 0xa8(%rsp), %rdi
callq 0x30be0
movq %rbx, %rdi
callq 0x33510
movq %rax, %rbx
jmp 0x348bc
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/request.h
// Function: int REST::Request::header<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&) const
T header(std::string const& key, const T& default_value) const {
      auto h = headers.find(key);
      if (h == headers.end())
        return default_value;
      else
        return Utils::parse_string<T>(h->second);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x28, %rdi
movq %rdx, %rbx
callq 0x31010
addq $0x30, %r14
cmpq %r14, %rax
je 0x34997
addq $0x40, %rax
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32fb0
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/request.h
// Function: REST::Request::header(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) const
std::string header(std::string const& key, const char default_value[]) const {
      auto h = headers.find(key);
      if (h == headers.end())
        return default_value;
      else
        return h->second;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x28(%rsi), %rdi
movq %rsi, %r15
movq %rdx, %rsi
movq %rcx, %r14
callq 0x31010
addq $0x30, %r15
cmpq %r15, %rax
je 0x349da
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x328c0
jmp 0x349ea
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30a10
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::parser::parse()
basic_json parse()
        {
            basic_json result = parse_internal(true);

            expect(lexer::token_type::end_of_input);

            // return parser result and replace it with null in case the
            // top-level value was discarded by the callback function
            return result.is_discarded() ? basic_json() : result;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x32180
pushq $0xd
popq %rsi
movq %r14, %rdi
callq 0x30fd0
cmpb $0x7, 0x8(%rsp)
jne 0x34e64
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rbx)
jmp 0x34e71
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32830
leaq 0x8(%rsp), %rdi
callq 0x310a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x310a0
movq %rbx, %rdi
callq 0x33510
nop
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::lexer::lexer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit lexer(const string_t& s) noexcept
            : m_stream(nullptr), m_buffer(s)
        {
            m_content = reinterpret_cast<const lexer_char_t*>(s.c_str());
            assert(m_content != nullptr);
            m_start = m_cursor = m_content;
            m_limit = m_content + s.size();
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andq $0x0, (%rdi)
movq %rdi, %rbx
movq %rsi, %r14
addq $0x8, %rdi
callq 0x328c0
vxorps %xmm0, %xmm0, %xmm0
andq $0x0, 0x48(%rbx)
vmovups %ymm0, 0x28(%rbx)
movq (%r14), %rax
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x34f02
movq %rax, 0x40(%rbx)
movq %rax, 0x30(%rbx)
addq 0x8(%r14), %rax
movq %rax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
vzeroupper
retq
leaq 0x1532b(%rip), %rdi     # 0x4a234
leaq 0x15339(%rip), %rsi     # 0x4a249
leaq 0x15344(%rip), %rcx     # 0x4a25b
movl $0x1a0f, %edx           # imm = 0x1A0F
vzeroupper
callq 0x31260
movq %rax, %rdi
callq 0x34aa2
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::lexer::yyfill()
void yyfill() noexcept
        {
            if (m_stream == nullptr or not * m_stream)
            {
                return;
            }

            const ssize_t offset_start = m_start - m_content;
            const ssize_t offset_marker = m_marker - m_start;
            const ssize_t offset_cursor = m_cursor - m_start;

            m_buffer.erase(0, static_cast<size_t>(offset_start));
            std::string line;
            assert(m_stream != nullptr);
            std::getline(*m_stream, line);
            m_buffer += "\n" + line; // add line with newline symbol

            m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
            assert(m_content != nullptr);
            m_start  = m_content;
            m_marker = m_start + offset_marker;
            m_cursor = m_start + offset_cursor;
            m_limit  = m_start + m_buffer.size() - 1;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x3567b
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3567b
movq 0x30(%rdi), %r13
movq 0x38(%rdi), %r15
movq 0x40(%rdi), %r12
leaq 0x8(%rdi), %r14
movq %rdi, %rbx
movq %r13, %rdx
subq 0x28(%rdi), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x304c0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x35689
movq %rsp, %rsi
callq 0x30360
leaq 0x172c6(%rip), %rsi     # 0x4c8e3
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x319b0
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x33a00
leaq 0x20(%rsp), %rdi
callq 0x33b38
movq 0x8(%rbx), %rax
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x356a8
subq %r13, %r15
subq %r13, %r12
movq %rax, 0x30(%rbx)
movq %rsp, %rdi
addq %rax, %r15
addq %rax, %r12
movq %r15, 0x38(%rbx)
movq %r12, 0x40(%rbx)
movq 0x10(%rbx), %rcx
leaq -0x1(%rax,%rcx), %rax
movq %rax, 0x48(%rbx)
callq 0x33b38
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x14dc4(%rip), %rdi     # 0x4a454
leaq 0x14bb2(%rip), %rsi     # 0x4a249
leaq 0x14dca(%rip), %rcx     # 0x4a468
movl $0x1dd3, %edx           # imm = 0x1DD3
callq 0x31260
leaq 0x14b85(%rip), %rdi     # 0x4a234
leaq 0x14b93(%rip), %rsi     # 0x4a249
leaq 0x14dab(%rip), %rcx     # 0x4a468
movl $0x1dd8, %edx           # imm = 0x1DD8
callq 0x31260
movq %rax, %rdi
callq 0x34aa2
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::parser::expect(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::lexer::token_type) const
void expect(typename lexer::token_type t) const
        {
            if (t != last_token)
            {
                std::string error_msg = "parse error - unexpected ";
                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token() + "'") :
                              lexer::token_type_name(last_token));
                error_msg += "; expected " + lexer::token_type_name(t);
                throw std::invalid_argument(error_msg);
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
cmpl %esi, 0x28(%rdi)
jne 0x35e2e
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebx
movq %rdi, %r14
leaq 0x1473a(%rip), %rsi     # 0x4a574
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x30a10
movl 0x28(%r14), %ebp
cmpl $0xc, %ebp
jne 0x35e95
addq $0x30, %r14
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32970
leaq 0x1478a(%rip), %rsi     # 0x4a5fa
leaq 0x68(%rsp), %rdi
movq %r15, %rdx
callq 0x332a0
leaq 0x14776(%rip), %rdx     # 0x4a5fa
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x30490
jmp 0x35ea1
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x32160
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x33a00
leaq 0x8(%rsp), %rdi
callq 0x33b38
cmpl $0xc, %ebp
jne 0x35ed6
leaq 0x68(%rsp), %rdi
callq 0x33b38
leaq 0x88(%rsp), %rdi
callq 0x33b38
leaq 0x48(%rsp), %rdi
movl %ebx, %esi
callq 0x32160
leaq 0x14c80(%rip), %rsi     # 0x4ab69
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x332a0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x33a00
leaq 0x8(%rsp), %rdi
callq 0x33b38
leaq 0x48(%rsp), %rdi
callq 0x33b38
pushq $0x10
popq %rdi
callq 0x30c90
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x33440
movq 0x27046(%rip), %rsi     # 0x5cf80
movq 0x26fe7(%rip), %rdx     # 0x5cf28
movq %r14, %rdi
callq 0x333b0
jmp 0x35f71
movq %r14, %rdi
movq %rax, %rbx
callq 0x31400
jmp 0x35fa9
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x33b38
jmp 0x35f6a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x35fa4
movq %rax, %rbx
jmp 0x35fa9
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x33b38
jmp 0x35f8d
movq %rax, %rbx
jmp 0x35f9c
movq %rax, %rbx
cmpl $0xc, %ebp
jne 0x35fa9
leaq 0x68(%rsp), %rdi
callq 0x33b38
leaq 0x88(%rsp), %rdi
callq 0x33b38
leaq 0x28(%rsp), %rdi
callq 0x33b38
movq %rbx, %rdi
callq 0x33510
nop
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::parser::unexpect(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::lexer::token_type) const
void unexpect(typename lexer::token_type t) const
        {
            if (t == last_token)
            {
                std::string error_msg = "parse error - unexpected ";
                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token() + "'") :
                              lexer::token_type_name(last_token));
                throw std::invalid_argument(error_msg);
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
cmpl %esi, 0x28(%rdi)
je 0x36112
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %r14
leaq 0x14458(%rip), %rsi     # 0x4a574
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
callq 0x30a10
movl 0x28(%r14), %ebx
cmpl $0xc, %ebx
jne 0x36170
addq $0x30, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32970
leaq 0x144ad(%rip), %rsi     # 0x4a5fa
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x332a0
leaq 0x14499(%rip), %rdx     # 0x4a5fa
leaq 0x20(%rsp), %rsi
movq %rsp, %rdi
callq 0x30490
jmp 0x3617a
movq %rsp, %rdi
movl %ebx, %esi
callq 0x32160
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x33a00
movq %rsp, %rdi
callq 0x33b38
cmpl $0xc, %ebx
jne 0x361a8
leaq 0x20(%rsp), %rdi
callq 0x33b38
leaq 0x60(%rsp), %rdi
callq 0x33b38
pushq $0x10
popq %rdi
callq 0x30c90
movq %rax, %rbx
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x33440
movq 0x26db9(%rip), %rsi     # 0x5cf80
movq 0x26d5a(%rip), %rdx     # 0x5cf28
movq %rbx, %rdi
callq 0x333b0
movq %rax, %r14
jmp 0x36216
movq %rbx, %rdi
movq %rax, %r14
callq 0x31400
jmp 0x36216
movq %rsp, %rdi
movq %rax, %r14
callq 0x33b38
jmp 0x361fd
movq %rax, %r14
jmp 0x3620c
movq %rax, %r14
cmpl $0xc, %ebx
jne 0x36216
leaq 0x20(%rsp), %rdi
callq 0x33b38
leaq 0x60(%rsp), %rdi
callq 0x33b38
leaq 0x40(%rsp), %rdi
callq 0x33b38
movq %r14, %rdi
callq 0x33510
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
reference operator[](const typename object_t::key_type& key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value.object = create<object_t>();
        }

        // [] only works for objects
        if (is_object())
        {
            assert(m_value.object != nullptr);
            return m_value.object->operator[](key);
        }
        else
        {
            throw std::domain_error("cannot use operator[] with " + type_name());
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movb (%rdi), %al
movq %rsi, %rbx
movq %rdi, %r14
testb %al, %al
jne 0x364ec
movb $0x1, (%r14)
callq 0x32be0
movq %rax, 0x8(%r14)
movb (%r14), %al
cmpb $0x1, %al
jne 0x36509
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3655b
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x31740
pushq $0x10
popq %rdi
callq 0x30c90
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x32730
leaq 0x14274(%rip), %rsi     # 0x4a79a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x332a0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x32320
xorl %ebp, %ebp
movq 0x26784(%rip), %rsi     # 0x5ccd0
movq 0x2685d(%rip), %rdx     # 0x5cdb0
movq %rbx, %rdi
callq 0x333b0
leaq 0x14619(%rip), %rdi     # 0x4ab7b
leaq 0x13ce0(%rip), %rsi     # 0x4a249
leaq 0x14119(%rip), %rcx     # 0x4a689
movl $0xbc6, %edx            # imm = 0xBC6
callq 0x31260
leaq 0x20(%rsp), %rdi
movq %rax, %r14
callq 0x33b38
jmp 0x3658f
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x33b38
testb %bpl, %bpl
jne 0x365a1
jmp 0x365a9
movq %rax, %r14
movq %rbx, %rdi
callq 0x31400
movq %r14, %rdi
callq 0x33510
nop
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::push_back(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>&&)
void push_back(basic_json&& val)
    {
        // push_back only works for null objects or arrays
        if (not(is_null() or is_array()))
        {
            throw std::domain_error("cannot use push_back() with " + type_name());
        }

        // transform null object into an array
        if (is_null())
        {
            m_type = value_t::array;
            m_value = value_t::array;
        }

        // add element to array (move semantics)
        assert(m_value.array != nullptr);
        m_value.array->push_back(std::move(val));
        // invalidate object
        val.m_type = value_t::null;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movzbl (%rdi), %eax
movq %rsi, %rbx
movq %rdi, %r14
testl %eax, %eax
je 0x365d2
cmpl $0x2, %eax
jne 0x3661a
movq 0x8(%r14), %rdi
jmp 0x365e2
movb $0x2, (%r14)
callq 0x302a0
movq %rax, %rdi
movq %rax, 0x8(%r14)
testq %rdi, %rdi
je 0x365fb
movq %rbx, %rsi
callq 0x31350
movb $0x0, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x146f2(%rip), %rdi     # 0x4acf4
leaq 0x13c40(%rip), %rsi     # 0x4a249
leaq 0x141ee(%rip), %rcx     # 0x4a7fe
movl $0x10da, %edx           # imm = 0x10DA
callq 0x31260
pushq $0x10
popq %rdi
callq 0x30c90
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x32730
leaq 0x141aa(%rip), %rsi     # 0x4a7e1
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x332a0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x32320
xorl %ebp, %ebp
movq 0x26673(%rip), %rsi     # 0x5ccd0
movq 0x2674c(%rip), %rdx     # 0x5cdb0
movq %rbx, %rdi
callq 0x333b0
leaq 0x20(%rsp), %rdi
movq %rax, %r14
callq 0x33b38
jmp 0x36681
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x33b38
testb %bpl, %bpl
jne 0x36693
jmp 0x3669b
movq %rax, %r14
movq %rbx, %rdi
callq 0x31400
movq %r14, %rdi
callq 0x33510
nop
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::lexer::get_number() const
number_float_t get_number() const
        {
            // conversion
            typename string_t::value_type* endptr;
            assert(m_start != nullptr);
            number_float_t float_val = str_to_float_t(static_cast<number_float_t*>(nullptr), &endptr);

            // return float_val if the whole number was translated and NAN
            // otherwise
            return (reinterpret_cast<lexer_char_t*>(endptr) == m_cursor) ? float_val : NAN;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x366e7
movq %rsp, %r14
movq %r14, %rsi
callq 0x31550
movq (%r14), %rax
vmovsd 0x139a6(%rip), %xmm1    # 0x4a070
cmpq 0x40(%rbx), %rax
sete %al
kmovd %eax, %k1
vmovsd %xmm0, %xmm1, %xmm1 {%k1}
vmovapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13c63(%rip), %rdi     # 0x4a351
leaq 0x13b54(%rip), %rsi     # 0x4a249
leaq 0x14274(%rip), %rcx     # 0x4a970
movl $0x1e9d, %edx           # imm = 0x1E9D
callq 0x31260
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>>>>* nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>::create<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator>>>>>()
static T* create(Args&& ... args)
    {
        AllocatorType<T> alloc;
        auto deleter = [&](T * object)
        {
            alloc.deallocate(object, 1);
        };
        std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
        alloc.construct(object.get(), std::forward<Args>(args)...);
        return object.release();
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
pushq $0x30
popq %rdi
callq 0x31d40
movq %rax, %rbx
vxorps %xmm0, %xmm0, %xmm0
leaq 0xf(%rsp), %rax
leaq 0x10(%rsp), %rdi
leaq 0x8(%rbx), %rcx
andq $0x0, 0x10(%rbx)
movq %rax, (%rdi)
vmovups %xmm0, (%rbx)
movq %rcx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
andq $0x0, 0x8(%rdi)
callq 0x30770
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq