LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ZmengXu[P]boxMesh/boxMesh.C
// Function: boxMesh(int, int, int, double, double, double)
void boxMesh(int Nx, int Ny, int Nz, double Lx, double Ly, double Lz)
{
    /* Create files
        constant/polyMesh/boundary
        constant/polyMesh/faces
        constant/polyMesh/neighbour
        constant/polyMesh/owner
        constant/polyMesh/points
    that would be created by calling OpenFOAM's blockMesh using the following
    blockMeshDict dictionary:

        vertices
        (
            (0     0     0    )
            (Nx*Lx 0     0    )
            (Nx*Lx Ny*Ly 0    )
            (0     Ny*Ly 0    )
            (0     0     Nz*Lz)
            (Nx*Lx 0     Nz*Lz)
            (Nx*Lx Ny*Ly Nz*Lz)
            (0     Ny*Ly Nz*Lz)
        );

        blocks
        (
            hex (0 1 2 3 4 5 6 7) (Nx Ny Nz) simpleGrading (1 1 1)
        );

        edges
        (
        );

        boundary
        (
        );

        mergePatchPairs
        (
        );
    */

    // Calculate number of points, faces and cells
    int nPoints        = (Nx+1)*(Ny+1)*(Nz+1);
    int nCells         = Nx*Ny*Nz;
    int nFaces         = Nx*Ny*(Nz+1)+Nx*Nz*(Ny+1)+Ny*Nz*(Nx+1);
    int nExternalFaces = 2*(Nx*Ny+Nx*Nz+Ny*Nz);

    // Write files
    writeBoundary(nFaces, nExternalFaces);
    writeFaces(nCells, nFaces, nExternalFaces, Nx, Ny, Nz);
    writeNeighbour(nPoints, nCells, nFaces, nExternalFaces, Nx, Ny, Nz);
    writeOwner(nPoints, nCells, nFaces, nExternalFaces, Nx, Ny, Nz);
    writePoints(nPoints, Nx, Ny, Nz, Lx, Ly, Lz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm2, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movl %edx, %r12d
movl %edi, %r15d
leal 0x1(%r15), %r13d
leal 0x1(%rsi), %eax
movl %eax, %edx
imull %r13d, %edx
leal 0x1(%r12), %ecx
imull %ecx, %edx
movl %edx, -0x2c(%rbp)
movl %esi, %r14d
movq %rsi, -0x38(%rbp)
imull %edi, %r14d
imull %r14d, %ecx
movl %r12d, %ebx
imull %edi, %ebx
imull %ebx, %eax
addl %r14d, %ebx
imull %r12d, %r14d
addl %ecx, %eax
movl %r12d, %ecx
imull %esi, %ecx
imull %ecx, %r13d
addl %eax, %r13d
addl %ecx, %ebx
addl %ebx, %ebx
movl %r13d, %edi
movl %ebx, %esi
callq 0x245c
movl %r14d, %edi
movl %r13d, %esi
movl %ebx, %edx
movq %r15, -0x40(%rbp)
movl %r15d, %ecx
movq -0x38(%rbp), %r8
movl %r12d, %r9d
callq 0x289d
movl %r12d, (%rsp)
movl -0x2c(%rbp), %edi
movl %r14d, %esi
movl %r13d, %edx
movl %ebx, %ecx
movl %r15d, %r8d
movq -0x38(%rbp), %r15
movl %r15d, %r9d
callq 0x398b
movl %r12d, (%rsp)
movl -0x2c(%rbp), %r12d
movl %r12d, %edi
movl %r14d, %esi
movl %r13d, %edx
movl %ebx, %ecx
movq -0x40(%rbp), %r14
movl %r14d, %r8d
movl %r15d, %r9d
callq 0x41a3
movl %r12d, %edi
movl %r14d, %esi
movl %r15d, %edx
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4db0
// File: /workspace/github_c_makefile_star2_O3/ZmengXu[P]boxMesh/boxMesh.C
// Function: main
int main(int argc, char *argv[])
{
    int Nx, Ny, Nz;
    double Lx, Ly, Lz;
    if ( argc != 7 ) // argc should be 2 for correct execution
        // We print argv[0] assuming it is the program name
        cout << "usage: " << argv[0] << " Nx Ny Nz Lx Ly Lz\n";
    else
    {
        Nx = atoi(argv[1]);
        Ny = atoi(argv[2]);
        Nz = atoi(argv[3]);
        Lx = atof(argv[4]);
        Ly = atof(argv[5]);
        Lz = atof(argv[6]);

        struct stat info;
        if( stat("constant/polyMesh", &info)==0 )   // Check if directory exists.
        boxMesh(Nx,Ny,Nz,Lx,Ly,Lz);
        else
            cout << "Please create directory constant/polyMesh first\n";
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
cmpl $0x7, %edi
jne 0x54e9
movq 0x8(%r14), %rdi
callq 0x2220
movl %eax, %ebx
movq 0x10(%r14), %rdi
callq 0x2220
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x2220
movl %eax, %r12d
movq 0x20(%r14), %rdi
callq 0x2190
movsd %xmm0, -0x38(%rbp)
movq 0x28(%r14), %rdi
callq 0x2190
movsd %xmm0, -0x30(%rbp)
movq 0x30(%r14), %rdi
callq 0x2190
movsd %xmm0, -0x28(%rbp)
leaq 0x1159(%rip), %rdi      # 0x661a
leaq -0xc8(%rbp), %rsi
callq 0x2140
testl %eax, %eax
je 0x5528
movq 0x3ae8(%rip), %rdi      # 0x8fc0
leaq 0x114d(%rip), %rsi      # 0x662c
movl $0x30, %edx
jmp 0x5570
movq 0x3ad0(%rip), %rbx      # 0x8fc0
leaq 0x1107(%rip), %rsi      # 0x65fe
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2180
movq (%r14), %r14
testq %r14, %r14
je 0x5546
movq %r14, %rdi
callq 0x20a0
movq 0x3aa5(%rip), %rdi      # 0x8fc0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x555d
movl %ebx, %edi
movl %r15d, %esi
movl %r12d, %edx
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
callq 0x5353
jmp 0x5575
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2280
movq 0x3a5c(%rip), %rdi      # 0x8fc0
leaq 0x109b(%rip), %rsi      # 0x6606
movl $0x13, %edx
callq 0x2180
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r15
leaq 0x30(%rdi), %r13
movq %r13, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x18549(%rip), %rcx     # 0x1c86b
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x3360
movq 0x28(%rbx), %rdx
leaq 0x18532(%rip), %rcx     # 0x1c86b
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x3360
movaps 0x17cc3(%rip), %xmm0    # 0x1c010
movups %xmm0, 0x40(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4372
movq (%r13), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3450
movq %r12, %rdi
callq 0x33e0
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r15
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rbp
movq %rbp, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x18468(%rip), %rcx     # 0x1c86b
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x3360
movq 0x28(%rbx), %rdx
leaq 0x18451(%rip), %rcx     # 0x1c86b
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x3360
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movabsq $0x1400000000, %rax     # imm = 0x1400000000
movq %rax, 0x70(%rbx)
movaps 0x17bdd(%rip), %xmm0    # 0x1c020
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 %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq 0x40(%rbx), %rdi
cmpq %rbp, %rdi
je 0x449a
movq (%rbp), %rsi
incq %rsi
callq 0x3230
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3464
movq %r13, %rdi
callq 0x33e0
nop
// File: /workspace/github_c_makefile_star2_O3/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 $0x38, %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 0x3140
movq %r14, %rdi
movq %r12, %rsi
callq 0x4834
movq %r15, %rdi
movq %r12, %rsi
callq 0x4834
testl %ebp, %ebp
jle 0x45ad
movl $0x2, %ebx
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl %ebx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x30(%rsp)
callq 0x31f0
cvttsd2si %xmm0, %eax
movslq %eax, %rsi
movl $0x0, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rdx
callq 0x4912
movq %r14, %rdi
movq %r12, %rsi
callq 0x4946
movsd 0x30(%rsp), %xmm0
callq 0x31f0
cvttsd2si %xmm0, %eax
movslq %eax, %rsi
movl $0x0, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rdx
callq 0x4912
movq %r15, %rdi
movq %r12, %rsi
callq 0x4946
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x45a2
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
addl $0x2, %ebx
decl %ebp
jne 0x4510
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x45e1
jmp 0x45c7
jmp 0x45c7
jmp 0x45c7
movq %rax, %r12
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x45e1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x28(%rsp), %rbx
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x4601
movq 0xe8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x461c
movq 0xd0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x4637
movq 0xb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq %r15, %rdi
callq 0x4972
movq %r14, %rdi
callq 0x4972
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x465c
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x4671
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x3230
leaq 0x30(%rbx), %rdi
leaq 0x18(%rbx), %r14
callq 0x49c6
movq %r14, %rdi
callq 0x4a24
movq %rbx, %rdi
callq 0x4a24
movq %r12, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O3/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 0x17556(%rip), %r15     # 0x1c83c
movq 0xe1cc3(%rip), %r13     # 0xe6fb0
leaq 0x17524(%rip), %r12     # 0x1c818
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3070
cmpl $0x6e, %eax
jle 0x5346
addl $-0x6f, %eax
cmpl $0x8, %eax
ja 0x53ed
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq (%r13), %r15
movq 0x8(%r14), %r13
movq %r15, %rdi
callq 0x3100
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq 0xe1c76(%rip), %r13     # 0xe6fb0
movq %r15, %rcx
leaq 0x174f8(%rip), %r15     # 0x1c83c
jmp 0x5384
cmpl $0x64, %eax
je 0x53c7
cmpl $0x69, %eax
jne 0x53d9
movq 0xe1c55(%rip), %rax     # 0xe6fb0
movq (%rax), %r13
movq 0x28(%r14), %r15
movq %r13, %rdi
callq 0x3100
movq (%rsp), %rdi
xorl %esi, %esi
movq %r15, %rdx
leaq 0x174c2(%rip), %r15     # 0x1c83c
movq %r13, %rcx
movq 0xe1c2c(%rip), %r13     # 0xe6fb0
movq %rax, %r8
callq 0x3360
jmp 0x52f4
movq (%r13), %rdi
callq 0x3370
movl %eax, 0x48(%r14)
jmp 0x52f4
movq (%r13), %rdi
callq 0x3370
movl %eax, 0x40(%r14)
jmp 0x52f4
movq (%r13), %rdi
callq 0x3370
movl %eax, 0x44(%r14)
jmp 0x52f4
movq (%r13), %rdi
callq 0x3370
movl %eax, 0x4c(%r14)
jmp 0x52f4
cmpl $-0x1, %eax
jne 0x53ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe1bfc(%rip), %rdi     # 0xe6ff0
leaq 0x79b8b(%rip), %rsi     # 0x7ef86
callq 0x3210
movq %rax, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32a0
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0xa, %esi
callq 0x74b0
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x479e
leaq 0xf(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movq %r14, %rdx
callq 0x5414
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x6797
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x479e
leaq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x479e
movups 0x40(%rbx), %xmm0
leaq 0x50(%rsp), %rsi
movups %xmm0, 0x40(%rsi)
leaq 0x30(%rsp), %rdx
callq 0x7056
movq 0x70(%rsp), %rdi
cmpq %r15, %rdi
je 0x6806
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x681d
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x30(%rsp), %rdi
callq 0x49c6
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4386
jmp 0x6878
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x6878
movq 0x60(%rsp), %rsi
jmp 0x6869
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x6878
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3230
jmp 0x6878
jmp 0x6875
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x49c6
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O3/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 0x7a42
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x8f28
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x8700
movq (%r14), %rdi
movq (%rbx), %rsi
movl 0x8(%r14), %edx
subl %edi, %edx
callq 0x1a160
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 $0x228, %rsp            # imm = 0x228
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x479e
leaq 0x15a54(%rip), %rsi     # 0x1c948
movq %r15, %rdi
callq 0x3420
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x14, %edx
callq 0x3250
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6f27
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x5, %rax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x32f0
cmpl $0x0, 0x8(%rsp)
jle 0x6f8d
movl $0x8, %r13d
xorl %ebp, %ebp
leaq 0x28(%rsp), %r15
leaq 0x4(%rsp), %r12
movq (%r14), %rax
movl (%rax,%r13), %eax
movl %eax, 0x4(%rsp)
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x32f0
incq %rbp
movslq 0x8(%rsp), %rax
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x6f61
movl 0x8(%rbx), %eax
subl (%rbx), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x32f0
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
je 0x6fcf
leaq 0x28(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x32f0
incq %r14
cmpq 0x8(%rbx), %r14
jne 0x6fb6
leaq 0x28(%rsp), %rdi
callq 0x3320
movq 0xdffe0(%rip), %rax     # 0xe6fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x31d0
leaq 0x120(%rsp), %rdi
callq 0x30d0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7041
jmp 0x7021
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x704e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
jmp 0x704e
jmp 0x7041
jmp 0x7041
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movslq 0x18(%rsp), %r10
movl (%rcx), %r11d
movl (%r8), %edi
movslq %r11d, %rbx
movq (%rdx), %rax
movslq (%rax,%rbx,4), %r14
addq %r10, %r14
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
cmpq %r14, %rsi
ja 0x73ba
leal 0x1(%r11), %esi
movl %esi, (%rcx)
cmpl %edi, %r11d
jle 0x73cf
movl $0x1, (%rcx)
xorl %r10d, %r10d
movl %r10d, (%r8)
popq %rbx
popq %r14
retq
movslq (%rax,%rbx,4), %rbx
movslq %r10d, %rsi
addq %rsi, %rbx
movb (%rdx,%rbx), %r10b
cmpl %edi, %r11d
jne 0x73e9
cmpb %r9b, %r10b
jne 0x73bf
jmp 0x73cb
cmpb %r9b, %r10b
jne 0x73f3
movl %r11d, %r10d
jmp 0x744e
leal -0x1(%rdi), %r10d
cmpl %r10d, %r11d
jge 0x7431
leal (%rdi,%r11), %ebx
movl %ebx, %r10d
shrl $0x1f, %r10d
addl %ebx, %r10d
sarl %r10d
movslq %r10d, %rbx
movslq (%rax,%rbx,4), %rbx
addq %rsi, %rbx
cmpb %r9b, (%rdx,%rbx)
jae 0x7423
movl %r10d, %r11d
movl %edi, %r10d
leal -0x1(%r10), %ebx
movl %r10d, %edi
cmpl %ebx, %r11d
jl 0x73fc
jmp 0x7434
movl %edi, %r10d
movslq %r10d, %rdi
movslq (%rax,%rdi,4), %rdi
addq %rsi, %rdi
cmpb %r9b, (%rdx,%rdi)
jne 0x73bf
movl %r10d, (%rcx)
movl (%r8), %edi
movslq %edi, %r11
movslq (%rax,%r11,4), %r11
addq %rsi, %r11
cmpb %r9b, (%rdx,%r11)
je 0x73cb
leal -0x1(%rdi), %r11d
cmpl %r11d, %r10d
jge 0x7496
leal (%rdi,%r10), %ebx
movl %ebx, %r11d
shrl $0x1f, %r11d
addl %ebx, %r11d
sarl %r11d
movslq %r11d, %rbx
movslq (%rax,%rbx,4), %rbx
addq %rsi, %rbx
cmpb %r9b, (%rdx,%rbx)
ja 0x7491
movl %r11d, %r10d
jmp 0x7462
movl %r11d, %edi
jmp 0x7462
movslq %r10d, %rdi
movslq (%rax,%rdi,4), %rax
addq %rsi, %rax
cmpb %r9b, (%rdx,%rax)
jne 0x73bf
jmp 0x73c8
nop
// File: /workspace/github_c_makefile_star2_O3/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 (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x903e
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xff(%rdi), %rcx
movq %rcx, 0x10(%rsp)
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
je 0x8fb1
movq %rbx, %rbp
shlq $0x5, %rbp
movl 0x8(%rax,%rbp), %eax
decl %eax
js 0x8ffe
movl %eax, %r13d
incq %r13
movq (%r15), %rax
movq (%rax,%rbp), %rax
movsbq -0x1(%rax,%r13), %rdx
addq %r12, %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x8fa2
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%r14)
jmp 0x8faa
movq %r14, %rdi
callq 0x9114
decq %r13
jg 0x8f7e
jmp 0x8ffe
movq %rbx, %rbp
shlq $0x5, %rbp
cmpq $0x0, 0x8(%rax,%rbp)
je 0x8ffe
addq %rbp, %rax
xorl %r13d, %r13d
movq (%rax), %rax
movsbq (%rax,%r13), %rdx
addq %r12, %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x8fe5
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%r14)
jmp 0x8fed
movq %r14, %rdi
callq 0x9114
incq %r13
movq (%r15), %rcx
leaq (%rcx,%rbp), %rax
cmpq %r13, 0x8(%rcx,%rbp)
ja 0x8fc6
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x9017
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, (%rsi)
incq 0x8(%r14)
jmp 0x9024
movq %r14, %rdi
movq 0x10(%rsp), %rdx
callq 0x9114
incq %rbx
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rbx, %rcx
ja 0x8f5e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x8(%rsi), %rax
testl %ecx, %ecx
je 0x90a0
decl %eax
js 0x90d8
movl %eax, %r12d
incq %r12
movq (%r15), %rax
movsbq -0x1(%rax,%r12), %rdx
addq %r14, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x9091
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x9099
movq %rbx, %rdi
callq 0x9114
decq %r12
jg 0x9071
jmp 0x90d8
testq %rax, %rax
je 0x90d8
xorl %r12d, %r12d
movq (%r15), %rax
movsbq (%rax,%r12), %rdx
addq %r14, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x90c7
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x90cf
movq %rbx, %rdi
callq 0x9114
incq %r12
cmpq %r12, 0x8(%r15)
ja 0x90a8
addq $0xff, %r14
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x90fe
movb (%r14), %al
movb %al, (%rsi)
incq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9114
// File: /workspace/github_c_makefile_star2_O3/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 0x9232
movq %rbx, %rdi
callq 0x979c
movq %rbx, %rdi
callq 0xa094
movq %rbx, %rdi
callq 0xac24
movq %rbx, %rdi
popq %rbx
jmp 0xb1e0
// File: /workspace/github_c_makefile_star2_O3/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 0x9232
movq %r15, %rdi
callq 0x979c
movq %r15, %rdi
callq 0xa094
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb4b6
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb1e0
// File: /workspace/github_c_makefile_star2_O3/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 0xbe1c
movslq %esi, %rax
testl %edx, %edx
jle 0xbe21
leaq (%rax,%rax,4), %r8
leaq (%rdi,%r8,8), %r8
movl %edx, %edx
movq 0x620f8(%rdi), %r9
movslq (%r9,%rdx,4), %rdx
xorpd %xmm0, %xmm0
addsd 0x61d80(%r8,%rdx,8), %xmm0
jmp 0xbe25
xorpd %xmm0, %xmm0
retq
xorpd %xmm0, %xmm0
movl 0x62110(%rdi), %edx
cmpl %ecx, %edx
jle 0xbe50
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %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 0xbe20
addsd 0xe68(%rdi), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbea3
movslq %eax, %rcx
movsd (%r14,%rcx,8), %xmm0
cmpl $0x3, %eax
jne 0xbee2
cmpl $0x3, %r15d
jl 0xbf17
addsd 0xe68(%r14), %xmm0
jmp 0xbf17
movsd 0xf0(%r14), %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x41b70(%rip), %xmm0    # 0x4da30
callq 0x31b0
mulsd 0x41b6b(%rip), %xmm0    # 0x4da38
mulsd 0x10a6b(%rip), %xmm0    # 0x1c940
divsd 0xdb38b(%rip), %xmm0    # 0xe7268
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
leaq (%rdx,%rdx,4), %rdx
leaq (%rax,%rdx,8), %rax
addsd 0xf8(%rax,%rcx,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $-0x8, %rax
movaps 0x3fdfb(%rip), %xmm0    # 0x4daa0
movaps 0x3fe04(%rip), %xmm1    # 0x4dab0
movaps 0x3fe0d(%rip), %xmm2    # 0x4dac0
movaps 0x3fe16(%rip), %xmm3    # 0x4dad0
movaps 0x3fe1f(%rip), %xmm4    # 0x4dae0
movaps 0x3fe28(%rip), %xmm5    # 0x4daf0
movaps 0x3fe31(%rip), %xmm6    # 0x4db00
movaps 0x3fe3a(%rip), %xmm7    # 0x4db10
movups %xmm0, 0x40(%rbx,%rax,4)
movups %xmm1, 0x20(%rbx,%rax,4)
movups %xmm2, 0x60(%rbx,%rax,4)
movups %xmm3, 0x80(%rbx,%rax,4)
movups %xmm4, 0xa0(%rbx,%rax,4)
movups %xmm5, 0xc0(%rbx,%rax,4)
movups %xmm6, 0x100(%rbx,%rax,4)
movups %xmm7, 0xe0(%rbx,%rax,4)
addq $0x4, %rax
jne 0xdcd6
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
mulss 0x3fe6a(%rip), %xmm0    # 0x4db90
callq 0x3430
movd %xmm0, %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %eax, 0x100(%rbx,%r14,4)
incq %r14
cmpq $0x400, %r14            # imm = 0x400
jne 0xdd16
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0x50(%rdi)
movsd 0x3fcf0(%rip), %xmm1    # 0x4da60
xorps %xmm0, %xmm0
movl $0xb, %r14d
movsd %xmm0, (%rsp)
movsd 0x3fcea(%rip), %xmm0    # 0x4da70
addsd %xmm0, %xmm1
addsd 0x3fce6(%rip), %xmm1    # 0x4da78
movapd %xmm1, %xmm0
callq 0x31b0
subsd (%rsp), %xmm0
divsd 0x3fcd8(%rip), %xmm0    # 0x4da80
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbx,%r14,8)
leaq -0xa(%r14), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x3fca9(%rip), %xmm0    # 0x4da70
addsd 0x3fc91(%rip), %xmm0    # 0x4da60
movsd %xmm0, (%rsp)
callq 0x31b0
movsd (%rsp), %xmm1
xorps %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm2
movss %xmm2, (%rbx,%r14,8)
incq %r14
cmpq $0x80a, %r14            # imm = 0x80A
jne 0xdd79
mulsd 0x3fc89(%rip), %xmm1    # 0x4da88
movsd 0x3fc59(%rip), %xmm0    # 0x4da60
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbx,%r14,8)
movss 0x4050(%rbx), %xmm0
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movaps 0x3fd37(%rip), %xmm1    # 0x4db60
movups %xmm1, (%rbx)
movaps 0x3fd3d(%rip), %xmm1    # 0x4db70
movups %xmm1, 0x10(%rbx)
movaps 0x3fd42(%rip), %xmm1    # 0x4db80
movups %xmm1, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movaps 0x3fc93(%rip), %xmm0    # 0x4dae0
movups %xmm0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x7a42
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x904e
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x8700
movq (%r14), %rdi
movq (%rbx), %rsi
movl 0x8(%r14), %edx
subl %edi, %edx
callq 0x1a160
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
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 0x15624
addq $0x10, %rsp
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0x11465
movq %rbp, %rax
subq %r13, %rax
sarq $0x4, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x1ea4(%rip), %rcx     # 0xf5a4
movq %r13, %rdi
movq %rbp, %rsi
callq 0x13422
movq %r13, %rdi
movq %rbp, %rsi
leaq -0x1ebc(%rip), %rdx     # 0xf5a4
callq 0x134fd
movsd 0x78(%r12), %xmm0
movq %r14, %rsi
callq 0x11f2c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1205c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %rax
movl 0x70(%rsi), %edx
leaq 0xc(%rsp), %rdi
movl %edx, (%rdi)
movq %rsi, (%rsp)
movq 0x94(%rsi), %rdx
movq %rdx, 0x4(%rdi)
leaq 0x60(%rax), %r10
leaq 0x18(%rax), %r11
leaq 0xc0(%rax), %r14
subq $0x8, %rsp
movq %rbx, %rsi
movq %rcx, %rdx
movq %r10, %rcx
pushq %r14
pushq %r11
pushq %rax
callq 0x174ec
addq $0x20, %rsp
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movq %r12, %rax
subq %r15, %rax
sarq $0x4, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r13, %rax
cmpq $0x2, %rax
jb 0x11545
movl $0x1, %ebp
movl $0x50, %r14d
addq %r14, %r15
movq %r15, %rdi
callq 0x1290a
incq %rbp
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movq %r12, %rax
subq %r15, %rax
sarq $0x4, %rax
imulq %r13, %rax
addq $0x50, %r14
cmpq %rbp, %rax
ja 0x11519
cmpq %r12, %r15
je 0x1157a
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x1fba(%rip), %r13     # 0xf5a4
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x13422
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x134fd
movq (%rsp), %rax
movsd 0x88(%rax), %xmm0
movq %rbx, %rsi
callq 0x11f2c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq (%rsi), %rdi
movq %rsi, 0x10(%rsp)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rsp)
subq %rdi, %rcx
je 0x12032
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
cmpq $0x1, %rax
movq %rax, %rsi
adcq $0x0, %rsi
leaq 0x80(%rdi), %rdx
movl $0x1, %r8d
xorl %r9d, %r9d
leaq (%r9,%r9,4), %r10
shlq $0x4, %r10
leaq (%rdi,%r10), %r15
movsd 0x28(%rdi,%r10), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x11fa1
movb $0x1, 0x30(%r15)
jmp 0x11fa8
testb $0x1, 0x30(%r15)
je 0x11fb9
incq %r9
incq %r8
addq $0x50, %rdx
cmpq %rsi, %r9
jne 0x11f81
jmp 0x12032
incq %r9
cmpq %r9, %rax
jbe 0x11fab
leaq 0x30(%r15), %r10
movl 0x8(%r15), %r11d
movzwl 0x10(%r15), %ebp
addl %r11d, %ebp
movzwl 0x14(%r15), %r14d
addl 0xc(%r15), %r14d
movq %rdx, %r15
movq %r8, %r12
cmpb $0x0, (%r15)
jne 0x12021
movl -0x24(%r15), %r13d
cmpl %r13d, %r14d
jle 0x11fab
movl -0x28(%r15), %ebx
cmpl %ebx, %r11d
jg 0x12021
movzwl -0x20(%r15), %ecx
addl %ebx, %ecx
cmpl %ecx, %ebp
jl 0x12021
movzwl -0x1c(%r15), %ecx
addl %r13d, %ecx
cmpl %ecx, %r14d
jl 0x12021
ucomisd -0x8(%r15), %xmm1
movq %r10, %rbx
ja 0x1201e
movq %r15, %rbx
movb $0x1, (%rbx)
incq %r12
addq $0x50, %r15
cmpq %r12, %rax
ja 0x11fe0
jmp 0x11fab
movq 0x8(%rsp), %rsi
callq 0x14253
movq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rdx
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14388
nop
// File: /workspace/github_c_makefile_star2_O3/fukunagatsu[P]RIblast/rna_interaction_search_parameters.cpp
// Function: RnaInteractionSearchParameters::SetParameters(int, char**)
void RnaInteractionSearchParameters::SetParameters(int argc, char* argv[]) {
  int c;
  extern char *optarg;
  while ((c = getopt(argc, argv, "i:o:d:l:e:y:x:f:g:s:m:")) != -1) {
    switch (c) {
    case 'i':
      _input_filename = optarg;
      break;

    case 'o':
      _output_filename = optarg;
      break;
      
    case 'd':
      _db_filename = optarg;
      break;

    case 'l':
      _max_seed_length = atoi(optarg);
      break;

    case 'e':
      _hybrid_energy_threshold = atof(optarg);
      break;
   
    case 'f':
      _interaction_energy_threshold = atof(optarg);
      break;

    case 'g':
      _final_threshold = atof(optarg);
      break;

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

    case 'x':
      _drop_out_length_w_gap = atoi(optarg);
      break;

    case 'y':
      _drop_out_length_wo_gap = atoi(optarg);
      break;

    case 'm':
      _min_helix_length = atoi(optarg);
      break;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x40(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x69d01(%rip), %r15     # 0x7ef68
leaq 0x69ca2(%rip), %r13     # 0x7ef10
movq 0xd1d3b(%rip), %r12     # 0xe6fb0
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3070
leal -0x64(%rax), %ecx
cmpl $0x15, %ecx
ja 0x1539b
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movq (%r12), %r15
movq 0x8(%r14), %r12
movq %r15, %rdi
callq 0x3100
movq %r14, %rdi
jmp 0x15335
movq (%r12), %rdi
callq 0x3370
movl %eax, 0x94(%r14)
jmp 0x15275
movq (%r12), %rdi
callq 0x3370
movl %eax, 0x90(%r14)
jmp 0x15275
movq (%r12), %rdi
callq 0x3370
movl %eax, 0x60(%r14)
jmp 0x15275
movq (%r12), %r15
movq 0x28(%r14), %r12
movq %r15, %rdi
callq 0x3100
movq 0x8(%rsp), %rdi
jmp 0x15335
movq (%r12), %rdi
callq 0x3370
movl %eax, 0x74(%r14)
jmp 0x15275
movq (%r12), %rdi
callq 0x32c0
movsd %xmm0, 0x78(%r14)
jmp 0x15275
movq (%r12), %r15
movq 0x48(%r14), %r12
movq %r15, %rdi
callq 0x3100
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
movq 0xd1c6f(%rip), %r12     # 0xe6fb0
movq %r15, %rcx
leaq 0x69c1d(%rip), %r15     # 0x7ef68
movq %rax, %r8
callq 0x3360
jmp 0x15275
movq (%r12), %rdi
callq 0x32c0
movsd %xmm0, 0x88(%r14)
jmp 0x15275
movq (%r12), %rdi
callq 0x32c0
movsd %xmm0, 0x80(%r14)
jmp 0x15275
movq (%r12), %rdi
callq 0x3370
movl %eax, 0x98(%r14)
jmp 0x15275
cmpl $-0x1, %eax
jne 0x153af
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd1c3a(%rip), %rdi     # 0xe6ff0
leaq 0x69bc2(%rip), %rsi     # 0x7ef7f
callq 0x3210
movq %rax, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r15
movq %rcx, (%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movslq 0x1c(%rdi), %rsi
movq %rbx, %rdi
callq 0x8732
leaq 0x10(%rsp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movslq 0x1c(%r12), %rsi
movq %r13, %rdi
callq 0x8732
movq 0x8(%rbp), %rax
subq (%rbp), %rax
shrq $0x2, %rax
decl %eax
movq 0x8(%r15), %r10
subq (%r15), %r10
shrq $0x2, %r10
decl %r10d
xorl %r11d, %r11d
xorps %xmm0, %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq (%rsp), %rcx
movq %r15, %r8
movq 0x8(%rsp), %r9
pushq %r11
pushq %r10
pushq %r11
pushq %rax
pushq %r11
pushq %r13
pushq %rbx
pushq 0xb8(%rsp)
callq 0x160c6
addq $0x40, %rsp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16062
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x16079
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x160a7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x160a7
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x160be
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0