LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/db_construction_parameters.cpp
// Function: DbConstructionParameters::SetParameters(int, char**)
void DbConstructionParameters::SetParameters(int argc, char* argv[]) {
  int c;
  extern char *optarg;
  while ((c = getopt(argc, argv, "i:o:r:s:w:d:t:")) != -1) {
    switch (c) {
    case 'i':
      _input_filename = optarg;
      break;

    case 'o':
      _db_filename = optarg;
      break;

    case 'r':
      _repeat_flag = atoi(optarg);
      break;

    case 's':
      _hash_size = atoi(optarg);
      break;

    case 'w':
      _maximal_span = atoi(optarg);
      break;
      
    case 'd':
      _min_accessible_length = atoi(optarg);
      break;

    default:
      cerr << "The argument is invalid command." << endl;
      exit(1);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
leaq 0x30a7b(%rip), %rdx     # 0x387f4
callq 0x3080
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x7e80
movl -0x1c(%rbp), %eax
addl $-0x64, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x13, %eax
ja 0x7e4f
movq -0x30(%rbp), %rax
leaq 0x309fa(%rip), %rcx     # 0x387a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq 0x441f2(%rip), %rax     # 0x4bfb0
movq (%rax), %rsi
addq $0x20, %rdi
callq 0x33c0
jmp 0x7e7b
movq -0x28(%rbp), %rdi
movq 0x441d6(%rip), %rax     # 0x4bfb0
movq (%rax), %rsi
callq 0x33c0
jmp 0x7e7b
movq 0x441c2(%rip), %rax     # 0x4bfb0
movq (%rax), %rdi
callq 0x3440
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x44(%rax)
jmp 0x7e7b
movq 0x441a8(%rip), %rax     # 0x4bfb0
movq (%rax), %rdi
callq 0x3440
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x40(%rax)
jmp 0x7e7b
movq 0x4418e(%rip), %rax     # 0x4bfb0
movq (%rax), %rdi
callq 0x3440
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x48(%rax)
jmp 0x7e7b
movq 0x44174(%rip), %rax     # 0x4bfb0
movq (%rax), %rdi
callq 0x3440
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0x7e7b
movq 0x4419a(%rip), %rdi     # 0x4bff0
leaq 0x30e71(%rip), %rsi     # 0x38cce
callq 0x3270
movq %rax, %rdi
movq 0x4413c(%rip), %rsi     # 0x4bfa8
callq 0x32b0
movl $0x1, %edi
callq 0x3330
jmp 0x7d6b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/db_construction.cpp
// Function: DbConstruction::ReadFastaFile(DbConstructionParameters, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void DbConstruction::ReadFastaFile(const DbConstructionParameters parameters,  vector<string> &sequences){
  vector<string> names; names.reserve(10);
  FastafileReader fastafile_reader;
  fastafile_reader.ReadFastafile(parameters.GetInputFilename(), sequences, names);
  SaveBasicInformation(parameters, names);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4700
movq -0xb8(%rbp), %rdi
movl $0xa, %esi
callq 0xb070
jmp 0x9e2c
leaq -0x3d(%rbp), %rdi
callq 0xb1c0
jmp 0x9e37
movq -0xc8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xb1d0
jmp 0x9e49
movq -0x18(%rbp), %rdx
leaq -0x3d(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rcx
callq 0x7e90
jmp 0x9e60
leaq -0x60(%rbp), %rdi
callq 0x3190
movq -0xc8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x40a0
jmp 0x9e7e
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xaa20
jmp 0x9e97
leaq -0xb0(%rbp), %rdi
callq 0x4120
leaq -0x30(%rbp), %rdi
callq 0x4af0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9ef2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3190
jmp 0x9ef2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x4120
leaq -0x30(%rbp), %rdi
callq 0x4af0
movq -0x38(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/db_construction.cpp
// Function: DbConstruction::ConstructSuffixArray(DbConstructionParameters, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<int, std::allocator<int>>&)
void DbConstruction::ConstructSuffixArray(const DbConstructionParameters parameters, vector<string> &sequences,  vector<unsigned char> &encoded_sequences, vector<int> &suffix_array){
  Encoder encoder(parameters.GetRepeatFlag());
  encoder.Encode(sequences, encoded_sequences, 1);
  suffix_array.resize(encoded_sequences.size());
  sais(&encoded_sequences[0], &suffix_array[0], encoded_sequences.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rsi, -0x150(%rbp)
movq %rdi, %rax
movq -0x150(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0xb860
movl %eax, %esi
leaq -0x129(%rbp), %rdi
callq 0xb880
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x129(%rbp), %rdi
movl $0x1, %ecx
callq 0xd290
movq -0x28(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x20(%rbp), %rdi
callq 0xba80
movq -0x148(%rbp), %rdi
movq %rax, %rsi
callq 0xb9f0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbaa0
movq %rax, -0x140(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbac0
movq %rax, -0x138(%rbp)
movq -0x20(%rbp), %rdi
callq 0xba80
movq -0x140(%rbp), %rdi
movq -0x138(%rbp), %rsi
movl %eax, %edx
callq 0x34e70
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/encoder.cpp
// Function: Encoder::Encode(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, int)
void Encoder::Encode(vector<string> &sequences, vector<unsigned char> &encoded_sequences, int r){
  for(int i = 0; i < sequences.size(); i++){
    if(r == 0){
      for(int j = 0; j<sequences[i].size();j++){
	encoded_sequences.push_back(_code_table[static_cast<int>(sequences[i][j])]);  
      }
    }else{
      for(int j = sequences[i].size()-1; j>= 0; j--){
	encoded_sequences.push_back(_code_table[static_cast<int>(sequences[i][j])]);  
      }
    }
    encoded_sequences.push_back(_sentinel_character);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9260
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xd3d7
cmpl $0x0, -0x1c(%rbp)
jne 0xd350
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xb720
movq %rax, %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xd34e
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xb720
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0x3560
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdi
movsbl (%rax), %eax
cltq
addq %rax, %rsi
callq 0xd4d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd2e4
jmp 0xd3b5
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xb720
movq %rax, %rdi
callq 0x31e0
subq $0x1, %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xd3b3
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xb720
movq %rax, %rdi
movslq -0x28(%rbp), %rsi
callq 0x3560
movq -0x30(%rbp), %rsi
movq -0x50(%rbp), %rdi
movsbl (%rax), %eax
cltq
addq %rax, %rsi
callq 0xd4d0
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd36c
jmp 0xd3b5
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0xff, %rsi
callq 0xd4d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd2b6
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/encoder.cpp
// Function: Encoder::Encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, int)
void Encoder::Encode(string &sequence, vector<unsigned char> &encoded_sequence, int r){
  if(r == 0){
    for(int i = 0; i<sequence.size();i++){
      encoded_sequence.push_back(_code_table[static_cast<int>(sequence[i])]);  
    }
  }else{
    for(int i = sequence.size()-1; i>= 0; i--){
      encoded_sequence.push_back(_code_table[static_cast<int>(sequence[i])]);  
    }
  }
  encoded_sequence.push_back(_sentinel_character);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xd460
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xd45e
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x3560
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movsbl (%rax), %eax
cltq
addq %rax, %rsi
callq 0xd4d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd40c
jmp 0xd4ad
movq -0x10(%rbp), %rdi
callq 0x31e0
subq $0x1, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xd4ab
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x3560
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdi
movsbl (%rax), %eax
cltq
addq %rax, %rsi
callq 0xd4d0
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd470
jmp 0xd4ad
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0xff, %rsi
callq 0xd4d0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/raccess.cpp
// Function: Raccess::Run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Raccess::Run(string &sequence){
  clock_t start, end;
  Initiallize(sequence);
  CalcInsideVariable();
  CalcOutsideVariable();
  CalcAccessibility(sequence);
  Clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0xdb90
movq -0x28(%rbp), %rdi
callq 0xe900
movq -0x28(%rbp), %rdi
callq 0xfc30
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11380
movq -0x28(%rbp), %rdi
callq 0x11ad0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/raccess.cpp
// Function: Raccess::Run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<float, std::allocator<float>>&, std::vector<float, std::allocator<float>>&)
void Raccess::Run(string &sequence, vector<float> &accessibility, vector<float> &conditional_accessibility){
  Initiallize(sequence);
  CalcInsideVariable();
  CalcOutsideVariable();
  CalcAccessibility(sequence, accessibility, conditional_accessibility);
  Clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0xdb90
movq -0x28(%rbp), %rdi
callq 0xe900
movq -0x28(%rbp), %rdi
callq 0xfc30
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x11dc0
movq -0x28(%rbp), %rdi
callq 0x11ad0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/raccess.cpp
// Function: Raccess::CalcDangleEnergy(int, int, int)
double Raccess::CalcDangleEnergy(int type, int a, int b){
  double x = 0;
  if (type != 0) {
    if (a>0) x += dangle5[type][_int_sequence[a]];
    if (b<_seq_length) x += dangle3[type][_int_sequence[b+1]];
    if( b == _seq_length && type>2){
      x += TermAU;
    }
  }
  return(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x12be0
cmpl $0x0, -0x10(%rbp)
jle 0x12b5a
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x61d80, %rax          # imm = 0x61D80
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
addq $0x620f8, %rdi          # imm = 0x620F8
movslq -0x10(%rbp), %rsi
callq 0xbac0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movslq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x62110(%rcx), %eax
jge 0x12bb3
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x61ec0, %rax          # imm = 0x61EC0
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
addq $0x620f8, %rdi          # imm = 0x620F8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xbac0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movslq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x62110(%rcx), %eax
jne 0x12bde
cmpl $0x2, -0xc(%rbp)
jle 0x12bde
movq -0x28(%rbp), %rax
movsd 0xe68(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x12be0
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/raccess.cpp
// Function: Raccess::HairpinEnergy(int, int, int)
double Raccess::HairpinEnergy(int type, int i, int j) {
  int d = j-i-1;
  double q = 0;

  q = d <= 30 ? hairpin[d] : hairpin[30] - lxc37*log( d/30.) *10./kT;  
  if(d!= 3){
    q += mismatchH[type][_int_sequence[i+1]][_int_sequence[j-1]];
  }else{
    if(type > 2){q += TermAU;}
  }
  return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x1e, -0x18(%rbp)
jg 0x12c3b
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x12c9d
movq -0x28(%rbp), %rax
movsd 0xf0(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x6a74c(%rip), %xmm0    # 0x7d3a0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
movsd 0x25ce2(%rip), %xmm1    # 0x38948
divsd %xmm1, %xmm0
callq 0x3220
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
mulsd %xmm2, %xmm1
movsd 0x25bc8(%rip), %xmm2    # 0x38850
mulsd %xmm2, %xmm1
divsd 0xfd274(%rip), %xmm1    # 0x10ff08
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x3, -0x18(%rbp)
je 0x12d2a
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0xf8, %rax
movslq -0xc(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
addq $0x620f8, %rdi          # imm = 0x620F8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xbac0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
movslq (%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
addq $0x620f8, %rdi          # imm = 0x620F8
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xbac0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movslq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x12d48
cmpl $0x2, -0xc(%rbp)
jle 0x12d46
movq -0x28(%rbp), %rax
movsd 0xe68(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x12d48
movsd -0x20(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/./fmath.hpp
// Function: fmath::log(float)
inline float log(float x)
{
	using namespace local;
	const LogVar<>& logVar = C<>::logVar;
	const size_t logLen = logVar.LEN;

	fi fi;
	fi.f = x;
	int a = fi.i & (mask(8) << 23);
	unsigned int b1 = fi.i & (mask(logLen) << (23 - logLen));
	unsigned int b2 = fi.i & mask(23 - logLen);
	int idx = b1 >> (23 - logLen);
	float f = float(a - (127 << 23)) * logVar.c_log2 + logVar.tbl[idx].app + float(b2) * logVar.tbl[idx].rev;
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movss %xmm0, -0x4(%rbp)
leaq 0xfffac(%rip), %rax     # 0x1150a0
movq %rax, -0x38(%rbp)
movq %rax, -0x10(%rbp)
movq $0xb, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl $0x8, %edi
callq 0x15dd0
movl %eax, %ecx
movl -0x44(%rbp), %eax
shll $0x17, %ecx
andl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl $0xb, %edi
callq 0x15dd0
movl %eax, %ecx
movl -0x40(%rbp), %eax
shll $0xc, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0xc, %edi
callq 0x15dd0
movl -0x3c(%rbp), %ecx
movl %eax, %edx
movq -0x38(%rbp), %rax
andl %edx, %ecx
movl %ecx, -0x28(%rbp)
movl -0x24(%rbp), %ecx
shrl $0xc, %ecx
movl %ecx, -0x2c(%rbp)
movl -0x20(%rbp), %ecx
addl $0xc0800000, %ecx       # imm = 0xC0800000
cvtsi2ss %ecx, %xmm1
movss 0x103f6c(%rip), %xmm2   # 0x1190f0
movslq -0x2c(%rbp), %rcx
movss 0x50(%rax,%rcx,8), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movl -0x28(%rbp), %eax
cvtsi2ss %rax, %xmm0
movslq -0x2c(%rbp), %rcx
leaq 0xffef7(%rip), %rax     # 0x1150a0
movss 0x54(%rax,%rcx,8), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/./fmath.hpp
// Function: fmath::local::ExpVar<10ul>::ExpVar()
ExpVar()
	{
		float log_2 = ::logf(2.0f);
		for (int i = 0; i < 8; i++) {
			maxX[i] = 88;
			minX[i] = -88;
			a[i] = n / log_2;
			b[i] = log_2 / n;
			f1[i] = 1.0f;
			i127s[i] = 127 << s;
			i7fffffff[i] = 0x7fffffff;
			mask_s[i] = mask(s);
		}

		for (int i = 0; i < n; i++) {
			float y = pow(2.0f, (float)i / n);
			fi fi;
			fi.f = y;
			tbl[i] = fi.i & mask(23);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movss 0x23044(%rip), %xmm0    # 0x389b0
callq 0x3510
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x15a3c
movq -0x28(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss 0x23029(%rip), %xmm0    # 0x389c0
movss %xmm0, 0x20(%rax,%rcx,4)
movslq -0x10(%rbp), %rcx
movss 0x23013(%rip), %xmm0    # 0x389bc
movss %xmm0, (%rax,%rcx,4)
movss 0x22ffe(%rip), %xmm0    # 0x389b4
divss -0xc(%rbp), %xmm0
movslq -0x10(%rbp), %rcx
movss %xmm0, 0x40(%rax,%rcx,4)
movss -0xc(%rbp), %xmm0
movss 0x22fe2(%rip), %xmm1    # 0x389b4
divss %xmm1, %xmm0
movslq -0x10(%rbp), %rcx
movss %xmm0, 0x60(%rax,%rcx,4)
movslq -0x10(%rbp), %rcx
movss 0x22fcc(%rip), %xmm0    # 0x389b8
movss %xmm0, 0x80(%rax,%rcx,4)
movslq -0x10(%rbp), %rcx
movl $0x1fc00, 0xa0(%rax,%rcx,4) # imm = 0x1FC00
movslq -0x10(%rbp), %rcx
movl $0x7fffffff, 0xe0(%rax,%rcx,4) # imm = 0x7FFFFFFF
movl $0xa, %edi
callq 0x15dd0
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, 0xc0(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1597d
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp)     # imm = 0x400
jge 0x15aaa
cvtsi2ssl -0x14(%rbp), %xmm1
movss 0x22f5b(%rip), %xmm0    # 0x389b4
divss %xmm0, %xmm1
movss 0x22f4b(%rip), %xmm0    # 0x389b0
callq 0x15f90
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x17, %edi
callq 0x15dd0
movl -0x2c(%rbp), %edx
movl %eax, %ecx
movq -0x28(%rbp), %rax
andl %ecx, %edx
movslq -0x14(%rbp), %rcx
movl %edx, 0x100(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15a43
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/./fmath.hpp
// Function: fmath::local::ExpdVar<11ul>::ExpdVar()
ExpdVar()
		: a(s / ::log(2.0))
		, ra(1 / a)
	{
		for (int i = 0; i < 2; i++) {
#if 0
			C1[i] = 1.0;
			C2[i] = 0.16667794882310216;
			C3[i] = 2.9997969303278795;
#else
			C1[i] = 1.0;
			C2[i] = 0.16666666685227835064;
			C3[i] = 3.0000000027955394;
#endif
		}
		for (int i = 0; i < s; i++) {
			di di;
			di.d = ::pow(2.0, i * (1.0 / s));
			tbl[i] = di.i & mask64(52);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x22ea4(%rip), %xmm0    # 0x38970
callq 0x3220
movq -0x20(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x22e88(%rip), %xmm0    # 0x38968
divsd %xmm1, %xmm0
movsd %xmm0, 0x4030(%rax)
movsd 0x22e5c(%rip), %xmm0    # 0x38950
divsd 0x4030(%rax), %xmm0
movsd %xmm0, 0x4038(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x15b55
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsd 0x22e2f(%rip), %xmm0    # 0x38950
movsd %xmm0, (%rax,%rcx,8)
movslq -0xc(%rbp), %rcx
movsd 0x22e56(%rip), %xmm0    # 0x38988
movsd %xmm0, 0x10(%rax,%rcx,8)
movslq -0xc(%rbp), %rcx
movsd 0x22e3c(%rip), %xmm0    # 0x38980
movsd %xmm0, 0x20(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15b0b
movl $0x0, -0x10(%rbp)
cmpl $0x800, -0x10(%rbp)     # imm = 0x800
jge 0x15bbc
cvtsi2sdl -0x10(%rbp), %xmm1
movsd 0x22e06(%rip), %xmm0    # 0x38978
mulsd %xmm0, %xmm1
movsd 0x22df2(%rip), %xmm0    # 0x38970
callq 0x34c0
movsd %xmm0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x34, %edi
callq 0x15fc0
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x20(%rbp), %rax
andq %rcx, %rdx
movslq -0x10(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15b5c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/rna_interaction_search.cpp
// Function: compare(Hit const&, Hit const&)
bool compare( const Hit& left, const Hit& right ) {
  if(left.GetDbSp() != right.GetDbSp()){
    return(left.GetDbSp() < right.GetDbSp());
  }else if(left.GetQSp() != right.GetQSp()){
    return(left.GetQSp() < right.GetQSp());
  }else if(left.GetDbLength() != right.GetDbLength()){
    return(left.GetDbLength() > right.GetDbLength());
  }else{
    return(left.GetQLength() > right.GetQLength());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1faf0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1faf0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
je 0x1ca77
movq -0x10(%rbp), %rdi
callq 0x1faf0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1faf0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1cb38
movq -0x10(%rbp), %rdi
callq 0x1fb10
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fb10
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x1cabb
movq -0x10(%rbp), %rdi
callq 0x1fb10
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fb10
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1cb38
movq -0x10(%rbp), %rdi
callq 0x1fb30
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fb30
movw %ax, %cx
movl -0x2c(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
je 0x1cb0d
movq -0x10(%rbp), %rdi
callq 0x1fb30
movzwl %ax, %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fb30
movw %ax, %cx
movl -0x30(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1cb38
movq -0x10(%rbp), %rdi
callq 0x1fb50
movzwl %ax, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fb50
movw %ax, %cx
movl -0x34(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/rna_interaction_search.cpp
// Function: RnaInteractionSearch::ConstructSuffixArray(RnaInteractionSearchParameters, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<int, std::allocator<int>>&)
void RnaInteractionSearch::ConstructSuffixArray(const RnaInteractionSearchParameters parameters, string &query_sequence,  vector<unsigned char> &query_encoded_sequence, vector<int> &query_suffix_array){
  Encoder encoder(parameters.GetRepeatFlag());
  encoder.Encode(query_sequence, query_encoded_sequence, 0);
  query_suffix_array.resize(query_encoded_sequence.size());
  sais(&query_encoded_sequence[0], &query_suffix_array[0], query_encoded_sequence.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rsi, -0x150(%rbp)
movq %rdi, %rax
movq -0x150(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x201e0
movl %eax, %esi
leaq -0x129(%rbp), %rdi
callq 0xb880
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x129(%rbp), %rdi
xorl %ecx, %ecx
callq 0xd3e0
movq -0x28(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x20(%rbp), %rdi
callq 0xba80
movq -0x148(%rbp), %rdi
movq %rax, %rsi
callq 0xb9f0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbaa0
movq %rax, -0x140(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbac0
movq %rax, -0x138(%rbp)
movq -0x20(%rbp), %rdi
callq 0xba80
movq -0x140(%rbp), %rdi
movq -0x138(%rbp), %rsi
movl %eax, %edx
callq 0x34e70
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/rna_interaction_search.cpp
// Function: RnaInteractionSearch::ExtendWithoutGap(RnaInteractionSearchParameters, std::vector<Hit, std::allocator<Hit>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<float, std::allocator<float>>&, std::vector<float, std::allocator<float>>&)
void RnaInteractionSearch::ExtendWithoutGap(const RnaInteractionSearchParameters parameters, vector<Hit> &hit_result, vector<unsigned char> &query_encoded_sequence, vector<float> &query_accessibility, vector<float> &query_conditional_accessibility){
  UngappedExtension ungapped_extension(parameters.GetMinAccessibleLength(), parameters.GetDropOutLengthWoGap());

  ungapped_extension.Run(hit_result, query_encoded_sequence, _db_seq, query_accessibility, query_conditional_accessibility, _db_accessibility, _db_conditional_accessibility);
  sort(hit_result.begin(), hit_result.end(), compare);
  CheckRedundancy(hit_result,parameters.GetInteractionEnergyThreshold());
  GetBasePair(hit_result, query_encoded_sequence);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1ff70
movq -0x60(%rbp), %rdi
movl %eax, -0x64(%rbp)
callq 0x204d0
movl -0x64(%rbp), %esi
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0x204f0
movq -0x50(%rbp), %r10
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq %r10, %rcx
addq $0x60, %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq %r10, %rax
addq $0x18, %rax
leaq -0x38(%rbp), %rdi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x28910
movq -0x18(%rbp), %rdi
callq 0x20560
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20590
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x1d56(%rip), %rdx     # 0x1ca20
callq 0x20510
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x205c0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x1f650
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f9a0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/rna_interaction_search.cpp
// Function: RnaInteractionSearch::ExtendWithGap(RnaInteractionSearchParameters, std::vector<Hit, std::allocator<Hit>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<float, std::allocator<float>>&, std::vector<float, std::allocator<float>>&)
void RnaInteractionSearch::ExtendWithGap(const RnaInteractionSearchParameters parameters, vector<Hit> &hit_result, vector<unsigned char> &query_encoded_sequence, vector<float> &query_accessibility, vector<float> &query_conditional_accessibility){
  GappedExtension gapped_extension(parameters.GetMinAccessibleLength(), parameters.GetDropOutLengthWGap(), parameters.GetMinHelixLength());
  gapped_extension.Run(hit_result, query_encoded_sequence, _db_seq, query_accessibility, query_conditional_accessibility, _db_accessibility, _db_conditional_accessibility, _db_seq_length);
  for(int i = 1; i<hit_result.size();i++){
    hit_result[i].SortBasePair();
  }
  sort(hit_result.begin(), hit_result.end(), compare);
  CheckRedundancy(hit_result,parameters.GetFinalThreshold());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1ff70
movq -0x68(%rbp), %rdi
movl %eax, -0x60(%rbp)
callq 0x205e0
movq -0x68(%rbp), %rdi
movl %eax, -0x5c(%rbp)
callq 0x20600
movl -0x60(%rbp), %esi
movl -0x5c(%rbp), %edx
movl %eax, %ecx
leaq -0x3c(%rbp), %rdi
callq 0x20620
movq -0x58(%rbp), %r11
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq %r11, %rcx
addq $0x60, %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq %r11, %r10
addq $0x18, %r10
movq %r11, %rax
addq $0xc0, %rax
leaq -0x3c(%rbp), %rdi
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x2c740
movl $0x1, -0x40(%rbp)
movslq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20650
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e8ae
movq -0x18(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x20680
movq %rax, %rdi
callq 0x206a0
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x1e871
movq -0x18(%rbp), %rdi
callq 0x20560
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20590
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x1eb7(%rip), %rdx     # 0x1ca20
callq 0x20510
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x206f0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x1f650
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/rna_interaction_search.cpp
// Function: RnaInteractionSearch::GetBasePair(std::vector<Hit, std::allocator<Hit>>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
void RnaInteractionSearch::GetBasePair(vector<Hit> &hit_result, vector<unsigned char> &query_encoded_sequence){
  for(int i = 0; i< hit_result.size(); i++){
    int q_start = hit_result[i].GetQSp();
    int db_start = hit_result[i].GetDbSp();
    int length = hit_result[i].GetQLength();
    for(int j = 0; j<length;j++){
      if(BP_pair[query_encoded_sequence[q_start+j]-1][_db_seq[db_start+j]-1] != 0){
	hit_result[i].AddBasePair(q_start+j, db_start+j);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20650
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1fadc
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x20680
movq %rax, %rdi
callq 0x1fb10
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x20680
movq %rax, %rdi
callq 0x1faf0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x20680
movq %rax, %rdi
callq 0x1fb50
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1facc
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
addl -0x2c(%rbp), %eax
movslq %eax, %rsi
callq 0xbaa0
movq -0x38(%rbp), %rdi
movzbl (%rax), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x5d948(%rip), %rax     # 0x7d3b0
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
addq $0x60, %rdi
movl -0x24(%rbp), %eax
addl -0x2c(%rbp), %eax
movslq %eax, %rsi
callq 0xbaa0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movzbl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1fabc
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x20680
movq %rax, %rdi
movl -0x20(%rbp), %esi
addl -0x2c(%rbp), %esi
movl -0x24(%rbp), %edx
addl -0x2c(%rbp), %edx
callq 0x208a0
jmp 0x1fabe
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1fa36
jmp 0x1face
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f9c3
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/seed_search.cpp
// Function: SeedSearch::Run(std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<int, std::allocator<int>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<int, std::allocator<int>>&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void SeedSearch::Run(vector<unsigned char> &query_seq, vector<int> &query_suffix_array, vector<unsigned char> &db_seq, vector<int> &db_suffix_array,  vector<vector<int> > &start_hash,  vector<vector<int> > &end_hash){
  vector<int> db_seed; db_seed.reserve(_max_seed_length);
  vector<int> q_seed; q_seed.reserve(_max_seed_length);
  
  SeedSearchCore(query_seq, query_suffix_array, db_seq, db_suffix_array, start_hash, end_hash, db_seed, q_seed, 0, query_suffix_array.size()-1, 0, db_suffix_array.size()-1, 0.0, 0);
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4720
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rdi
movslq 0x1c(%rax), %rsi
callq 0xbae0
jmp 0x29ac6
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4720
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rdi
movslq 0x1c(%rax), %rsi
callq 0xbae0
jmp 0x29aef
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
callq 0x55a0
decl %eax
movl %eax, -0xcc(%rbp)
movq -0x30(%rbp), %rdi
callq 0x55a0
movl -0xcc(%rbp), %r11d
movq -0xc8(%rbp), %r10
movq -0x88(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq -0xb0(%rbp), %rcx
movq -0xa8(%rbp), %r8
movq -0xa0(%rbp), %r9
movl %eax, %ebx
decl %ebx
movq %rsp, %rax
movq %rax, -0x98(%rbp)
movl %ebx, 0x30(%rax)
movl %r11d, 0x20(%rax)
leaq -0x78(%rbp), %r11
movq %r11, 0x10(%rax)
leaq -0x50(%rbp), %r11
movq %r11, 0x8(%rax)
movq %r10, (%rax)
movl $0x0, 0x38(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
callq 0x29c20
jmp 0x29bc6
leaq -0x78(%rbp), %rdi
callq 0x49d0
leaq -0x50(%rbp), %rdi
callq 0x49d0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x29c05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x49d0
leaq -0x50(%rbp), %rdi
callq 0x49d0
movq -0x58(%rbp), %rdi
callq 0x34d0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/seed_search.cpp
// Function: SeedSearch::CalcAccessibility(std::vector<float, std::allocator<float>>&, std::vector<float, std::allocator<float>>&, int, int)
double SeedSearch::CalcAccessibility(vector<float> &accessibility, vector<float> &conditional_accessibility, int sp, int length){
  double temp = accessibility[sp];
  for(int i =_min_accessible_length; i < length; i++){
    temp += conditional_accessibility[sp+i];
  }
  return(temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x15690
movq %rax, %rcx
movq -0x38(%rbp), %rax
movss (%rcx), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2ab41
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl -0x2c(%rbp), %eax
movslq %eax, %rsi
callq 0x15690
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2ab0a
movsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/./hit.h
// Function: Hit::Hit(int, int, int, double, double)
Hit(int q_sp, int db_sp, int length, double accessiblity_energy, double hybridization_energy){
    _dbseq_id = -1;
    _dbseq_id_start = -1;
    _q_sp = q_sp;
    _db_sp = db_sp;
    _q_length = length;
    _db_length = length;
    _accessibility_energy = accessiblity_energy;
    _hybridization_energy = hybridization_energy;
    _energy = accessiblity_energy + hybridization_energy;
    _flag = false;
    _base_pair.reserve(10);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x38, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2b520
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movb $0x0, 0x30(%rax)
movl $0xa, %esi
callq 0x2b540
jmp 0x2b338
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x23d80
movq -0x30(%rbp), %rdi
callq 0x34d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/./hit.h
// Function: Hit_candidate::Hit_candidate(int, int, int, int, int, double)
Hit_candidate(int sp_q_sa, int ep_q_sa, int sp_db_sa, int ep_db_sa, int length, double energy){
    _sp_q_sa = sp_q_sa;
    _ep_q_sa = ep_q_sa;
    _sp_db_sa = sp_db_sa;
    _ep_db_sa = ep_db_sa;
    _length = length;
    _energy = energy;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/gapped_extension.cpp
// Function: GappedExtension::GetChar(std::vector<unsigned char, std::allocator<unsigned char>>&, int)
int GappedExtension::GetChar(vector<unsigned char> &seq, int i){
  if(i<0 || seq[i]<2){
    return(0);
  }else{
    return(seq[i] <=5 ? seq[i]-1 : seq[i]-5);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x2e29e
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xbaa0
movzbl (%rax), %eax
cmpl $0x2, %eax
jge 0x2e2a7
movl $0x0, -0x4(%rbp)
jmp 0x2e2f0
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xbaa0
movzbl (%rax), %eax
cmpl $0x5, %eax
jg 0x2e2d4
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xbaa0
movzbl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2e2ea
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xbaa0
movzbl (%rax), %eax
subl $0x5, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/gapped_extension.cpp
// Function: GappedExtension::traceback(Hit&, std::vector<std::vector<Cell, std::allocator<Cell>>, std::allocator<std::vector<Cell, std::allocator<Cell>>>>&, int, int, int, int, bool)
void GappedExtension::traceback(Hit &candidate,vector<vector<Cell> > &matrix_c, int i,int i_start, int j, int j_start, bool flag){
  while(i !=0 && j !=0){
    if(flag == 0){
      candidate.AddBasePair(i_start-i,  j_start-j);
    }else{
      candidate.AddBasePair(i_start+i,  j_start+j);
    }
    int temp_i = i; int temp_j = j;
    i =  matrix_c[temp_i][temp_j].first;
    j =  matrix_c[temp_i][temp_j].second;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %r10d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
andb $0x1, %al
movb %al, -0x25(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x31(%rbp)
je 0x2e990
cmpl $0x0, -0x24(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2e99c
jmp 0x2ea23
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2e9c0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
subl -0x1c(%rbp), %esi
movl 0x10(%rbp), %edx
subl -0x24(%rbp), %edx
callq 0x208a0
jmp 0x2e9d5
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
addl -0x1c(%rbp), %esi
movl 0x10(%rbp), %edx
addl -0x24(%rbp), %edx
callq 0x208a0
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x2ed90
movq %rax, %rdi
movslq -0x30(%rbp), %rsi
callq 0x2edb0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x2ed90
movq %rax, %rdi
movslq -0x30(%rbp), %rsi
callq 0x2edb0
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x2e97b
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/gapped_extension.cpp
// Function: GappedExtension::GetBPType(int, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, int, int, int, int, int)
int GappedExtension::GetBPType(int flag, vector<unsigned char> &query_seq, vector<unsigned char> &db_seq, int q_start, int db_start,int i, int j,int x){
  int q_char,db_char;
  if(flag == 0){
    q_char = GetChar(query_seq,q_start-i-x);
    db_char = GetChar(db_seq,db_start-j-x);
  }else{
    q_char = GetChar(query_seq,q_start+i+x);
    db_char = GetChar(db_seq,db_start+j+x);
  }
  int type = BP_pair[q_char][db_char];
  if(flag == 1){type = rtype[type];}
  return(type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2ea9a
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
subl 0x10(%rbp), %edx
subl 0x20(%rbp), %edx
callq 0x2e270
movq -0x40(%rbp), %rdi
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %edx
subl 0x18(%rbp), %edx
subl 0x20(%rbp), %edx
callq 0x2e270
movl %eax, -0x30(%rbp)
jmp 0x2eacc
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
addl 0x10(%rbp), %edx
addl 0x20(%rbp), %edx
callq 0x2e270
movq -0x40(%rbp), %rdi
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %edx
addl 0x18(%rbp), %edx
addl 0x20(%rbp), %edx
callq 0x2e270
movl %eax, -0x30(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0xb0679(%rip), %rax     # 0xdf150
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x2eaff
movslq -0x34(%rbp), %rcx
leaq 0xb06c7(%rip), %rax     # 0xdf1c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/sais.c
// Function: sais_bwt
int
sais_bwt(const unsigned char *T, unsigned char *U, int *A, int n) {
  int i, pidx;
  if((T == NULL) || (U == NULL) || (A == NULL) || (n < 0)) { return -1; }
  if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }
  pidx = sais_main(T, A, 0, n, UCHAR_SIZE, sizeof(unsigned char), 1);
  if(pidx < 0) { return pidx; }
  U[0] = T[n - 1];
  for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)A[i]; }
  for(i += 1; i < n; ++i) { U[i] = (unsigned char)A[i]; }
  pidx += 1;
  return pidx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x35cf2
cmpq $0x0, -0x18(%rbp)
je 0x35cf2
cmpq $0x0, -0x20(%rbp)
je 0x35cf2
cmpl $0x0, -0x24(%rbp)
jge 0x35cfe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x35dea
cmpl $0x1, -0x24(%rbp)
jg 0x35d21
cmpl $0x1, -0x24(%rbp)
jne 0x35d16
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35dea
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %ecx
xorl %edx, %edx
movl $0x100, %r8d            # imm = 0x100
movl $0x1, %r9d
movl $0x1, (%rsp)
callq 0x34ef0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x35d5a
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35dea
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x35da7
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x35d77
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x35ddb
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x35db0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)