LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::insertJumps(Block&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ThirdIR::insertJumps(Block&b, std::string var)
{
    Line jzero;
    jzero.operation = "JZERO";
    jzero.one = var;
    jzero.two = "#"+b.blockIfFalse;
    b.lines.push_back(jzero);

    Line jump;
    jump.operation = "JUMP";
    jump.two = "#"+b.blockIfTrue;
    b.lines.push_back(jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x80(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xa0(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xc0(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x928c(%rip), %rcx      # 0x3817c
leaq 0x70(%rsp), %rdi
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4440
leaq 0x90(%rsp), %rdi
movq %r14, %rsi
callq 0x4170
leaq 0x58(%rbx), %rdx
leaq 0x963c(%rip), %rsi      # 0x3855b
leaq 0x8(%rsp), %rdi
callq 0x5474
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x4380
movq (%r14), %rdi
leaq 0x18(%rsp), %rbp
cmpq %rbp, %rdi
je 0x2ef58
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x20(%rbx), %r14
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x1f9be
leaq 0x38(%rsp), %r15
movq %rbp, -0x30(%r15)
xorl %eax, %eax
movq %rax, -0x28(%r15)
movb %al, -0x20(%r15)
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x91eb(%rip), %rcx      # 0x3818c
leaq 0x8(%rsp), %rdi
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4440
addq $0x38, %rbx
leaq 0x959b(%rip), %rsi      # 0x3855b
leaq 0xd8(%rsp), %rdi
movq %rbx, %rdx
callq 0x5474
leaq 0x48(%rsp), %rdi
leaq 0xd8(%rsp), %rbx
movq %rbx, %rsi
callq 0x4380
movq (%rbx), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x2f005
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1f9be
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f029
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f040
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
leaq 0x80(%rsp), %rbx
leaq 0xa0(%rsp), %r14
je 0x2f067
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0xb0(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f084
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x90(%rsp), %rdi
cmpq %r14, %rdi
je 0x2f0a1
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x70(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2f0bb
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f0d1
jmp 0x2f0e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbf10
jmp 0x2f0e3
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xbf10
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/External/Parser.cpp
// Function: yytnamerr(char*, char const*)
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;
      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x22, (%rsi)
jne 0x35595
xorl %eax, %eax
movq %rsi, %rdx
leaq 0x1(%rdx), %rcx
movzbl 0x1(%rdx), %edi
cmpl $0x5b, %edi
jle 0x35574
cmpl $0x5c, %edi
jne 0x35583
cmpb $0x5c, 0x2(%rdx)
jne 0x35595
addq $0x2, %rdx
movq %rdx, %rcx
jmp 0x35583
cmpl $0x22, %edi
je 0x355ba
cmpl $0x27, %edi
je 0x35595
cmpl $0x2c, %edi
je 0x35595
testq %rbx, %rbx
je 0x3558d
movb (%rcx), %dl
movb %dl, (%rbx,%rax)
incq %rax
movq %rcx, %rdx
jmp 0x35553
testq %rbx, %rbx
je 0x355ac
movq %rbx, %rdi
callq 0x42d0
subq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4140
testq %rbx, %rbx
je 0x355a5
movb $0x0, (%rbx,%rax)
jmp 0x355a5
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/train.c
// Function: main
int main(int argc, char **argv)
{
	char input_file_name[1024];
	char model_file_name[1024];
	const char *error_msg;

	parse_command_line(argc, argv, input_file_name, model_file_name);
	read_problem(input_file_name);
	error_msg = check_parameter(&prob,&param);

	if(error_msg)
	{
		fprintf(stderr,"ERROR: %s\n",error_msg);
		exit(1);
	}

	if (flag_find_parameters)
	{
		do_find_parameters();
	}
	else if(flag_cross_validation)
	{
		do_cross_validation();
	}
	else
	{
		model_=train(&prob, &param);
		if(save_model(model_file_name, model_))
		{
			fprintf(stderr,"can't save model to file %s\n",model_file_name);
			exit(1);
		}
		free_and_destroy_model(&model_);
	}
	destroy_param(&param);
	free(prob.y);
	free(prob.x);
	free(x_space);
	free(line);

	return 0;
}

// Assembly:
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
leaq 0x400(%rsp), %rbx
movq %rsp, %rcx
movq %rbx, %rdx
callq 0x2ab4
movq %rbx, %rdi
callq 0x2eca
leaq 0xf815(%rip), %rdi      # 0x12208
leaq 0xf7be(%rip), %rsi      # 0x121b8
callq 0xb134
testq %rax, %rax
jne 0x2aa4
cmpl $0x0, 0xf825(%rip)      # 0x12234
je 0x2a18
callq 0x3286
jmp 0x2a5d
cmpl $0x0, 0xf811(%rip)      # 0x12230
je 0x2a28
callq 0x336b
jmp 0x2a5d
leaq 0xf7d9(%rip), %rdi      # 0x12208
leaq 0xf782(%rip), %rsi      # 0x121b8
callq 0x5b58
movq %rax, 0xf7e6(%rip)      # 0x12228
movq %rsp, %rdi
movq %rax, %rsi
callq 0xa7ef
testl %eax, %eax
jne 0x2aac
leaq 0xf7d0(%rip), %rdi      # 0x12228
callq 0x9a97
leaq 0xf754(%rip), %rdi      # 0x121b8
callq 0xb0fb
movq 0xf7a0(%rip), %rdi      # 0x12210
callq 0x21a0
movq 0xf79c(%rip), %rdi      # 0x12218
callq 0x21a0
movq 0xf728(%rip), %rdi      # 0x121b0
callq 0x21a0
movq 0xf7bc(%rip), %rdi      # 0x12250
callq 0x21a0
xorl %eax, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
retq
movq %rax, %rdi
callq 0x2310
movq %rsp, %rdi
callq 0x2334
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/train.c
// Function: do_find_parameters()
void do_find_parameters()
{
	double start_C, start_p, best_C, best_p, best_score;
	if (flag_C_specified)
		start_C = param.C;
	else
		start_C = -1.0;
	if (flag_p_specified)
		start_p = param.p;
	else
		start_p = -1.0;

	printf("Doing parameter search with %d-fold cross validation.\n", nr_fold);
	find_parameters(&prob, &param, nr_fold, start_C, start_p, &best_C, &best_p, &best_score);
	if(param.solver_type == L2R_LR || param.solver_type == L2R_L2LOSS_SVC)
		printf("Best C = %g  CV accuracy = %g%%\n", best_C, 100.0*best_score);
	else if(param.solver_type == L2R_L2LOSS_SVR)
		printf("Best C = %g Best p = %g  CV MSE = %g\n", best_C, best_p, best_score);
}

// Assembly:
cmpl $0x0, 0xefab(%rip)      # 0x12238
movsd 0x9d83(%rip), %xmm0     # 0xd018
movaps %xmm0, %xmm1
je 0x32a2
movsd 0xef26(%rip), %xmm1     # 0x121c8
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x20(%rsp)
leaq 0xef04(%rip), %rbx      # 0x121b8
cmpl $0x0, 0xef81(%rip)      # 0x1223c
je 0x32c5
movsd 0xef23(%rip), %xmm0     # 0x121e8
movsd %xmm0, 0x18(%rsp)
movl 0xef73(%rip), %esi      # 0x12244
leaq 0x9e6f(%rip), %rdi      # 0xd147
xorl %eax, %eax
callq 0x2050
movl 0xef5f(%rip), %edx      # 0x12244
leaq 0xef1c(%rip), %rdi      # 0x12208
leaq 0x10(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rbx, %rsi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x9ad5
movl 0xeea3(%rip), %eax      # 0x121b8
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
je 0x3343
cmpl $0xb, %eax
jne 0x3365
movsd 0x10(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
leaq 0x9e65(%rip), %rdi      # 0xd19f
movb $0x3, %al
callq 0x2050
jmp 0x3365
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x9cc9(%rip), %xmm1     # 0xd020
leaq 0x9e20(%rip), %rdi      # 0xd17e
movb $0x2, %al
callq 0x2050
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/train.c
// Function: readline(_IO_FILE*)
static char* readline(FILE *input)
{
	int len;

	if(fgets(line,max_line_len,input) == NULL)
		return NULL;

	while(strrchr(line,'\n') == NULL)
	{
		max_line_len *= 2;
		line = (char *) realloc(line,max_line_len);
		len = (int) strlen(line);
		if(fgets(line+len,max_line_len-len,input) == NULL)
			break;
	}
	return line;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xecf3(%rip), %rdi      # 0x12250
movl 0xecf5(%rip), %esi      # 0x12258
movq %rbx, %rdx
callq 0x2260
testq %rax, %rax
je 0x35db
movq 0xecd9(%rip), %r14      # 0x12250
movq %r14, %rdi
movl $0xa, %esi
callq 0x2160
testq %rax, %rax
jne 0x35d2
movslq 0xecc8(%rip), %r15      # 0x12258
addq %r15, %r15
movl %r15d, 0xecbe(%rip)     # 0x12258
movq %r14, %rdi
movq %r15, %rsi
callq 0x2270
movq %rax, %r14
movq %rax, 0xeca1(%rip)      # 0x12250
movq %rax, %rdi
callq 0x20a0
cltq
addq %rax, %r14
subl %eax, %r15d
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x2260
testq %rax, %rax
jne 0x3570
movq 0xec77(%rip), %rax      # 0x12250
jmp 0x35dd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/newton.cpp
// Function: function::linesearch_and_update(double*, double*, double*, double*, double)
double function::linesearch_and_update(double *w, double *s, double *f, double *g, double alpha)
{
	double gTs = 0;
	double eta = 0.01;
	int n = get_nr_variable();
	int max_num_linesearch = 20;
	double *w_new = new double[n];
	double fold = *f;

	for (int i=0;i<n;i++)
		gTs += s[i] * g[i];

	int num_linesearch = 0;
	for(num_linesearch=0; num_linesearch < max_num_linesearch; num_linesearch++)
	{
		for (int i=0;i<n;i++)
			w_new[i] = w[i] + alpha*s[i];
		*f = fun(w_new);
		if (*f - fold <= eta * alpha * gTs)
			break;
		else
			alpha *= 0.5;
	}

	if (num_linesearch >= max_num_linesearch)
	{
		*f = fold;
		return 0;
	}
	else
		memcpy(w, w_new, sizeof(double)*n);

	delete [] w_new;
	return alpha;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x8(%rsp)
movq %r8, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x1c(%rsp)
movslq %eax, %rcx
leaq (,%rcx,8), %rax
testl %ecx, %ecx
movq %rcx, %r15
movq $-0x1, %rdi
movq %rax, 0x28(%rsp)
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r12
movq %r15, %rax
movl %eax, %r15d
xorpd %xmm3, %xmm3
testl %eax, %eax
jle 0x3663
xorl %eax, %eax
movsd (%r13,%rax,8), %xmm0
mulsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm3
incq %rax
cmpq %rax, %r15
jne 0x364b
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %ebx, %ebx
movsd 0x8(%rsp), %xmm2
movsd %xmm3, 0x30(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x36a8
xorl %eax, %eax
movsd (%r13,%rax,8), %xmm0
mulsd %xmm2, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%r12,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x3689
movq (%rbp), %rax
movq %rbp, %rdi
movq %r12, %rsi
movsd %xmm2, 0x8(%rsp)
callq *(%rax)
movsd 0x8(%rsp), %xmm2
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
subsd 0x20(%rsp), %xmm0
movapd %xmm2, %xmm1
mulsd 0xa525(%rip), %xmm1     # 0xdc00
movsd 0x30(%rsp), %xmm3
mulsd %xmm3, %xmm1
ucomisd %xmm0, %xmm1
jae 0x36ff
mulsd 0xa515(%rip), %xmm2     # 0xdc08
incl %ebx
cmpl $0x14, %ebx
jne 0x3680
movl $0x14, %ebx
cmpl $0x14, %ebx
jb 0x3718
movq 0x10(%rsp), %rax
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
jmp 0x373c
movq %r14, %rdi
movq %r12, %rsi
movq 0x28(%rsp), %rdx
movsd %xmm2, 0x8(%rsp)
callq 0x2100
movq %r12, %rdi
callq 0x21e0
movsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/newton.cpp
// Function: NEWTON::NEWTON(function const*, double, double, int)
NEWTON::NEWTON(const function *fun_obj, double eps, double eps_cg, int max_iter)
{
	this->fun_obj=const_cast<function *>(fun_obj);
	this->eps=eps;
	this->eps_cg=eps_cg;
	this->max_iter=max_iter;
	newton_print_string = default_print;
}

// Assembly:
movq %rsi, 0x18(%rdi)
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movl %edx, 0x10(%rdi)
leaq 0x5(%rip), %rax         # 0x3806
movq %rax, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_erm_fun::l2r_erm_fun(problem const*, parameter const*, double*)
l2r_erm_fun::l2r_erm_fun(const problem *prob, const parameter *param, double *C)
{
	int l=prob->l;

	this->prob = prob;

	wx = new double[l];
	tmp = new double[l];
	this->C = C;
	this->regularize_bias = param->regularize_bias;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0xdbe4(%rip), %rax      # 0x11b50
movq %rax, (%rdi)
movslq (%rsi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq %rsi, 0x10(%rdi)
movq $-0x1, %r12
cmovnsq %rcx, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, 0x18(%r15)
movq %r12, %rdi
callq 0x2030
movq %rax, 0x20(%r15)
movq %rbx, 0x8(%r15)
movl 0x48(%r14), %eax
movl %eax, 0x30(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_erm_fun::fun(double*)
double l2r_erm_fun::fun(double *w)
{
	int i;
	double f=0;
	int l=prob->l;
	int w_size=get_nr_variable();

	wTw = 0;
	Xv(w, wx);

	for(i=0;i<w_size;i++)
		wTw += w[i]*w[i];
	if(regularize_bias == 0)
		wTw -= w[w_size-1]*w[w_size-1];
	for(i=0;i<l;i++)
		f += C_times_loss(i, wx[i]);
	f = f + 0.5 * wTw;

	return f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl (%rcx), %r15d
callq *0x18(%rax)
movl %eax, %ebp
movq $0x0, 0x28(%rbx)
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40be
testl %ebp, %ebp
jle 0x4047
movsd 0x28(%rbx), %xmm0
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rbx)
incq %rcx
cmpq %rcx, %rax
jne 0x402c
cmpl $0x0, 0x30(%rbx)
jne 0x4069
movslq %ebp, %rax
movsd -0x8(%r14,%rax,8), %xmm0
movsd 0x28(%rbx), %xmm1
mulsd %xmm0, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rbx)
xorpd %xmm1, %xmm1
testl %r15d, %r15d
jle 0x40a1
xorl %r14d, %r14d
movsd %xmm1, (%rsp)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movsd (%rcx,%r14,8), %xmm0
movq %rbx, %rdi
movl %r14d, %esi
callq *0x40(%rax)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r14
cmpq %r14, %r15
jne 0x4075
movsd 0x28(%rbx), %xmm0
mulsd 0x9b5a(%rip), %xmm0     # 0xdc08
addsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_erm_fun::Xv(double*, double*)
void l2r_erm_fun::Xv(double *v, double *Xv)
{
	int i;
	int l=prob->l;
	feature_node **x=prob->x;

	for(i=0;i<l;i++)
		Xv[i]=sparse_operator::dot(v, x[i]);
}

// Assembly:
movq 0x10(%rdi), %rcx
movslq (%rcx), %rax
testq %rax, %rax
jle 0x4119
movq 0x10(%rcx), %rcx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
movl (%r8), %r9d
cmpl $-0x1, %r9d
je 0x4108
addq $0x10, %r8
xorpd %xmm0, %xmm0
movslq %r9d, %r9
movsd -0x8(%rsi,%r9,8), %xmm1
mulsd -0x8(%r8), %xmm1
addsd %xmm1, %xmm0
movl (%r8), %r9d
addq $0x10, %r8
cmpl $-0x1, %r9d
jne 0x40e5
jmp 0x410c
xorpd %xmm0, %xmm0
movsd %xmm0, (%rdx,%rdi,8)
incq %rdi
cmpq %rax, %rdi
jne 0x40d0
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_erm_fun::XTv(double*, double*)
void l2r_erm_fun::XTv(double *v, double *XTv)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		XTv[i]=0;
	for(i=0;i<l;i++)
		sparse_operator::axpy(v[i], x[i], XTv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl (%rcx), %r12d
callq *0x18(%rax)
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %r15
testl %eax, %eax
jle 0x43d6
movl %eax, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20c0
testl %r12d, %r12d
jle 0x441d
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movl (%rcx), %edx
cmpl $-0x1, %edx
je 0x4415
movsd (%r14,%rax,8), %xmm0
addq $0x10, %rcx
movslq %edx, %rdx
movsd -0x8(%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd -0x8(%rbx,%rdx,8), %xmm1
movsd %xmm1, -0x8(%rbx,%rdx,8)
movl (%rcx), %edx
addq $0x10, %rcx
cmpl $-0x1, %edx
jne 0x43f2
incq %rax
cmpq %r12, %rax
jne 0x43dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_lr_fun::C_times_loss(int, double)
double l2r_lr_fun::C_times_loss(int i, double wx_i)
{
	double ywx_i = wx_i * prob->y[i];
	if (ywx_i >= 0)
		return C[i]*log(1 + exp(-ywx_i));
	else
		return C[i]*(-ywx_i + log(1 + exp(ywx_i)));
}

// Assembly:
subq $0x28, %rsp
movapd %xmm0, %xmm1
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rcx
movslq %esi, %rdx
mulsd (%rcx,%rdx,8), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
jae 0x4513
movapd %xmm1, %xmm0
movapd %xmm1, 0x10(%rsp)
callq 0x22a0
addsd 0x9712(%rip), %xmm0     # 0xdc18
callq 0x20f0
subsd 0x10(%rsp), %xmm0
jmp 0x4531
xorpd 0x9735(%rip), %xmm1     # 0xdc50
movapd %xmm1, %xmm0
callq 0x22a0
addsd 0x96ec(%rip), %xmm0     # 0xdc18
callq 0x20f0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_lr_fun::grad(double*, double*)
void l2r_lr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	for(i=0;i<l;i++)
	{
		tmp[i] = 1/(1 + exp(-y[i]*wx[i]));
		D[i] = tmp[i]*(1-tmp[i]);
		tmp[i] = C[i]*(tmp[i]-1)*y[i];
	}
	XTv(tmp, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + g[i];
	if(regularize_bias == 0)
		g[w_size-1] -= w[w_size-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %r12
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, 0x4(%rsp)
testq %r13, %r13
jle 0x45eb
xorl %ebp, %ebp
movsd (%r12,%rbp,8), %xmm0
xorpd 0x96ce(%rip), %xmm0     # 0xdc50
movq 0x18(%r15), %rax
mulsd (%rax,%rbp,8), %xmm0
callq 0x22a0
movsd 0x9680(%rip), %xmm2     # 0xdc18
addsd %xmm2, %xmm0
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
movq 0x20(%r15), %rax
movsd %xmm1, (%rax,%rbp,8)
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movq 0x38(%r15), %rcx
movsd %xmm0, (%rcx,%rbp,8)
movq 0x8(%r15), %rcx
movsd (%rax,%rbp,8), %xmm0
addsd 0x8a45(%rip), %xmm0     # 0xd018
mulsd (%rcx,%rbp,8), %xmm0
mulsd (%r12,%rbp,8), %xmm0
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x4574
movq 0x20(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x439c
movl 0x4(%rsp), %edx
testl %edx, %edx
jle 0x461e
movl %edx, %eax
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x4606
cmpl $0x0, 0x30(%r15)
jne 0x463b
movslq %edx, %rax
movsd -0x8(%rbx,%rax,8), %xmm0
subsd -0x8(%r14,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_lr_fun::get_diag_preconditioner(double*)
void l2r_lr_fun::get_diag_preconditioner(double *M)
{
	int i;
	int l = prob->l;
	int w_size=get_nr_variable();
	feature_node **x = prob->x;

	for (i=0; i<w_size; i++)
		M[i] = 1;
	if(regularize_bias == 0)
		M[w_size-1] = 0;

	for (i=0; i<l; i++)
	{
		feature_node *xi = x[i];
		while (xi->index!=-1)
		{
			M[xi->index-1] += xi->value*xi->value*C[i]*D[i];
			xi++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl (%rcx), %r15d
callq *0x18(%rax)
movq 0x10(%r14), %rcx
movq 0x10(%rcx), %rcx
testl %eax, %eax
jle 0x4688
movl %eax, %edx
xorl %esi, %esi
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
movq %rdi, (%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x467c
cmpl $0x0, 0x30(%r14)
jne 0x469a
cltq
movq $0x0, -0x8(%rbx,%rax,8)
testl %r15d, %r15d
jle 0x46f3
movq 0x8(%r14), %rax
movq 0x38(%r14), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movl (%rdi), %r8d
cmpl $-0x1, %r8d
je 0x46eb
addq $0x10, %rdi
movsd -0x8(%rdi), %xmm0
mulsd %xmm0, %xmm0
mulsd (%rax,%rsi,8), %xmm0
movslq %r8d, %r8
mulsd (%rdx,%rsi,8), %xmm0
addsd -0x8(%rbx,%r8,8), %xmm0
movsd %xmm0, -0x8(%rbx,%r8,8)
movl (%rdi), %r8d
addq $0x10, %rdi
cmpl $-0x1, %r8d
jne 0x46ba
incq %rsi
cmpq %r15, %rsi
jne 0x46a9
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_lr_fun::Hv(double*, double*)
void l2r_lr_fun::Hv(double *s, double *Hs)
{
	int i;
	int l=prob->l;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		Hs[i] = 0;
	for(i=0;i<l;i++)
	{
		feature_node * const xi=x[i];
		double xTs = sparse_operator::dot(s, xi);

		xTs = C[i]*D[i]*xTs;

		sparse_operator::axpy(xTs, xi, Hs);
	}
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + Hs[i];
	if(regularize_bias == 0)
		Hs[w_size-1] -= s[w_size-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl (%rcx), %r13d
callq *0x18(%rax)
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %rbp
movl %eax, %r12d
testl %eax, %eax
jle 0x474a
leaq (,%r12,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, (%rsp)
movl %eax, %r15d
callq 0x20c0
movl %r15d, %eax
movq (%rsp), %r15
testl %r13d, %r13d
jle 0x47e2
movq 0x8(%r15), %r10
movq 0x38(%r15), %rcx
xorl %edx, %edx
movq (%rbp,%rdx,8), %rsi
movl (%rsi), %edi
cmpl $-0x1, %edi
je 0x4797
leaq 0x10(%rsi), %r8
xorpd %xmm0, %xmm0
movl %edi, %r9d
movslq %r9d, %r9
movsd -0x8(%r14,%r9,8), %xmm1
mulsd -0x8(%r8), %xmm1
addsd %xmm1, %xmm0
movl (%r8), %r9d
addq $0x10, %r8
cmpl $-0x1, %r9d
jne 0x4774
jmp 0x479b
xorpd %xmm0, %xmm0
cmpl $-0x1, %edi
je 0x47d6
movsd (%r10,%rdx,8), %xmm1
mulsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm0
addq $0x10, %rsi
movslq %edi, %rdi
movsd -0x8(%rsi), %xmm1
mulsd %xmm0, %xmm1
addsd -0x8(%rbx,%rdi,8), %xmm1
movsd %xmm1, -0x8(%rbx,%rdi,8)
movl (%rsi), %edi
addq $0x10, %rsi
cmpl $-0x1, %edi
jne 0x47b3
incq %rdx
cmpq %r13, %rdx
jne 0x475d
testl %eax, %eax
jle 0x4800
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x47e8
cmpl $0x0, 0x30(%r15)
jne 0x481c
cltq
movsd -0x8(%rbx,%rax,8), %xmm0
subsd -0x8(%r14,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svc_fun::C_times_loss(int, double)
double l2r_l2_svc_fun::C_times_loss(int i, double wx_i)
{
	double d = 1 - prob->y[i] * wx_i;
	if (d > 0)
		return C[i] * d * d;
	else
		return 0;
}

// Assembly:
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rcx
movslq %esi, %rax
mulsd (%rcx,%rax,8), %xmm0
movsd 0x9366(%rip), %xmm1     # 0xdc18
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x48d1
movq 0x8(%rdi), %rcx
movsd (%rcx,%rax,8), %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svc_fun::grad(double*, double*)
void l2r_l2_svc_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();

	sizeI = 0;
	for (i=0;i<l;i++)
	{
		tmp[i] = wx[i] * y[i];
		if (tmp[i] < 1)
		{
			tmp[sizeI] = C[i]*y[i]*(tmp[i]-1);
			I[sizeI] = i;
			sizeI++;
		}
	}
	subXTv(tmp, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + 2*g[i];
	if(regularize_bias == 0)
		g[w_size-1] -= w[w_size-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %r12
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, %ebp
movl $0x0, 0x40(%r15)
testq %r13, %r13
jle 0x496b
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rdx
movq 0x38(%r15), %rsi
xorl %edi, %edi
movsd 0x92f8(%rip), %xmm0     # 0xdc18
movsd 0x86f0(%rip), %xmm1     # 0xd018
movsd (%rcx,%rdi,8), %xmm2
mulsd (%r12,%rdi,8), %xmm2
movsd %xmm2, (%rdx,%rdi,8)
ucomisd %xmm2, %xmm0
jbe 0x4963
movsd (%rax,%rdi,8), %xmm3
mulsd (%r12,%rdi,8), %xmm3
addsd %xmm1, %xmm2
mulsd %xmm3, %xmm2
movslq 0x40(%r15), %r8
movsd %xmm2, (%rdx,%r8,8)
movl %edi, (%rsi,%r8,4)
incl 0x40(%r15)
incq %rdi
cmpq %rdi, %r13
jne 0x4928
movq 0x20(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x49ca
testl %ebp, %ebp
jle 0x499e
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x4982
cmpl $0x0, 0x30(%r15)
jne 0x49bb
movslq %ebp, %rax
movsd -0x8(%rbx,%rax,8), %xmm0
subsd -0x8(%r14,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svc_fun::subXTv(double*, double*)
void l2r_l2_svc_fun::subXTv(double *v, double *XTv)
{
	int i;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		XTv[i]=0;
	for(i=0;i<sizeI;i++)
		sparse_operator::axpy(v[i], x[I[i]], XTv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %r12
testl %eax, %eax
jle 0x49fd
movl %eax, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20c0
movslq 0x40(%r15), %rax
testq %rax, %rax
jle 0x4a50
movq 0x38(%r15), %rcx
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
movq (%r12,%rsi,8), %rsi
movl (%rsi), %edi
cmpl $-0x1, %edi
je 0x4a48
movsd (%r14,%rdx,8), %xmm0
addq $0x10, %rsi
movslq %edi, %rdi
movsd -0x8(%rsi), %xmm1
mulsd %xmm0, %xmm1
addsd -0x8(%rbx,%rdi,8), %xmm1
movsd %xmm1, -0x8(%rbx,%rdi,8)
movl (%rsi), %edi
addq $0x10, %rsi
cmpl $-0x1, %edi
jne 0x4a25
incq %rdx
cmpq %rax, %rdx
jne 0x4a0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svc_fun::get_diag_preconditioner(double*)
void l2r_l2_svc_fun::get_diag_preconditioner(double *M)
{
	int i;
	int w_size=get_nr_variable();
	feature_node **x = prob->x;

	for (i=0; i<w_size; i++)
		M[i] = 1;
	if(regularize_bias == 0)
		M[w_size-1] = 0;

	for (i=0; i<sizeI; i++)
	{
		int idx = I[i];
		feature_node *xi = x[idx];
		while (xi->index!=-1)
		{
			M[xi->index-1] += xi->value*xi->value*C[idx]*2;
			xi++;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%r14), %rcx
movq 0x10(%rcx), %rcx
testl %eax, %eax
jle 0x4a92
movl %eax, %edx
xorl %esi, %esi
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
movq %rdi, (%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x4a86
cmpl $0x0, 0x30(%r14)
jne 0x4aa4
cltq
movq $0x0, -0x8(%rbx,%rax,8)
movslq 0x40(%r14), %rax
testq %rax, %rax
jle 0x4b06
movq 0x8(%r14), %rdx
movq 0x38(%r14), %rsi
xorl %edi, %edi
movslq (%rsi,%rdi,4), %r8
movq (%rcx,%r8,8), %r9
movl (%r9), %r10d
cmpl $-0x1, %r10d
je 0x4afe
addq $0x10, %r9
movsd -0x8(%r9), %xmm0
mulsd %xmm0, %xmm0
mulsd (%rdx,%r8,8), %xmm0
movslq %r10d, %r10
addsd %xmm0, %xmm0
addsd -0x8(%rbx,%r10,8), %xmm0
movsd %xmm0, -0x8(%rbx,%r10,8)
movl (%r9), %r10d
addq $0x10, %r9
cmpl $-0x1, %r10d
jne 0x4acc
incq %rdi
cmpq %rax, %rdi
jne 0x4ab7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svc_fun::Hv(double*, double*)
void l2r_l2_svc_fun::Hv(double *s, double *Hs)
{
	int i;
	int w_size=get_nr_variable();
	feature_node **x=prob->x;

	for(i=0;i<w_size;i++)
		Hs[i]=0;
	for(i=0;i<sizeI;i++)
	{
		feature_node * const xi=x[I[i]];
		double xTs = sparse_operator::dot(s, xi);

		xTs = C[I[i]]*xTs;

		sparse_operator::axpy(xTs, xi, Hs);
	}
	for(i=0;i<w_size;i++)
		Hs[i] = s[i] + 2*Hs[i];
	if(regularize_bias == 0)
		Hs[w_size-1] -= s[w_size-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq 0x10(%r15), %rax
movq 0x10(%rax), %r13
movl %ebp, %r12d
testl %ebp, %ebp
jle 0x4b4b
leaq (,%r12,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20c0
movslq 0x40(%r15), %rax
testq %rax, %rax
jle 0x4be9
movq 0x8(%r15), %rcx
movq 0x38(%r15), %rdx
xorl %esi, %esi
movslq (%rdx,%rsi,4), %r9
movq (%r13,%r9,8), %rdi
movl (%rdi), %r8d
cmpl $-0x1, %r8d
je 0x4ba2
leaq 0x10(%rdi), %r10
xorpd %xmm0, %xmm0
movl %r8d, %r11d
movslq %r11d, %r11
movsd -0x8(%r14,%r11,8), %xmm1
mulsd -0x8(%r10), %xmm1
addsd %xmm1, %xmm0
movl (%r10), %r11d
addq $0x10, %r10
cmpl $-0x1, %r11d
jne 0x4b7f
jmp 0x4ba6
xorpd %xmm0, %xmm0
cmpl $-0x1, %r8d
je 0x4bdd
mulsd (%rcx,%r9,8), %xmm0
addq $0x10, %rdi
movslq %r8d, %r8
movsd -0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd -0x8(%rbx,%r8,8), %xmm1
movsd %xmm1, -0x8(%rbx,%r8,8)
movl (%rdi), %r8d
addq $0x10, %rdi
cmpl $-0x1, %r8d
jne 0x4bb6
incq %rsi
cmpq %rax, %rsi
jne 0x4b62
testl %ebp, %ebp
jle 0x4c0b
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x4bef
cmpl $0x0, 0x30(%r15)
jne 0x4c28
movslq %ebp, %rax
movsd -0x8(%rbx,%rax,8), %xmm0
subsd -0x8(%r14,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svr_fun::C_times_loss(int, double)
double l2r_l2_svr_fun::C_times_loss(int i, double wx_i)
{
	double d = wx_i - prob->y[i];
	if(d < -p)
		return C[i]*(d+p)*(d+p);
	else if(d > p)
		return C[i]*(d-p)*(d-p);
	return 0;
}

// Assembly:
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rcx
movslq %esi, %rax
subsd (%rcx,%rax,8), %xmm0
movsd 0x48(%rdi), %xmm2
movapd 0x8fc7(%rip), %xmm1     # 0xdc50
xorpd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4c9d
movq 0x8(%rdi), %rcx
addsd %xmm2, %xmm0
jmp 0x4caf
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm0
jbe 0x4cbc
movq 0x8(%rdi), %rcx
subsd %xmm2, %xmm0
movsd (%rcx,%rax,8), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: l2r_l2_svr_fun::grad(double*, double*)
void l2r_l2_svr_fun::grad(double *w, double *g)
{
	int i;
	double *y=prob->y;
	int l=prob->l;
	int w_size=get_nr_variable();
	double d;

	sizeI = 0;
	for(i=0;i<l;i++)
	{
		d = wx[i] - y[i];

		// generate index set I
		if(d < -p)
		{
			tmp[sizeI] = C[i]*(d+p);
			I[sizeI] = i;
			sizeI++;
		}
		else if(d > p)
		{
			tmp[sizeI] = C[i]*(d-p);
			I[sizeI] = i;
			sizeI++;
		}

	}
	subXTv(tmp, g);

	for(i=0;i<w_size;i++)
		g[i] = w[i] + 2*g[i];
	if(regularize_bias == 0)
		g[w_size-1] -= w[w_size-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %r12
movslq (%rcx), %r13
callq *0x18(%rax)
movl %eax, %ebp
movl $0x0, 0x40(%r15)
testq %r13, %r13
jle 0x4d5e
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rdx
movq 0x38(%r15), %rsi
xorl %edi, %edi
movapd 0x8f40(%rip), %xmm0     # 0xdc50
movsd (%rcx,%rdi,8), %xmm1
subsd (%r12,%rdi,8), %xmm1
movsd 0x48(%r15), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x4d35
addsd %xmm2, %xmm1
jmp 0x4d3f
ucomisd %xmm2, %xmm1
jbe 0x4d56
subsd %xmm2, %xmm1
mulsd (%rax,%rdi,8), %xmm1
movslq 0x40(%r15), %r8
movsd %xmm1, (%rdx,%r8,8)
movl %edi, (%rsi,%r8,4)
incl 0x40(%r15)
incq %rdi
cmpq %rdi, %r13
jne 0x4d10
movq 0x20(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x49ca
testl %ebp, %ebp
jle 0x4d91
movl %ebp, %eax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x4d75
cmpl $0x0, 0x30(%r15)
jne 0x4dae
movslq %ebp, %rax
movsd -0x8(%rbx,%rax,8), %xmm0
subsd -0x8(%r14,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: Solver_MCSVM_CS::Solver_MCSVM_CS(problem const*, int, double*, double, int)
Solver_MCSVM_CS::Solver_MCSVM_CS(const problem *prob, int nr_class, double *weighted_C, double eps, int max_iter)
{
	this->w_size = prob->n;
	this->l = prob->l;
	this->nr_class = nr_class;
	this->eps = eps;
	this->max_iter = max_iter;
	this->prob = prob;
	this->B = new double[nr_class];
	this->G = new double[nr_class];
	this->C = weighted_C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
movl %eax, 0x18(%rdi)
movl (%rsi), %eax
movl %eax, 0x1c(%rdi)
movl %edx, 0x20(%rdi)
movsd %xmm0, 0x28(%rdi)
movl %r8d, 0x24(%rdi)
movq %rsi, 0x30(%rdi)
movslq %edx, %rax
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: Solver_MCSVM_CS::solve_sub_problem(double, int, double, int, double*)
void Solver_MCSVM_CS::solve_sub_problem(double A_i, int yi, double C_yi, int active_i, double *alpha_new)
{
	int r;
	double *D;

	clone(D, B, active_i);
	if(yi < active_i)
		D[yi] += A_i*C_yi;
	qsort(D, active_i, sizeof(double), compare_double);

	double beta = D[0] - A_i*C_yi;
	for(r=1;r<active_i && beta<r*D[r];r++)
		beta += D[r];
	beta /= r;

	for(r=0;r<active_i;r++)
	{
		if(r == yi)
			alpha_new[r] = min(C_yi, (beta-B[r])/A_i);
		else
			alpha_new[r] = min((double)0, (beta - B[r])/A_i);
	}
	delete[] D;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movsd %xmm1, 0x10(%rsp)
movl %esi, %ebp
movsd %xmm0, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movq (%rdi), %r15
movl %edx, 0x4(%rsp)
movslq %edx, %r13
leaq (,%r13,8), %r12
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %r12d
callq 0x2100
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
cmpl %r13d, %ebp
jge 0x4edf
movslq %r12d, %rax
movsd (%r14,%rax,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rax,8)
movl %r13d, %r15d
leaq -0xa9(%rip), %rcx       # 0x4e40
movl $0x8, %edx
movq %r14, %rdi
movq %r13, %rsi
movsd %xmm1, 0x20(%rsp)
callq 0x22e0
movsd (%r14), %xmm0
subsd 0x20(%rsp), %xmm0
cmpl $0x2, %r13d
jl 0x4f54
movl $0x1, %eax
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
movl 0x4(%rsp), %ebp
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movsd (%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x4f4b
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %r15
jne 0x4f25
movl %r15d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
jmp 0x4f6c
movsd 0x8cbc(%rip), %xmm1     # 0xdc18
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
jle 0x4fac
divsd %xmm1, %xmm0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %r12d, %ecx
xorl %edx, %edx
movapd %xmm3, %xmm1
cmpq %rdx, %rcx
je 0x4f8e
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
subsd (%rax,%rdx,8), %xmm2
divsd %xmm4, %xmm2
minsd %xmm2, %xmm1
movsd %xmm1, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x4f81
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: Solver_MCSVM_CS::be_shrunk(int, int, int, double, double)
bool Solver_MCSVM_CS::be_shrunk(int i, int m, int yi, double alpha_i, double minG)
{
	double bound = 0;
	if(m == yi)
		bound = C[GETI(i)];
	if(alpha_i == bound && G[m] < minG)
		return true;
	return false;
}

// Assembly:
xorpd %xmm2, %xmm2
cmpl %ecx, %edx
jne 0x4fe5
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movslq %esi, %rcx
cvttsd2si (%rax,%rcx,8), %eax
movq 0x8(%rdi), %rcx
cltq
movsd (%rcx,%rax,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x4ffd
jp 0x4ffd
movq 0x10(%rdi), %rcx
movslq %edx, %rdx
movb $0x1, %al
ucomisd (%rcx,%rdx,8), %xmm1
ja 0x4fff
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: predict
double predict(const model *model_, const feature_node *x)
{
	double *dec_values = Malloc(double, model_->nr_class);
	double label=predict_values(model_, x, dec_values);
	free(dec_values);
	return label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x50(%rdi), %rdi
shlq $0x3, %rdi
callq 0x21f0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xa598
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x21a0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: free_and_destroy_model
void free_and_destroy_model(struct model **model_ptr_ptr)
{
	struct model *model_ptr = *model_ptr_ptr;
	if(model_ptr != NULL)
	{
		free_model_content(model_ptr);
		free(model_ptr);
		*model_ptr_ptr = NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x9acf
movq %rdi, %rbx
movq 0x58(%r14), %rdi
callq 0x21a0
xorl %r15d, %r15d
movq %r15, 0x58(%r14)
movq 0x60(%r14), %rdi
callq 0x21a0
movq %r15, 0x60(%r14)
movq %r14, %rdi
callq 0x21a0
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: calc_start_C(problem const*, parameter const*)
static double calc_start_C(const problem *prob, const parameter *param)
{
	int i;
	double xTx, max_xTx;
	max_xTx = 0;
	for(i=0; i<prob->l; i++)
	{
		xTx = 0;
		feature_node *xi=prob->x[i];
		while(xi->index != -1)
		{
			double val = xi->value;
			xTx += val*val;
			xi++;
		}
		if(xTx > max_xTx)
			max_xTx = xTx;
	}

	double min_C = 1.0;
	if(param->solver_type == L2R_LR)
		min_C = 1.0 / (prob->l * max_xTx);
	else if(param->solver_type == L2R_L2LOSS_SVC)
		min_C = 1.0 / (2 * prob->l * max_xTx);
	else if(param->solver_type == L2R_L2LOSS_SVR)
	{
		double sum_y, loss, y_abs;
		double delta2 = 0.1;
		sum_y = 0, loss = 0;
		for(i=0; i<prob->l; i++)
		{
			y_abs = fabs(prob->y[i]);
			sum_y += y_abs;
			loss += max(y_abs - param->p, 0.0) * max(y_abs - param->p, 0.0);
		}
		if(loss > 0)
			min_C = delta2 * delta2 * loss / (8 * sum_y * sum_y * max_xTx);
		else
			min_C = INF;
	}

	return pow( 2, floor(log(min_C) / log(2.0)) );
}

// Assembly:
pushq %rax
movslq (%rdi), %rax
testq %rax, %rax
jle 0x9fdf
movq 0x10(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movq (%rcx,%rdx,8), %r8
cmpl $-0x1, (%r8)
xorpd %xmm1, %xmm1
je 0x9fcd
addq $0x10, %r8
movsd -0x8(%r8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
cmpl $-0x1, (%r8)
leaq 0x10(%r8), %r8
jne 0x9fb5
maxsd %xmm0, %xmm1
incq %rdx
movapd %xmm1, %xmm0
cmpq %rax, %rdx
jne 0x9fa3
jmp 0x9fe3
xorpd %xmm1, %xmm1
movl (%rsi), %ecx
testl %ecx, %ecx
je 0xa06d
cmpl $0x2, %ecx
je 0xa06b
cmpl $0xb, %ecx
jne 0xa086
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
xorpd %xmm0, %xmm0
testl %eax, %eax
jle 0xa047
movq 0x8(%rdi), %rcx
movsd 0x30(%rsi), %xmm4
xorpd %xmm5, %xmm5
xorl %edx, %edx
movapd 0x3c1e(%rip), %xmm6     # 0xdc40
movsd (%rcx,%rdx,8), %xmm7
andpd %xmm6, %xmm7
addsd %xmm7, %xmm3
subsd %xmm4, %xmm7
maxsd %xmm5, %xmm7
mulsd %xmm7, %xmm7
addsd %xmm7, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xa022
ucomisd %xmm2, %xmm0
jbe 0xa090
mulsd 0x3dab(%rip), %xmm0     # 0xde00
movsd 0x3dab(%rip), %xmm2     # 0xde08
mulsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
jmp 0xa080
addl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm0, %xmm1
movsd 0x3b98(%rip), %xmm0     # 0xdc18
divsd %xmm1, %xmm0
jmp 0xa098
movsd 0x3b8a(%rip), %xmm0     # 0xdc18
jmp 0xa098
movsd 0x2f70(%rip), %xmm0     # 0xd008
callq 0x20f0
divsd 0x3d6b(%rip), %xmm0     # 0xde10
callq 0x2280
popq %rax
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: predict_values
double predict_values(const struct model *model_, const struct feature_node *x, double *dec_values)
{
	int idx;
	int n;
	if(model_->bias>=0)
		n=model_->nr_feature+1;
	else
		n=model_->nr_feature;
	double *w=model_->w;
	int nr_class=model_->nr_class;
	int i;
	int nr_w;
	if(nr_class==2 && model_->param.solver_type != MCSVM_CS)
		nr_w = 1;
	else
		nr_w = nr_class;

	const feature_node *lx=x;
	for(i=0;i<nr_w;i++)
		dec_values[i] = 0;
	for(; (idx=lx->index)!=-1; lx++)
	{
		// the dimension of testing data may exceed that of training
		if(idx<=n)
			for(i=0;i<nr_w;i++)
				dec_values[i] += w[(idx-1)*nr_w+i]*lx->value;
	}
	if(check_oneclass_model(model_))
		dec_values[0] -= model_->rho;

	if(nr_class==2)
	{
		if(check_regression_model(model_))
			return dec_values[0];
		else if(check_oneclass_model(model_))
			return (dec_values[0]>0)?1:-1;
		else
			return (dec_values[0]>0)?model_->label[0]:model_->label[1];
	}
	else
	{
		int dec_max_idx = 0;
		for(i=1;i<nr_class;i++)
		{
			if(dec_values[i] > dec_values[dec_max_idx])
				dec_max_idx = i;
		}
		return model_->label[dec_max_idx];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movsd 0x68(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0x50(%rdi), %esi
movl 0x54(%rdi), %ebp
sbbl $-0x1, %ebp
cmpq $0x2, %rsi
jne 0xa5d3
movl $0x1, %r13d
cmpl $0x4, (%rdi)
jne 0xa5d6
movl %esi, %r13d
movq 0x58(%rdi), %rbx
movl %r13d, %r12d
testl %r13d, %r13d
jle 0xa608
leaq (,%r12,8), %rdx
movq %rdi, 0x10(%rsp)
movq %r14, %rdi
movq %rsi, 0x8(%rsp)
xorl %esi, %esi
callq 0x20c0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl (%r15), %eax
cmpl $-0x1, %eax
je 0xa656
testl %r13d, %r13d
setle %cl
cmpl %ebp, %eax
setg %dl
orb %cl, %dl
jne 0xa64c
decl %eax
imull %r13d, %eax
cltq
leaq (%rbx,%rax,8), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
mulsd 0x8(%r15), %xmm0
addsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0xa62d
movl 0x10(%r15), %eax
addq $0x10, %r15
jmp 0xa60b
movl (%rdi), %eax
cmpl $0x15, %eax
jne 0xa66c
movsd (%r14), %xmm0
subsd 0x70(%rdi), %xmm0
movsd %xmm0, (%r14)
cmpl $0x2, %esi
jne 0xa69e
leal -0xb(%rax), %ecx
movsd (%r14), %xmm0
cmpl $0x3, %ecx
jb 0xa6e3
xorpd %xmm1, %xmm1
cmpl $0x15, %eax
jne 0xa6ce
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x37a9(%rip), %rcx      # 0xde40
movsd (%rcx,%rax,8), %xmm0
jmp 0xa6e3
xorl %eax, %eax
cmpl $0x2, %esi
jl 0xa6d7
movl $0x1, %ecx
movsd (%r14,%rcx,8), %xmm0
movslq %eax, %rdx
ucomisd (%r14,%rdx,8), %xmm0
movl %ecx, %edx
ja 0xa6bf
movl %eax, %edx
incq %rcx
movl %edx, %eax
cmpq %rcx, %rsi
jne 0xa6aa
movslq %edx, %rax
jmp 0xa6d7
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setbe %al
movq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax,4), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: predict_probability
double predict_probability(const struct model *model_, const struct feature_node *x, double* prob_estimates)
{
	if(check_probability_model(model_))
	{
		int i;
		int nr_class=model_->nr_class;
		int nr_w;
		if(nr_class==2)
			nr_w = 1;
		else
			nr_w = nr_class;

		double label=predict_values(model_, x, prob_estimates);
		for(i=0;i<nr_w;i++)
			prob_estimates[i]=1/(1+exp(-prob_estimates[i]));

		if(nr_class==2) // for binary classification
			prob_estimates[1]=1.-prob_estimates[0];
		else
		{
			double sum=0;
			for(i=0; i<nr_class; i++)
				sum+=prob_estimates[i];

			for(i=0; i<nr_class; i++)
				prob_estimates[i]=prob_estimates[i]/sum;
		}

		return label;
	}
	else
		return 0;
}

// Assembly:
movl (%rdi), %eax
xorpd %xmm0, %xmm0
cmpl $0x7, %eax
ja 0xa7d5
movl $0xc1, %ecx
btl %eax, %ecx
jae 0xa7d5
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl 0x50(%rdi), %r14d
cmpq $0x2, %r14
movl $0x1, %ebp
cmovnel %r14d, %ebp
callq 0xa598
movsd %xmm0, 0x8(%rsp)
testl %ebp, %ebp
jle 0xa775
movl %ebp, %r15d
xorl %r12d, %r12d
movsd (%rbx,%r12,8), %xmm0
xorpd 0x34fe(%rip), %xmm0     # 0xdc50
callq 0x22a0
movsd 0x34b9(%rip), %xmm1     # 0xdc18
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xa744
cmpl $0x2, %r14d
jne 0xa78e
movsd 0x3495(%rip), %xmm0     # 0xdc18
subsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xa7c3
xorpd %xmm0, %xmm0
testl %r14d, %r14d
jle 0xa7a6
xorl %eax, %eax
addsd (%rbx,%rax,8), %xmm0
incq %rax
cmpq %rax, %r14
jne 0xa799
testl %r14d, %r14d
jle 0xa7c3
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xa7ad
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: get_decfun_bias
double get_decfun_bias(const struct model *model_, int label_idx)
{
	if(check_oneclass_model(model_))
	{
		fprintf(stderr, "ERROR: get_decfun_bias can not be called for a one-class SVM model\n");
		return 0;
	}
	int bias_idx = model_->nr_feature;
	double bias = model_->bias;
	if(bias <= 0)
		return 0;
	else
		return bias*get_w_value(model_, bias_idx, label_idx);
}

// Assembly:
movl (%rdi), %ecx
cmpl $0x15, %ecx
je 0xb099
movsd 0x68(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0xb05c
movslq 0x54(%rdi), %rax
testq %rax, %rax
js 0xb054
movl 0x50(%rdi), %r8d
movq 0x58(%rdi), %rdx
cmpl $0x15, %ecx
ja 0xb05d
movl $0x203800, %edi         # imm = 0x203800
btl %ecx, %edi
jae 0xb05d
movsd (%rdx,%rax,8), %xmm0
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
testl %esi, %esi
setns %dil
cmpl %esi, %r8d
setg %r9b
andb %dil, %r9b
cmpb $0x1, %r9b
jne 0xb054
cmpl $0x2, %r8d
setne %dil
cmpl $0x4, %ecx
sete %cl
orb %dil, %cl
jne 0xb0a7
movsd (%rdx,%rax,8), %xmm0
testl %esi, %esi
je 0xb054
xorpd 0x2bb9(%rip), %xmm0     # 0xdc50
jmp 0xb054
pushq %rax
callq 0x2867
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
imull %eax, %r8d
addl %esi, %r8d
movsd (%rdx,%r8,8), %xmm0
jmp 0xb054
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: get_decfun_rho
double get_decfun_rho(const struct model *model_)
{
	if(check_oneclass_model(model_))
		return model_->rho;
	else
	{
		fprintf(stderr, "ERROR: get_decfun_rho can be called only for a one-class SVM model\n");
		return 0;
	}
}

// Assembly:
cmpl $0x15, (%rdi)
jne 0xb0c1
movsd 0x70(%rdi), %xmm0
retq
pushq %rax
callq 0x2883
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: free_model_content
void free_model_content(struct model *model_ptr)
{
	free(model_ptr->w);
	model_ptr->w = NULL;
	free(model_ptr->label);
	model_ptr->label = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0x21a0
xorl %r14d, %r14d
movq %r14, 0x58(%rbx)
movq 0x60(%rbx), %rdi
callq 0x21a0
movq %r14, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjlin1[P]liblinear/linear.cpp
// Function: destroy_param
void destroy_param(parameter* param)
{
	free(param->weight_label);
	param->weight_label = NULL;
	free(param->weight);
	param->weight = NULL;
	free(param->init_sol);
	param->init_sol = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x21a0
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x21a0
movq %r14, 0x28(%rbx)
movq 0x40(%rbx), %rdi
callq 0x21a0
movq %r14, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq