LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: SumUpSigma(std::vector<std::vector<mm_t, std::allocator<mm_t>>, std::allocator<std::vector<mm_t, std::allocator<mm_t>>>>&, int)
static void
SumUpSigma( std::vector<std::vector<mm_t> > &data, const int threads )
{
  const std::size_t data_size = data[0].size();

  for (int i = 1; i < threads; i++) {
    for (std::size_t j = 0; j < data_size; j++) {
      data[0][j].sigma += data[i][j].sigma;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x792c0
movq %rax, %rdi
callq 0x78990
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x76abf
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x76ab2
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x792c0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x792e0
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x792c0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x792e0
movsd -0x30(%rbp), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x76a4f
jmp 0x76ab4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x76a3f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: UpdateGamma(std::vector<std::vector<mm_t, std::allocator<mm_t>>, std::allocator<std::vector<mm_t, std::allocator<mm_t>>>>&)
static void
UpdateGamma( std::vector<std::vector<mm_t> > &data )
{
  const std::size_t size = data[0].size();

  for (mm_t &datum : data[0]) {
    if (datum.sigma > 0.0) {
      datum.gamma = (datum.w + 1) / (datum.sigma + 2.0 / (1.0 + datum.gamma));
    }
  }

  for (std::vector<mm_t> &vec : data) {
    for (size_t i = 0; i < size; i++) {
      vec[i].gamma = data[0][i].gamma;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x792c0
movq %rax, %rdi
callq 0x78990
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x792c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x779c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x779f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x77a20
testb $0x1, %al
jne 0x76b33
jmp 0x76ba6
leaq -0x20(%rbp), %rdi
callq 0x77a60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x76b96
movq -0x30(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x30(%rbp), %rax
movsd 0x35494(%rip), %xmm3    # 0xac008
addsd 0x18(%rax), %xmm3
movsd 0x37d9f(%rip), %xmm2    # 0xae920
divsd %xmm3, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0x76b98
leaq -0x20(%rbp), %rdi
callq 0x77a80
jmp 0x76b20
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x77870
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x778a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x778d0
testb $0x1, %al
jne 0x76bdb
jmp 0x76c52
leaq -0x40(%rbp), %rdi
callq 0x77910
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x76c42
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x792c0
movq %rax, %rdi
movq -0x58(%rbp), %rsi
callq 0x792e0
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x792e0
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x76bf0
jmp 0x76c44
leaq -0x40(%rbp), %rdi
callq 0x77aa0
jmp 0x76bc8
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/learn/MinorizationMaximization.cpp
// Function: TestingWorker(train_thread_arg_t*)
static void
TestingWorker( train_thread_arg_t *targ )
{
  game_info_t *game = AllocateGame();
  game_info_t *init_game = AllocateGame();

  InitializeBoard(init_game);

  for (int i = TEST_KIFU_START_INDEX; i <= TEST_KIFU_LAST_INDEX; i++) {
    if (i % TRAIN_THREAD_NUM == targ->id) {
      std::ostringstream oss;

      oss << TEST_KIFU_PATH << PATH_SEPARATOR << i << ".sgf";
      if (targ->id == 0) {
        std::cerr << "Test : " << oss.str() << std::endl;
      }
      CopyGame(game, init_game);
      CheckAccuracy(game, oss.str());
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
callq 0x9bce0
movq %rax, -0x10(%rbp)
callq 0x9bce0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9bd70
movl $0x9c41, -0x1c(%rbp)    # imm = 0x9C41
cmpl $0x11170, -0x1c(%rbp)   # imm = 0x11170
jg 0x76e7b
movl -0x1c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
cmpl (%rax), %edx
jne 0x76e6b
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x7750
movq -0x1f8(%rbp), %rdi
leaq 0x380f7(%rip), %rsi     # 0xaedcd
callq 0x7530
movq %rax, -0x1f0(%rbp)
jmp 0x76ce4
movq -0x1f0(%rbp), %rdi
leaq 0x7359e(%rip), %rsi     # 0xea290
callq 0x7480
movq %rax, -0x200(%rbp)
jmp 0x76d00
movq -0x200(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7980
movq %rax, -0x208(%rbp)
jmp 0x76d18
movq -0x208(%rbp), %rdi
leaq 0x3739d(%rip), %rsi     # 0xae0c3
callq 0x7530
jmp 0x76d2d
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x76de1
movq 0x702af(%rip), %rdi     # 0xe6ff0
leaq 0x3801e(%rip), %rsi     # 0xaed66
callq 0x7530
movq %rax, -0x210(%rbp)
jmp 0x76d56
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x7580
jmp 0x76d6b
movq -0x210(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x7480
movq %rax, -0x218(%rbp)
jmp 0x76d87
movq -0x218(%rbp), %rdi
movq 0x701d3(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x76d9c
leaq -0x1c8(%rbp), %rdi
callq 0x7ae8
jmp 0x76de1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x76e5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x7ae8
jmp 0x76e5d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c660
jmp 0x76df0
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x7580
jmp 0x76e10
movq -0x220(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x76e90
jmp 0x76e25
leaq -0x1e8(%rbp), %rdi
callq 0x7ae8
leaq -0x198(%rbp), %rdi
callq 0x7110
jmp 0x76e6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x7ae8
leaq -0x198(%rbp), %rdi
callq 0x7110
jmp 0x76e84
jmp 0x76e6d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x76c91
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x79b0
// File: kobanium[P]Ray/./include/feature/SimulationFeature.hpp
// Function: ClearTacticalFeatures(unsigned char*)
inline void
ClearTacticalFeatures( unsigned char *features )
{
  features[CAPTURE] = 0;
  features[SAVE_EXTENSION] = 0;
  features[ATARI] = 0;
  features[EXTENSION] = 0;
  features[DAME] = 0;
  features[THROW_IN] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5(%rax)
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/learn/MovePredictionTest.cpp
// Function: PredictionTestWorker(int)
static void
PredictionTestWorker( const int thread_id )
{
  game_info_t *game = AllocateGame();
  game_info_t *init_game = AllocateGame();

  InitializeBoard(init_game);
  
  for (int i = KIFU_START; i <= KIFU_END; i++) {
    if (i % TEST_WORKER_THREADS == thread_id) {
      CopyGame(game, init_game);

      const std::string filename = KIFU_PATH + PATH_SEPARATOR + std::to_string(i) + ".sgf";

      if (i % 1000 == 0) {
        std::cerr << filename << std::endl;
      }
      CheckMovePrediction(game, filename.c_str());
    }
  }

  FreeGame(game);
  FreeGame(init_game);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
callq 0x9bce0
movq %rax, -0x10(%rbp)
callq 0x9bce0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9bd70
movl $0x9c41, -0x1c(%rbp)    # imm = 0x9C41
cmpl $0x11170, -0x1c(%rbp)   # imm = 0x11170
jg 0x7a709
movl -0x1c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl -0x4(%rbp), %edx
jne 0x7a6f9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c660
leaq 0x34837(%rip), %rsi     # 0xaeddc
leaq 0x70c44(%rip), %rdx     # 0xeb1f0
leaq -0x80(%rbp), %rdi
callq 0x668e0
movl -0x1c(%rbp), %esi
leaq -0xa0(%rbp), %rdi
callq 0x669f0
jmp 0x7a5c6
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x66810
jmp 0x7a5dc
leaq 0x33ae0(%rip), %rdx     # 0xae0c3
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x63310
jmp 0x7a5f2
leaq -0x60(%rbp), %rdi
callq 0x7ae8
leaq -0xa0(%rbp), %rdi
callq 0x7ae8
leaq -0x80(%rbp), %rdi
callq 0x7ae8
movl -0x1c(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x7a6cb
movq 0x6c9c5(%rip), %rdi     # 0xe6ff0
leaq -0x40(%rbp), %rsi
callq 0x7480
movq %rax, -0xb8(%rbp)
jmp 0x7a63d
movq -0xb8(%rbp), %rdi
movq 0x6c91d(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x7a652
jmp 0x7a6cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x7a6a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x7a697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7ae8
leaq -0xa0(%rbp), %rdi
callq 0x7ae8
leaq -0x80(%rbp), %rdi
callq 0x7ae8
jmp 0x7a724
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7ae8
jmp 0x7a724
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x71d0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x7a730
jmp 0x7a6f0
leaq -0x40(%rbp), %rdi
callq 0x7ae8
jmp 0x7a6fb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7a570
movq -0x10(%rbp), %rdi
callq 0x9bd30
movq -0x18(%rbp), %rdi
callq 0x9bd30
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x79b0
// File: kobanium[P]Ray/src/learn/LearningUtility.cpp
// Function: OutputGamma(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<mm_t, std::allocator<mm_t>> const&)
void
OutputGamma( const std::string filename, const std::vector<mm_t> &data )
{
  std::ofstream ofs(filename, std::ios::out);

  if (!ofs) {
    std::cerr << "Cannot open \"" << filename << "\"" << std::endl;
    return;
  }

  for (const mm_t &datum : data) {
    ofs << std::scientific << datum.gamma << "\n";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x250(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x7a90
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x7220
movb %al, -0x241(%rbp)
jmp 0x7afe1
movb -0x241(%rbp), %al
testb $0x1, %al
jne 0x7aff0
jmp 0x7b08b
movq 0x6bff9(%rip), %rdi     # 0xe6ff0
leaq 0x33d5a(%rip), %rsi     # 0xaed58
callq 0x7530
movq %rax, -0x258(%rbp)
jmp 0x7b00c
movq -0x250(%rbp), %rsi
movq -0x258(%rbp), %rdi
callq 0x7480
movq %rax, -0x260(%rbp)
jmp 0x7b028
movq -0x260(%rbp), %rdi
leaq 0x31a9d(%rip), %rsi     # 0xacad3
callq 0x7530
movq %rax, -0x268(%rbp)
jmp 0x7b044
movq -0x268(%rbp), %rdi
movq 0x6bf16(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x7b059
movl $0x1, -0x220(%rbp)
jmp 0x7b157
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
jmp 0x7b16c
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0x7c580
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0x7c5b0
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x7c5e0
testb $0x1, %al
jne 0x7b0d5
jmp 0x7b14d
leaq -0x230(%rbp), %rdi
callq 0x7c620
movq %rax, -0x240(%rbp)
leaq -0xf20f(%rip), %rsi     # 0x6bee0
leaq -0x210(%rbp), %rdi
callq 0x7170
movq %rax, -0x270(%rbp)
jmp 0x7b104
movq -0x270(%rbp), %rdi
movq -0x240(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x7a60
movq %rax, -0x278(%rbp)
jmp 0x7b125
movq -0x278(%rbp), %rdi
leaq 0x345d2(%rip), %rsi     # 0xaf705
callq 0x7530
jmp 0x7b13a
jmp 0x7b13c
leaq -0x230(%rbp), %rdi
callq 0x7c640
jmp 0x7b0bc
movl $0x0, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x79b0
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/learn/LearningUtility.cpp
// Function: OutputGamma(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<mm_t, std::allocator<mm_t>> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
void
OutputGamma( const std::string filename, const std::vector<mm_t> &data, const std::vector<unsigned int> &index_list )
{
  std::ofstream ofs(filename, std::ios::out);

  if (!ofs) {
    std::cerr << "Cannot open \"" << filename << "\"" << std::endl;
    return;
  }

  const std::size_t data_size = data.size();

  for (std::size_t i = 0; i < data_size; i++) {
    if (data[i].gamma != 1.0) {
      ofs << index_list[i] << "\t" << std::scientific << data[i].gamma << "\n";
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x248(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x7a90
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x7220
movb %al, -0x239(%rbp)
jmp 0x7b1d5
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x7b1e4
jmp 0x7b27f
movq 0x6be05(%rip), %rdi     # 0xe6ff0
leaq 0x33b66(%rip), %rsi     # 0xaed58
callq 0x7530
movq %rax, -0x250(%rbp)
jmp 0x7b200
movq -0x248(%rbp), %rsi
movq -0x250(%rbp), %rdi
callq 0x7480
movq %rax, -0x258(%rbp)
jmp 0x7b21c
movq -0x258(%rbp), %rdi
leaq 0x318a9(%rip), %rsi     # 0xacad3
callq 0x7530
movq %rax, -0x260(%rbp)
jmp 0x7b238
movq -0x260(%rbp), %rdi
movq 0x6bd22(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x7b24d
movl $0x1, -0x228(%rbp)
jmp 0x7b39b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x7820
jmp 0x7b3b0
movq -0x10(%rbp), %rdi
callq 0x78990
movq %rax, -0x230(%rbp)
movq $0x0, -0x238(%rbp)
movq -0x238(%rbp), %rax
cmpq -0x230(%rbp), %rax
jae 0x7b391
movq -0x10(%rbp), %rdi
movq -0x238(%rbp), %rsi
callq 0x7c660
movsd 0x18(%rax), %xmm0
movsd 0x30d3d(%rip), %xmm1    # 0xac008
ucomisd %xmm1, %xmm0
jne 0x7b2d8
jp 0x7b2d8
jmp 0x7b378
movq -0x18(%rbp), %rdi
movq -0x238(%rbp), %rsi
callq 0x7c680
movl (%rax), %esi
leaq -0x218(%rbp), %rdi
callq 0x7740
movq %rax, -0x268(%rbp)
jmp 0x7b2ff
movq -0x268(%rbp), %rdi
leaq 0x33b1f(%rip), %rsi     # 0xaee2c
callq 0x7530
movq %rax, -0x270(%rbp)
jmp 0x7b31b
movq -0x270(%rbp), %rdi
leaq -0xf449(%rip), %rsi     # 0x6bee0
callq 0x7170
movq %rax, -0x278(%rbp)
jmp 0x7b337
movq -0x10(%rbp), %rdi
movq -0x238(%rbp), %rsi
callq 0x7c660
movq -0x278(%rbp), %rdi
movsd 0x18(%rax), %xmm0
callq 0x7a60
movq %rax, -0x280(%rbp)
jmp 0x7b361
movq -0x280(%rbp), %rdi
leaq 0x34396(%rip), %rsi     # 0xaf705
callq 0x7530
jmp 0x7b376
jmp 0x7b378
jmp 0x7b37a
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
jmp 0x7b29a
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x7820
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x79b0
nopl (%rax)
// File: kobanium[P]Ray/src/learn/LearningUtility.cpp
// Function: OutputBTFMParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<btfm_t, std::allocator<btfm_t>> const&)
void
OutputBTFMParameter( const std::string filename, const std::vector<btfm_t> &data )
{
  std::ofstream ofs(filename, std::ios::out);

  if (!ofs) {
    std::cerr << "Cannot open \"" << filename << "\"" << std::endl;
    return;
  }

  for (const btfm_t &datum : data) {
    ofs << std::scientific << datum.w;
    for (int k = 0; k < FM_DIMENSION; k++) {
      ofs << " " << std::scientific << datum.v[k];
    }
    ofs << "\n";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x250(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x7a90
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x7220
movb %al, -0x245(%rbp)
jmp 0x7b411
movb -0x245(%rbp), %al
testb $0x1, %al
jne 0x7b420
jmp 0x7b4bb
movq 0x6bbc9(%rip), %rdi     # 0xe6ff0
leaq 0x3392a(%rip), %rsi     # 0xaed58
callq 0x7530
movq %rax, -0x258(%rbp)
jmp 0x7b43c
movq -0x250(%rbp), %rsi
movq -0x258(%rbp), %rdi
callq 0x7480
movq %rax, -0x260(%rbp)
jmp 0x7b458
movq -0x260(%rbp), %rdi
leaq 0x3166d(%rip), %rsi     # 0xacad3
callq 0x7530
movq %rax, -0x268(%rbp)
jmp 0x7b474
movq -0x268(%rbp), %rdi
movq 0x6bae6(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x7b489
movl $0x1, -0x220(%rbp)
jmp 0x7b602
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
jmp 0x7b617
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0x7c6a0
movq %rax, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0x7c6d0
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x7c700
testb $0x1, %al
jne 0x7b508
jmp 0x7b5f8
leaq -0x230(%rbp), %rdi
callq 0x7c740
movq %rax, -0x240(%rbp)
leaq -0xf642(%rip), %rsi     # 0x6bee0
leaq -0x210(%rbp), %rdi
callq 0x7170
movq %rax, -0x270(%rbp)
jmp 0x7b537
movq -0x270(%rbp), %rdi
movq -0x240(%rbp), %rax
movsd (%rax), %xmm0
callq 0x7a60
jmp 0x7b550
movl $0x0, -0x244(%rbp)
cmpl $0x5, -0x244(%rbp)
jge 0x7b5d0
leaq 0x30edc(%rip), %rsi     # 0xac446
leaq -0x210(%rbp), %rdi
callq 0x7530
movq %rax, -0x278(%rbp)
jmp 0x7b57f
movq -0x278(%rbp), %rdi
leaq -0xf6ad(%rip), %rsi     # 0x6bee0
callq 0x7170
movq %rax, -0x280(%rbp)
jmp 0x7b59b
movq -0x280(%rbp), %rdi
movq -0x240(%rbp), %rax
movslq -0x244(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
callq 0x7a60
jmp 0x7b5bd
jmp 0x7b5bf
movl -0x244(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x244(%rbp)
jmp 0x7b55a
leaq 0x3412e(%rip), %rsi     # 0xaf705
leaq -0x210(%rbp), %rdi
callq 0x7530
jmp 0x7b5e5
jmp 0x7b5e7
leaq -0x230(%rbp), %rdi
callq 0x7c760
jmp 0x7b4ec
movl $0x0, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x79b0
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/LearningUtility.cpp
// Function: OutputGammaAdditionMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, mm_t const&)
void
OutputGammaAdditionMode( const std::string filename, const mm_t &datum )
{
  std::ofstream ofs(filename, std::ios::app);

  if (!ofs) {
    std::cerr << "Cannot open \"" << filename << "\"" << std::endl;
    return;
  }

  ofs << std::scientific << datum.gamma << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x230(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movl $0x1, %edx
callq 0x7a90
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x7220
movb %al, -0x221(%rbp)
jmp 0x7bc71
movb -0x221(%rbp), %al
testb $0x1, %al
jne 0x7bc80
jmp 0x7bd15
movq 0x6b369(%rip), %rdi     # 0xe6ff0
leaq 0x330ca(%rip), %rsi     # 0xaed58
callq 0x7530
movq %rax, -0x238(%rbp)
jmp 0x7bc9c
movq -0x230(%rbp), %rsi
movq -0x238(%rbp), %rdi
callq 0x7480
movq %rax, -0x240(%rbp)
jmp 0x7bcb8
movq -0x240(%rbp), %rdi
leaq 0x30e0d(%rip), %rsi     # 0xacad3
callq 0x7530
movq %rax, -0x248(%rbp)
jmp 0x7bcd4
movq -0x248(%rbp), %rdi
movq 0x6b286(%rip), %rsi     # 0xe6f68
callq 0x75b0
jmp 0x7bce9
movl $0x1, -0x220(%rbp)
jmp 0x7bd6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
jmp 0x7bd83
leaq -0xfe3c(%rip), %rsi     # 0x6bee0
leaq -0x210(%rbp), %rdi
callq 0x7170
movq %rax, -0x250(%rbp)
jmp 0x7bd31
movq -0x250(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x7a60
movq %rax, -0x258(%rbp)
jmp 0x7bd4f
movq -0x258(%rbp), %rdi
leaq 0x339a8(%rip), %rsi     # 0xaf705
callq 0x7530
jmp 0x7bd64
movl $0x0, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x7820
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x79b0
nop
// File: kobanium[P]Ray/src/learn/LearningUtility.cpp
// Function: GetUniquePattern(unsigned int*, int)
int
GetUniquePattern( unsigned int pattern[], const int array_size )
{
  int size = 0;

  for (int i = 0; i < array_size; i++) {
    bool is_unique = true;
    for (int j = 0; j < size; j++) {
      if (pattern[i] == pattern[j]) {
        is_unique = false;
        break;
      }
    }
    if (is_unique) {
      pattern[size++] = pattern[i];
    }
  }

  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7c492
movb $0x1, -0x15(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7c45f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x7c452
movb $0x0, -0x15(%rbp)
jmp 0x7c45f
jmp 0x7c454
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c42c
testb $0x1, -0x15(%rbp)
je 0x7c485
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x7c487
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7c419
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: kobanium[P]Ray/src/learn/LearningUtility.cpp
// Function: TrimRightSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string
TrimRightSpace( const std::string &src )
{
  std::string trimCharacters = " 　";
  size_t pos = src.find_last_not_of(trimCharacters);
  std::string dst = src.substr(0, pos + 1);
  return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x79c0
movq -0x60(%rbp), %rdx
leaq 0x32969(%rip), %rsi     # 0xaee3c
leaq -0x30(%rbp), %rdi
callq 0x256b0
jmp 0x7c4de
leaq -0x31(%rbp), %rdi
callq 0x75d0
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq $-0x1, %rdx
callq 0x7a20
movq -0x70(%rbp), %rdi
movq %rax, -0x50(%rbp)
movb $0x0, -0x51(%rbp)
movq -0x10(%rbp), %rsi
movq -0x50(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x7590
jmp 0x7c51d
movb $0x1, -0x51(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x7c560
jmp 0x7c557
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x75d0
jmp 0x7c573
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7ae8
jmp 0x7c573
movq -0x70(%rbp), %rdi
callq 0x7ae8
leaq -0x30(%rbp), %rdi
callq 0x7ae8
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x79b0
nopl (%rax)
// File: kobanium[P]Ray/src/learn/PatternAnalyzer.cpp
// Function: ClearAllHashData(std::unique_ptr<hash_table_t, std::default_delete<hash_table_t>>&)
static void
ClearAllHashData( std::unique_ptr<hash_table_t> &count )
{
  for (int i = 0; i < HASH_TABLE_MAX; i++) {
    count->data[i].hash = 0;
    for (int j = 0; j < 3; j++) {
      count->data[i].pattern[j] = 0;
    }
    count->data[i].large_pat[0] = 0;
    count->data[i].count = 0;
    count->data[i].appearance = 0;
    count->data[i].hash_flag = PatternHashStatus::Empty;
  }
  count->num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1000000, -0xc(%rbp)  # imm = 0x1000000
jge 0x7fc7e
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x7fc03
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0x0, 0x8(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7fbd2
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x28(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7fba3
movq -0x8(%rbp), %rdi
callq 0x80910
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/learn/PatternAnalyzer.cpp
// Function: Count(std::unique_ptr<hash_table_t, std::default_delete<hash_table_t>>&, unsigned long long, pattern_t*)
static void
Count( std::unique_ptr<hash_table_t> &hash_table, unsigned long long hash, pattern_t *pat )
{
  const int key = SearchData(hash_table, hash);

  if (key == -1) {
    if (hash_table->num >= HASH_TABLE_LIMIT) {
      RemoveData(hash_table);
    }
    AddData(hash_table, hash, pat);
  } else {
    hash_table->data[key].count++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x803c0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x7fceb
movq -0x8(%rbp), %rdi
callq 0x80910
cmpl $0xf42400, 0x30000000(%rax) # imm = 0xF42400
jl 0x7fcd8
movq -0x8(%rbp), %rdi
callq 0x80480
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x80550
jmp 0x7fd08
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/learn/PatternAnalyzer.cpp
// Function: SearchData(std::unique_ptr<hash_table_t, std::default_delete<hash_table_t>>&, unsigned long long)
static int
SearchData( std::unique_ptr<hash_table_t> &hash_table, unsigned long long hash )
{
  const unsigned int key = TransHash24(hash);
  hash_data_t *data = hash_table->data;
  unsigned int i = key;

  do {
    if (data[i].hash_flag == PatternHashStatus::Empty) {
      return -1;
    } else if (data[i].hash_flag == PatternHashStatus::Registered &&
               data[i].hash == hash) {
      return i;
    }
    i++;
    if (i >= HASH_TABLE_MAX) i = 0;
  } while (i != key);

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x809f0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x80910
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x28(%rax)
jne 0x8040c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8046b
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x28(%rax)
jne 0x8043f
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x8043f
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8046b
jmp 0x80441
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1000000, -0x2c(%rbp) # imm = 0x1000000
jb 0x8045a
movl $0x0, -0x2c(%rbp)
jmp 0x8045c
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x803ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/PatternAnalyzer.cpp
// Function: RemoveData(std::unique_ptr<hash_table_t, std::default_delete<hash_table_t>>&)
static void
RemoveData( std::unique_ptr<hash_table_t> &hash_table )
{
  hash_data_t *data = hash_table->data;

  for (int count = 1;; count++) {
    for (int i = 0; i < HASH_TABLE_MAX; i++) {
      if (data[i].hash_flag == PatternHashStatus::Registered) {
        if (data[i].count <= count) {
          data[i].hash_flag = PatternHashStatus::Deleted;
          hash_table->num--;
        }
      }
    }
    if (hash_table->num < HASH_TABLE_HALF) break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80910
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1000000, -0x18(%rbp) # imm = 0x1000000
jge 0x80519
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x28(%rax)
jne 0x8050c
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
cmpl -0x14(%rbp), %eax
jg 0x8050a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x2, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x80910
movl 0x30000000(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30000000(%rax)
jmp 0x8050c
jmp 0x8050e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x804a7
movq -0x8(%rbp), %rdi
callq 0x80910
cmpl $0x800000, 0x30000000(%rax) # imm = 0x800000
jge 0x80530
jmp 0x80540
jmp 0x80532
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x804a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/learn/PatternAnalyzer.cpp
// Function: AddData(std::unique_ptr<hash_table_t, std::default_delete<hash_table_t>>&, unsigned long long, pattern_t*)
static void
AddData( std::unique_ptr<hash_table_t> &hash_table, unsigned long long hash, pattern_t *pat )
{
  int key = SearchEmpty(hash_table, hash);
  if (key == -1) exit(1);

  hash_table->data[key].hash = hash;
  hash_table->data[key].pattern[MD_2] = pat->list[MD_2];
  hash_table->data[key].pattern[MD_3] = pat->list[MD_3];
  hash_table->data[key].pattern[MD_4] = pat->list[MD_4];
  hash_table->data[key].large_pat[MD_5] = pat->large_list[MD_5];
  hash_table->data[key].count = 1;
  hash_table->data[key].hash_flag = PatternHashStatus::Registered;

  hash_table->num++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x80690
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x80584
movl $0x1, %edi
callq 0x76a0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80910
movq -0x40(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80910
movl -0x34(%rbp), %ecx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80910
movl -0x30(%rbp), %ecx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80910
movl -0x2c(%rbp), %ecx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x80910
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x80910
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x80910
movl 0x30000000(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30000000(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: kobanium[P]Ray/src/learn/PatternAnalyzer.cpp
// Function: SearchEmpty(std::unique_ptr<hash_table_t, std::default_delete<hash_table_t>>&, unsigned long long)
static int
SearchEmpty( std::unique_ptr<hash_table_t> &hash_table, unsigned long long hash )
{
  const unsigned int key = TransHash24(hash);
  hash_data_t *data = hash_table->data;
  unsigned int i = key;

  do {
    if (data[i].hash_flag == PatternHashStatus::Empty ||
        data[i].hash_flag == PatternHashStatus::Deleted) {
      return i;
    }
    i++;
    if (i >= HASH_TABLE_MAX) i = 0;
  } while (i != key);

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x809f0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x80910
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x28(%rax)
je 0x806e7
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x28(%rax)
jne 0x806ef
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x80719
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1000000, -0x2c(%rbp) # imm = 0x1000000
jb 0x80708
movl $0x0, -0x2c(%rbp)
jmp 0x8070a
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x806bf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kobanium[P]Ray/src/sgf/SgfExtractor.cpp
// Function: GetSize(SGF_record_t*, char const*, int)
static int
GetSize( SGF_record_t *kifu, const char *sgf_text, const int cursor )
{
  int tmp_cursor = 3;
  char size[10];
  
  memset(size, 0, sizeof(char) * 10);

  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;
  
  for (int i = 0; i < tmp_cursor - 3; i++) {
    if (cursor + i + 3 < 100000){
      size[i] = sgf_text[cursor + i + 3];
    }
  }
  kifu->board_size = atoi(size);
  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;  
  return cursor + tmp_cursor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
leaq -0x22(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x72b0
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x29(%rbp)
jge 0x82187
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x82190
jmp 0x8219b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8215a
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x821e7
movl -0x14(%rbp), %eax
addl -0x28(%rbp), %eax
addl $0x3, %eax
cmpl $0x186a0, %eax          # imm = 0x186A0
jge 0x821da
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x28(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x22(%rbp,%rax)
jmp 0x821dc
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x821a2
leaq -0x22(%rbp), %rdi
callq 0x7840
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3e94(%rax)
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x2a(%rbp)
jge 0x82229
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x82232
jmp 0x8223d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x821fc
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/sgf/SgfExtractor.cpp
// Function: GetResult(SGF_record_t*, char const*, int)
static int
GetResult( SGF_record_t *kifu, const char *sgf_text, const int cursor )
{
  int tmp_cursor = 3;

  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;  

  if (cursor + 3 < 100000){
    switch (sgf_text[cursor + 3]) {
    case 'B':
      kifu->result = R_BLACK;
      break;
    case 'W':
      kifu->result = R_WHITE;
      break;
    case '0':
    case 'D':
      kifu->result = R_JIGO;
      break;
    default:
      break;
    }
  }
  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;  
  return cursor + tmp_cursor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x19(%rbp)
jge 0x82293
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8229c
jmp 0x822a7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x82266
movl -0x14(%rbp), %eax
addl $0x3, %eax
cmpl $0x186a0, %eax          # imm = 0x186A0
jge 0x82317
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
movsbl 0x3(%rax,%rcx), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x27, %eax
ja 0x82313
movq -0x28(%rbp), %rax
leaq 0x2cc86(%rip), %rcx     # 0xaef60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl $0x1, 0x1908(%rax)
jmp 0x82315
movq -0x8(%rbp), %rax
movl $0x2, 0x1908(%rax)
jmp 0x82315
movq -0x8(%rbp), %rax
movl $0x0, 0x1908(%rax)
jmp 0x82315
jmp 0x82315
jmp 0x82317
jmp 0x82319
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x29(%rbp)
jge 0x82346
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x8234f
jmp 0x8235a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x82319
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kobanium[P]Ray/src/sgf/SgfExtractor.cpp
// Function: GetHandicaps(SGF_record_t*, char const*, int)
static int
GetHandicaps( SGF_record_t *kifu, const char *sgf_text, const int cursor )
{
  int tmp_cursor = 3;
  char handicaps[10] = {0};

  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;  
  
  for (int i = 0; i < tmp_cursor - 3; i++) {
    if (cursor + i + 3 < 100000){
      handicaps[i] = sgf_text[cursor + i + 3];
    }
  }
  
  kifu->handicaps = atoi(handicaps);
  
  return cursor + tmp_cursor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
leaq -0x22(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x72b0
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x29(%rbp)
jge 0x823c7
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x823d0
jmp 0x823db
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8239a
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x82427
movl -0x14(%rbp), %eax
addl -0x28(%rbp), %eax
addl $0x3, %eax
cmpl $0x186a0, %eax          # imm = 0x186A0
jge 0x8241a
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x28(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x22(%rbp,%rax)
jmp 0x8241c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x823e2
leaq -0x22(%rbp), %rdi
callq 0x7840
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x190c(%rax)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kobanium[P]Ray/src/sgf/SgfExtractor.cpp
// Function: GetKomi(SGF_record_t*, char const*, int)
static int
GetKomi( SGF_record_t *kifu, const char *sgf_text, const int cursor )
{
  int tmp_cursor = 3;
  char komi[10] = {0};
  
  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;
  
  for (int i = 0; i < tmp_cursor - 3; i++) {
    if (cursor + i + 3 < 100000){
      komi[i] = sgf_text[cursor + i + 3];
    }
  }
  kifu->komi = atof(komi);
  
  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;
  
  return cursor + tmp_cursor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
leaq -0x22(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x72b0
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x29(%rbp)
jge 0x82767
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x82770
jmp 0x8277b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8273a
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x827c7
movl -0x14(%rbp), %eax
addl -0x28(%rbp), %eax
addl $0x3, %eax
cmpl $0x186a0, %eax          # imm = 0x186A0
jge 0x827ba
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x28(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x22(%rbp,%rax)
jmp 0x827bc
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x82782
leaq -0x22(%rbp), %rdi
callq 0x76d0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x4098(%rax)
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x2a(%rbp)
jge 0x82809
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x82812
jmp 0x8281d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x827dc
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: kobanium[P]Ray/src/sgf/SgfExtractor.cpp
// Function: GetPlayerName(SGF_record_t*, char const*, int, int)
static int
GetPlayerName( SGF_record_t *kifu, const char *sgf_text, const int cursor, const int color )
{
  int tmp_cursor = 0;

  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;

  if (color == S_BLACK) {
    for (int i = 0; i < tmp_cursor - 3; i++) {
      if (cursor + i + 3 < 100000){
        kifu->black_name[i] = sgf_text[cursor + i + 3];
      }
    }
  } else {
    for (int i = 0; i < tmp_cursor - 3; i++) {
      if (cursor + i + 3 < 100000){
        kifu->white_name[i] = sgf_text[cursor + i + 3];
      }
    }
  }

  while ((cursor + tmp_cursor < 100000) && (sgf_text[cursor + tmp_cursor] != ']')) tmp_cursor++;  
  return cursor + tmp_cursor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x25(%rbp)
jge 0x82876
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x8287f
jmp 0x8288a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x82849
cmpl $0x1, -0x18(%rbp)
jne 0x828e5
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x828e3
movl -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
addl $0x3, %eax
cmpl $0x186a0, %eax          # imm = 0x186A0
jge 0x828d6
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x20(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, 0x3e98(%rax,%rcx)
jmp 0x828d8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x82897
jmp 0x8293a
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x82938
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
addl $0x3, %eax
cmpl $0x186a0, %eax          # imm = 0x186A0
jge 0x8292b
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, 0x3f98(%rax,%rcx)
jmp 0x8292d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x828ec
jmp 0x8293a
jmp 0x8293c
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl $0x186a0, %ecx          # imm = 0x186A0
movb %al, -0x26(%rbp)
jge 0x82969
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
testb $0x1, %al
jne 0x82972
jmp 0x8297d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8293c
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)