LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r13
callq 0x54a9c
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb %al, %al
je 0x5b041
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x6410
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
callq 0x5197c
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x51bb9
movq %rbx, %r12
addq $0x95f0, %r12           # imm = 0x95F0
movslq %r15d, %r15
movslq 0x956f0(%rbx,%r15,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movzwl 0x9b6c(%rbx,%rax), %ecx
cmpl $0x11f, %ecx            # imm = 0x11F
je 0x5afce
leaq (%r12,%rax), %rdx
movswq %cx, %rcx
imulq $0x7c8, %rcx, %rsi      # imm = 0x7C8
cmpl $0x1, 0x4(%r12,%rsi)
je 0x5b02e
movzwl 0x57c(%rdx,%rcx,2), %ecx
cmpl $0x11f, %ecx            # imm = 0x11F
jne 0x5afab
xorl $0x3, %ebp
movswl 0x8(%r12,%rax), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x51adc
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb %al, %al
je 0x5b034
movslq 0x956f0(%rbx,%r15,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movswl 0x8(%r12,%rax), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x51bb9
movslq 0x956f0(%rbx,%r15,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x4(%r12,%rax)
jne 0x5b034
addq %rax, %r12
movl 0x7c0(%r12), %r14d
jmp 0x5b034
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %rbx, %rdi
callq 0x6420
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b057
jmp 0x5b057
movq %rax, %r14
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %rbx, %rdi
callq 0x6420
movq %r14, %rdi
callq 0x6770
// File: /workspace/github_cpp_makefile_star2_O1/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
movzwl 0x9b9c(%rdi,%rcx), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x11f, %esi            # imm = 0x11F
je 0x5b0db
addq $0x9620, %rdi           # imm = 0x9620
xorl %edx, %edx
addq %rdi, %rcx
movswq %si, %rsi
imulq $0x7c8, %rsi, %r8       # imm = 0x7C8
cmpl $0x1, 0x4(%rdi,%r8)
jne 0x5b0cb
addq %rdi, %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, 0x7c0(%r8)
jg 0x5b0db
testb $0x1, %dl
jne 0x5b0db
movswl 0x8(%r8), %eax
movb $0x1, %dl
movzwl 0x57c(%rcx,%rsi,2), %esi
cmpl $0x11f, %esi            # imm = 0x11F
jne 0x5b09a
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
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 0x4f84b
movl %eax, %eax
leaq 0x1aae35cb(%rip), %rcx  # 0x1ab3e6e0
cmpb $0x0, (%rcx,%rax)
jne 0x5b135
leaq 0x9620(%r15), %rsi
movq %r15, %rdi
movl %ebx, %edx
movl %ebp, %ecx
callq 0x54c72
movb $0x1, %r12b
testb %al, %al
jne 0x5b185
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x6410
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x5197c
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x51bb9
movslq %ebp, %rax
movslq 0x956f0(%r14,%rax,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x95f4(%r14,%rax)
sete %r12b
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x6420
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b193
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x6420
movq %rbx, %rdi
callq 0x6770
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
callq 0x54a9c
testb %al, %al
je 0x5b229
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x6410
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5197c
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x51bb9
movslq %ebp, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movslq 0x9ddc(%r14,%rax), %rax
movslq 0x956f0(%rbx,%rax,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x95f4(%rbx,%rax)
sete %bpl
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %rbx, %rdi
callq 0x6420
jmp 0x5b22b
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b238
movq %rax, %r14
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %rbx, %rdi
callq 0x6420
movq %r14, %rdi
callq 0x6770
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movl %esi, %r14d
movq %rdi, %r15
movslq %ecx, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movslq 0x9ddc(%rdi,%rax), %rbx
movl 0x9624(%rdi,%rax), %r13d
callq 0x54a9c
xorl %r12d, %r12d
testb %al, %al
je 0x5b2ec
movq %rbx, %r12
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x6410
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5197c
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x51bb9
movslq 0x956f0(%rbx,%r12,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movl 0x95f4(%rbx,%rax), %eax
leal 0x1(%r13), %ecx
xorl %edx, %edx
cmpl %r13d, %eax
setg %dl
cmpl %ecx, %eax
movl $0x2, %r12d
cmovlel %edx, %r12d
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %rbx, %rdi
callq 0x6420
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b300
movq %rax, %r14
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %rbx, %rdi
callq 0x6420
movq %r14, %rdi
callq 0x6770
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movslq %esi, %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
movl 0x9624(%rdi,%rax), %ecx
movb $0x1, %bl
cmpl $0x1, %ecx
je 0x5bb2b
cmpl $0x2, %ecx
jne 0x5bb29
movq %rdx, %r14
movq %rdi, %r15
addq %rdi, %rax
addq $0x9620, %rax           # imm = 0x9620
movswq 0x8(%rax), %rsi
movswl 0x8(%rax,%rsi,2), %r12d
movq %rsp, %rdi
callq 0x53e40
movl %ebp, %r13d
xorl %eax, %eax
xorl %ecx, %ecx
testl %ebp, %ebp
jle 0x5bad4
movslq (%rsp,%rax,4), %rdx
xorl %esi, %esi
movl (%r14,%rsi,4), %edi
cmpl 0x95720(%r15,%rdx,4), %edi
jne 0x5bacc
movl $0x0, (%r14,%rsi,4)
movb $0x1, %cl
incq %rsi
cmpq %rsi, %r13
jne 0x5bab4
incq %rax
cmpq $0x4, %rax
jne 0x5baaa
testb $0x1, %cl
je 0x5bb29
movq %rsp, %rdi
movl %r12d, %esi
callq 0x53e40
xorl %eax, %eax
xorl %ecx, %ecx
testl %ebp, %ebp
jle 0x5bb1b
movslq (%rsp,%rax,4), %rdx
xorl %esi, %esi
movl (%r14,%rsi,4), %edi
cmpl 0x95720(%r15,%rdx,4), %edi
jne 0x5bb13
movl $0x0, (%r14,%rsi,4)
movb $0x1, %cl
incq %rsi
cmpq %rsi, %r13
jne 0x5bafb
incq %rax
cmpq $0x4, %rax
jne 0x5baf1
testb $0x1, %cl
jne 0x5bb3c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
jle 0x5bb2b
decq %r13
xorl %eax, %eax
cmpl $0x0, (%r14,%rax,4)
sete %bl
jne 0x5bb2b
leaq 0x1(%rax), %rcx
cmpq %rax, %r13
movq %rcx, %rax
jne 0x5bb45
jmp 0x5bb2b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c53d
movq %rdi, %r15
movslq 0x95720(%rdi,%rax,4), %rax
imulq $0x7c8, %rax, %rax      # imm = 0x7C8
cmpl $0x1, 0x9624(%rdi,%rax)
jne 0x5c53d
movl %esi, %ebx
movswl 0x9628(%r15,%rax), %ebp
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x54a9c
testb %al, %al
je 0x5c53d
movl $0x69ae40, %edi         # imm = 0x69AE40
callq 0x6410
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x5197c
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x51bb9
xorl $0x3, %ebx
xorl %edi, %edi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x5c284
movl %eax, %ebx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x6420
movb $0x1, %al
testb %bl, %bl
je 0x5c53f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c54c
movq %rax, %rbx
movl $0x69ae40, %esi         # imm = 0x69AE40
movq %r14, %rdi
callq 0x6420
movq %rbx, %rdi
callq 0x6770
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movl $0x9, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x30(%rdi), %rcx
movl %eax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
leaq 0x60(%rdi), %rcx
movl %eax, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movq %rcx, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
leaq 0x98(%rdi), %rcx
movq %rcx, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movb %al, 0x98(%rdi)
movq %rax, 0xa8(%rdi)
movb %al, 0xb0(%rdi)
vxorps %xmm0, %xmm0, %xmm0
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 0x210d0
movq %rax, 0xc0(%rbx)
vmovups 0x1a589(%rip), %xmm0    # 0x3e0d0
movq %rsp, %rcx
vmovaps %xmm0, (%rcx)
movl 0xc8(%rbx), %edi
movl $0x1, %esi
movl $0x14, %edx
movl $0x10, %r8d
callq 0x23180
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsi), %rdi
movq %rdx, %rsi
callq 0x219b0
addq $0x30, %r15
cmpq %r15, %rax
je 0x248cb
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x21600
jmp 0x248db
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x215f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x224d0
movq %r14, %rdi
movl $0xd, %esi
callq 0x21980
cmpb $0x7, 0x8(%rsp)
jne 0x24e02
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rbx)
jmp 0x24e0f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x22920
leaq 0x8(%rsp), %rdi
callq 0x21a10
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21a10
movq %rbx, %rdi
callq 0x23170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x21600
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x28(%rbx)
movq $0x0, 0x48(%rbx)
movq (%r14), %rax
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x24ed8
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 0x1934e(%rip), %rdi     # 0x3e22d
leaq 0x1935c(%rip), %rsi     # 0x3e242
leaq 0x19367(%rip), %rcx     # 0x3e254
movl $0x1a0f, %edx           # imm = 0x1A0F
vzeroupper
callq 0x21b40
movq %rax, %rdi
callq 0x249b5
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x256fb
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x256fb
movq %rdi, %rbx
movq 0x30(%rdi), %rbp
movq 0x38(%rdi), %r12
movq %rbp, %rdx
subq 0x28(%rdi), %rdx
movq 0x40(%rdi), %r13
leaq 0x8(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x212d0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %r15
testq %r15, %r15
je 0x2570a
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x22180
movsbl %al, %edx
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x23250
leaq 0x1b332(%rip), %rsi     # 0x409b3
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x21fb0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x21440
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x256b5
callq 0x22130
movq 0x8(%rbx), %rax
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x25729
subq %rbp, %r12
subq %rbp, %r13
movq %rax, 0x30(%rbx)
addq %rax, %r12
movq %r12, 0x38(%rbx)
addq %rax, %r13
movq %r13, 0x40(%rbx)
movq 0x10(%rbx), %rcx
leaq -0x1(%rax,%rcx), %rax
movq %rax, 0x48(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x256fb
callq 0x22130
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18d3c(%rip), %rdi     # 0x3e44d
leaq 0x18b2a(%rip), %rsi     # 0x3e242
leaq 0x18d42(%rip), %rcx     # 0x3e461
movl $0x1dd3, %edx           # imm = 0x1DD3
callq 0x21b40
leaq 0x18afd(%rip), %rdi     # 0x3e22d
leaq 0x18b0b(%rip), %rsi     # 0x3e242
leaq 0x18d23(%rip), %rcx     # 0x3e461
movl $0x1dd8, %edx           # imm = 0x1DD8
callq 0x21b40
movq %rax, %rdi
callq 0x249b5
// File: /workspace/github_cpp_makefile_star2_O1/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>::basic_json(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, double, std::allocator> const&)
basic_json(const basic_json& other)
        : m_type(other.m_type)
    {
        switch (m_type)
        {
            case value_t::object:
            {
                assert(other.m_value.object != nullptr);
                m_value = *other.m_value.object;
                break;
            }

            case value_t::array:
            {
                assert(other.m_value.array != nullptr);
                m_value = *other.m_value.array;
                break;
            }

            case value_t::string:
            {
                assert(other.m_value.string != nullptr);
                m_value = *other.m_value.string;
                break;
            }

            case value_t::boolean:
            {
                m_value = other.m_value.boolean;
                break;
            }

            case value_t::number_integer:
            {
                m_value = other.m_value.number_integer;
                break;
            }

            case value_t::number_float:
            {
                m_value = other.m_value.number_float;
                break;
            }

            default:
            {
                break;
            }
        }
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movzbl (%rsi), %eax
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
decl %eax
cmpl $0x5, %eax
ja 0x262cc
movq %rdi, %rbx
leaq 0x17da9(%rip), %rcx     # 0x3e01c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x262f1
callq 0x228c0
jmp 0x262c8
movq 0x8(%rsi), %rax
jmp 0x262c8
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x262d2
callq 0x234d0
jmp 0x262c8
movzbl 0x8(%rsi), %eax
jmp 0x262c8
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x26310
callq 0x22f50
jmp 0x262c8
vmovsd 0x8(%rsi), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x18a64(%rip), %rdi     # 0x3ed3d
leaq 0x17f62(%rip), %rsi     # 0x3e242
leaq 0x188de(%rip), %rcx     # 0x3ebc5
movl $0x6b1, %edx            # imm = 0x6B1
callq 0x21b40
leaq 0x188ad(%rip), %rdi     # 0x3eba5
leaq 0x17f43(%rip), %rsi     # 0x3e242
leaq 0x188bf(%rip), %rcx     # 0x3ebc5
movl $0x6a3, %edx            # imm = 0x6A3
callq 0x21b40
leaq 0x18a07(%rip), %rdi     # 0x3ed1e
leaq 0x17f24(%rip), %rsi     # 0x3e242
leaq 0x188a0(%rip), %rcx     # 0x3ebc5
movl $0x6aa, %edx            # imm = 0x6AA
callq 0x21b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
cmpl %esi, 0x28(%rdi)
je 0x26378
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x181e1(%rip), %rsi     # 0x3e56d
leaq 0x181f3(%rip), %rdx     # 0x3e586
leaq 0x20(%rsp), %rdi
callq 0x215e0
movl 0x28(%r14), %ebx
cmpl $0xc, %ebx
sete %bpl
jne 0x26405
addq $0x30, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x229e0
leaq 0x18265(%rip), %rsi     # 0x3e62a
leaq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0x22ff0
leaq 0x18251(%rip), %rsi     # 0x3e62a
leaq 0x40(%rsp), %rdi
callq 0x233d0
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
jne 0x26411
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rdx)
jmp 0x2641d
movq %rsp, %rdi
movl %ebx, %esi
callq 0x224b0
jmp 0x26435
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x21440
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2645b
callq 0x22130
cmpl $0xc, %ebx
jne 0x26486
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26473
callq 0x22130
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26486
callq 0x22130
movl $0x10, %edi
callq 0x217b0
movq %rax, %rbx
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x23110
movq 0x27ae1(%rip), %rsi     # 0x4df88
movq 0x27a8a(%rip), %rdx     # 0x4df38
movq %rbx, %rdi
callq 0x230a0
movq %rax, %r14
jmp 0x2651e
movq %rax, %r14
movq %rbx, %rdi
callq 0x21c50
jmp 0x2651e
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x264eb
callq 0x22130
jmp 0x264eb
movq %rax, %r14
movb $0x1, %bpl
jmp 0x26506
movq %rax, %r14
cmpl $0xc, %ebx
jne 0x26506
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
movb $0x1, %bpl
cmpq %rax, %rdi
je 0x26506
callq 0x22130
testb %bpl, %bpl
je 0x2651e
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2651e
callq 0x22130
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2652d
callq 0x22130
movq %r14, %rdi
callq 0x23170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x26874
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x22250
leaq 0x8(%rax), %rcx
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
vmovups %ymm0, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
cmpb $0x1, (%r14)
jne 0x26896
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x268ed
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
vzeroupper
jmp 0x21e40
movl $0x10, %edi
vzeroupper
callq 0x217b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x22850
leaq 0x17f12(%rip), %rsi     # 0x3e7ca
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x22ff0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x225e0
xorl %ebp, %ebp
movq 0x273ea(%rip), %rsi     # 0x4dcc8
movq 0x274c3(%rip), %rdx     # 0x4dda8
movq %rbx, %rdi
callq 0x230a0
leaq 0x182b7(%rip), %rdi     # 0x3ebab
leaq 0x17947(%rip), %rsi     # 0x3e242
leaq 0x17db7(%rip), %rcx     # 0x3e6b9
movl $0xbc6, %edx            # imm = 0xBC6
vzeroupper
callq 0x21b40
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2692d
callq 0x22130
jmp 0x2692d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26948
callq 0x22130
jmp 0x26948
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x26955
movq %rbx, %rdi
callq 0x21c50
movq %r14, %rdi
callq 0x23170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x269cc
cmpl $0x2, %eax
je 0x269ee
movl $0x10, %edi
callq 0x217b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x22850
leaq 0x17e7a(%rip), %rsi     # 0x3e811
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x22ff0
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x225e0
xorl %ebp, %ebp
movq 0x2730b(%rip), %rsi     # 0x4dcc8
movq 0x273e4(%rip), %rdx     # 0x4dda8
movq %rbx, %rdi
callq 0x230a0
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x22250
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x26a0b
movq %rbx, %rsi
callq 0x21bd0
movb $0x0, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18312(%rip), %rdi     # 0x3ed24
leaq 0x17829(%rip), %rsi     # 0x3e242
leaq 0x17e0e(%rip), %rcx     # 0x3e82e
movl $0x10da, %edx           # imm = 0x10DA
callq 0x21b40
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26a48
callq 0x22130
jmp 0x26a48
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26a63
callq 0x22130
jmp 0x26a63
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x26a70
movq %rbx, %rdi
callq 0x21c50
movq %r14, %rdi
callq 0x23170
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26abb
movq %rsp, %r14
movq %r14, %rsi
callq 0x21d10
movq (%r14), %rax
cmpq 0x40(%rbx), %rax
sete %al
kmovd %eax, %k1
vmovsd 0x175af(%rip), %xmm1    # 0x3e058
vmovsd %xmm0, %xmm1, %xmm1 {%k1}
vmovapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x17888(%rip), %rdi     # 0x3e34a
leaq 0x17779(%rip), %rsi     # 0x3e242
leaq 0x17ed0(%rip), %rcx     # 0x3e9a0
movl $0x1e9d, %edx           # imm = 0x1E9D
callq 0x21b40
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/json.hpp
// Function: 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>::create<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x22250
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x21600
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x22130
movq %r14, %rdi
callq 0x23170
nop
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/utils.h
// Function: int REST::Utils::parse_string<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
R parse_string(const S& str) {
  std::stringstream buf;
  buf << str;
  R val;
  buf >> val;
  return val;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21c30
leaq 0x18(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x22480
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x21a40
movl 0x4(%rsp), %ebx
movq 0x25f4d(%rip), %rsi     # 0x4dc50
leaq 0x8(%rsp), %rdi
callq 0x21ca0
leaq 0x88(%rsp), %rdi
callq 0x21510
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x27d27
movq %rax, %rbx
movq 0x25f1f(%rip), %rsi     # 0x4dc50
leaq 0x8(%rsp), %rdi
callq 0x21ca0
leaq 0x88(%rsp), %rdi
callq 0x21510
movq %rbx, %rdi
callq 0x23170
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/router.cpp
// Function: REST::Router::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<void (REST::LambdaService*)>)
void Router::match(std::string path, LambdaService::function lambda) {
    auto r = to_regex(path, false);

    std::vector<Service*> services;
    services.resize(Worker::POOL_SIZE);
    for (int i = 0; i < Worker::POOL_SIZE; i++)
      services[i] = new LambdaService(lambda);

    path = nested_path(path);

    routes.emplace_back(r, path, services);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x21600
leaq 0x70(%rsp), %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x21210
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x28ba8
callq 0x22130
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
vmovaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x2503c(%rip), %rbp     # 0x4dc00
movslq (%rbp), %rsi
callq 0x23140
cmpl $0x0, (%rbp)
jle 0x28c32
xorl %r14d, %r14d
leaq 0x30(%rsp), %r12
movl $0x98, %edi
callq 0x22250
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x23450
movq %r13, %rdi
movq %r12, %rsi
callq 0x22430
movq (%r13), %rax
addq -0x18(%rax), %r13
movq 0x10(%rsp), %rax
movq %r13, (%rax,%r14,8)
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x28c26
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
incq %r14
movslq (%rbp), %rax
cmpq %rax, %r14
jl 0x28bdb
leaq 0xa8(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x22770
leaq 0xa8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22620
movq (%r15), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x28c6f
callq 0x22130
leaq 0x70(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x21450
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28c95
callq 0x22130
leaq 0x90(%rsp), %rdi
callq 0x21c70
leaq 0x70(%rsp), %rdi
callq 0x221f0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28cd8
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x28d2c
callq 0x22130
jmp 0x28d2c
jmp 0x28cd8
jmp 0x28d34
movq %rax, %rbx
jmp 0x28d06
movq %rax, %rbx
jmp 0x28cfe
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x28cfe
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r13, %rdi
callq 0x22130
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28d15
callq 0x22130
leaq 0x90(%rsp), %rdi
callq 0x21c70
leaq 0x70(%rsp), %rdi
callq 0x221f0
movq %rbx, %rdi
callq 0x23170
movq %rax, %rdi
callq 0x249b5
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/router.h
// Function: REST::Router::nested_path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string nested_path(std::string const& path) {
      std::string np;
      for (auto& p : nested_paths)
        np += p;

      return np + path;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x18(%rsi), %r13
movq 0x20(%rsi), %rbp
cmpq %rbp, %r13
je 0x29055
leaq 0x8(%rsp), %r15
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r15, %rdi
callq 0x21440
addq $0x20, %r13
cmpq %rbp, %r13
jne 0x2903c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x23440
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x29074
callq 0x22130
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29088
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2909a
callq 0x22130
movq %rbx, %rdi
callq 0x23170
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/utils.cpp
// Function: REST::Utils::random_uuid[abi:cxx11]()
std::string random_uuid() {
  std::string uuid(36, ' ');

  for (int i = 0; i < 36; i++) {
    switch (i) {
      case 8:
      case 13:
      case 18:
      case 23:
        uuid[i] = '-';
        break;
      case 14:
        uuid[i] = '4';
        break;
      case 19:
        uuid[i] = DEC2HEX[rand()%4 + 8];
        break;
      default:
        uuid[i] = DEC2HEX[rand()%16];
    }
  }

  return uuid;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl $0x24, %esi
movl $0x20, %edx
callq 0x22520
xorl %r14d, %r14d
leaq 0x8db1(%rip), %r15      # 0x401d0
leaq 0x8c7a(%rip), %r12      # 0x400a0
movb $0x2d, %al
leal -0xd(%r14), %ecx
cmpl $0xa, %ecx
ja 0x3743e
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movb $0x34, %al
jmp 0x37474
cmpl $0x8, %r14d
je 0x37474
callq 0x213b0
leal 0xf(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x10, %ecx
subl %ecx, %eax
cltq
jmp 0x37470
callq 0x213b0
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x4, %ecx
negl %ecx
leal 0x8(%rax,%rcx), %eax
movb (%rax,%r15), %al
movq (%rbx), %rcx
movb %al, (%rcx,%r14)
incq %r14
cmpq $0x24, %r14
jne 0x37426
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/utils.cpp
// Function: REST::Utils::uri_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string uri_decode(const std::string & sSrc) {
   // Note from RFC1630: "Sequences which start with a percent
   // sign but are not followed by two hexadecimal characters
   // (0-9, A-F) are reserved for future extension"

   const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
   const int SRC_LEN = sSrc.length();
   const unsigned char * const SRC_END = pSrc + SRC_LEN;
   // last decodable '%'
   const unsigned char * const SRC_LAST_DEC = SRC_END - 2;

   char * const pStart = new char[SRC_LEN];
   char * pEnd = pStart;

   while (pSrc < SRC_LAST_DEC)
   {
      if (*pSrc == '%')
      {
         char dec1, dec2;
         if (-1 != (dec1 = HEX2DEC[*(pSrc + 1)])
            && -1 != (dec2 = HEX2DEC[*(pSrc + 2)]))
         {
            *pEnd++ = (dec1 << 4) + dec2;
            pSrc += 3;
            continue;
         }
      }

      *pEnd++ = *pSrc++;
   }

   // the last 2- chars
   while (pSrc < SRC_END)
      *pEnd++ = *pSrc++;

   std::string sResult(pStart, pEnd);
   delete [] pStart;
   return sResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r15
movslq 0x8(%rsi), %rax
leaq (%r15,%rax), %r12
leaq -0x2(%r15,%rax), %r13
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x21050
movq %rax, %r14
cmpq %r13, %r15
jae 0x37523
leaq 0x8bff(%rip), %rax      # 0x400d0
movq %r14, %rdx
cmpb $0x25, (%r15)
jne 0x37511
movzbl 0x1(%r15), %ecx
movb (%rcx,%rax), %sil
movb $0x1, %cl
cmpb $-0x1, %sil
je 0x3750d
movzbl 0x2(%r15), %edi
movb (%rdi,%rax), %dil
cmpb $-0x1, %dil
je 0x3750d
shlb $0x4, %sil
addb %sil, %dil
movb %dil, (%rdx)
incq %rdx
addq $0x3, %r15
xorl %ecx, %ecx
testb %cl, %cl
je 0x3751c
movb (%r15), %cl
incq %r15
movb %cl, (%rdx)
incq %rdx
cmpq %r13, %r15
jb 0x374d4
jmp 0x37526
movq %r14, %rdx
cmpq %r12, %r15
jae 0x37542
subq %r15, %r12
xorl %eax, %eax
movb (%r15,%rax), %cl
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r12
jne 0x37530
addq %rax, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21600
movq %r14, %rdi
callq 0x22710
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/utils.cpp
// Function: REST::Utils::rfc1123_datetime[abi:cxx11](long)
std::string rfc1123_datetime( time_t time ) {
  struct tm * timeinfo;
  char buffer [80];

  timeinfo = gmtime ( &time );
  strftime (buffer,80,"%a, %d %b %Y %H:%M:%S GMT",timeinfo);

  return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
callq 0x21f80
leaq 0x8c59(%rip), %rdx      # 0x401e0
leaq 0x10(%rsp), %r14
movl $0x50, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x21dc0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x21710
leaq 0x10(%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x215e0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/service.cpp
// Function: REST::Service::make_action()
void Service::make_action() {
    for (auto feature = features.cbegin(); feature != features.cend(); ++feature) {
      (*feature)->feature_push();
    }

    before();

    method(request->method);

    after();

    for (auto feature = features.crbegin(); feature != features.crend(); ++feature) {
      (*feature)->feature_pop();
    }
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpq 0x20(%rdi), %r14
je 0x37b62
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq 0x20(%rbx), %r14
jne 0x37b4f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %esi
movq %rbx, %rdi
callq *0x28(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x20(%rbx), %r14
cmpq 0x18(%rbx), %r14
je 0x37b9d
movq -0x8(%r14), %rdi
addq $-0x8, %r14
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x37b87
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/resource.cpp
// Function: REST::Resource::method(REST::Request::Method)
void Resource::method(Request::Method method) {
  switch (method) {
    case Request::Method::POST:
      create();
      break;
    case Request::Method::GET:
      read();
      break;
    case Request::Method::PATCH:
    case Request::Method::PUT:
      update();
      break;
    case Request::Method::DELETE:
      destroy();
      break;
    default:
      throw HTTP::MethodNotAllowed();
  }
}

// Assembly:
cmpl $0x8, %esi
ja 0x37cc5
movl %esi, %eax
leaq 0x85ec(%rip), %rcx      # 0x40288
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
addq $0x10, %rax
jmpq *(%rax)
movq (%rdi), %rax
addq $0x18, %rax
jmpq *(%rax)
movq (%rdi), %rax
jmpq *(%rax)
movq (%rdi), %rax
addq $0x8, %rax
jmpq *(%rax)
pushq %rax
movl $0x8, %edi
callq 0x217b0
movq 0x16069(%rip), %rcx     # 0x4dd40
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1620b(%rip), %rsi     # 0x4def0
movq 0x162cc(%rip), %rdx     # 0x4dfb8
movq %rax, %rdi
callq 0x230a0
// File: /workspace/github_cpp_makefile_star2_O1/alfanick[P]rest-cpp/src/rest/dispatcher.cpp
// Function: REST::Dispatcher::Dispatcher(int, int)
Dispatcher::Dispatcher(int wc, int sc) : workers_count(wc), streamers_count(sc) {
  Worker::POOL_SIZE = workers_count;
  workers.resize(workers_count);

  for (int i = 0; i < workers_count; i++) {
    workers[i] = new Worker(i, sc);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %r14
movq 0x1619c(%rip), %rax     # 0x4ded0
addq $0x10, %rax
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq 0x15ea3(%rip), %rax     # 0x4dc00
movl %esi, (%rax)
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x21330
cmpl $0x0, 0x8(%r14)
jle 0x37da2
xorl %r15d, %r15d
movl $0xe0, %edi
callq 0x22250
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x21cc0
movq 0x10(%r14), %rax
movq %r12, (%rax,%r15,8)
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x37d74
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37dad
movq %rax, %r14
jmp 0x37dbd
movq %rax, %r14
movq %r12, %rdi
callq 0x22130
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x37dca
callq 0x22130
movq %r14, %rdi
callq 0x23170