LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/main.cpp
// Function: main
int main(int argc, char* argv[]) {
  if(argc == 1 || strcmp(argv[1],"-h") == 0){
    PrintUsage();
    exit(1);
  }
  
  if(strcmp(argv[1],"db") == 0){
    DbConstructionParameters parameters;
    parameters.SetParameters(argc - 1, argv + 1);
    DbConstruction db_construction;
    db_construction.Run(parameters);    
  }else if(strcmp(argv[1],"ris") == 0){
    RnaInteractionSearchParameters parameters;
    parameters.SetParameters(argc - 1, argv + 1);
    parameters.SetDbParameters();
    RnaInteractionSearch rna_interaction_search(parameters.GetHashSize());
    rna_interaction_search.Run(parameters);
  }else{
    cerr << "Error: You must specify the mode of RIblast (db or ris)." << endl;
    exit(1);
  }
  return(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x290, %rsp            # imm = 0x290
cmpl $0x1, %edi
je 0x3a00
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rdi
addq $0x8, %rbx
movzbl (%rdi), %eax
cmpl $0x64, %eax
je 0x3a0a
cmpl $0x2d, %eax
jne 0x3a1a
cmpb $0x68, 0x1(%rdi)
jne 0x3a1a
cmpb $0x0, 0x2(%rdi)
jne 0x3a1a
callq 0x375c
jmp 0x3b35
cmpb $0x62, 0x1(%rdi)
jne 0x3a1a
cmpb $0x0, 0x2(%rdi)
je 0x3ac1
leaq 0x12d1f(%rip), %rsi     # 0x16740
callq 0x32e0
testl %eax, %eax
jne 0x3b1a
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x3c66
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xf9a4
leaq 0x58(%rsp), %rdi
callq 0xfb08
movl 0xbc(%rsp), %esi
leaq 0xf8(%rsp), %rdi
callq 0x3d40
leaq 0x1f0(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3f06
leaq 0xf8(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
callq 0xbd9a
leaq 0x1f0(%rsp), %rdi
callq 0x3f8a
leaq 0xf8(%rsp), %rdi
callq 0x3faa
leaq 0x58(%rsp), %rdi
callq 0x3f8a
xorl %eax, %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xf8(%rsp), %r14
movq %r14, %rdi
callq 0x3b9c
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x482c
leaq 0x8(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x3c10
leaq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x531c
leaq 0x8(%rsp), %rdi
callq 0x3c50
leaq 0xf8(%rsp), %rdi
callq 0x3c50
jmp 0x3ab3
movq 0xdf4cf(%rip), %rdi     # 0xe2ff0
leaq 0x12c1c(%rip), %rsi     # 0x16744
callq 0x31e0
movq %rax, %rdi
callq 0x3110
pushq $0x1
popq %rdi
callq 0x3250
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3c50
jmp 0x3b51
jmp 0x3b4e
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x3c50
jmp 0x3b93
movq %rax, %rbx
leaq 0x1f0(%rsp), %rdi
callq 0x3f8a
jmp 0x3b75
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x3faa
jmp 0x3b89
jmp 0x3b86
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3f8a
movq %rbx, %rdi
callq 0x33a0
nop
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/./db_construction_parameters.h
// Function: DbConstructionParameters::DbConstructionParameters()
DbConstructionParameters(){
    _db_filename = "";
    _input_filename = "";
    _hash_size = 8;
    _repeat_flag = 0;
    _maximal_span = 70;
    _min_accessible_length = 5;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x12c43(%rip), %rsi     # 0x16813
callq 0x33e0
leaq 0x12c37(%rip), %rsi     # 0x16813
movq %r14, %rdi
callq 0x33e0
movaps 0x12425(%rip), %xmm0    # 0x16010
movups %xmm0, 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3100
movq %r15, %rdi
callq 0x33a0
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/./rna_interaction_search_parameters.h
// Function: RnaInteractionSearchParameters::RnaInteractionSearchParameters()
RnaInteractionSearchParameters(){
    _db_filename = "";
    _input_filename = "";
    _hash_size = 0;
    _repeat_flag = 0;
    _maximal_span = 0;
    _min_accessible_length = 0;
    _output_style = 0;
    _max_seed_length = 20;
    _hybrid_energy_threshold = -6.0;
    _interaction_energy_threshold = -4;
    _final_threshold = -8.0;
    _drop_out_length_wo_gap = 5;
    _drop_out_length_w_gap = 16;
    _min_helix_length = 3;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x12b62(%rip), %rsi     # 0x16813
callq 0x33e0
leaq 0x12b56(%rip), %rsi     # 0x16813
movq %r14, %rdi
callq 0x33e0
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movabsq $0x1400000000, %rax     # imm = 0x1400000000
movq %rax, 0x70(%rbx)
movaps 0x1233f(%rip), %xmm0    # 0x16020
movups %xmm0, 0x78(%rbx)
movabsq $-0x3fe0000000000000, %rax # imm = 0xC020000000000000
movq %rax, 0x88(%rbx)
movabsq $0x1000000005, %rax     # imm = 0x1000000005
movq %rax, 0x90(%rbx)
movl $0x3, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3100
movq %r12, %rdi
callq 0x33a0
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/./rna_interaction_search.h
// Function: RnaInteractionSearch::RnaInteractionSearch(int)
RnaInteractionSearch(int hash_size) {
    int nucleotide_size = 4;
    _start_hash.reserve(hash_size);
    _end_hash.reserve(hash_size);
    for(int i = 0; i < hash_size; i++){
      vector <int> temp_vector; temp_vector.resize((int)pow(nucleotide_size,i+1), 0);
      _start_hash.push_back(temp_vector);
      vector <int> temp2_vector; temp_vector.resize((int)pow(nucleotide_size,i+1), 0);
      _end_hash.push_back(temp_vector);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
leaq 0x78(%rdi), %r14
leaq 0x90(%rdi), %r15
movslq %esi, %r12
movl $0xf0, %edx
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
callq 0x3130
movq %r14, %rdi
movq %r12, %rsi
callq 0x4020
movq %r15, %rdi
movq %r12, %rsi
callq 0x4020
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
pushq $0x2
popq %rbp
leaq 0x50(%rsp), %r12
leaq 0x30(%rsp), %r13
subl $0x1, %ebx
jb 0x3e39
andq $0x0, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
callq 0x31d0
cvttsd2si %xmm0, %eax
movslq %eax, %rsi
andl $0x0, 0x30(%rsp)
movq %r12, %rdi
movq %r13, %rdx
callq 0x40c2
movq %r14, %rdi
movq %r12, %rsi
callq 0x40f6
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movsd (%rsp), %xmm0
callq 0x31d0
cvttsd2si %xmm0, %eax
movslq %eax, %rsi
andl $0x0, 0xc(%rsp)
movq %r12, %rdi
leaq 0xc(%rsp), %rdx
callq 0x40c2
movq %r15, %rdi
movq %r12, %rsi
callq 0x40f6
movq %r13, %rdi
callq 0x4632
movq %r12, %rdi
callq 0x4632
addl $0x2, %ebp
jmp 0x3d99
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
jmp 0x3e70
jmp 0x3e50
movq %rax, (%rsp)
jmp 0x3e66
jmp 0x3e58
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4632
leaq 0x50(%rsp), %rdi
callq 0x4632
movq 0x28(%rsp), %rbx
leaq 0xd8(%rbx), %rdi
leaq 0xc0(%rbx), %r12
leaq 0xa8(%rbx), %r13
leaq 0x60(%rbx), %rbp
leaq 0x48(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rbx), %rax
movq %rax, 0x20(%rsp)
callq 0x4632
movq %r12, %rdi
callq 0x4632
movq %r13, %rdi
callq 0x4632
movq %r15, %rdi
callq 0x4122
movq %r14, %rdi
callq 0x4122
movq %rbp, %rdi
callq 0x4710
movq 0x10(%rsp), %rdi
callq 0x4632
movq 0x18(%rsp), %rdi
callq 0x4144
movq 0x20(%rsp), %rdi
callq 0x4166
movq %rbx, %rdi
callq 0x4166
movq (%rsp), %rdi
callq 0x33a0
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20(%rdi), %rax
movq %rax, (%rsp)
leaq 0x11f96(%rip), %r12     # 0x167e4
movq 0xde763(%rip), %r13     # 0xe2fb8
leaq 0x11f64(%rip), %r15     # 0x167c0
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3070
leal -0x6f(%rax), %ecx
cmpl $0x8, %ecx
ja 0x4888
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
movq (%r13), %rsi
movq %r14, %rdi
callq 0x33e0
jmp 0x485c
cmpl $0x64, %eax
je 0x48ce
cmpl $0x69, %eax
jne 0x48e0
movq (%r13), %rsi
movq (%rsp), %rdi
callq 0x33e0
jmp 0x485c
movq (%r13), %rdi
callq 0x3330
movl %eax, 0x44(%r14)
jmp 0x485c
movq (%r13), %rdi
callq 0x3330
movl %eax, 0x40(%r14)
jmp 0x485c
movq (%r13), %rdi
callq 0x3330
movl %eax, 0x48(%r14)
jmp 0x485c
movq (%r13), %rdi
callq 0x3330
movl %eax, 0x4c(%r14)
jmp 0x485c
cmpl $-0x1, %eax
jne 0x48f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xde6f5(%rip), %rdi     # 0xe2ff0
leaq 0x744c4(%rip), %rsi     # 0x78dc6
callq 0x31e0
movq %rax, %rdi
callq 0x3110
pushq $0x1
popq %rdi
callq 0x3250
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
pushq $0xa
popq %rsi
callq 0x5f58
leaq 0x20(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x32d0
leaq 0xf(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq %r14, %rdx
callq 0x4918
leaq 0x28(%rsp), %rdi
callq 0x3100
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x3c10
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5ca4
leaq 0x48(%rsp), %rdi
callq 0x3c50
leaq 0x10(%rsp), %rdi
callq 0x4144
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3c50
jmp 0x566f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x566f
jmp 0x566c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4144
movq %rbx, %rdi
callq 0x33a0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl 0x44(%rsi), %esi
leaq 0x7(%rsp), %r12
movq %r12, %rdi
callq 0x6374
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6c70
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x6456
movq (%r14), %rdi
movq (%rbx), %rsi
movl 0x8(%r14), %edx
subl %edi, %edx
callq 0x13fdc
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/db_construction.cpp
// Function: DbConstruction::SaveSequenceData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>&)
void DbConstruction::SaveSequenceData(string file_name, vector<string> &sequences, vector<unsigned char> &encoded_sequences){
  ofstream of((file_name+".seq").c_str(), ios::out | ios::binary);
  int number_of_seq = sequences.size();
  of.write(reinterpret_cast<const char*>(&number_of_seq), sizeof(int));
  for(int i = 0; i < number_of_seq; i++){
    int seq_size = sequences[i].size();
    of.write(reinterpret_cast<const char*>(&seq_size), sizeof(int));
  }
  int count = encoded_sequences.size();
  vector<unsigned char>::iterator it;
  of.write(reinterpret_cast<const char*>(&count), sizeof(int));
  for(it = encoded_sequences.begin(); it != encoded_sequences.end(); it++){
    of.write(reinterpret_cast<const char*>(&*it), sizeof(unsigned char));
  }
  of.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x10ce4(%rip), %rdx     # 0x16868
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x653c
movq (%r15), %rsi
leaq 0x38(%rsp), %rdi
pushq $0x14
popq %rdx
callq 0x3220
movq %rbx, 0x10(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3100
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x5, %rax
movl %eax, (%r15)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x32b0
pushq $0x8
popq %rbp
xorl %ebx, %ebx
leaq 0x38(%rsp), %r15
leaq 0xc(%rsp), %r12
pushq $0x4
popq %r13
movslq 0x18(%rsp), %rax
cmpq %rax, %rbx
jge 0x5c11
movq (%r14), %rax
movl (%rax,%rbp), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x32b0
incq %rbx
addq $0x20, %rbp
jmp 0x5be6
movq 0x10(%rsp), %rbx
movl 0x8(%rbx), %eax
subl (%rbx), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x38(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x32b0
movq (%rbx), %r14
leaq 0x38(%rsp), %r15
pushq $0x1
popq %r12
cmpq 0x8(%rbx), %r14
je 0x5c54
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x32b0
incq %r14
jmp 0x5c3b
leaq 0x38(%rsp), %rdi
callq 0x32f0
leaq 0x38(%rsp), %rdi
callq 0x3310
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c8f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3100
jmp 0x5c9c
jmp 0x5c8f
jmp 0x5c8f
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/db_construction.cpp
// Function: DbConstruction::Search(std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<int, std::allocator<int>>&, int*, int*, unsigned char, int)
void DbConstruction::Search(vector<unsigned char> &encoded_sequences, vector<int> &suffix_array, int* start, int* end, unsigned char c, int offset){
  int s = *start;
  int e = *end;
  int m;

  if (suffix_array[s] + offset >= encoded_sequences.size()) {
    ++(*start);
  }
  
  if(s>e){
    *start = 1;
    *end = 0;
    return;
  }else if (s == e) {
    if (encoded_sequences[suffix_array[s]+offset] == c) {
      return;
    } else {
      *start = 1;
      *end = 0;
      return;
    }
  }
  
  if (encoded_sequences[suffix_array[s]+offset] != c) {
    while (s < e - 1) {
      m = (s + e) / 2;
      if (encoded_sequences[suffix_array[m]+offset] < c) {
        s = m;
      } else {
        e = m;
      }
    }
    if (encoded_sequences[suffix_array[e]+offset] != c) {
      *start = 1;
      *end = 0;
      return;
    }
    *start = e;
    s = e;
    e = *end;
  }

  if (encoded_sequences[suffix_array[e]+offset] != c) {
    while (s < e - 1) {
      m = (s + e) / 2;
      if (encoded_sequences[suffix_array[m]+offset] > c) {
        e = m;
      } else {
        s = m;
      }
    }
    if (encoded_sequences[suffix_array[s]+offset] != c) {
      *start = 1;
      *end = 0;
      return;
    }
    *end = s;
  }
  return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq 0x20(%rsp), %rax
movl (%rcx), %edi
movl (%r8), %ebx
movslq %edi, %r14
movq (%rdx), %r10
movslq (%r10,%r14,4), %rdx
addq %rax, %rdx
movq (%rsi), %r11
movq 0x8(%rsi), %rsi
subq %r11, %rsi
cmpq %rdx, %rsi
ja 0x5e99
leal 0x1(%rdi), %edx
movl %edx, (%rcx)
cmpl %ebx, %edi
jle 0x5ead
movl $0x1, (%rcx)
xorl %edi, %edi
movl %edi, (%r8)
popq %rbx
popq %r14
popq %rbp
retq
movslq (%r10,%r14,4), %rdx
movslq %eax, %rsi
addq %rsi, %rdx
movb (%r11,%rdx), %al
cmpl %ebx, %edi
jne 0x5ec6
cmpb %r9b, %al
jne 0x5e9d
jmp 0x5ea8
movl $0x2, %ebp
cmpb %r9b, %al
je 0x5f0d
leal -0x1(%rbx), %eax
cmpl %eax, %edi
jge 0x5ef4
leal (%rbx,%rdi), %eax
cltd
idivl %ebp
cltq
movslq (%r10,%rax,4), %rdx
addq %rsi, %rdx
cmpb %r9b, (%r11,%rdx)
cmovbl %eax, %edi
cmovbl %ebx, %eax
movl %eax, %ebx
jmp 0x5ed0
movslq %ebx, %rax
movslq (%r10,%rax,4), %rax
addq %rsi, %rax
cmpb %r9b, (%r11,%rax)
jne 0x5e9d
movl %ebx, (%rcx)
movl %ebx, %edi
movl (%r8), %eax
movl %eax, %ebx
movslq %ebx, %rax
movslq (%r10,%rax,4), %rax
addq %rsi, %rax
cmpb %r9b, (%r11,%rax)
je 0x5ea8
leal -0x1(%rbx), %eax
cmpl %eax, %edi
jge 0x5f3f
leal (%rbx,%rdi), %eax
cltd
idivl %ebp
cltq
movslq (%r10,%rax,4), %rdx
addq %rsi, %rdx
cmpb %r9b, (%r11,%rdx)
cmovbel %eax, %edi
cmoval %eax, %ebx
jmp 0x5f1d
movslq %edi, %rax
movslq (%r10,%rax,4), %rax
addq %rsi, %rax
cmpb %r9b, (%r11,%rax)
jne 0x5e9d
jmp 0x5ea5
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/./encoder.h
// Function: Encoder::Encoder(int)
Encoder(int flag) {
    _sentinel_character = 0;
    _unknown_character = 1; 
    if(flag == 0){
      for (int i = 0; i < UCHAR_MAX; ++i) {
	_code_table[i] = _unknown_character;
      }
      
      _code_table[static_cast<int>('A')] = 2;
      _code_table[static_cast<int>('C')] = 3;
      _code_table[static_cast<int>('G')] = 4;
      _code_table[static_cast<int>('T')] = 5;
      _code_table[static_cast<int>('U')] = 5;
      
    }else if(flag == 1){
      for (int i = 0; i < UCHAR_MAX; ++i) {
	_code_table[i] = _unknown_character;
      }
      
      _code_table[static_cast<int>('A')] = 2;
      _code_table[static_cast<int>('C')] = 3;
      _code_table[static_cast<int>('G')] = 4;
      _code_table[static_cast<int>('T')] = 5;
      _code_table[static_cast<int>('U')] = 5;
      _code_table[static_cast<int>('a')] = 6;
      _code_table[static_cast<int>('c')] = 7;
      _code_table[static_cast<int>('g')] = 8;
      _code_table[static_cast<int>('t')] = 9;
      _code_table[static_cast<int>('u')] = 9;
      
    }else if(flag == 2){
      for (int i = 0; i < UCHAR_MAX; ++i) {
	_code_table[i] = _unknown_character;
      }
      _code_table[static_cast<int>('A')] = 2;
      _code_table[static_cast<int>('C')] = 3;
      _code_table[static_cast<int>('G')] = 4;
      _code_table[static_cast<int>('T')] = 5;
      _code_table[static_cast<int>('U')] = 5;
      _code_table[static_cast<int>('a')] = 2;
      _code_table[static_cast<int>('c')] = 3;
      _code_table[static_cast<int>('g')] = 4;
      _code_table[static_cast<int>('t')] = 5;
      _code_table[static_cast<int>('u')] = 5;
      
    }else{
      cerr << "Error: -r option must be 0, 1, or 2." << endl;
      exit(1);
    }
  }

// Assembly:
pushq %rbx
movw $0x100, 0xff(%rdi)      # imm = 0x100
testl %esi, %esi
je 0x63c1
cmpl $0x1, %esi
je 0x63a3
cmpl $0x2, %esi
jne 0x6433
xorl %eax, %eax
cmpq $0xff, %rax
je 0x63f1
movb $0x1, (%rdi,%rax)
incq %rax
jmp 0x6392
xorl %eax, %eax
cmpq $0xff, %rax
je 0x63b6
movb $0x1, (%rdi,%rax)
incq %rax
jmp 0x63a5
movb $0x9, %al
movb $0x8, %cl
movb $0x7, %dl
movb $0x6, %r9b
jmp 0x63fa
xorl %eax, %eax
pushq $0x55
popq %rsi
pushq $0x54
popq %r8
pushq $0x47
popq %r10
pushq $0x43
popq %r11
pushq $0x41
popq %rbx
cmpq $0xff, %rax
je 0x63e6
movb $0x1, (%rdi,%rax)
incq %rax
jmp 0x63d5
movb $0x5, %al
movb $0x4, %cl
movb $0x3, %dl
movb $0x2, %r9b
jmp 0x641e
movb $0x5, %al
movb $0x4, %cl
movb $0x3, %dl
movb $0x2, %r9b
movb $0x2, 0x41(%rdi)
movb $0x3, 0x43(%rdi)
movb $0x4, 0x47(%rdi)
movw $0x505, 0x54(%rdi)      # imm = 0x505
pushq $0x75
popq %rsi
pushq $0x74
popq %r8
pushq $0x67
popq %r10
pushq $0x63
popq %r11
pushq $0x61
popq %rbx
movb %r9b, (%rdi,%rbx)
movb %dl, (%rdi,%r11)
movb %cl, (%rdi,%r10)
movb %al, (%rdi,%r8)
movb %al, (%rdi,%rsi)
popq %rbx
retq
movq 0xdcbb6(%rip), %rdi     # 0xe2ff0
leaq 0x1049b(%rip), %rsi     # 0x168dc
callq 0x31e0
movq %rax, %rdi
callq 0x3110
pushq $0x1
popq %rdi
callq 0x3250
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xff(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rbx, %rcx
jbe 0x6d30
cmpl $0x0, 0xc(%rsp)
je 0x6ced
movq %rbx, %rbp
shlq $0x5, %rbp
movl 0x8(%rax,%rbp), %r13d
decq %r13
testl %r13d, %r13d
js 0x6d1b
movq (%r15), %rax
movl %r13d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq (%rax,%rbp), %rax
movsbq (%rax,%rcx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x6dbc
jmp 0x6cc3
movq %rbx, %r13
shlq $0x5, %r13
xorl %ebp, %ebp
cmpq %rbp, 0x8(%rax,%r13)
jbe 0x6d1b
addq %r13, %rax
movq (%rax), %rax
movsbq (%rax,%rbp), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x6dbc
incq %rbp
movq (%r15), %rax
jmp 0x6cf6
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x6dbc
incq %rbx
jmp 0x6c99
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testl %ecx, %ecx
je 0x6d7e
movl 0x8(%r15), %r12d
decq %r12
testl %r12d, %r12d
js 0x6d9f
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq (%r15), %rcx
movsbq (%rcx,%rax), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x6dbc
jmp 0x6d59
xorl %r12d, %r12d
cmpq %r12, 0x8(%r15)
jbe 0x6d9f
movq (%r15), %rax
movsbq (%rax,%r12), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x6dbc
incq %r12
jmp 0x6d81
addq $0xff, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6dbc
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x6f22
movq %rbx, %rdi
callq 0x73da
movq %rbx, %rdi
callq 0x7cba
movq %rbx, %rdi
callq 0x86b0
movq %rbx, %rdi
popq %rbx
jmp 0x8b28
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x6f22
movq %r15, %rdi
callq 0x73da
movq %r15, %rdi
callq 0x7cba
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8e1e
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8b28
// File: /workspace/github_c_makefile_star2_O2/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:
testl %esi, %esi
je 0x9525
movslq %esi, %rax
testl %edx, %edx
jle 0x952a
imulq $0x28, %rax, %r8
addq %rdi, %r8
movl %edx, %edx
movq 0x620f8(%rdi), %r9
movslq (%r9,%rdx,4), %rdx
xorpd %xmm0, %xmm0
addsd 0x61d80(%r8,%rdx,8), %xmm0
jmp 0x952e
xorpd %xmm0, %xmm0
retq
xorpd %xmm0, %xmm0
movl 0x62110(%rdi), %edx
cmpl %ecx, %edx
jle 0x9558
imulq $0x28, %rax, %rax
addq %rdi, %rax
movq 0x620f8(%rdi), %r8
movslq %ecx, %r9
movslq 0x4(%r8,%r9,4), %r8
addsd 0x61ec0(%rax,%r8,8), %xmm0
cmpl %ecx, %edx
setne %al
cmpl $0x3, %esi
setl %cl
orb %al, %cl
jne 0x9529
addsd 0xe68(%rdi), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movl %edx, %eax
notl %eax
addl %ecx, %eax
cmpl $0x1f, %eax
jge 0x95ab
movslq %eax, %rcx
movsd (%r14,%rcx,8), %xmm0
cmpl $0x3, %eax
jne 0x95e7
cmpl $0x3, %r15d
jl 0x961b
addsd 0xe68(%r14), %xmm0
jmp 0x961b
movsd 0xf0(%r14), %xmm0
movsd %xmm0, (%rsp)
cvtsi2sd %eax, %xmm0
divsd 0x3e38b(%rip), %xmm0    # 0x47950
callq 0x3190
mulsd 0x3e386(%rip), %xmm0    # 0x47958
mulsd 0xd286(%rip), %xmm0     # 0x16860
divsd 0xd9c86(%rip), %xmm0    # 0xe3268
addsd (%rsp), %xmm0
movslq %r15d, %rax
imulq $0xc8, %rax, %rax
addq %r14, %rax
movq 0x620f8(%r14), %rcx
movslq %ebp, %rdx
movslq 0x4(%rcx,%rdx,4), %rdx
movslq %ebx, %rsi
movslq -0x4(%rcx,%rsi,4), %rcx
imulq $0x28, %rdx, %rdx
addq %rax, %rdx
addsd 0xf8(%rdx,%rcx,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/raccess.cpp
// Function: Raccess::CalcMultiProbability(int, int)
double Raccess::CalcMultiProbability(int x, int w){
  double probability = 0.0;
  double temp = 0.0;
  bool flag = 0;
  
  for(int i = x+w-1; i<=min(x+_maximal_span,_seq_length);i++){
    if(_Beta_multi[x-1][i-x+1] != -INF && _Alpha_multi[x+w-1][i-x-w+1] != -INF){
      temp = flag == 0 ? _Beta_multi[x-1][i-x+1] + _Alpha_multi[x+w-1][i-x-w+1] : logsumexp(temp,_Beta_multi[x-1][i-x+1] + _Alpha_multi[x+w-1][i-x-w+1]);
      flag = 1;
    }
  }
  
  for(int i = max(0,x+w-1-_maximal_span); i<x;i++){
    if(_Beta_multi2[i][x+w-1-i] != -INF && _Alpha_multi2[i][x-i-1] != -INF){
      temp = flag == 0 ? _Beta_multi2[i][x+w-1-i] + _Alpha_multi2[i][x-i-1] : logsumexp(temp,_Beta_multi2[i][x+w-1-i] + _Alpha_multi2[i][x-i-1]);
      flag = 1;
    }
  }
  if(flag == 1){ probability = fmath::expd(temp-_Alpha_outer[_seq_length]); }
  return(probability);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leal -0x1(%rsi,%rdx), %eax
movslq %esi, %rcx
movslq %eax, %r14
movslq %edx, %rbp
movq %r14, %r12
subq %rcx, %r12
incq %r12
shlq $0x3, %rbp
negq %rbp
xorpd %xmm0, %xmm0
xorl %edi, %edi
movq %rcx, (%rsp)
imulq $0x18, %rcx, %r9
movsd 0x3d34e(%rip), %xmm3    # 0x47930
imulq $0x18, %r14, %r13
movq %r14, %r15
movq %r9, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x62110(%rbx), %ecx
movl 0x62114(%rbx), %eax
leal (%rax,%rsi), %edx
cmpl %edx, %ecx
cmovll %ecx, %edx
movslq %edx, %rcx
cmpq %rcx, %r15
jg 0xa67d
movq 0x62230(%rbx), %rax
movq -0x18(%rax,%r9), %rax
movsd (%rax,%r12,8), %xmm1
ucomisd %xmm3, %xmm1
jne 0xa629
jnp 0xa672
movq 0x62188(%rbx), %rax
movq (%rax,%r13), %rax
addq %rbp, %rax
movsd (%rax,%r12,8), %xmm2
ucomisd %xmm3, %xmm2
jne 0xa645
jnp 0xa672
addsd %xmm2, %xmm1
testb $0x1, %dil
movb $0x1, %dil
jne 0xa658
movapd %xmm1, %xmm0
jmp 0xa672
callq 0x94a2
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rsi
movsd 0x3d2c1(%rip), %xmm3    # 0x47930
movb $0x1, %dil
incq %r15
incq %r12
jmp 0xa5f3
movl %r14d, %ecx
subl %eax, %ecx
xorl %r12d, %r12d
testl %ecx, %ecx
cmovgl %ecx, %r12d
imulq $0x18, %r12, %r13
movl %r12d, %ebp
notl %ebp
addl %esi, %ebp
subq %r12, %r14
movq (%rsp), %r15
cmpq %r15, %r12
jge 0xa707
movq 0x62278(%rbx), %rax
movq (%rax,%r13), %rax
movsd (%rax,%r14,8), %xmm1
ucomisd %xmm3, %xmm1
jne 0xa6bb
jnp 0xa6f9
movq 0x621d0(%rbx), %rax
movslq %ebp, %rcx
movq (%rax,%r13), %rax
movsd (%rax,%rcx,8), %xmm2
ucomisd %xmm3, %xmm2
jne 0xa6d6
jnp 0xa6f9
addsd %xmm2, %xmm1
testb $0x1, %dil
movb $0x1, %dil
jne 0xa6e9
movapd %xmm1, %xmm0
jmp 0xa6f9
callq 0x94a2
movsd 0x3d23a(%rip), %xmm3    # 0x47930
movb $0x1, %dil
incq %r12
addq $0x18, %r13
decl %ebp
decq %r14
jmp 0xa69d
testb $0x1, %dil
je 0xa733
movslq 0x62110(%rbx), %rax
movq 0x62140(%rbx), %rcx
subsd (%rcx,%rax,8), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa856
xorpd %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movd %xmm0, %eax
movl %eax, %ecx
andl $0x7f800000, %ecx       # imm = 0x7F800000
addl $0xc0800000, %ecx       # imm = 0xC0800000
cvtsi2ss %ecx, %xmm1
movl %eax, %ecx
leaq 0xddbd5(%rip), %rdx     # 0xe8400
shrl $0x9, %eax
andl $0x3ff8, %eax           # imm = 0x3FF8
mulss 0xe1c15(%rip), %xmm1    # 0xec450
addss 0x50(%rax,%rdx), %xmm1
andl $0xfff, %ecx            # imm = 0xFFF
cvtsi2ss %ecx, %xmm0
mulss 0x54(%rax,%rdx), %xmm0
addss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x20
popq %rax
testq %rax, %rax
je 0xaa6e
movl $0x42b00000, 0x40(%rbx,%rax) # imm = 0x42B00000
movl $0xc2b00000, 0x20(%rbx,%rax) # imm = 0xC2B00000
movl $0x44b8aa3b, 0x60(%rbx,%rax) # imm = 0x44B8AA3B
movl $0x3a317218, 0x80(%rbx,%rax) # imm = 0x3A317218
movl $0x3f800000, 0xa0(%rbx,%rax) # imm = 0x3F800000
movl $0x1fc00, 0xc0(%rbx,%rax) # imm = 0x1FC00
movl $0x7fffffff, 0x100(%rbx,%rax) # imm = 0x7FFFFFFF
movl $0x3ff, 0xe0(%rbx,%rax) # imm = 0x3FF
addq $0x4, %rax
jmp 0xaa14
xorl %r14d, %r14d
cmpq $0x400, %r14            # imm = 0x400
je 0xaaa2
cvtsi2ss %r14d, %xmm0
mulss 0x3cf49(%rip), %xmm0    # 0x479d0
callq 0x3400
movd %xmm0, %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %eax, 0x100(%rbx,%r14,4)
incq %r14
jmp 0xaa71
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movapd 0x3cf06(%rip), %xmm0    # 0x479c0
movupd %xmm0, 0x4030(%rdi)
pushq $-0x10
popq %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movabsq $0x3fc5555555bb5fdb, %rdx # imm = 0x3FC5555555BB5FDB
movabsq $0x4008000000600dd3, %rsi # imm = 0x4008000000600DD3
testq %rax, %rax
je 0xaafd
movq %rcx, 0x10(%rbx,%rax)
movq %rdx, 0x20(%rbx,%rax)
movq %rsi, 0x30(%rbx,%rax)
addq $0x8, %rax
jmp 0xaae3
xorl %r14d, %r14d
movabsq $0xfffffffffffff, %r15  # imm = 0xFFFFFFFFFFFFF
cmpq $0x800, %r14            # imm = 0x800
je 0xab37
cvtsi2sd %r14d, %xmm0
mulsd 0x3ce70(%rip), %xmm0    # 0x47990
callq 0x31d0
movq %xmm0, %rax
andq %r15, %rax
movq %rax, 0x30(%rbx,%r14,8)
incq %r14
jmp 0xab0a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/./fmath.hpp
// Function: fmath::local::LogVar<12ul>::LogVar()
LogVar()
		: c_log2(::logf(2.0f) / (1 << 23))
	{
		const double e = 1 / double(1 << 24);
		const double h = 1 / double(1 << LEN);
		const size_t n = 1U << LEN;
		for (size_t i = 0; i < n; i++) {
			double x = 1 + double(i) / n;
			double a = ::log(x);
			tbl[i].app = (float)a;
			if (i < n - 1) {
				double b = ::log(x + h - e);
				tbl[i].rev = (float)((b - a) / ((h - e) * (1 << 23)));
			} else {
				tbl[i].rev = (float)(1 / (x * (1 << 23)));
			}
		}
		for (int i = 0; i < 4; i++) {
			m1[i] = mask(8) << 23;
			m2[i] = mask(LEN) << (23 - LEN);
			m3[i] = mask(23 - LEN);
			m4[i] = c_log2;
			m5[i] = 127U << 23;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x33b17218, 0x4050(%rdi) # imm = 0x33B17218
xorl %r14d, %r14d
movsd 0x3ce36(%rip), %xmm2    # 0x47990
movsd 0x3cdfe(%rip), %xmm1    # 0x47960
cmpq $0x800, %r14            # imm = 0x800
je 0xac0c
cvtsi2sd %r14, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
callq 0x3190
movapd %xmm0, %xmm1
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x50(%rbx,%r14,8)
cmpq $0x7ff, %r14            # imm = 0x7FF
jne 0xabbd
movsd (%rsp), %xmm2
mulsd 0x3cdfd(%rip), %xmm2    # 0x479a8
movsd 0x3cdad(%rip), %xmm1    # 0x47960
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
jmp 0xabf1
movsd (%rsp), %xmm0
addsd 0x3cdc6(%rip), %xmm0    # 0x47990
addsd 0x3cdc6(%rip), %xmm0    # 0x47998
movsd %xmm1, (%rsp)
callq 0x3190
subsd (%rsp), %xmm0
divsd 0x3cdb7(%rip), %xmm0    # 0x479a0
movsd 0x3cd6f(%rip), %xmm1    # 0x47960
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x54(%rbx,%r14,8)
incq %r14
movsd 0x3cd89(%rip), %xmm2    # 0x47990
jmp 0xab62
pushq $-0x10
popq %rax
testq %rax, %rax
je 0xac48
movl $0x7f800000, 0x10(%rbx,%rax) # imm = 0x7F800000
movl $0x7ff000, 0x20(%rbx,%rax) # imm = 0x7FF000
movl $0xfff, 0x30(%rbx,%rax) # imm = 0xFFF
movss 0x4050(%rbx), %xmm0
movss %xmm0, 0x40(%rbx,%rax)
movl $0x3f800000, 0x50(%rbx,%rax) # imm = 0x3F800000
addq $0x4, %rax
jmp 0xac0f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl 0x68(%rsi), %esi
leaq 0x7(%rsp), %r12
movq %r12, %rdi
callq 0x6374
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x6d40
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x6456
movq (%r14), %rdi
movq (%rbx), %rsi
movl 0x8(%r14), %edx
subl %edi, %edx
callq 0x13fdc
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x70(%rsi), %eax
movl 0x90(%rsi), %ecx
movq %rsp, %rdi
movl %eax, (%rdi)
movl %ecx, 0x4(%rdi)
leaq 0x60(%r15), %rcx
leaq 0x18(%r15), %rax
movq %rdx, %rsi
movq %rbx, %rdx
pushq %rax
pushq %r15
callq 0xfc78
addq $0x10, %rsp
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq -0xfd5(%rip), %rdx      # 0xbd68
callq 0xe8ad
movsd 0x78(%r12), %xmm0
movq %r14, %rsi
callq 0xd480
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd57e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
movl 0x70(%rsi), %edx
leaq 0x4(%rsp), %rdi
movl %edx, (%rdi)
movq 0x94(%rsi), %rdx
movq %rdx, 0x4(%rdi)
leaq 0x60(%rax), %r10
leaq 0x18(%rax), %r11
leaq 0xc0(%rax), %r15
subq $0x8, %rsp
movq %rbx, %rsi
movq %rcx, %rdx
movq %r10, %rcx
pushq %r15
pushq %r11
pushq %rax
callq 0x116fc
addq $0x20, %rsp
pushq $0x1
popq %r15
pushq $0x50
popq %r12
movq %r12, %r13
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r15, %rax
jbe 0xcdf4
addq %r13, %rdi
callq 0xdb82
incq %r15
addq $0x50, %r13
jmp 0xcdcc
leaq -0x1093(%rip), %rdx     # 0xbd68
callq 0xe8ad
movsd 0x88(%r14), %xmm0
movq %rbx, %rsi
callq 0xd480
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/fukunagatsu[P]RIblast/rna_interaction_search.cpp
// Function: RnaInteractionSearch::CheckRedundancy(std::vector<Hit, std::allocator<Hit>>&, double)
void RnaInteractionSearch::CheckRedundancy(vector<Hit> &hit_result, double energy_threshold){
  for(int i = 0; i<hit_result.size();i++){
    if(hit_result[i].GetEnergy() > energy_threshold){
      hit_result[i].SetFlag();
    }

    if(!hit_result[i].GetFlag()){
      int a_QSp = hit_result[i].GetQSp();
      int a_DbSp = hit_result[i].GetDbSp();
      int a_QEp = a_QSp+hit_result[i].GetQLength()-1;
      int a_DbEp = a_DbSp+hit_result[i].GetDbLength()-1;

      for(int j = i+1; j<hit_result.size();j++){
        if(!hit_result[j].GetFlag()){
          int b_DbSp = hit_result[j].GetDbSp();
          if(a_DbEp < b_DbSp){
            break;
          }

          int b_QSp = hit_result[j].GetQSp();
          int b_QEp = b_QSp+hit_result[j].GetQLength()-1;
          int b_DbEp = b_DbSp+hit_result[j].GetDbLength()-1;
          if(a_QEp>=b_QEp && a_QSp <= b_QSp && a_DbEp >= b_DbEp){
	    if(hit_result[i].GetEnergy() > hit_result[j].GetEnergy()){
	      hit_result[i].SetFlag();
	    }else{
	      hit_result[j].SetFlag();
	    }
          }
        }
      }
    }
  }
  hit_result.erase(remove_if(hit_result.begin(), hit_result.end(), CheckFlag()), hit_result.end());

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rdi
movq %rsi, (%rsp)
movq 0x8(%rsi), %rsi
movq %rsi, %rax
subq %rdi, %rax
pushq $0x50
popq %rcx
cqto
idivq %rcx
leaq 0x80(%rdi), %rcx
pushq $0x1
popq %rdx
xorl %r8d, %r8d
cmpq %rax, %r8
je 0xd55a
imulq $0x50, %r8, %r9
leaq (%rdi,%r9), %r14
movsd 0x28(%rdi,%r9), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd4d6
movb $0x1, 0x30(%r14)
jmp 0xd4dd
testb $0x1, 0x30(%r14)
je 0xd4e9
incq %r8
incq %rdx
addq $0x50, %rcx
jmp 0xd4b1
leaq 0x30(%r14), %r9
movl 0x8(%r14), %r10d
movzwl 0x10(%r14), %r11d
addl %r10d, %r11d
movzwl 0x14(%r14), %ebp
addl 0xc(%r14), %ebp
movq %rcx, %r14
movq %rdx, %r15
cmpq %r15, %rax
jbe 0xd4dd
cmpb $0x0, (%r14)
jne 0xd551
movl -0x24(%r14), %r12d
cmpl %r12d, %ebp
jle 0xd4dd
movl -0x28(%r14), %r13d
cmpl %r13d, %r10d
jg 0xd551
movzwl -0x20(%r14), %ebx
addl %r13d, %ebx
cmpl %ebx, %r11d
jl 0xd551
movzwl -0x1c(%r14), %ebx
addl %r12d, %ebx
cmpl %ebx, %ebp
jl 0xd551
ucomisd -0x8(%r14), %xmm1
movq %r9, %r12
ja 0xd54c
movq %r14, %r12
movb $0x1, (%r12)
incq %r15
addq $0x50, %r14
jmp 0xd508
callq 0xf280
movq (%rsp), %rdi
movq 0x8(%rdi), %rdx
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdbd6
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
xorl %esi, %esi
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cqto
pushq $0x50
popq %rdi
idivq %rdi
cmpq %rsi, %rax
jbe 0xd625
movq %rsi, 0x10(%rsp)
imulq $0x50, %rsi, %rbp
movslq 0x8(%rcx,%rbp), %r12
movslq 0xc(%rcx,%rbp), %r13
movzwl 0x10(%rcx,%rbp), %r14d
subq $0x1, %r14
jb 0xd618
movq (%rbx), %rax
movzbl (%rax,%r12), %eax
imulq $0x14, %rax, %rax
leaq 0x3a6e9(%rip), %rcx     # 0x47cd0
addq %rcx, %rax
movq 0x60(%r15), %rcx
movzbl (%rcx,%r13), %ecx
cmpl $0x0, -0x18(%rax,%rcx,4)
je 0xd610
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq %rbp, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0xdbbe
incq %r12
incq %r13
jmp 0xd5ce
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0xd599
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq