LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/exportDataAndIndex.cpp
// Function: exportDataFile()
int exportDataFile(){
    int id=countFiles("./dataDir/","data");
    strcpy(dateFileName,"data");
    char strId[16];
    int res=iToStr(id,strId);
    strcat(dateFileName,strId);
    char path[128];
    strcpy(path,"./dataDir/");
    strcat(path,dateFileName);
    int fd=open(path,O_WRONLY | O_APPEND | O_CREAT,0555);
    if(fd == -1){
        printf("fail to open file %s\n",path);
        return -1;
    }
    int writedBytes=write(fd,flowWaitExport,outBase*FLOWSIZE);
    if(writedBytes==-1){
        printf("write error!\n");
        return -1;
    }
    if(writedBytes<outBase*FLOWSIZE){
        printf("did not write enough data!\n");
    }
    return writedBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x29d2(%rip), %rdi      # 0x729a
leaq 0x2794(%rip), %rsi      # 0x7063
callq 0x418c
movl $0x61746164, 0x6ab0c692(%rip) # imm = 0x61746164
movb $0x0, 0x6ab0c68f(%rip)  # 0x6ab10f74
leaq 0x6ab0c684(%rip), %rbx  # 0x6ab10f70
leaq -0x20(%rbp), %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x4217
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24c0
movabsq $0x6944617461642f2e, %rax # imm = 0x6944617461642F2E
leaq -0xa0(%rbp), %r14
movq %rax, (%r14)
movl $0x2f7269, 0x7(%r14)    # imm = 0x2F7269
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24c0
movq %r14, %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x16d, %edx            # imm = 0x16D
xorl %eax, %eax
callq 0x21b0
cmpl $-0x1, %eax
je 0x4988
leaq 0x653d2b88(%rip), %r14  # 0x653d74d4
movslq (%r14), %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rdx
leaq 0xed35362(%rip), %rsi   # 0xed39cc0
movl %eax, %edi
callq 0x20d0
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x499f
movl (%r14), %eax
shll $0x4, %eax
leal (%rax,%rax,2), %eax
cmpl %ebx, %eax
jle 0x49b0
leaq 0x29bc(%rip), %rdi      # 0x733d
callq 0x2450
jmp 0x49b0
leaq 0x2916(%rip), %rdi      # 0x72a5
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
callq 0x2040
jmp 0x49ab
leaq 0x29b2(%rip), %rdi      # 0x7358
callq 0x2450
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/exportDataAndIndex.cpp
// Function: getFirstLeafNode(innerNode*)
void *getFirstLeafNode(innerNode *rootNode){
    void *pNode=rootNode;
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<256;j++){
            if(((innerNode *)pNode)->nextLevelNodes[j]){
                pNode=((innerNode *)pNode)->nextLevelNodes[j];
                break;
            } 
        }
    }
    return pNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
