LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: myudelson[P]hmm-scalable/HMMProblemEloSt.cpp
// Function: HMMProblemEloSt::postPredictionSave(char const*)
void HMMProblemEloSt::postPredictionSave(const char *filename) {
    // reuse prediction file name to generat new file
    if(this->task->predictions==2) { // if we are saving the skill p-known
        // set file name
        char *fn_suffix = "__ratings.txt";
        char *fn_new = (char *) malloc(1 + strlen(filename)+ strlen(fn_suffix) );
        strcpy(fn_new, filename);
        strcat(fn_new, fn_suffix);
        // open file
        FILE *fid = fopen(fn_new,"w");
        if(fid == NULL)
        {
            fprintf(stderr,"Can't write post-prediction file %s\n",fn_new);
            exit(1);
        }
        for(NDAT t=0; t<this->task->N; t++) {
            fprintf(fid,"%12.10f\n", sigmoid(this->elo_track_t[t]) ); // write probability value, not logit
        }
        // close file
        fclose(fid);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x68(%rax), %rax
cmpl $0x2, 0x70(%rax)
jne 0x1a5c7
leaq 0x2140(%rip), %rax      # 0x1c61d
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3120
movq -0x40(%rbp), %rdi
addq %rax, %rdi
callq 0x3380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3250
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34b0
movq -0x20(%rbp), %rdi
leaq 0x1e02(%rip), %rsi      # 0x1c332
callq 0x3310
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1a566
movq 0x7a91(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x20d6(%rip), %rsi      # 0x1c62b
movb $0x0, %al
callq 0x33c0
movl $0x1, %edi
callq 0x3330
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq 0x68(%rcx), %rcx
cmpl 0x8f8(%rcx), %eax
jge 0x1a5be
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x108(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x76e0
movq -0x48(%rbp), %rdi
leaq 0x20a4(%rip), %rsi      # 0x1c650
movb $0x1, %al
callq 0x33c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a56d
movq -0x28(%rbp), %rdi
callq 0x3260
addq $0x50, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x4, -0x20(%rbp)
movl $0x5, -0x24(%rbp)
cmpl $0x5, -0xc(%rbp)
je 0x3696
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x19b0(%rip), %rsi      # 0x5011
callq 0x33b0
jmp 0x3668
movq -0x48(%rbp), %rdi
movq 0x3975(%rip), %rsi      # 0x6fe8
movq 0x395e(%rip), %rdx      # 0x6fd8
callq 0x3330
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31b0
jmp 0x36f2
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x448, %rdi            # imm = 0x448
callq 0x3280
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3280
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x20, %rdi
callq 0x3280
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x468, %rdi            # imm = 0x468
callq 0x3280
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: tscott8706[P]cpp-csv-col-replacer/src/CsvArgs.cpp
// Function: CsvArgs::~CsvArgs()
CsvArgs::~CsvArgs()
{
    if (isInputOpen)
    {
        inputFile.close();
    }
    if (isOutputOpen)
    {
        outputFile.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x488(%rax)
je 0x372e
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x3080
jmp 0x372c
jmp 0x372e
movq -0x10(%rbp), %rax
testb $0x1, 0x489(%rax)
je 0x374f
movq -0x10(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x32a0
jmp 0x374d
jmp 0x374f
movq -0x10(%rbp), %rdi
addq $0x468, %rdi            # imm = 0x468
callq 0x3160
movq -0x10(%rbp), %rdi
addq $0x448, %rdi            # imm = 0x448
callq 0x3160
movq -0x10(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0x32c0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x3090
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3160
movq -0x10(%rbp), %rdi
callq 0x3160
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3b60
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x488(%rax)
jne 0x38af
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x60(%rbp)
addq $0x448, %rdi            # imm = 0x448
callq 0x30d0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x3170
movq -0x48(%rbp), %rcx
addq $0x40, %rcx
movq %rcx, -0x58(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x50(%rbp)
je 0x3824
movq -0x58(%rbp), %rax
movq (%rax), %rcx
addq -0x18(%rcx), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3370
movq -0x68(%rbp), %rdx
leaq 0x17c0(%rip), %rsi      # 0x5004
leaq -0x28(%rbp), %rdi
callq 0x3b70
jmp 0x384f
movq -0x70(%rbp), %rsi
movq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x38d0
jmp 0x3862
leaq -0x28(%rbp), %rdi
callq 0x3160
leaq -0x29(%rbp), %rdi
callq 0x3200
movq -0x48(%rbp), %rax
movb $0x1, 0x488(%rax)
jmp 0x38af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x38a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3160
leaq -0x29(%rbp), %rdi
callq 0x3200
jmp 0x38bd
movq -0x48(%rbp), %rax
addq $0x40, %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x489(%rax)
jne 0x3acb
movq -0x50(%rbp), %rdi
movq %rdi, %rax
addq $0x248, %rax            # imm = 0x248
movq %rax, -0x68(%rbp)
addq $0x468, %rdi            # imm = 0x468
callq 0x30d0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x3040
movq -0x50(%rbp), %rcx
addq $0x248, %rcx            # imm = 0x248
movq %rcx, -0x60(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x58(%rbp)
je 0x3a40
movq -0x60(%rbp), %rax
movq (%rax), %rcx
addq -0x18(%rcx), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3370
movq -0x70(%rbp), %rdx
leaq 0x15aa(%rip), %rsi      # 0x500a
leaq -0x30(%rbp), %rdi
callq 0x3b70
jmp 0x3a6b
movq -0x78(%rbp), %rsi
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x38d0
jmp 0x3a7e
leaq -0x30(%rbp), %rdi
callq 0x3160
leaq -0x31(%rbp), %rdi
callq 0x3200
movq -0x50(%rbp), %rax
movb $0x1, 0x489(%rax)
jmp 0x3acb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3ac0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3160
leaq -0x31(%rbp), %rdi
callq 0x3200
jmp 0x3ae8
movq -0x50(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
movq -0x10(%rbp), %rsi
callq 0x31e0
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x45f0
movq -0x1d0(%rbp), %rsi
movl 0x2c(%rsi), %eax
movl %eax, -0x14(%rbp)
addq $0x8, %rsi
leaq -0x198(%rbp), %rdi
movl $0x8, %edx
callq 0x3300
leaq -0x1b8(%rbp), %rdi
callq 0x3290
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
movl $0x2c, %edx
callq 0x33a0
movq %rax, -0x1d8(%rbp)
jmp 0x4202
movq -0x1d8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3250
movb %al, -0x1d9(%rbp)
jmp 0x4220
movb -0x1d9(%rbp), %al
testb $0x1, %al
jne 0x422c
jmp 0x427d
movq -0x10(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x4a80
testb $0x1, %al
jne 0x4242
jmp 0x4268
movq -0x1d0(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x4268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x431d
movq -0x1d0(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x41e1
movq -0x1d0(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jne 0x42ed
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
leaq 0xdf1(%rip), %rsi       # 0x509b
callq 0x33b0
jmp 0x42b1
movq -0x1e8(%rbp), %rdi
movq 0x2d29(%rip), %rsi      # 0x6fe8
movq 0x2d12(%rip), %rdx      # 0x6fd8
callq 0x3330
jmp 0x4341
movq -0x1e8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x31b0
jmp 0x431d
movl -0x14(%rbp), %eax
movl %eax, -0x1ec(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x3160
leaq -0x198(%rbp), %rdi
callq 0x3120
movl -0x1ec(%rbp), %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x1b8(%rbp), %rdi
callq 0x3160
leaq -0x198(%rbp), %rdi
callq 0x3120
movq -0x1c0(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2c, %edx
callq 0x33a0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3390
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x21(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x47fe
movb $0x1, -0x95(%rbp)
movl $0x10, %edi
callq 0x3130
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rdx
leaq 0x9d5(%rip), %rsi       # 0x50dc
leaq -0x88(%rbp), %rdi
callq 0x3c70
jmp 0x4715
leaq 0x9db(%rip), %rdx       # 0x50f7
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3c20
jmp 0x472e
movq -0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4b10
jmp 0x4741
movq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3350
jmp 0x4753
movq -0xa0(%rbp), %rdi
movb $0x0, -0x95(%rbp)
movq 0x2880(%rip), %rsi      # 0x6fe8
movq 0x2869(%rip), %rdx      # 0x6fd8
callq 0x3330
jmp 0x4813
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x47e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x47d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x47d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3160
leaq -0x68(%rbp), %rdi
callq 0x3160
leaq -0x88(%rbp), %rdi
callq 0x3160
testb $0x1, -0x95(%rbp)
jne 0x47f0
jmp 0x47fc
movq -0xa0(%rbp), %rdi
callq 0x31b0
jmp 0x4807
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x550, %rsp            # imm = 0x550
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x4a0(%rbp), %rdi
movq %rdi, -0x550(%rbp)
callq 0x34f0
movq -0x550(%rbp), %rdi
callq 0x37b0
movq %rax, -0x548(%rbp)
jmp 0x4c28
movq -0x548(%rbp), %rsi
leaq -0x4d0(%rbp), %rdi
callq 0x4070
jmp 0x4c3d
leaq -0x520(%rbp), %rdi
leaq -0x4a0(%rbp), %rsi
callq 0x3b00
jmp 0x4c52
leaq -0x540(%rbp), %rdi
leaq -0x4a0(%rbp), %rsi
callq 0x3b30
jmp 0x4c67
leaq -0x500(%rbp), %rdi
leaq -0x4d0(%rbp), %rsi
leaq -0x520(%rbp), %rdx
leaq -0x540(%rbp), %rcx
callq 0x40b0
jmp 0x4c8a
leaq -0x540(%rbp), %rdi
callq 0x3160
leaq -0x520(%rbp), %rdi
callq 0x3160
leaq -0x4a0(%rbp), %rdi
leaq -0x500(%rbp), %rsi
callq 0x39c0
jmp 0x4cb7
movl $0x0, -0x4(%rbp)
leaq -0x500(%rbp), %rdi
callq 0x3160
leaq -0x4d0(%rbp), %rdi
callq 0x4da0
leaq -0x4a0(%rbp), %rdi
callq 0x3700
movl -0x4(%rbp), %eax
addq $0x550, %rsp            # imm = 0x550
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4d8(%rbp)
movl %eax, -0x4dc(%rbp)
jmp 0x4d80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4d8(%rbp)
movl %eax, -0x4dc(%rbp)
jmp 0x4d74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4d8(%rbp)
movl %eax, -0x4dc(%rbp)
jmp 0x4d48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4d8(%rbp)
movl %eax, -0x4dc(%rbp)
leaq -0x540(%rbp), %rdi
callq 0x3160
leaq -0x520(%rbp), %rdi
callq 0x3160
jmp 0x4d74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4d8(%rbp)
movl %eax, -0x4dc(%rbp)
leaq -0x500(%rbp), %rdi
callq 0x3160
leaq -0x4d0(%rbp), %rdi
callq 0x4da0
leaq -0x4a0(%rbp), %rdi
callq 0x3700
movq -0x4d8(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
callq 0x3c20
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d20
movq %rax, %rdi
callq 0x3d40
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3d60
movq %rax, 0x18(%rsp)
movq $0x1, 0x40(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2720
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x40(%rsp), %rdx
callq 0x3d80
jmp 0x2696
leaq 0x3f(%rsp), %rdi
callq 0x28d0
movq (%rsp), %rdi
callq 0x3e00
jmp 0x26ab
movq (%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3eb0
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
imulq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x28d0
jmp 0x2706
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x2870
movq 0x8(%rsp), %rdi
callq 0x3ae0
movq 0x30(%rsp), %rdi
callq 0x1130
nopw (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3d40
movq %rax, 0x38(%rsp)
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x2340
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x7260
jmp 0x2c51
leaq 0x9f(%rsp), %rdi
callq 0x23e0
movq 0xb8(%rsp), %rdi
callq 0x3d40
movq %rax, 0x20(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2720
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x72e0
jmp 0x2c95
leaq 0x6f(%rsp), %rdi
callq 0x28d0
movq 0xb8(%rsp), %rdi
callq 0x3d40
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2720
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x72e0
jmp 0x2cd6
leaq 0x4f(%rsp), %rdi
callq 0x28d0
movq 0x30(%rsp), %rdi
movq 0xb8(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x7360
jmp 0x2d06
movq 0x30(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x7530
jmp 0x2d1f
movq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x7660
jmp 0x2d35
movq 0x30(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2870
leaq 0x70(%rsp), %rdi
callq 0x2870
leaq 0xa0(%rsp), %rdi
callq 0x24f0
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x9f(%rsp), %rdi
callq 0x23e0
jmp 0x2e09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x28d0
jmp 0x2dfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x28d0
jmp 0x2df2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2870
leaq 0x70(%rsp), %rdi
callq 0x2870
leaq 0xa0(%rsp), %rdi
callq 0x24f0
movq 0x90(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xed60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x3623
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5490
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0xed70
jmp 0x3582
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
movq 0x50(%rsp), %rsi
callq 0xee30
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2bf0
movq %rax, (%rsp)
jmp 0x35a8
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0xee50
jmp 0x35cc
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x50(%rsp), %rsi
callq 0x4dd0
movq (%rax), %rax
addq 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x24f0
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x3533
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x24f0
jmp 0x3631
movq 0x18(%rsp), %rax
addq $0x18, %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1130
nopl (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rsi
callq 0xf440
movq %rax, 0x18(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xc660
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rdi
movq %rax, %rcx
callq 0xc670
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
movq %rdi, 0x28(%rsp)
callq 0xf4e0
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xc750
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x37ce
movq 0x20(%rsp), %rax
addq $0x50, %rax
movq %rax, (%rsp)
movq 0xa8(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xc790
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x3220
jmp 0x372a
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf4f0
jmp 0x373a
leaq 0x48(%rsp), %rdi
callq 0x3a00
movq 0xa8(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xc790
movq %rax, %rdi
callq 0xc7f0
movq 0x20(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
imulq %rax, %rax
movq %rax, 0x30(%rsp)
addq $0x30, %rdi
leaq 0x30(%rsp), %rsi
callq 0xf520
jmp 0x3789
jmp 0x378b
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x36ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x37d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3a00
jmp 0x37d6
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xf590
movq 0x20(%rsp), %rdi
callq 0xc860
movq 0x40(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq $0x0, 0x68(%rsp)
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xed60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x3979
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5490
leaq 0x38(%rsp), %rdi
callq 0x5490
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x68(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0xed70
jmp 0x38a3
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x80(%rsp), %rdx
leaq 0x38(%rsp), %rcx
callq 0xed70
jmp 0x38c1
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
movq 0x68(%rsp), %rsi
callq 0x10500
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x32a0
movq %rax, (%rsp)
jmp 0x38ec
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x78(%rsp), %rdx
leaq 0x70(%rsp), %rcx
callq 0xee50
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x68(%rsp), %rsi
callq 0x4dd0
movq (%rax), %rax
addq 0x78(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x24f0
leaq 0x50(%rsp), %rdi
callq 0x24f0
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x3847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x24f0
leaq 0x50(%rsp), %rdi
callq 0x24f0
jmp 0x398a
movq 0x18(%rsp), %rax
addq $0x18, %rax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x68(%rsp)
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x4cd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x74e8
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x4df0
movq %rax, 0x60(%rsp)
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x7da0
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x60(%rsp), %rdx
leaq 0x58(%rsp), %rsi
callq 0x7dc0
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x7e60
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x3eb0
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x7da0
movsd (%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
addq $0x1, %rsi
callq 0x7da0
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x48(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x58(%rsp), %xmm2
callq 0x7f40
movsd %xmm0, 0x8(%rsp)
movq 0x80(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x7f80
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x3eb0
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x739f
movq 0x70(%rsp), %rdi
callq 0x8000
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rdi
callq 0x8030
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x7fa0
addq $0x98, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
addq $0x38, %rdi
callq 0x9c60
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x6bc0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x7629
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x4dd0
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x7da0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
subsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x38, %rdi
movq 0x38(%rsp), %rsi
subq 0x30(%rsp), %rsi
subq $0x1, %rsi
callq 0x9c80
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x40(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x7576
movq 0x28(%rsp), %rdi
movsd 0xa9d2(%rip), %xmm0     # 0x12008
subsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9c80
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x68, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x58(%rsp), %rsi
callq 0x9ca0
movq 0x28(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9c80
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq $0x1, 0x38(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
callq 0x9c60
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x7786
movq 0x28(%rsp), %rdi
callq 0x9d50
movq 0x28(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x9d50
movq %rax, %rdi
callq 0x4d30
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq 0x38(%rsp), %rsi
callq 0x4dd0
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x4dd0
movq 0x28(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x40(%rsp)
addq $0x38, %rdi
movq 0x38(%rsp), %rsi
subq $0x1, %rsi
callq 0x9c80
movq 0x28(%rsp), %rdi
movq (%rax), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x38, %rdi
movq 0x38(%rsp), %rsi
callq 0x9c80
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x76af
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8060
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7e15
movq 0x10(%rsp), %rdi
callq 0x8060
movsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x7e51
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x8090
movsd (%rsp), %xmm0
ucomisd (%rax), %xmm0
jbe 0x7e4f
movq 0x10(%rsp), %rdi
callq 0x8090
movsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x7e51
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x7dc0
movq 0x38(%rsp), %rdi
callq 0x8190
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x81c0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x8130
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x5620
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x81f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x3d40
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x7f26
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7da0
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
ucomisd (%rax), %xmm0
jne 0x7f26
jp 0x7f26
jmp 0x7f34
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4d30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x9d39
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4dd0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, (%rsp)
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x4dd0
movq %rax, %rcx
movq (%rsp), %rax
imulq (%rcx), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x9cca
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4cd0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x9f50
movq 0x10(%rsp), %rdi
callq 0xa070
movq 0x10(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x4cd0
movq 0x10(%rsp), %rdi
shrq %rax
movq %rax, 0x8(%rsp)
callq 0xa070
movq 0x10(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x4cd0
movq %rax, %rsi
shrq %rsi
leaq 0x68(%rsp), %rdi
callq 0xa0a0
movq 0x8(%rsp), %rsi
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rdx
callq 0x9ff0
movq 0x10(%rsp), %rdi
movq %rax, 0x60(%rsp)
movq 0x18(%rdi), %rax
imulq %rax, %rax
movq %rax, 0x18(%rdi)
callq 0x4cd0
movq %rax, 0x18(%rsp)
movq $0x1, 0x40(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2720
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x3d80
jmp 0x9e47
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x48(%rsp), %rsi
callq 0xa0e0
leaq 0x48(%rsp), %rdi
callq 0x2870
leaq 0x3f(%rsp), %rdi
callq 0x28d0
movq 0x10(%rsp), %rdi
callq 0x3e00
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x28d0
movq 0x30(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3d40
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0xb5a2
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7da0
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7da0
movsd 0x10(%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb550
movb $0x1, 0x47(%rsp)
jmp 0xb5a7
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7da0
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7da0
movsd 0x8(%rsp), %xmm0
ucomisd (%rax), %xmm0
jbe 0xb58b
movb $0x0, 0x47(%rsp)
jmp 0xb5a7
jmp 0xb58d
jmp 0xb58f
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xb4ec
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x23f0
movq 0x10(%rsp), %rdi
callq 0x57e0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xb770
movq 0x70(%rsp), %rdi
callq 0x5620
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rdi
callq 0x5650
movq 0x10(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0xb6b0
movq %rax, 0x18(%rsp)
jmp 0xb656
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x2bf0
movq %rax, (%rsp)
jmp 0xb675
leaq 0x58(%rsp), %rdi
callq 0x24f0
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x24f0
movq 0x30(%rsp), %rdi
callq 0x1130
nopl (%rax)
// File: IDEmbedder[P]IDembedder/./IDgroups.hpp
// Function: IDgroups::_embedded_vector_size_calc(std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&) const
size_t _embedded_vector_size_calc(const std::vector<std::vector<size_t> >& indices_of_groups) const {
            size_t result = 0;

                for (const auto& group : indices_of_groups) {
                    result += (group.size() + 1);
                }

            return result;
        }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc8a0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc8d0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc900
testb $0x1, %al
jne 0xc624
jmp 0xc655
leaq 0x10(%rsp), %rdi
callq 0xc940
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x4d30
addq $0x1, %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xc950
jmp 0xc60f
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nop