LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::parseCommandLine(int, char**)
void CsvArgs::parseCommandLine(int argc, char *argv[])
{
    const int programName = 1;
    const int requiredUserArgs = 4;
    const int requiredArgs = programName + requiredUserArgs;

    if (argc != requiredArgs)
    {
        throw std::invalid_argument("Usage: ./colReplacer inputData "
            "colToOverwrite colReplaceVal outputData\n");
    }

    inputFname = argv[1];
    colToOverwrite = argv[2];
    colReplaceVal = argv[3];
    outputFname = argv[4];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x5, %esi
jne 0x24b4
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
addq $0x448, %rdi            # imm = 0x448
callq 0x2240
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x2240
movq 0x18(%r14), %rsi
leaq 0x20(%rbx), %rdi
callq 0x2240
movq 0x20(%r14), %rsi
addq $0x468, %rbx            # imm = 0x468
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2240
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x1b4b(%rip), %rsi      # 0x4011
movq %rax, %rdi
callq 0x2220
movq 0x3b13(%rip), %rsi      # 0x5fe8
movq 0x3afc(%rip), %rdx      # 0x5fd8
movq %rbx, %rdi
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::~CsvArgs()
CsvArgs::~CsvArgs()
{
    if (isInputOpen)
    {
        inputFile.close();
    }
    if (isOutputOpen)
    {
        outputFile.close();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x488(%rdi)
jne 0x250e
leaq 0x40(%rbx), %rdi
callq 0x2060
cmpb $0x1, 0x489(%rbx)
jne 0x2523
leaq 0x248(%rbx), %rdi
callq 0x2170
leaq 0x468(%rbx), %rdi
callq 0x20c0
leaq 0x448(%rbx), %rdi
callq 0x20c0
leaq 0x248(%rbx), %rdi
callq 0x2180
leaq 0x40(%rbx), %rdi
callq 0x2070
leaq 0x20(%rbx), %rdi
callq 0x20c0
movq %rbx, %rdi
popq %rbx
jmp 0x20c0
movq %rax, %rdi
callq 0x276a
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::getInputData()
std::istream &CsvArgs::getInputData()
{
    if (!isInputOpen)
    {
        inputFile.open(inputFname.c_str(), std::ifstream::in);
        checkFile(&inputFile, "input");
        isInputOpen = true;
    }
    return inputFile;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x488(%rdi)
jne 0x25d2
leaq 0x40(%rbx), %r14
movq 0x448(%rbx), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x20f0
movq 0x40(%rbx), %rax
addq -0x18(%rax), %r14
leaq 0x1a60(%rip), %rsi      # 0x4004
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x2776
movq %r14, %rsi
movq %r15, %rdx
callq 0x25f8
leaq 0x10(%rsp), %rdi
callq 0x20c0
movb $0x1, 0x488(%rbx)
addq $0x40, %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::setOutputData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CsvArgs::setOutputData(const std::string &data)
{
    if (!isOutputOpen)
    {
        outputFile.open(outputFname.c_str(), std::ofstream::out);
        checkFile(&outputFile, "output");
        isOutputOpen = true;
    }
    outputFile << data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x489(%rdi)
jne 0x2716
leaq 0x248(%r14), %r15
movq 0x468(%r14), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2030
movq 0x248(%r14), %rax
addq -0x18(%rax), %r15
leaq 0x1923(%rip), %rsi      # 0x400a
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x2776
movq %r15, %rsi
movq %r12, %rdx
callq 0x25f8
leaq 0x8(%rsp), %rdi
callq 0x20c0
movb $0x1, 0x489(%r14)
addq $0x248, %r14            # imm = 0x248
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/CsvProcessor.cpp
// Function: CsvProcessor::findColToReplace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int CsvProcessor::findColToReplace(const std::string &headerName)
{
    getColHeaders();

    int colNum = COL_NOT_FOUND;
    std::istringstream colHeaderProcessor(colHeaders);
    std::string colHeader;

    while (getline(colHeaderProcessor, colHeader, ','))
    {
        if (colHeader == headerName)
        {
            colNum = numCols;
        }
        numCols++;
    }

    if (colNum == COL_NOT_FOUND)
    {
        throw std::invalid_argument("column name doesn't exist in the input "
            "data\n");
    }

    return colNum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %r14
callq 0x2c7a
movl 0x2c(%r14), %ebx
leaq 0x8(%r14), %rsi
leaq 0x28(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
callq 0x21b0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r13
pushq $0x2c
popq %rbp
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x2210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2a24
movq %r13, %rdi
movq %r15, %rsi
callq 0x2ec7
movl 0x28(%r14), %ecx
testb %al, %al
cmovnel %ecx, %ebx
incl %ecx
movl %ecx, 0x28(%r14)
jmp 0x29ed
cmpl 0x2c(%r14), %ebx
je 0x2a52
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x28(%rsp), %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %r14
leaq 0x1637(%rip), %rsi      # 0x409b
movq %rax, %rdi
callq 0x2220
movq 0x3575(%rip), %rsi      # 0x5fe8
movq 0x355e(%rip), %rdx      # 0x5fd8
movq %r14, %rdi
callq 0x21d0
jmp 0x2a91
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
jmp 0x2a94
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x28(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/CsvProcessor.cpp
// Function: CsvProcessor::replaceAllCols(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string CsvProcessor::replaceAllCols(int colNum,
    const std::string &replaceVal)
{
    std::string line;
    std::string word;
    std::string output;

    while (getline(inputData, line))
    {
        std::istringstream colProcessor(line);
        for (int col = 0; col < numCols; col++)
        {
            checkedGetNextWord(word, colProcessor, line, (col != numCols - 1));
            output += (determineNextColWord(col, colNum, replaceVal, word) +
                getOutputWordDelimiter(col));
        }
    }

    return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rcx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, %r15
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdi, (%rsp)
movb %dl, 0x10(%rdi)
leaq 0x38(%rsp), %r12
leaq 0x78(%rsp), %r13
leaq 0x58(%rsp), %rbx
leaq 0x98(%rsp), %r14
movq (%r15), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2be1
leaq 0xb8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x21b0
xorl %ebp, %ebp
movl 0x28(%r15), %eax
cmpl %eax, %ebp
jge 0x2bcf
decl %eax
xorl %r8d, %r8d
cmpl %eax, %ebp
setne %r8b
movq %r12, %rsi
leaq 0xb8(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x2ce6
cmpl %ebp, 0xc(%rsp)
movq %r12, %rsi
cmoveq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x2160
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2df4
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2e28
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x20c0
movq %r13, %rdi
callq 0x20c0
incl %ebp
jmp 0x2b4f
leaq 0xb8(%rsp), %rdi
callq 0x20d0
jmp 0x2b19
leaq 0x38(%rsp), %rdi
callq 0x20c0
leaq 0x18(%rsp), %rdi
callq 0x20c0
movq (%rsp), %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c0d
movq %rax, %rbx
jmp 0x2c54
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x20c0
jmp 0x2c27
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20c0
jmp 0x2c38
jmp 0x2c44
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x20c0
jmp 0x2c47
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x20d0
movq (%rsp), %rdi
callq 0x20c0
leaq 0x38(%rsp), %rdi
callq 0x20c0
leaq 0x18(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/CsvProcessor.cpp
// Function: CsvProcessor::checkedGetNextWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void CsvProcessor::checkedGetNextWord(std::string &word,
    std::istringstream &colProcessor, const std::string &line,
    bool expectedResult)
{
    bool result = !getline(colProcessor, word, ',').eof();
    if (result != expectedResult)
    {
        throw std::invalid_argument("Input file is malformed.  " +
            line + " has a different number of columns.  word is " + word);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %rdi
movq %rsi, %r14
pushq $0x2c
popq %rdx
callq 0x2210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movb 0x20(%rax,%rcx), %al
andb $0x2, %al
shrb %al
cmpb %bl, %al
je 0x2d22
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x13a8(%rip), %rsi      # 0x40dc
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x27d0
leaq 0x13af(%rip), %rdx      # 0x40f7
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x27b1
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x2ef0
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x21e0
xorl %ebp, %ebp
movq 0x3266(%rip), %rsi      # 0x5fe8
movq 0x324f(%rip), %rdx      # 0x5fd8
movq %rbx, %rdi
callq 0x21d0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x20c0
jmp 0x2da6
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x20c0
jmp 0x2db8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x2dcc
jmp 0x2dd4
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/tscott8706[P]cpp-csv-col-replacer/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    CsvArgs args(argc, argv);
    CsvProcessor processor(args.getInputData());
    std::string output = processor.replaceColVals(args.getColToOverwrite(),
        args.getColReplaceVal());
    args.setOutputData(output);
    return 0;
}

// Assembly:
pushq %rbx
subq $0x520, %rsp            # imm = 0x520
movq %rsi, %rdx
movl %edi, %esi
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x235c
movq %rbx, %rdi
callq 0x256a
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x28dc
leaq 0x20(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x274a
movq %rsp, %rdi
leaq 0x90(%rsp), %rsi
callq 0x2758
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
callq 0x2900
movq %rsp, %rdi
callq 0x20c0
leaq 0x20(%rsp), %rdi
callq 0x20c0
leaq 0x90(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x26a2
leaq 0x40(%rsp), %rdi
callq 0x20c0
leaq 0x68(%rsp), %rdi
callq 0x20c0
leaq 0x90(%rsp), %rdi
callq 0x24f8
xorl %eax, %eax
addq $0x520, %rsp            # imm = 0x520
popq %rbx
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x2ff6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20c0
jmp 0x2ff1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20c0
jmp 0x3000
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x20c0
jmp 0x300f
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x24f8
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./Grid.hpp
// Function: Grid::Grid(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
Grid(const std::vector<std::vector<double> >& discrete_points_for_all_dims)
            : _discrete_points(discrete_points_for_all_dims)
            , _number_of_vertices(_discrete_points[0].size())
            , _steps_between_dims(discrete_points_for_all_dims.size(), 1)
            {
                assert(_discrete_points_dim_assert() 
                && "Each dimension in the Grid should contain at least 2 discrete points");
                assert(_discrete_points_dim_sort_assert()
                && "The discrete points should be sorted per each dimension");
                
                _steps_between_dims_calc(); 
                _number_of_vertices *= _steps_between_dims[0];    
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23d2
movq (%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movq %rcx, 0x18(%rbx)
movq 0x8(%r14), %rax
subq (%r14), %rax
leaq 0x20(%rbx), %r14
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x8(%rsp), %rdx
movq $0x1, (%rdx)
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq 0x242c
movq %rbx, %rdi
callq 0x2482
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
imulq (%rcx), %rax
movq %rax, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x2644
jmp 0x1aed
movq %rax, %r15
movq %rbx, %rdi
callq 0x23b0
movq %r15, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./GridsOfGroups.hpp
// Function: GridsOfGroups::GridsOfGroups(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&, std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&)
GridsOfGroups(const std::vector<std::vector<double> >& discrete_points_for_all_dims, const std::vector<std::vector<size_t> >& indices_of_groups) 
            : _max_number_of_dimensions(discrete_points_for_all_dims.size())
            {
                for (size_t i = 0; i < indices_of_groups.size(); i++) {
                    size_t group_size = indices_of_groups[i].size();
                    std::vector<std::vector<double> > temp_discrete_points(group_size);
                        
                    for (size_t j = 0; j < group_size; j++) {
                        size_t dim = indices_of_groups[i][j];
                        temp_discrete_points[j] = discrete_points_for_all_dims[dim];
                    }
                    
                    Grid grid(temp_discrete_points);
                    _grids_of_groups.push_back(grid);
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rdi, 0x8(%rsp)
movq %rax, 0x18(%rdi)
xorl %edi, %edi
leaq 0x18(%rsp), %rbx
leaq 0x30(%rsp), %r13
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rax, %rdi
jae 0x1c5e
movq %rdi, 0x10(%rsp)
imulq $0x18, %rdi, %r12
movq 0x8(%rcx,%r12), %rbp
subq (%rcx,%r12), %rbp
sarq $0x3, %rbp
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x2702
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x1c1f
movq (%r14), %rax
movq (%rax,%r12), %rax
imulq $0x18, (%rax,%rbx,8), %rsi
addq (%r15), %rsi
movq 0x18(%rsp), %rdi
addq %r13, %rdi
callq 0x2754
incq %rbx
addq $0x18, %r13
jmp 0x1bf5
leaq 0x30(%rsp), %r13
movq %r13, %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x1a66
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x281e
movq %r13, %rdi
callq 0x239a
movq %rbx, %rdi
callq 0x23b0
movq 0x10(%rsp), %rdi
incq %rdi
jmp 0x1bb1
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x239a
jmp 0x1c86
jmp 0x1c83
movq %rax, %r14
jmp 0x1c90
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x23b0
movq 0x8(%rsp), %rdi
callq 0x284a
movq %r14, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./ID.hpp
// Function: ID::operator()(std::vector<double, std::allocator<double>> const&) const
const std::vector<Pair>& operator()(const std::vector<double>& vector_to_embed) const {
            assert( _num_of_dims() == vector_to_embed.size()
            && "Number of features should be equal to number of dimensions of discrete points");
            
            std::vector<double> norms(vector_to_embed.size());
            std::vector<size_t> lower_bounds(vector_to_embed.size());
            std::vector<size_t> indices(vector_to_embed.size());
            
            _discrete_points_for_all_dims.find_simplex(vector_to_embed, norms, lower_bounds, indices);
            _embedded_vector_lambdas_calc(norms, indices);
            _embedded_vector_indices_calc(lower_bounds, indices);
            
            return _embedded_vector;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x2cf6
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2d48
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2d48
leaq 0x40(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d9a
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2e8e
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2ef0
addq $0x38, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2644
leaq 0x28(%rsp), %rdi
callq 0x2644
leaq 0x40(%rsp), %rdi
callq 0x2f82
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x1dc8
movq %rax, %rbx
jmp 0x1dd2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2644
leaq 0x28(%rsp), %rdi
callq 0x2644
leaq 0x40(%rsp), %rdi
callq 0x2f82
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./IDgroups.hpp
// Function: IDgroups::operator()(std::vector<double, std::allocator<double>> const&) const
const std::vector<Pair>& operator()(const std::vector <double>& vector_to_embed) const {
            assert( _max_number_of_dimensions == vector_to_embed.size()
            && "Number of features should be equal to number of dimensions of discrete points");
            
          	size_t shift_index = 0;
            size_t next_place_index = 0;
            
            for (size_t i = 0; i < _num_of_groups(); i++) {
                std::vector<double> temp_vector_to_embed;
                _init_temp_vector_to_embed(i, vector_to_embed, temp_vector_to_embed);
                const std::vector<Pair>& _part_results(_ids_of_groups[i](temp_vector_to_embed));
                
                _copy_part_results(_part_results, shift_index, next_place_index);
                shift_index += _number_of_vertices_of_groups[i];
            }
            
            return _embedded_vector_groups;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
andq $0x0, (%rax)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
xorl %r15d, %r15d
pushq $0x18
popq %r12
leaq 0x10(%rsp), %r13
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
cmpq %rax, %rbp
jae 0x210b
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x4560
movq 0x50(%rbx), %rdi
addq %r15, %rdi
movq %r13, %rsi
callq 0x1cea
movq %rbx, %rdi
movq %rax, %rsi
movq %rsp, %rdx
leaq 0x8(%rsp), %rcx
callq 0x45c2
movq 0x30(%rbx), %rax
movq (%rax,%rbp,8), %rax
addq %rax, (%rsp)
movq %r13, %rdi
callq 0x2f82
incq %rbp
addq $0x50, %r15
jmp 0x209c
addq $0x18, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2123
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f82
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./IDgroupsPair.hpp
// Function: IDgroupsPair::IDgroupsPair(GridsOfGroups const&, std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&)
IDgroupsPair(const GridsOfGroups& grids_of_groups, const std::vector<std::vector<size_t> >& indices_of_groups) 
            : IDgroupsBase(  indices_of_groups, 
                            _embedded_vector_size_calc(indices_of_groups), 
                            grids_of_groups.get_max_number_of_dimensions())
                            {
                                for (size_t i = 0; i < grids_of_groups.get_number_of_groups(); i++) {
                                    _ids_of_groups.push_back(grids_of_groups[i]);
                                                                        
                                    size_t number_of_vertices = grids_of_groups[i].get_num_of_vertices();
                                    number_of_vertices *= number_of_vertices;
                                    
                                    _number_of_vertices_of_groups.push_back(number_of_vertices);
                                }
                            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x4726
movq 0x18(%r15), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3e14
leaq 0x50(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
andq $0x0, 0x60(%rbx)
movq %rbx, (%rsp)
leaq 0x30(%rbx), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
xorl %ebx, %ebx
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
cqto
pushq $0x38
popq %rcx
idivq %rcx
cmpq %rax, %rbx
jae 0x21e4
addq %rbp, %rsi
movq %r13, %rdi
callq 0x1f08
movq %r14, %rdi
movq %r13, %rsi
callq 0x478e
movq %r13, %rdi
callq 0x2362
movq (%r15), %rax
movq 0x18(%rax,%rbp), %rax
imulq %rax, %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x474c
incq %rbx
addq $0x38, %rbp
jmp 0x218a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2204
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x2362
jmp 0x2207
movq %rax, %r15
movq %r14, %rdi
callq 0x476c
movq (%rsp), %rdi
callq 0x3e8c
movq %r15, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./IDgroupsPair.hpp
// Function: IDgroupsPair::operator()(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
const std::vector<Pair>& operator()(const std::vector<double>& vector_to_cmp1, const std::vector<double>& vector_to_cmp2) const {
            assert(_max_number_of_dimensions == vector_to_cmp1.size()
            && _max_number_of_dimensions == vector_to_cmp2.size()
            && "Number of features should be equal to number of dimensions of discrete points");
            
            size_t shift_index = 0;
            size_t next_place_index = 0;
            
            for (size_t i = 0; i < _num_of_groups(); i++) {
                std::vector<double> temp_vector_to_cmp1;
                std::vector<double> temp_vector_to_cmp2;
                _init_temp_vector_to_embed(i, vector_to_cmp1, temp_vector_to_cmp1);
                _init_temp_vector_to_embed(i, vector_to_cmp2, temp_vector_to_cmp2);

                const std::vector<Pair>& _part_results(_ids_of_groups[i](temp_vector_to_cmp1, temp_vector_to_cmp2));
                
                _copy_part_results(_part_results, shift_index, next_place_index);
                shift_index += _number_of_vertices_of_groups[i];
            }
            
            return _embedded_vector_groups;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
leaq 0x18(%rsp), %rax
andq $0x0, (%rax)
movq %rsi, %r13
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x40(%rsp), %rbp
leaq 0x20(%rsp), %r14
xorl %r12d, %r12d
movq 0x8(%r15), %rax
subq (%r15), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %rax, %r12
jae 0x22ff
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x4560
movq %r15, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0x4560
movq 0x50(%r15), %rdi
addq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1f54
movq %r15, %rdi
movq %rax, %rsi
leaq 0x8(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x45c2
movq 0x30(%r15), %rax
movq (%rax,%r12,8), %rax
addq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x2f82
movq %rbp, %rdi
callq 0x2f82
incq %r12
addq $0x50, %rbx
jmp 0x225a
addq $0x18, %r15
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2317
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2f82
leaq 0x40(%rsp), %rdi
callq 0x2f82
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./Grid.hpp
// Function: Grid::find_simplex(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&) const
void find_simplex(const std::vector<double>& vector_to_embed, std::vector<double>& norms, std::vector<size_t>& lower_bounds, std::vector<size_t>& indices) const {
            for (size_t i = 0; i < get_num_of_dims(); i++) {
                const std::vector<double>& current_dim(_discrete_points[i]);
                double feature_value = vector_to_embed[i];
        
                _correction_of_feature_out_of_range(feature_value, current_dim);
                size_t bound_of_feature = _find_lower_bound(current_dim, feature_value);
                lower_bounds[i] = bound_of_feature;
                
                double lower_value = current_dim[bound_of_feature];
                double upper_value = current_dim[bound_of_feature + 1];
                norms[i] = _norm_calc(lower_value, upper_value, feature_value);
                
                indices[i] = i;
            }
        
            sort(indices.begin(), indices.end(), [&](const size_t& i, const size_t& j)
            { return norms[i] < norms[j]; });
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r13
xorl %ebx, %ebx
xorl %r15d, %r15d
movq (%r13), %rbp
movq 0x8(%r13), %rax
subq %rbp, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %rax, %r15
jae 0x2e6d
movq (%r12), %rax
movsd (%rax,%r15,8), %xmm1
movsd %xmm1, (%rsp)
movq (%rbp,%rbx), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
ja 0x2e0a
movq 0x8(%rbp,%rbx), %rax
movsd -0x8(%rax), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x2e0f
movsd %xmm0, (%rsp)
addq %rbx, %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %rsp, %rdx
callq 0x3060
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx,%r15,8)
movq (%rbp), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd 0x8(%rcx,%rax,8), %xmm1
movsd (%rsp), %xmm2
subsd %xmm0, %xmm2
subsd %xmm0, %xmm1
divsd %xmm1, %xmm2
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd %xmm2, (%rax,%r15,8)
movq (%r14), %rax
movq %r15, (%rax,%r15,8)
incq %r15
addq $0x18, %rbx
jmp 0x2dc0
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq 0x8(%rsp), %rdx
callq 0x30f3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./ID.hpp
// Function: ID::_embedded_vector_lambdas_calc(std::vector<double, std::allocator<double>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) const
void _embedded_vector_lambdas_calc(const std::vector<double>& normalized_features, const std::vector<size_t>& indices_order) const {
            double sum_of_lambdas = 0;
            double current_lambda = 0;
            size_t size_of_lambdas = _embedded_vector.size();
            
            for (size_t i = 0; i < _num_of_dims(); i++) {
                current_lambda = normalized_features[indices_order[i]] - sum_of_lambdas;
                
                _embedded_vector[size_of_lambdas - i - 1]._weight = current_lambda;
                sum_of_lambdas += current_lambda;
            }
            _embedded_vector[0]._weight = 1 - sum_of_lambdas;
        }

// Assembly:
movq %rdx, %rcx
movq 0x40(%rdi), %r9
movq 0x8(%rdi), %rax
movq 0x38(%rdi), %r8
subq (%rdi), %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
movq (%rcx), %rcx
movq (%rsi), %rdx
addq $-0x8, %r9
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rsi, %rax
je 0x2edc
movq (%rcx,%rsi,8), %rdi
movsd (%rdx,%rdi,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r9)
addsd %xmm1, %xmm0
incq %rsi
addq $-0x10, %r9
jmp 0x2eb8
movsd 0x213c(%rip), %xmm1     # 0x5020
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%r8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./ID.hpp
// Function: ID::_embedded_vector_indices_calc(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) const
void _embedded_vector_indices_calc(const std::vector<size_t>& lower_bounds, const std::vector<size_t>& indices_order) const {
            size_t next_index;
            size_t prod_size_i;
            
            _embedded_vector[0]._index = _discrete_points_for_all_dims.index_calc(lower_bounds);
        
            for (size_t i = 1; i < _embedded_vector.size(); i++) {
                prod_size_i = _steps_between_dims()[indices_order[_steps_between_dims().size() - i]];
                next_index = _embedded_vector[i - 1]._index + prod_size_i;
                _embedded_vector[i]._index = next_index;    
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x35fe
movq 0x38(%r14), %rcx
movq %rax, (%rcx)
movq 0x40(%r14), %rax
subq %rcx, %rax
sarq $0x4, %rax
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rsi
subq %rdx, %rsi
movq (%rbx), %rdi
addq $0x10, %rcx
addq %rdi, %rsi
addq $-0x8, %rsi
pushq $0x1
popq %rdi
cmpq %rax, %rdi
jae 0x2f4d
movq (%rsi), %r8
movq -0x10(%rcx), %r9
addq (%rdx,%r8,8), %r9
movq %r9, (%rcx)
incq %rdi
addq $0x10, %rcx
addq $-0x8, %rsi
jmp 0x2f2d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./Grid.hpp
// Function: Grid::_correction_of_feature_out_of_range(double&, std::vector<double, std::allocator<double>> const&) const
void _correction_of_feature_out_of_range(double& feature_value, const std::vector<double>& dim_discrete_points) const {
            if (feature_value < dim_discrete_points.front())
                feature_value = dim_discrete_points.front();
            else if (feature_value > dim_discrete_points.back())
                feature_value = dim_discrete_points.back();
        }

// Assembly:
movsd (%rsi), %xmm1
movq (%rdx), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
ja 0x305a
movq 0x8(%rdx), %rax
movsd -0x8(%rax), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x305e
movsd %xmm0, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./Grid.hpp
// Function: Grid::_find_lower_bound(std::vector<double, std::allocator<double>> const&, double&) const
size_t _find_lower_bound(const std::vector<double>& dim_discrete_points, double& feature_value) const {
            _correction_of_feature_out_of_range(feature_value, dim_discrete_points);
            
            auto l_iterator = lower_bound(dim_discrete_points.cbegin(), dim_discrete_points.cend(), feature_value);
            size_t lower_bound = l_iterator - dim_discrete_points.begin();

            if ((lower_bound == (dim_discrete_points.size() - 1)) || (dim_discrete_points[lower_bound] != feature_value)) {
                lower_bound--;
            }
        
            return lower_bound;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdx, %rsi
movq %r14, %rdx
callq 0x303a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x30bf
movq %rax, %rcx
movq (%r14), %rdx
movq 0x8(%r14), %rsi
subq %rdx, %rcx
movq %rcx, %rax
sarq $0x3, %rax
subq %rdx, %rsi
sarq $0x3, %rsi
decq %rsi
cmpq %rsi, %rax
je 0x30b4
movsd (%rdx,%rcx), %xmm0
ucomisd (%rbx), %xmm0
jne 0x30b4
jnp 0x30b7
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./Grid.hpp
// Function: Grid::index_calc(std::vector<unsigned long, std::allocator<unsigned long>> const&) const
size_t index_calc(const std::vector<size_t>& lower_bounds) const {
            size_t result = 0;
            
            for (size_t i = 0; i < lower_bounds.size(); i++) {
                result += (lower_bounds[i] * _steps_between_dims[i]);
            }
            
            return result;
        }

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movq 0x20(%rdi), %rsi
xorl %eax, %eax
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x362a
movq (%rsi,%rdi,8), %r8
imulq (%rcx,%rdi,8), %r8
addq %r8, %rax
incq %rdi
jmp 0x3614
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./Grid.hpp
// Function: Grid::double_grid()
void double_grid() {
            _discrete_points.resize(2 * get_num_of_dims());
            std::copy_n(_discrete_points.begin(), get_num_of_dims()/2, _discrete_points.begin() + get_num_of_dims()/2);
            _number_of_vertices *= _number_of_vertices;
            _steps_between_dims = std::vector<size_t>(get_num_of_dims(), 1);
            _steps_between_dims_calc();
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %r14
cqto
idivq %r14
leaq (%rax,%rax), %rsi
callq 0x3702
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r14
shrq %rax
imulq $0x18, %rax, %rdx
addq %rdi, %rdx
movq %rax, %rsi
callq 0x3737
movq 0x18(%rbx), %rax
imulq %rax, %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r14
leaq 0x8(%rsp), %rdx
movq $0x1, (%rdx)
leaq 0x10(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq 0x242c
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x397e
movq %r14, %rdi
callq 0x2644
movq %rbx, %rdi
callq 0x2482
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./IDpair.hpp
// Function: IDpair::_less(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
bool _less(const std::vector<double>& vector_to_cmp1, const std::vector<double>& vector_to_cmp2) const {
            for (size_t i = 0; i < vector_to_cmp1.size(); i++) {
                if (vector_to_cmp1[i] < vector_to_cmp2[i])
                    return true;
                else if (vector_to_cmp1[i] > vector_to_cmp2[i])
                    return false;
            }
            
            return false;
        }

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
sarq $0x3, %rax
movq (%rdx), %rsi
xorl %edi, %edi
movq %rdi, %rdx
cmpq %rdx, %rax
je 0x3b62
movsd (%rcx,%rdx,8), %xmm0
movsd (%rsi,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3b5f
leaq 0x1(%rdx), %rdi
ucomisd %xmm1, %xmm0
jbe 0x3b39
xorl %edi, %edi
jmp 0x3b62
movb $0x1, %dil
cmpq %rax, %rdx
setb %al
andb %dil, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./IDpair.hpp
// Function: IDpair::_embed(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
const std::vector<Pair>& _embed(const std::vector<double>& vector_to_cmp1, const std::vector<double>& vector_to_cmp2) const {
/*            std::cout << _num_of_dims() << " " << vector_to_cmp1.size() << " " << vector_to_cmp2.size() << std::endl;
            
            for (auto i : vector_to_cmp1) {
                std::cout << i << " ";
            }
            std::cout << std::endl;
            for (auto i : vector_to_cmp2) {
                std::cout << i << " ";
            }
            std::cout << std::endl;*/
            
            assert((_num_of_dims() / 2) == vector_to_cmp1.size()
            && (_num_of_dims() / 2) == vector_to_cmp2.size()
            && "Number of features should be equal to number of dimensions of discrete points");
            
            std::vector<double> concat_vector_to_map(vector_to_cmp1);
            
            concat_vector_to_map.insert(concat_vector_to_map.end(), vector_to_cmp2.begin(), vector_to_cmp2.end());
        
            return ID::operator()(concat_vector_to_map);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x19de
movq 0x8(%r15), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x3bda
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1cea
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f82
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3bc4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f82
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O2/IDEmbedder[P]IDembedder/./IDgroupsBase.hpp
// Function: IDgroupsBase::_init_temp_vector_to_embed(unsigned long, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&) const
void _init_temp_vector_to_embed(size_t group_index,
                                   const std::vector<double>& vector_to_embed,
                                   std::vector<double>& temp_vector_to_embed) const 
                                   {
                                        const std::vector<size_t>& group(_indices_of_groups[group_index]);
                                        size_t group_size = group.size();
                                        temp_vector_to_embed.resize(group_size);
                                        
                                        for (size_t i = 0; i < group_size; i++) {
                                            size_t dim = group[i];
                                            temp_vector_to_embed[i] = vector_to_embed[dim];
                                        }
                                    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq (%rdi), %rax
imulq $0x18, %rsi, %rcx
leaq (%rax,%rcx), %r12
movq 0x8(%rax,%rcx), %rbx
subq (%rax,%rcx), %rbx
sarq $0x3, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45fe
movq (%r15), %rax
movq (%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x45b5
movq (%r12), %rsi
movq (%rsi,%rdx,8), %rsi
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
jmp 0x4599
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/utils/StringHelper.h
// Function: abcdl::utils::StringHelper::int2str[abi:cxx11](int)
std::string StringHelper::int2str(int n){
    std::stringstream ss;
    std::string s;
    ss << n;
    ss >> s;
    return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa300
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0xa770
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xa580
leaq 0x8(%rsp), %rdi
callq 0xa380
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1d0
leaq 0x8(%rsp), %rdi
callq 0xa380
movq %r14, %rdi
callq 0xa7a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/utils/StringHelper.h
// Function: abcdl::utils::StringHelper::real2str[abi:cxx11](float)
std::string StringHelper::real2str(real f){
    std::stringstream ss;
    std::string s;
    ss << f;
    ss >> s;
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa300
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x20(%rsp), %rdi
movss 0xc(%rsp), %xmm0
callq 0xa370
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xa580
leaq 0x10(%rsp), %rdi
callq 0xa380
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1d0
leaq 0x10(%rsp), %rdi
callq 0xa380
movq %r14, %rdi
callq 0xa7a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/utils/StringHelper.h
// Function: abcdl::utils::StringHelper::strtoupper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringHelper::strtoupper(std::string s){
    std::string t = s;
    int i = -1;
    while(t[i++]){
        t[i] = toupper(t[i]);
    }
    return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xa5e0
xorl %r14d, %r14d
movq (%rbx), %r15
cmpb $0x0, -0x1(%r15,%r14)
je 0xafc1
movsbl (%r15,%r14), %edi
callq 0xa810
movb %al, (%r15,%r14)
incq %r14
jmp 0xafa3
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/include/utils/StringHelper.h
// Function: abcdl::utils::StringHelper::strtolower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringHelper::strtolower(std::string s){
    std::string t = s;
    int i = -1;
    while(t[i++]){
        t[i] = tolower(t[i]);
    }
    return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xa5e0
xorl %r14d, %r14d
movq (%rbx), %r15
cmpb $0x0, -0x1(%r15,%r14)
je 0xb037
movsbl (%r15,%r14), %edi
callq 0xa660
movb %al, (%r15,%r14)
incq %r14
jmp 0xb019
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/rnn/RNN.cpp
// Function: abcdl::rnn::RNN::write_model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool RNN::write_model(const std::string& path){
    std::vector<abcdl::algebra::Mat*> models;
    models.push_back(&_U);
    models.push_back(&_W);
    models.push_back(&_V);
    return loader.write<real>(models, path, "RNNMODEL", false);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
andq $0x0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x70(%r14), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
callq 0x222f2
leaq 0xa8(%r14), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x222f2
leaq 0xe0(%r14), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x222f2
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21f28
leaq 0x1db6b(%rip), %rsi     # 0x3eca1
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xa180
addq $0x50, %r14
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0x21c44
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0xa1d0
leaq 0x50(%rsp), %rdi
callq 0x21f76
leaq 0x10(%rsp), %rdi
callq 0x21f76
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa1d0
jmp 0x2119d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x21f76
jmp 0x211b2
jmp 0x211af
jmp 0x211af
jmp 0x211af
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x21f76
movq %rbx, %rdi
callq 0xa7a0
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/rnn/RNN.cpp
// Function: abcdl::rnn::RNN::loss(abcdl::algebra::MatrixSet<float> const&, abcdl::algebra::MatrixSet<float> const&)
real RNN::loss(const abcdl::algebra::MatSet& train_seq_data,
               const abcdl::algebra::MatSet& train_seq_label){

    //L(y, o) = - (1/N)(Sum y_n*log(o_n))

    real loss_value = total_loss(train_seq_data, train_seq_label);
    size_t N = 0;
    
    size_t size = train_seq_label.size();
    for(size_t i = 0; i != size; i++){
        N += train_seq_label[i].rows();
    }

    return loss_value / N;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
callq 0x2125c
movss %xmm0, 0x4(%rsp)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x21221
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2170c
addq 0x8(%rsp), %r13
movq %r15, %rdi
callq 0x23a32
incq %r12
jmp 0x211fc
testq %r13, %r13
js 0x2122d
cvtsi2ss %r13, %xmm1
jmp 0x21243
movq %r13, %rax
shrq %rax
andl $0x1, %r13d
orq %rax, %r13
cvtsi2ss %r13, %xmm1
addss %xmm1, %xmm1
movss 0x4(%rsp), %xmm0
divss %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/src/rnn/RNN.cpp
// Function: abcdl::rnn::RNN::total_loss(abcdl::algebra::MatrixSet<float> const&, abcdl::algebra::MatrixSet<float> const&)
real RNN::total_loss(const abcdl::algebra::MatSet& train_seq_data,
                     const abcdl::algebra::MatSet& train_seq_label){

	real loss_value = 0;
    abcdl::algebra::Mat state;
    abcdl::algebra::Mat activation;
	
    size_t num_train_data = train_seq_data.size();
	for(size_t j = 0; j != num_train_data; j++){
		_layer->farward(train_seq_data[j], _U, _W, _V, state, activation);

		auto mat_label = train_seq_label[j].argmax(abcdl::algebra::Axis_type::ROW);
        size_t rows = mat_label.rows();
        for(size_t row = 0; row != rows; row++){
            loss_value -= std::log(activation.get_data(row, mat_label.get_data(row, 0)));
        }
	}

	return loss_value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsp), %rdi
callq 0x23808
leaq 0x98(%rsp), %r12
movq %r12, %rdi
callq 0x23808
movq 0x8(%rbx), %rax
movq %rbx, 0x38(%rsp)
subq (%rbx), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rax, 0x40(%rsp)
leaq 0x70(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0xa8(%r14), %rax
movq %rax, 0x20(%rsp)
movq %r14, 0x30(%rsp)
leaq 0xe0(%r14), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %r15d, %r15d
leaq 0x48(%rsp), %rbp
leaq 0xc0(%rsp), %rbx
cmpq 0x40(%rsp), %r15
je 0x213b7
movq 0x30(%rsp), %rax
movq 0x118(%rax), %r14
movq %rbp, %rdi
movq 0x38(%rsp), %rsi
movq %r15, %rdx
callq 0x2170c
movq %r12, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
leaq 0x70(%rsp), %r9
callq 0x201d8
movq %rbp, %rdi
callq 0x23a32
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x2170c
movq %rbp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2f77a
movq %rbx, %rdi
callq 0x23a32
movq 0x48(%rsp), %r13
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x213a7
movq %rbp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x217fa
movq (%rax), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x21772
movss (%rax), %xmm0
callq 0xa830
movss 0xc(%rsp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
incq %r14
jmp 0x21369
movq %rbp, %rdi
callq 0x25db4
incq %r15
jmp 0x212ea
leaq 0x98(%rsp), %rdi
callq 0x23a32
leaq 0x70(%rsp), %rdi
callq 0x23a32
movss 0xc(%rsp), %xmm0
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x21428
jmp 0x213f7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x21407
movq %rax, %rbx
jmp 0x2141b
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x23a32
jmp 0x2141b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x25db4
leaq 0x98(%rsp), %rdi
callq 0x23a32
leaq 0x70(%rsp), %rdi
callq 0x23a32
movq %rbx, %rdi
callq 0xa7a0