movq %rax, %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rax
testq %rax, %rax
jne 0x4ea7
incq %rsi
cmpq $0x100, %rsi            # imm = 0x100
jne 0x4e8f
movq %rdx, %rax
incl %ecx
cmpl $0x3, %ecx
jne 0x4e8a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/exportDataAndIndex.cpp
// Function: writeIpIndexFile(char const*)
int writeIpIndexFile(const char *path){
    int writedBytes=writeIndexFile(path,trieNodeArr,sizeof(trieNodeOffset)*trieNodeNum);
    if(writedBytes==-1){
        printf("suffer error when write ip index file!\n");
    }
    return writedBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x679f8054(%rip), %edx  # 0x679fcf10
shll $0xa, %edx
leaq 0x679f805a(%rip), %rsi  # 0x679fcf20
callq 0x4f1a
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x4ede
leaq 0x248c(%rip), %rdi      # 0x7365
callq 0x2450
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/exportDataAndIndex.cpp
// Function: writePortIndexFile(char const*)
int writePortIndexFile(const char *path){
    int writedBytes=writeIndexFile(path,portOffsetTable,65536*sizeof(int));
    if(writedBytes==-1){
        printf("suffer error when write port index file!\n");
    }
    return writedBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x6aacc07c(%rip), %rsi  # 0x6aad0f70
movl $0x40000, %edx          # imm = 0x40000
callq 0x4f1a
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x4f11
leaq 0x2480(%rip), %rdi      # 0x738c
callq 0x2450
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/exportDataAndIndex.cpp
// Function: writeIndexFile(char const*, void*, int)
int writeIndexFile(const char *path,void *ptr,int size){
    int fd=open(path,O_WRONLY | O_APPEND | O_CREAT,0555);
    if(fd == -1){
        printf("fail to open file %s\n",path);
        return -1;
    }
    int writedPointerBytes=write(fd,ptr,size);
    if(writedPointerBytes==-1){
        printf("write pointer info error!\n");
        return -1;
    }
    if(writedPointerBytes<size){
        printf("did not write enough pointer info!\n");
    }
    int writedIndexNumBytes=write(fd,compressedIndexArr,sizeof(unsigned)*indexOffset);
    if(writedIndexNumBytes==-1){
        printf("write index number error!\n");
        return -1;
    }
    if(writedIndexNumBytes<sizeof(unsigned)*indexOffset){
        printf("do not write enough index number data!\n");
    }
    return writedPointerBytes+writedIndexNumBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl $0x441, %esi            # imm = 0x441
movl $0x16d, %edx            # imm = 0x16D
xorl %eax, %eax
callq 0x21b0
cmpl $-0x1, %eax
je 0x4fb3
movl %eax, %r14d
movslq %r15d, %rdx
movl %eax, %edi
movq %r12, %rsi
callq 0x20d0
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x4fc6
cmpl %r15d, %ebx
jge 0x4f6d
leaq 0x244d(%rip), %rdi      # 0x73b5
callq 0x2450
leaq 0x679f7f8c(%rip), %r15  # 0x679fcf00
movslq (%r15), %rdx
shlq $0x2, %rdx
leaq 0x653d257e(%rip), %rsi  # 0x653d7500
movl %r14d, %edi
callq 0x20d0
movq %rax, %r14
cmpl $-0x1, %r14d
je 0x4fcf
movslq %r14d, %rax
movslq (%r15), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jae 0x4fae
leaq 0x242f(%rip), %rdi      # 0x73d8
callq 0x2450
addl %r14d, %ebx
jmp 0x4fe0
leaq 0x22eb(%rip), %rdi      # 0x72a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
jmp 0x4fdb
leaq 0x244c(%rip), %rdi      # 0x7419
jmp 0x4fd6
leaq 0x2429(%rip), %rdi      # 0x73ff
callq 0x2450
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/test.c
// Function: processFunc(void*)
void *processFunc(void *arg){
    //pthread_setcanceltype(PTHREAD_CANCEL_ASYCHRONOUS,NULL);
    //pthread_t pro,con;
    pthread_mutex_init(&mutex,0);
    pthread_cond_init(&cond_p,0);
    pthread_cond_init(&cond_c,0);
    pthread_create(&pro,0,receiveData,0);
    pthread_create(&con,0,outputFlows,0);
    pthread_join(pro,0);
    pthread_join(con,0);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_p);
    pthread_cond_destroy(&cond_c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4239(%rip), %rbx      # 0xa2c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2400
leaq 0x4250(%rip), %r14      # 0xa2e8
movq %r14, %rdi
xorl %esi, %esi
callq 0x2340
leaq 0x6ab0af6f(%rip), %r15  # 0x6ab11018
movq %r15, %rdi
xorl %esi, %esi
callq 0x2340
leaq 0x6ab3a4b6(%rip), %rdi  # 0x6ab40570
leaq -0x3592(%rip), %rdx     # 0x2b2f
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x24e0
leaq 0x6ab3a4a7(%rip), %rdi  # 0x6ab40578
leaq -0xc94(%rip), %rdx      # 0x5444
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x24e0
movq 0x6ab3a488(%rip), %rdi  # 0x6ab40570
xorl %esi, %esi
callq 0x2280
movq 0x6ab3a482(%rip), %rdi  # 0x6ab40578
xorl %esi, %esi
callq 0x2280
movq %rbx, %rdi
callq 0x2300
movq %r14, %rdi
callq 0x24f0
movq %r15, %rdi
callq 0x24f0
// File: /workspace/github_cpp_makefile_star2_O1/yueww[P]TSR/test.c
// Function: processCommand(char const*, char const*)
char *processCommand(const char *opt,const char *name){
    char *command=(char *)malloc(sizeof(char)*COMMANDSIZE);
    if(!strcmp(opt,"-i")){
       strcpy(command,"fprobe -i ");
       strcat(command,name);
       strcat(command," -B 8192 -r 2 -q 10000 localhost:555");
    }else if(!strcmp(opt,"-f")){
       strcpy(command,"cat < ");
       strcat(command,name);
       strcat(command," | fprobe -i - -B 8192 -r 2 -q 10000 -t 10000:10000000 localhost:555");
    }else{
        printf("unknown options!\n");
        free(command);
        command=NULL;
    }
    return command;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x200, %edi            # imm = 0x200
callq 0x2360
movq %rax, %rbx
leaq 0x14aa(%rip), %rsi      # 0x75e3
movq %r15, %rdi
callq 0x23c0
testl %eax, %eax
je 0x6173
leaq 0x14ca(%rip), %rsi      # 0x7616
movq %r15, %rdi
callq 0x23c0
testl %eax, %eax
je 0x61c2
leaq 0x1679(%rip), %rdi      # 0x77d8
callq 0x2450
movq %rbx, %rdi
callq 0x2330
xorl %ebx, %ebx
jmp 0x61f9
movabsq $0x2d2065626f727066, %rax # imm = 0x2D2065626F727066
movq %rax, (%rbx)
movl $0x20692d, 0x7(%rbx)    # imm = 0x20692D
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24c0
movq %rbx, %rdi
callq 0x2100
movabsq $0x3535353a74736f, %rcx # imm = 0x3535353A74736F
movq %rcx, 0x1d(%rbx,%rax)
movups 0x1441(%rip), %xmm0     # 0x75f1
movups %xmm0, (%rbx,%rax)
movups 0x1446(%rip), %xmm0     # 0x7601
movups %xmm0, 0x10(%rbx,%rax)
jmp 0x61f9
movl $0x203c20, 0x3(%rbx)    # imm = 0x203C20
movl $0x20746163, (%rbx)     # imm = 0x20746163
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24c0
movq %rbx, %rdi
callq 0x2100
movq %rbx, %rdi
addq %rax, %rdi
leaq 0x1431(%rip), %rsi      # 0x7620
movl $0x45, %edx
callq 0x2240
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::Column::l2_norm_centered() const
value_t Column::l2_norm_centered() const
  {
    if (l2_norm_centered_cache == -1.0)
    {
      value_t mean_value = this->mean();
      value_t value_sq = l2_norm_sq() - mean_value * mean_value * length;
      if (value_sq <= 0)
        l2_norm_centered_cache = 0.0;
      else
        l2_norm_centered_cache = sqrt(value_sq);
    }
    return l2_norm_centered_cache;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x20(%rdi), %xmm0
ucomisd 0x4613(%rip), %xmm0     # 0xa010
jne 0x5a72
jp 0x5a72
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movsd 0x8(%rbx), %xmm1
unpcklps 0x45fb(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x4603(%rip), %xmm1     # 0xa030
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x5a6d
ucomisd %xmm1, %xmm0
jb 0x5a64
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0x5a6d
callq 0x5230
movapd %xmm0, %xmm1
movsd %xmm1, 0x20(%rbx)
movsd 0x20(%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::SparseColumnFromPointers::inner_product(std::vector<double, std::allocator<double>> const&) const
value_t SparseColumnFromPointers::inner_product(const vector<value_t> &vec) const
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < nnz; ++ind)
    {
      index_t i = indices[ind];
      result += values[ind] * vec[i];
    }
    return result;
  }

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x5ade
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq (%rsi), %rsi
xorpd %xmm0, %xmm0
xorl %edi, %edi
movslq (%rcx,%rdi,4), %r8
movsd (%rdx,%rdi,8), %xmm1
mulsd (%rsi,%r8,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x5ac2
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::SparseColumnFromPointers::weighted_inner_product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
value_t SparseColumnFromPointers::weighted_inner_product(const std::vector<value_t> &vec, const std::vector<value_t> &weights) const
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < nnz; ++ind)
    {
      index_t i = indices[ind];
      result += values[ind] * vec[i] * weights[i];
    }
    return result;
  }

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x5b23
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdi
movq (%rsi), %rsi
movq (%rdx), %rdx
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movslq (%rcx,%r8,4), %r9
movsd (%rdi,%r8,8), %xmm1
mulsd (%rsi,%r9,8), %xmm1
mulsd (%rdx,%r9,8), %xmm1
addsd %xmm1, %xmm0
incq %r8
cmpq %r8, %rax
jne 0x5b00
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::SparseColumnFromPointers::h_norm_sq(std::vector<double, std::allocator<double>> const&) const
value_t SparseColumnFromPointers::h_norm_sq(const vector<value_t> &h_values) const
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < nnz; ++ind)
    {
      index_t i = indices[ind];
      result += values[ind] * values[ind] * h_values[i];
    }
    return result;
  }

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x5b9a
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq (%rsi), %rsi
xorpd %xmm0, %xmm0
xorl %edi, %edi
movslq (%rcx,%rdi,4), %r8
movsd (%rdx,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
mulsd (%rsi,%r8,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x5b7a
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::sum_array(double const*, unsigned long)
value_t sum_array(const value_t *values, size_t length)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < length; ++ind)
      result += values[ind];
    return result;
  }

// Assembly:
xorpd %xmm0, %xmm0
testq %rsi, %rsi
je 0x5c01
xorl %eax, %eax
addsd (%rdi,%rax,8), %xmm0
incq %rax
cmpq %rax, %rsi
jne 0x5bf4
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l2_norm_sq(double const*, unsigned long)
value_t l2_norm_sq(const value_t *values, size_t length)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < length; ++ind)
      result += values[ind] * values[ind];
    return result;
  }

// Assembly:
xorpd %xmm0, %xmm0
testq %rsi, %rsi
je 0x5c4f
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %rsi
jne 0x5c3a
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DenseColumnFromPointers::inner_product(std::vector<double, std::allocator<double>> const&) const
value_t DenseColumnFromPointers::inner_product(const vector<value_t> &vec) const
  {
    value_t result = 0.0;
    for (size_t i = 0; i < length; ++i)
      result += values[i] * vec[i];
    return result;
  }

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x5ca7
movq 0x28(%rdi), %rcx
movq (%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x5c90
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DenseColumnFromPointers::weighted_inner_product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
value_t DenseColumnFromPointers::weighted_inner_product(const std::vector<value_t> &vec, const std::vector<value_t> &weights) const
  {
    value_t result = 0.0;
    for (size_t i = 0; i < length; ++i)
      result += values[i] * vec[i] * weights[i];
    return result;
  }

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x5ce1
movq 0x28(%rdi), %rcx
movq (%rsi), %rsi
movq (%rdx), %rdx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm1
mulsd (%rsi,%rdi,8), %xmm1
mulsd (%rdx,%rdi,8), %xmm1
addsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x5cc5
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DenseColumnFromPointers::h_norm_sq(std::vector<double, std::allocator<double>> const&) const
value_t DenseColumnFromPointers::h_norm_sq(const vector<value_t> &h_values) const
  {
    value_t result = 0.0;
    for (size_t i = 0; i < length; ++i)
      result += values[i] * values[i] * h_values[i];
    return result;
  }

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x5d45
movq 0x28(%rdi), %rcx
movq (%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x5d2a
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DatasetFromCSCPointers::DatasetFromCSCPointers(int*, int*, double*, double*, unsigned long, unsigned long, unsigned long)
DatasetFromCSCPointers::DatasetFromCSCPointers(index_t *indices,
                                                 index_t *indptr,
                                                 value_t *data,
                                                 value_t *labels,
                                                 size_t n,
                                                 size_t d,
                                                 size_t nnz)
  {
    this->n = n;
    this->d = d;
    this->nnz = nnz;
    this->labels = labels;
    columns_vec.clear();
    columns_vec.reserve(d);
    for (size_t j = 0; j < this->d; ++j)
    {
      index_t offset = indptr[j];
      index_t col_nnz = (size_t)(indptr[j + 1] - offset);
      value_t *col_data = data + offset;
      index_t *col_indices = indices + offset;
      Column *col = new SparseColumnFromPointers(col_indices, col_data, col_nnz, n);
      columns_vec.push_back(col);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r9, 0x18(%rsp)
movq %r9, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x5e2a
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x5260
cmpq $0x0, 0x20(%rbx)
je 0x5ea6
xorl %r13d, %r13d
movslq (%r12,%r13,4), %r14
movslq 0x4(%r12,%r13,4), %r15
movl $0x38, %edi
callq 0x5320
movq %rax, %rbp
movq 0x8(%rsp), %rax
leaq (%rax,%r14,4), %rsi
movq 0x10(%rsp), %rax
leaq (%rax,%r14,8), %rdx
subq %r14, %r15
movq %rbp, %rdi
movq %r15, %rcx
movq 0x18(%rsp), %r8
callq 0x5270
movq %rbp, 0x20(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5e90
movq %rbp, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x5e9d
movq %rbx, %rdi
leaq 0x20(%rsp), %rdx
callq 0x5290
incq %r13
cmpq 0x20(%rbx), %r13
jb 0x5e3c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ec9
movq %rax, %r14
movl $0x38, %esi
movq %rbp, %rdi
callq 0x5330
jmp 0x5ecc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5ee0
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5330
movq %r14, %rdi
callq 0x5580
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DatasetFromFContiguousPointer::DatasetFromFContiguousPointer(double*, double*, unsigned long, unsigned long)
DatasetFromFContiguousPointer::DatasetFromFContiguousPointer(
      value_t *data, value_t *labels, size_t n, size_t d)
  {
    this->n = n;
    this->d = d;
    this->nnz = n * d;
    this->labels = labels;
    columns_vec.clear();
    columns_vec.reserve(d);
    for (size_t j = 0; j < d; ++j)
    {
      value_t *col_data = data + j * n;
      Column *col = new DenseColumnFromPointers(col_data, n);
      columns_vec.push_back(col);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r13
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r8, %rax
imulq %rcx, %rax
movq %rax, 0x28(%rdi)
movq %rdx, 0x30(%rdi)
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x5f31
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5260
testq %r14, %r14
je 0x5f8e
movq %r13, %r15
shlq $0x3, %r15
movl $0x30, %edi
callq 0x5320
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x55b0
movq %rbp, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5f7b
movq %rbp, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x5f86
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x5290
addq %r15, %r12
decq %r14
jne 0x5f48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fb1
movq %rax, %r14
movl $0x30, %esi
movq %rbp, %rdi
callq 0x5330
jmp 0x5fb4
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5fc8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x5330
movq %r14, %rdi
callq 0x5580
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l2_norm_sq(std::vector<double, std::allocator<double>> const&)
value_t l2_norm_sq(const vector<value_t> &vec)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec.size(); ++ind)
      result += vec[ind] * vec[ind];
    return result;
  }

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x6004
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x5fee
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l1_norm(double const*, unsigned long)
value_t l1_norm(const value_t *vec, size_t len)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < len; ++ind)
    {
      if (vec[ind] != 0.0)
        result += fabs(vec[ind]);
    }
    return result;
  }

// Assembly:
testq %rsi, %rsi
je 0x604e
xorpd %xmm1, %xmm1
xorl %eax, %eax
movapd 0x4035(%rip), %xmm2     # 0xa050
xorpd %xmm3, %xmm3
movsd (%rdi,%rax,8), %xmm0
movapd %xmm0, %xmm4
andpd %xmm2, %xmm4
addsd %xmm3, %xmm4
cmpneqsd %xmm1, %xmm0
andpd %xmm0, %xmm4
andnpd %xmm3, %xmm0
orpd %xmm4, %xmm0
incq %rax
movapd %xmm0, %xmm3
cmpq %rax, %rsi
jne 0x601f
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l0_norm(double const*, unsigned long)
size_t l0_norm(const value_t *values, size_t len)
  {
    index_t result = 0;
    for (size_t ind = 0; ind < len; ++ind)
    {
      if (values[ind] != 0.0)
        result++;
    }
    return result;
  }

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x607a
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rdx
subl %edx, %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x605f
movl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l2_norm_diff_sq(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
value_t l2_norm_diff_sq(const std::vector<value_t> &vec1,
                          const std::vector<value_t> &vec2)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec1.size(); ++ind)
    {
      value_t diff = vec1[ind] - vec2[ind];
      result += diff * diff;
    }
    return result;
  }

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x60b7
sarq $0x3, %rcx
movq (%rsi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rcx
jne 0x609c
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::inner_product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
value_t inner_product(const vector<value_t> &vec1,
                        const vector<value_t> &vec2)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec1.size(); ++ind)
      result += vec1[ind] * vec2[ind];
    return result;
  }

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x6154
sarq $0x3, %rcx
movq (%rsi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rcx
jne 0x613d
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::max_abs(std::vector<double, std::allocator<double>> const&)
value_t max_abs(const vector<value_t> &vec)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec.size(); ++ind)
    {
      if (fabs(vec[ind]) > result)
        result = fabs(vec[ind]);
    }
    return result;
  }

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x6198
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm2, %xmm2
xorl %edx, %edx
movapd 0x3ed2(%rip), %xmm1     # 0xa050
movsd (%rax,%rdx,8), %xmm0
andpd %xmm1, %xmm0
maxsd %xmm2, %xmm0
incq %rdx
movapd %xmm0, %xmm2
cmpq %rdx, %rcx
jne 0x617e
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::soft_threshold(double, double)
value_t soft_threshold(value_t value, value_t threshold)
  {
    if (value > threshold)
      return value - threshold;
    else if (value < -threshold)
      return value + threshold;
    else
      return 0.0;
  }

// Assembly:
ucomisd %xmm1, %xmm0
jbe 0x61a8
subsd %xmm1, %xmm0
jmp 0x61c2
movapd 0x3eb0(%rip), %xmm3     # 0xa060
xorpd %xmm1, %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm3
jbe 0x61c6
addsd %xmm1, %xmm0
movapd %xmm0, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/logger.cpp
// Function: BlitzL1::Logger::log_value(char*, double)
void Logger::log_value(char *name, value_t value)
{
  FILE *out_file;
  char file_path[256];

  snprintf(file_path, 256, "%s/%s.%d", log_directory, name, num_points_logged);

  out_file = fopen(file_path, "w");
  if (out_file == NULL)
  {
    std::cerr << "Warning: could not open log path \"" << file_path << "\"" << std::endl;
  }
  else
  {
    fprintf(out_file, "%.15f\n", value);
    fclose(out_file);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r8
movq (%rdi), %rcx
movl 0x8(%rdi), %r9d
leaq 0x3bbc(%rip), %rdx      # 0xa0f5
leaq 0x10(%rsp), %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
xorl %eax, %eax
callq 0x54d0
leaq 0x3baa(%rip), %rsi      # 0xa0fe
movq %rbx, %rdi
callq 0x53e0
testq %rax, %rax
je 0x658d
movq %rax, %rbx
leaq 0x3bb8(%rip), %rsi      # 0xa123
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x5440
movq %rbx, %rdi
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
jmp 0x5300
movq 0x6a5c(%rip), %rbx      # 0xcff0
leaq 0x3b65(%rip), %rsi      # 0xa100
movl $0x22, %edx
movq %rbx, %rdi
callq 0x53d0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5110
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x53d0
leaq 0x3b57(%rip), %rsi      # 0xa121
movl $0x1, %edx
movq %rbx, %rdi
callq 0x53d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x52d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5200
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/logger.cpp
// Function: BlitzL1::Logger::log_point(double, double)
void Logger::log_point(double elapsed_time, value_t obj)
{
  if (!strlen(log_directory))
    return;

  char time_str[] = "time";
  log_value(time_str, (value_t)elapsed_time);
  char obj_str[] = "obj";
  log_value(obj_str, obj);

  num_points_logged++;
}

// Assembly:
movq (%rdi), %rax
cmpb $0x0, (%rax)
je 0x6655
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rsi
movb $0x0, 0x4(%rsi)
movl $0x656d6974, (%rsi)     # imm = 0x656D6974
movsd %xmm1, 0x8(%rsp)
callq 0x50e0
leaq 0x14(%rsp), %rsi
movl $0x6a626f, (%rsi)       # imm = 0x6A626F
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x50e0
incl 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/loss.cpp
// Function: BlitzL1::Loss::compute_Ax(std::vector<double, std::allocator<double>>&, double const*, double, BlitzL1::Dataset const*) const
void Loss::compute_Ax(
    std::vector<value_t> &Ax,
    const value_t *x,
    value_t intercept,
    const Dataset *data) const
{

  index_t n = data->get_n();
  index_t d = data->get_d();
  Ax.assign(n, intercept);
  for (index_t j = 0; j < d; ++j)
  {
    if (x[j] != 0)
      data->get_column(j)->add_multiple(Ax, x[j]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movslq 0x18(%rcx), %rsi
movq 0x20(%rcx), %r12
movq %r15, %rdi
callq 0x55a0
testl %r12d, %r12d
jle 0x66c0
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movsd (%r14,%r13,8), %xmm0
ucomisd 0x3a8c(%rip), %xmm0     # 0xa130
jne 0x66a8
jnp 0x66b8
movq (%rbx), %rax
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
incq %r13
cmpq %r13, %r12
jne 0x6696
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::dual_obj(std::vector<double, std::allocator<double>> const&, BlitzL1::Dataset const*, double) const
value_t LogisticLoss::dual_obj(const vector<value_t> &theta,
                               const Dataset *data,
                               value_t theta_scaler) const
{
  value_t result = 0.0;
  index_t n = data->get_n();
  for (index_t i = 0; i < n; ++i)
  {
    value_t label = data->get_label(i);
    if (fabs(label) < MIN_ABS_LABEL)
    {
      result += log(2.0);
    }
    else
    {
      value_t val = theta_scaler * theta[i] / label;
      result += val * log(-val) - (1 + val) * log1p(val);
    }
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rdx), %r12
testl %r12d, %r12d
jle 0x6bf6
movq %rdx, %rbx
movq %rsi, %r14
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm0, 0x18(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x52c0
movapd %xmm0, %xmm1
andpd 0x34eb(%rip), %xmm1     # 0xa050
movsd 0x364b(%rip), %xmm2     # 0xa1b8
ucomisd %xmm1, %xmm2
movsd 0x3637(%rip), %xmm1     # 0xa1b0
ja 0x6bde
movq (%r14), %rax
movsd (%rax,%r15,8), %xmm1
mulsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movapd %xmm1, %xmm0
xorpd 0x34c0(%rip), %xmm0     # 0xa060
callq 0x5240
movsd %xmm0, 0x10(%rsp)
movapd 0x20(%rsp), %xmm0
movapd %xmm0, %xmm1
addsd 0x3603(%rip), %xmm1     # 0xa1c0
movapd %xmm1, 0x30(%rsp)
callq 0x5600
movsd 0x10(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r15
cmpq %r15, %r12
jne 0x6b48
jmp 0x6bfa
xorpd %xmm0, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::compute_dual_points(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, BlitzL1::Dataset const*) const
void LogisticLoss::compute_dual_points(
    vector<value_t> &Ax,
    vector<value_t> &theta,
    vector<value_t> &aux_dual,
    const Dataset *data) const
{

  index_t n = data->get_n();
  theta.resize(n);
  aux_dual.resize(n);
  for (index_t i = 0; i < n; ++i)
  {
    value_t minus_label = -data->get_label(i);
    aux_dual[i] = exp(minus_label * Ax[i]);
    theta[i] = minus_label * aux_dual[i] / (1.0 + aux_dual[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x18(%r8), %rbp
movslq %ebp, %r13
movq %rdx, %rdi
movq %r13, %rsi
callq 0x5340
movq %r14, %rdi
movq %r13, %rsi
callq 0x5340
testl %r13d, %r13d
jle 0x6ca9
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x52c0
movapd %xmm0, %xmm1
xorpd 0x33fe(%rip), %xmm1     # 0xa060
movapd %xmm1, (%rsp)
movq (%r12), %rax
movsd (%rax,%r13,8), %xmm0
mulsd %xmm1, %xmm0
callq 0x5590
movq (%r14), %rax
movsd %xmm0, (%rax,%r13,8)
movapd (%rsp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x352c(%rip), %xmm0     # 0xa1c0
divsd %xmm0, %xmm1
movq (%r15), %rax
movsd %xmm1, (%rax,%r13,8)
incq %r13
cmpq %r13, %rbp
jne 0x6c4b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::compute_H(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, BlitzL1::Dataset const*) const
void LogisticLoss::compute_H(vector<value_t> &H,
                             const vector<value_t> &theta,
                             const vector<value_t> &Ax,
                             const Dataset *data) const
{
  index_t n = data->get_n();
  H.resize(n);
  for (index_t i = 0; i < n; ++i)
  {
    value_t label = data->get_label(i);
    H[i] = -theta[i] * (label + theta[i]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x18(%r8), %r13
movslq %r13d, %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x5340
testl %r12d, %r12d
jle 0x6d20
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x52c0
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm1
addsd %xmm1, %xmm0
xorpd 0x3355(%rip), %xmm1     # 0xa060
mulsd %xmm0, %xmm1
movq (%r15), %rax
movsd %xmm1, (%rax,%r12,8)
incq %r12
cmpq %r12, %r13
jne 0x6ceb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::apply_intercept_update(double, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, BlitzL1::Dataset const*) const
void LogisticLoss::apply_intercept_update(
    value_t delta,
    vector<value_t> &Ax,
    vector<value_t> &theta,
    vector<value_t> &aux_dual,
    const Dataset *data) const
{
  index_t n = data->get_n();
  for (index_t i = 0; i < n; ++i)
  {
    value_t minus_label = -data->get_label(i);
    Ax[i] += delta;
    aux_dual[i] = exp(minus_label * Ax[i]);
    theta[i] = minus_label * aux_dual[i] / (1.0 + aux_dual[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq 0x18(%r8), %rbp
testl %ebp, %ebp
jle 0x6dcb
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x52c0
movapd %xmm0, %xmm1
xorpd 0x32ea(%rip), %xmm1     # 0xa060
movapd %xmm1, 0x10(%rsp)
movq (%r12), %rax
movsd (%rax,%r13,8), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%r13,8)
mulsd %xmm1, %xmm0
callq 0x5590
movq (%r14), %rax
movsd %xmm0, (%rax,%r13,8)
movapd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x340a(%rip), %xmm0     # 0xa1c0
divsd %xmm0, %xmm1
movq (%r15), %rax
movsd %xmm1, (%rax,%r13,8)
incq %r13
cmpq %r13, %rbp
jne 0x6d5f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/loss_squared.cpp
// Function: BlitzL1::SquaredLoss::dual_obj(std::vector<double, std::allocator<double>> const&, BlitzL1::Dataset const*, double) const
value_t SquaredLoss::dual_obj(const vector<value_t> &theta,
                              const Dataset *data,
                              value_t theta_scaler) const
{
  value_t dot_prod = 0;
  index_t n = data->get_n();
  for (index_t i = 0; i < n; ++i)
    dot_prod += data->get_label(i) * theta[i];
  return -0.5 * theta_scaler * theta_scaler * l2_norm_sq(theta) - theta_scaler * dot_prod;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq 0x18(%rdx), %r12
testl %r12d, %r12d
jle 0x6fe5
movq %rdx, %r14
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x52c0
movq (%rbx), %rax
mulsd (%rax,%r15,8), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r15
cmpq %r15, %r12
jne 0x6fb9
jmp 0x6fee
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd 0x3232(%rip), %xmm0     # 0xa228
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x5490
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/loss_squared.cpp
// Function: BlitzL1::SquaredLoss::compute_dual_points(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, BlitzL1::Dataset const*) const
void SquaredLoss::compute_dual_points(
    vector<value_t> &Ax,
    vector<value_t> &theta,
    vector<value_t> &aux_dual,
    const Dataset *data) const
{
  size_t n = data->get_n();
  theta.resize(n);
  for (size_t i = 0; i < n; ++i)
  {
    theta[i] = Ax[i] - data->get_label(i);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x18(%r8), %r12
movq %rdx, %rdi
movq %r12, %rsi
callq 0x5340
testq %r12, %r12
je 0x7096
xorl %r13d, %r13d
movq (%r15), %rax
movsd (%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x52c0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movq (%r14), %rax
movsd %xmm1, (%rax,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x7061
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::update_intercept(double&, BlitzL1::Loss const*, BlitzL1::Dataset const*)
value_t Solver::update_intercept(value_t &intercept,
                                   const Loss *loss_function,
                                   const Dataset *data)
  {
    // Optimizes over intercept variable with other weights fixed
    // Modifies intercept, theta, and Ax
    // Returns change in intercept value

    if (!use_intercept)
      return 0.0;

    // 1-d newton method:
    value_t intercept_old = intercept;
    vector<value_t> H;
    for (int itr = 0; itr < 10; ++itr)
    {
      value_t grad = sum_vector(theta);
      if (fabs(grad) <= 1e-14)
        break;
      loss_function->compute_H(H, theta, Ax, data);
      value_t hess = sum_vector(H);
      value_t delta = -grad / hess;
      loss_function->apply_intercept_update(
          delta, Ax, theta, aux_dual, data);
      intercept += delta;
    }

    return intercept - intercept_old;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorpd %xmm0, %xmm0
cmpb $0x1, 0xd9(%rdi)
jne 0x724b
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movsd (%rsi), %xmm0
movsd %xmm0, 0x28(%rsp)
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movapd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rdi), %rbp
leaq 0x78(%rdi), %rax
movq %rax, 0x30(%rsp)
movl $0xa, %r13d
movq %r12, %rdi
callq 0x5210
movapd %xmm0, (%rsp)
movapd (%rsp), %xmm0
andpd 0x2ea9(%rip), %xmm0     # 0xa050
movsd 0x30a1(%rip), %xmm1     # 0xa250
ucomisd %xmm0, %xmm1
jae 0x721f
movq (%r15), %rax
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %rbp, %rcx
movq %rbx, %r8
callq *0x18(%rax)
leaq 0x10(%rsp), %rdi
callq 0x5210
movapd (%rsp), %xmm1
xorpd 0x2e7d(%rip), %xmm1     # 0xa060
divsd %xmm0, %xmm1
movq (%r15), %rax
movq %r15, %rdi
movapd %xmm1, (%rsp)
movapd %xmm1, %xmm0
movq %rbp, %rsi
movq %r12, %rdx
movq 0x30(%rsp), %rcx
movq %rbx, %r8
callq *0x20(%rax)
movapd (%rsp), %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
decl %r13d
jne 0x718d
movsd (%r14), %xmm0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7245
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
movsd %xmm0, (%rsp)
callq 0x5330
movsd (%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x725e
jmp 0x725e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7278
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x5330
movq %rbx, %rdi
callq 0x5580
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::get_loss_function(char const*)
Loss *get_loss_function(const char *loss_type)
  {
    // Returns pointer to new loss object of type "loss_type"
    // Raises exception if loss type not recognized

    if (strcmp(loss_type, "logistic") == 0)
      return new LogisticLoss();
    else if (strcmp(loss_type, "squared") == 0)
      return new SquaredLoss();
    else
      throw loss_type;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3022(%rip), %rsi      # 0xa2b0
callq 0x5430
testl %eax, %eax
je 0x72c1
leaq 0x301b(%rip), %rsi      # 0xa2b9
movq %rbx, %rdi
callq 0x5430
testl %eax, %eax
jne 0x72e1
movl $0x18, %edi
callq 0x5320
movq %rax, %rbx
movq %rax, %rdi
callq 0x5390
jmp 0x72d6
movl $0x18, %edi
callq 0x5320
movq %rax, %rbx
movq %rax, %rdi
callq 0x5450
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x5160
movq %rbx, (%rax)
movq 0x5cc3(%rip), %rsi      # 0xcfb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x5540
jmp 0x7301
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x5330
movq %r14, %rdi
callq 0x5580
nop
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::compute_lambda_max(BlitzL1::Dataset const*, char const*)
value_t Solver::compute_lambda_max(const Dataset *data, const char *loss_type)
  {
    // Returns smallest lambda value for which solution is entirely 0

    // Initialize theta:
    Loss *loss_function = get_loss_function(loss_type);
    size_t n = data->get_n();
    size_t d = data->get_d();
    Ax.assign(n, 0.0);
    loss_function->compute_dual_points(Ax, theta, aux_dual, data);

    // Center theta (if using intercept term):
    value_t intercept;
    update_intercept(intercept, loss_function, data);

    // Compute loss gradient for all features:
    prioritized_features.resize(d);
    for (size_t j = 0; j < d; ++j)
      prioritized_features[j] = j;
    update_ATtheta(data);

    // Return largest magnitude in loss gradients:
    return max_abs(ATtheta);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x5090
movq %rax, %r12
movq 0x18(%r14), %rsi
movq 0x20(%r14), %r15
leaq 0x18(%rbx), %r13
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %r13, %rdi
callq 0x55a0
leaq 0x78(%rbx), %rcx
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq *0x10(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x55d0
leaq 0xa0(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x53f0
testq %r15, %r15
je 0x7433
movq (%r12), %rax
leaq 0x1(%r15), %rcx
andq $-0x2, %rcx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x2d82(%rip), %xmm1     # 0xa140
xorl %edx, %edx
movdqa 0x2d88(%rip), %xmm2     # 0xa150
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x2e98(%rip), %xmm4     # 0xa270
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x740e
movq %rdx, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x7426
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x73d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5080
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x5410
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::update_ATtheta(BlitzL1::Dataset const*)
void Solver::update_ATtheta(const Dataset *data)
  {
    // Updates values of ATtheta for all feature indices in
    // prioritized_features vector

    size_t d = data->get_d();
    ATtheta.resize(d);
    for (vector<size_t>::iterator j = prioritized_features.begin();
         j != prioritized_features.end();
         ++j)
    {
      const Column *col = data->get_column(*j);
      ATtheta[*j] = col->inner_product(theta);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rsi
addq $0x30, %rdi
callq 0x5340
movq 0xa0(%r14), %r15
cmpq 0xa8(%r14), %r15
je 0x74a4
movslq (%r15), %rax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movq (%r15), %rax
movq 0x30(%r14), %rcx
movsd %xmm0, (%rcx,%rax,8)
addq $0x8, %r15
jmp 0x7477
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::compute_alpha(BlitzL1::Dataset const*, double, double)
value_t Solver::compute_alpha(const Dataset *data, value_t lambda, value_t theta_scale)
  {
    // Returns alpha, the largest value in [0,1] such that
    // (1 - alpha) * phi + alpha * theta * theta_scale is feasible
    // Requires values of ATphi and ATtheta to be current

    value_t best_alpha = 1.0;
    for (vector<size_t>::iterator j = prioritized_features.begin();
         j != prioritized_features.end();
         ++j)
    {

      value_t norm = priority_norm_j(*j, data);
      if (norm <= 0.0)
        continue;

      value_t l = ATphi[*j];
      value_t r = theta_scale * ATtheta[*j];
      if (fabs(r) <= lambda)
        continue;

      value_t alpha;
      if (r >= 0)
        alpha = (lambda - l) / (r - l);
      else
        alpha = (-lambda - l) / (r - l);

      if (alpha < best_alpha)
        best_alpha = alpha;
    }
    return best_alpha;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x8(%rsp)
movq 0xa0(%rdi), %r15
cmpq 0xa8(%rdi), %r15
je 0x7f71
movq %rsi, %rbx
movq %rdi, %r14
movapd 0x219b(%rip), %xmm1     # 0xa060
movapd %xmm0, 0x20(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd 0x22e3(%rip), %xmm0     # 0xa1c0
movsd %xmm0, (%rsp)
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5060
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x7f5e
movq (%r15), %rax
movq 0x30(%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
mulsd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
andpd 0x2138(%rip), %xmm1     # 0xa050
movapd 0x20(%rsp), %xmm4
ucomisd %xmm1, %xmm4
jae 0x7f5e
movq 0x60(%r14), %rcx
movsd (%rcx,%rax,8), %xmm1
xorpd %xmm2, %xmm2
cmpnlesd %xmm0, %xmm2
subsd %xmm1, %xmm0
movapd %xmm2, %xmm3
andpd 0x10(%rsp), %xmm3
andnpd %xmm4, %xmm2
orpd %xmm3, %xmm2
subsd %xmm1, %xmm2
divsd %xmm0, %xmm2
minsd (%rsp), %xmm2
movsd %xmm2, (%rsp)
addq $0x8, %r15
cmpq 0xa8(%r14), %r15
jne 0x7ee2
jmp 0x7f7e
movsd 0x2247(%rip), %xmm0     # 0xa1c0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop