LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::checkZeroJump(Block&)
bool ThirdIR::checkZeroJump(Block& b)
{
    Line lastLine = b.lines.back();
    if (_symbolTable->isConst(lastLine.one) && _symbolTable->getConstValue(lastLine.one) == "0" && !_symbolTable->isConst(lastLine.two))
    {
        return true;
    }
    if (_symbolTable->isConst(lastLine.two) && _symbolTable->getConstValue(lastLine.two) == "0" && !_symbolTable->isConst(lastLine.one))
    {
        return true;
    }    
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
addq $-0x68, %rsi
leaq 0xe8(%rsp), %rdi
callq 0x8a26
movq (%rbx), %r15
leaq 0x108(%rsp), %r14
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4390
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x10282
testb %al, %al
je 0x1d1c4
movq (%rbx), %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x4390
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r15, %rsi
callq 0x107fa
leaq 0x63f6(%rip), %rsi      # 0x23535
leaq 0x8(%rsp), %rdi
callq 0x8453
testb %al, %al
je 0x1d1b0
movq (%rbx), %r15
leaq 0x128(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
callq 0x4390
leaq 0xc8(%rsp), %rsi
movq %r15, %rdi
callq 0x10282
movl %eax, %r15d
leaq 0xc8(%rsp), %rdi
callq 0x4548
leaq 0x8(%rsp), %rdi
callq 0x4548
leaq 0x28(%rsp), %rdi
callq 0x4548
leaq 0x48(%rsp), %rdi
callq 0x4548
movb $0x1, %bpl
testb %r15b, %r15b
jne 0x1d1ce
jmp 0x1d293
leaq 0x8(%rsp), %rdi
callq 0x4548
leaq 0x28(%rsp), %rdi
callq 0x4548
leaq 0x48(%rsp), %rdi
callq 0x4548
movq (%rbx), %r12
leaq 0x128(%rsp), %r15
leaq 0xa8(%rsp), %rdi
movq %r15, %rsi
callq 0x4390
leaq 0xa8(%rsp), %rsi
movq %r12, %rdi
callq 0x10282
testb %al, %al
je 0x1d269
movq (%rbx), %r12
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
callq 0x4390
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
movq %r12, %rsi
callq 0x107fa
leaq 0x6309(%rip), %rsi      # 0x23535
leaq 0x8(%rsp), %rdi
callq 0x8453
testb %al, %al
je 0x1d26d
movq (%rbx), %rbx
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0x4390
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x10282
movl %eax, %ebp
xorb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x4548
jmp 0x1d26f
xorl %ebp, %ebp
jmp 0x1d286
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x4548
leaq 0x88(%rsp), %rdi
callq 0x4548
leaq 0xa8(%rsp), %rdi
callq 0x4548
leaq 0xe8(%rsp), %rdi
callq 0x81fe
movl %ebp, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4548
jmp 0x1d2c4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x1d2f4
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x4548
jmp 0x1d2e5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x1d308
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4548
jmp 0x1d319
jmp 0x1d316
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4548
jmp 0x1d326
jmp 0x1d323
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
jmp 0x1d32b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4548
jmp 0x1d335
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x81fe
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalizeZeroJump(Block&)
void ThirdIR::legalizeZeroJump(Block& b)
{
    Line lastLine = b.lines.back();
    b.lines.clear();

    std::string argument = lastLine.one;
    if (_symbolTable->isConst(argument))
    {
        argument = lastLine.two;
    }
    Line l;
    l.operation = "JZERO";
    l.one = argument;
    l.two = "#" + b.blockIfTrue;
    b.lines.push_back(l);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsi), %rbx
movq 0x28(%rsi), %rsi
addq $-0x68, %rsi
leaq 0x130(%rsp), %rdi
callq 0x8a26
movq %rbx, %rdi
callq 0xfbda
leaq 0x150(%rsp), %rsi
movq %rsp, %rdi
callq 0x4390
movq (%r15), %r15
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x4390
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x10282
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x4548
testb %bpl, %bpl
je 0x1d9b0
leaq 0x170(%rsp), %rsi
movq %rsp, %rdi
callq 0x4180
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0xd8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0xf8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x578a(%rip), %rsi      # 0x2317c
leaq 0xa8(%rsp), %rdi
callq 0x44e0
leaq 0xc8(%rsp), %rdi
movq %rsp, %rsi
callq 0x4180
leaq 0x38(%r14), %rdx
leaq 0x5b41(%rip), %rsi      # 0x2355b
leaq 0x40(%rsp), %rdi
callq 0x4acd
leaq 0xe8(%rsp), %rdi
leaq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0x4340
movq %r15, %rdi
callq 0x4548
leaq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x13a3e
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x56ff(%rip), %rsi      # 0x2318c
leaq 0x40(%rsp), %rdi
callq 0x44e0
addq $0x58, %r14
leaq 0x5ab9(%rip), %rsi      # 0x2355b
leaq 0x110(%rsp), %rdi
movq %r14, %rdx
callq 0x4acd
leaq 0x80(%rsp), %rdi
leaq 0x110(%rsp), %r14
movq %r14, %rsi
callq 0x4340
movq %r14, %rdi
callq 0x4548
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x13a3e
leaq 0x40(%rsp), %rdi
callq 0x81fe
leaq 0xa8(%rsp), %rdi
callq 0x81fe
movq %rsp, %rdi
callq 0x4548
leaq 0x130(%rsp), %rdi
callq 0x81fe
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1db36
jmp 0x1db45
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4548
jmp 0x1db55
movq %rax, %rbx
jmp 0x1db5d
movq %rax, %rbx
jmp 0x1db55
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x81fe
jmp 0x1db48
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x81fe
movq %rsp, %rdi
callq 0x4548
leaq 0x130(%rsp), %rdi
callq 0x81fe
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/External/Utilities.hpp
// Function: validateAndConvertData[abi:cxx11](Driver&, Data const&)
std::string validateAndConvertData(Driver& d, const Data& data)
{
    if (!data.name.empty())
    {
        checkForErrors(d.ST->checkVariableExistsAndIsInitialized(data.name));
        return data.name;
    }
    else
    {
        std::string reg = d.FIR->getVariable(std::to_string(data.value));
        d.FIR->addNewCode("CONST", reg , std::to_string(data.value));
        return reg;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdx)
je 0x1dcb3
addq $0x8, %r14
movq (%r15), %r15
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4390
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x105c4
leaq -0x50(%rbp), %rdi
callq 0x1dbe0
leaq -0x50(%rbp), %rdi
callq 0x4548
leaq -0xb0(%rbp), %rdi
callq 0x4548
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4390
jmp 0x1dd2c
movq 0x10(%r15), %r12
movq (%r14), %rsi
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0xfc06
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1af90
leaq -0x90(%rbp), %rdi
callq 0x4548
movq 0x10(%r15), %r15
leaq 0x5833(%rip), %rsi      # 0x23521
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x4a54
movq (%r14), %rsi
leaq -0x70(%rbp), %rdi
callq 0xfc06
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rcx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x12014
leaq -0x70(%rbp), %rdi
callq 0x4548
leaq -0x50(%rbp), %rdi
callq 0x4548
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x4548
jmp 0x1dd52
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4548
jmp 0x1dd60
movq %rax, %r14
movq %rbx, %rdi
jmp 0x1dd89
movq %rax, %r14
leaq -0x90(%rbp), %rdi
jmp 0x1dd89
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4548
jmp 0x1dd82
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
callq 0x4548
movq %r14, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/External/Parser.cpp
// Function: yy_symbol_print(_IO_FILE*, yysymbol_kind_t, Data const*)
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  yy_symbol_value_print (yyo, yykind, yyvaluep);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x28, %esi
leaq 0x3acd(%rip), %rax      # 0x245bf
leaq 0x3acc(%rip), %rdx      # 0x245c5
cmovlq %rax, %rdx
movq %rdi, %rbx
movslq %esi, %rax
leaq 0x10f46(%rip), %rcx     # 0x31a50
movq (%rcx,%rax,8), %rcx
leaq 0x3aa2(%rip), %rsi      # 0x245b7
xorl %eax, %eax
callq 0x43b0
pushq $0x29
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4350
// File: /workspace/github_cpp_makefile_star2_O2/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 0x211de
xorl %eax, %eax
movq %rsi, %rcx
movzbl 0x1(%rcx), %edx
cmpl $0x5c, %edx
je 0x211c7
cmpl $0x22, %edx
je 0x21203
cmpl $0x27, %edx
je 0x211de
cmpl $0x2c, %edx
je 0x211de
incq %rcx
jmp 0x211d1
cmpb $0x5c, 0x2(%rcx)
jne 0x211de
addq $0x2, %rcx
testq %rbx, %rbx
je 0x211d9
movb %dl, (%rbx,%rax)
incq %rax
jmp 0x211aa
testq %rbx, %rbx
je 0x211f5
movq %rbx, %rdi
callq 0x42b0
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 0x211ee
movb $0x0, (%rbx,%rax)
jmp 0x211ee
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2549
movq %rbx, %rdi
callq 0x2961
leaq 0xeda9(%rip), %rdi      # 0x11208
leaq 0xed52(%rip), %rsi      # 0x111b8
callq 0xa2ba
testq %rax, %rax
jne 0x2510
cmpl $0x0, 0xedb9(%rip)      # 0x11234
je 0x2484
callq 0x2cd7
jmp 0x24c9
cmpl $0x0, 0xeda5(%rip)      # 0x11230
je 0x2494
callq 0x2dbc
jmp 0x24c9
leaq 0xed6d(%rip), %rdi      # 0x11208
leaq 0xed16(%rip), %rsi      # 0x111b8
callq 0x537c
movq %rax, 0xed7a(%rip)      # 0x11228
movq %rsp, %rdi
movq %rax, %rsi
callq 0x9a1f
testl %eax, %eax
jne 0x2533
leaq 0xed64(%rip), %rdi      # 0x11228
callq 0x8da1
leaq 0xece8(%rip), %rdi      # 0x111b8
callq 0xa28a
movq 0xed34(%rip), %rdi      # 0x11210
callq 0x21a0
movq 0xed30(%rip), %rdi      # 0x11218
callq 0x21a0
movq 0xecbc(%rip), %rdi      # 0x111b0
callq 0x21a0
movq 0xed50(%rip), %rdi      # 0x11250
callq 0x21a0
xorl %eax, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
retq
movq 0xeac9(%rip), %rcx      # 0x10fe0
movq (%rcx), %rdi
leaq 0x9c26(%rip), %rsi      # 0xc147
movq %rax, %rdx
xorl %eax, %eax
callq 0x2220
pushq $0x1
popq %rdi
callq 0x21b0
movq 0xeaa6(%rip), %rax      # 0x10fe0
movq (%rax), %rdi
leaq 0x9c0e(%rip), %rsi      # 0xc152
movq %rsp, %rdx
jmp 0x2524
// File: /workspace/github_cpp_makefile_star2_O2/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, 0xe55a(%rip)      # 0x11238
movsd 0x935a(%rip), %xmm0     # 0xc040
movaps %xmm0, %xmm1
je 0x2cf3
movsd 0xe4d5(%rip), %xmm1     # 0x111c8
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x20(%rsp)
leaq 0xe4b3(%rip), %rbx      # 0x111b8
cmpl $0x0, 0xe530(%rip)      # 0x1123c
je 0x2d16
movsd 0xe4d2(%rip), %xmm0     # 0x111e8
movsd %xmm0, 0x18(%rsp)
movl 0xe522(%rip), %esi      # 0x11244
leaq 0x9446(%rip), %rdi      # 0xc16f
xorl %eax, %eax
callq 0x2050
movl 0xe50e(%rip), %edx      # 0x11244
leaq 0xe4cb(%rip), %rdi      # 0x11208
leaq 0x10(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rbx, %rsi
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8dcc
movl 0xe452(%rip), %eax      # 0x111b8
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
je 0x2d94
cmpl $0xb, %eax
jne 0x2db6
movsd 0x10(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
leaq 0x943c(%rip), %rdi      # 0xc1c7
movb $0x3, %al
callq 0x2050
jmp 0x2db6
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x92a0(%rip), %xmm1     # 0xc048
leaq 0x93f7(%rip), %rdi      # 0xc1a6
movb $0x2, %al
callq 0x2050
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe2ef(%rip), %rdi      # 0x11250
movl 0xe2f1(%rip), %esi      # 0x11258
movq %rbx, %rdx
callq 0x2260
testq %rax, %rax
je 0x2fdf
pushq $0xa
popq %rbp
movq 0xe2d2(%rip), %r14      # 0x11250
movq %r14, %rdi
movl %ebp, %esi
callq 0x2160
testq %rax, %rax
jne 0x2fe2
movslq 0xe2c4(%rip), %r15      # 0x11258
addq %r15, %r15
movl %r15d, 0xe2ba(%rip)     # 0x11258
movq %r14, %rdi
movq %r15, %rsi
callq 0x2270
movq %rax, %r14
movq %rax, 0xe29d(%rip)      # 0x11250
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 0x2f77
movq 0xe273(%rip), %r14      # 0x11250
jmp 0x2fe2
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movq %rcx, 0x20(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq (%rdi), %rax
movq %rdi, 0x30(%rsp)
callq *0x18(%rax)
movslq %eax, %rbx
leaq (,%rbx,8), %rax
xorl %r12d, %r12d
testl %ebx, %ebx
pushq $-0x1
popq %rdi
movq %rax, 0x18(%rsp)
cmovnsq %rax, %rdi
cmovlel %r12d, %ebx
callq 0x2030
movq %rax, %rbp
movq 0x20(%rsp), %rcx
movq %rcx, %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rsp)
xorpd %xmm3, %xmm3
cmpq %r12, %rbx
je 0x3076
movsd (%r15,%r12,8), %xmm0
mulsd (%r13,%r12,8), %xmm0
addsd %xmm0, %xmm3
incq %r12
jmp 0x305b
xorl %r13d, %r13d
movsd 0x8(%rsp), %xmm2
movq %rax, %r12
movsd %xmm3, 0x28(%rsp)
cmpl $0x14, %r13d
je 0x30fe
xorl %eax, %eax
cmpq %rax, %rbx
je 0x30b0
movsd (%r15,%rax,8), %xmm0
mulsd %xmm2, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbp,%rax,8)
incq %rax
jmp 0x3090
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
movsd %xmm2, 0x8(%rsp)
callq *(%rax)
movsd 0x28(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movsd %xmm0, (%r12)
subsd 0x10(%rsp), %xmm0
movapd %xmm2, %xmm1
mulsd 0x9b41(%rip), %xmm1     # 0xcc28
mulsd %xmm3, %xmm1
ucomisd %xmm0, %xmm1
jae 0x3110
mulsd 0x9b37(%rip), %xmm2     # 0xcc30
incl %r13d
jmp 0x3088
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r12)
xorpd %xmm0, %xmm0
jmp 0x312e
movq %r14, %rdi
movq %rbp, %rsi
movq 0x18(%rsp), %rdx
callq 0x20f0
movq %rbp, %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_O2/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         # 0x31f8
movq %rax, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd24c(%rip), %rax      # 0x10b50
movq %rax, (%rdi)
movslq (%rsi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq %rsi, 0x10(%rdi)
pushq $-0x1
popq %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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x28(%rbx)
movq 0x18(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a56
movsd 0x28(%rbx), %xmm0
xorl %eax, %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpq %rax, %rcx
je 0x39e0
movsd (%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rbx)
incq %rax
jmp 0x39c3
cmpl $0x0, 0x30(%rbx)
jne 0x39fd
movslq %ebp, %rax
movsd -0x8(%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rbx)
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
xorpd %xmm1, %xmm1
cmpq %r14, %r15
je 0x3a39
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movsd (%rcx,%r14,8), %xmm0
movq %rbx, %rdi
movl %r14d, %esi
movsd %xmm1, (%rsp)
callq *0x40(%rax)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r14
jmp 0x3a0b
movsd 0x28(%rbx), %xmm0
mulsd 0x91ea(%rip), %xmm0     # 0xcc30
addsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rax
movl (%rax), %r15d
movq 0x10(%rax), %r12
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0x3a96
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
callq 0xb45a
movsd %xmm0, (%rbx,%r13,8)
incq %r13
jmp 0x3a7a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
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
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x3d37
andq $0x0, (%rbx,%rcx,8)
incq %rcx
jmp 0x3d28
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x3d5d
movsd (%r14,%r13,8), %xmm0
movq (%r15,%r13,8), %rdi
movq %rbx, %rsi
callq 0xb47e
incq %r13
jmp 0x3d41
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e4b
movapd %xmm1, %xmm0
movapd %xmm1, 0x10(%rsp)
callq 0x22a0
addsd 0x8e02(%rip), %xmm0     # 0xcc40
callq 0x20e0
subsd 0x10(%rsp), %xmm0
jmp 0x3e69
xorpd 0x8e2d(%rip), %xmm1     # 0xcc80
movapd %xmm1, %xmm0
callq 0x22a0
addsd 0x8ddc(%rip), %xmm0     # 0xcc40
callq 0x20e0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl (%rcx), %r13d
callq *0x18(%rax)
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
movl %eax, 0x4(%rsp)
cmpq %rbp, %r13
je 0x3f27
movsd (%r12,%rbp,8), %xmm0
xorpd 0x8dbf(%rip), %xmm0     # 0xcc80
movq 0x18(%r15), %rax
mulsd (%rax,%rbp,8), %xmm0
callq 0x22a0
movsd 0x8d69(%rip), %xmm2     # 0xcc40
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 0x812e(%rip), %xmm0     # 0xc040
mulsd (%rcx,%rbp,8), %xmm0
mulsd (%r12,%rbp,8), %xmm0
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x3eae
movq 0x20(%r15), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x3cfa
xorl %eax, %eax
movl 0x4(%rsp), %edx
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpq %rax, %rcx
je 0x3f60
movsd (%r14,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x3f46
cmpl $0x0, 0x30(%r15)
jne 0x3f7d
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_O2/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
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
cmpq %rdx, %rsi
je 0x3fd0
movq %rdi, (%rbx,%rdx,8)
incq %rdx
jmp 0x3fc2
cmpl $0x0, 0x30(%r14)
jne 0x3fdf
cltq
andq $0x0, -0x8(%rbx,%rax,8)
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %r15, %rax
je 0x402e
movq (%rcx,%rax,8), %rdx
movq 0x8(%r14), %rsi
movq 0x38(%r14), %rdi
movslq (%rdx), %r8
cmpq $-0x1, %r8
je 0x4029
movsd 0x8(%rdx), %xmm0
mulsd %xmm0, %xmm0
mulsd (%rsi,%rax,8), %xmm0
mulsd (%rdi,%rax,8), %xmm0
addsd -0x8(%rbx,%r8,8), %xmm0
movsd %xmm0, -0x8(%rbx,%r8,8)
addq $0x10, %rdx
jmp 0x3ff9
incq %rax
jmp 0x3fe8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl (%rcx), %r14d
callq *0x18(%rax)
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %r13d
movl %eax, 0xc(%rsp)
cmovgl %eax, %r13d
cmpq %rcx, %r13
je 0x4087
andq $0x0, (%rbx,%rcx,8)
incq %rcx
jmp 0x4078
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
cmpq %rbp, %r14
je 0x40d0
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %r12
movq (%rsp), %rdi
movq %r12, %rsi
callq 0xb45a
movq 0x8(%r15), %rax
movq 0x38(%r15), %rcx
movsd (%rax,%rbp,8), %xmm1
mulsd (%rcx,%rbp,8), %xmm1
mulsd %xmm1, %xmm0
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb47e
incq %rbp
jmp 0x4090
xorl %eax, %eax
movq (%rsp), %rcx
cmpq %rax, %r13
je 0x40ef
movsd (%rcx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x40d6
cmpl $0x0, 0x30(%r15)
jne 0x4111
movslq 0xc(%rsp), %rax
movsd -0x8(%rbx,%rax,8), %xmm0
movq (%rsp), %rcx
subsd -0x8(%rcx,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8aa0(%rip), %xmm1     # 0xcc40
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x41bf
movq 0x8(%rdi), %rcx
movsd (%rcx,%rax,8), %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl (%rcx), %r13d
callq *0x18(%rax)
andl $0x0, 0x40(%r15)
movl %eax, %ebp
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rsi
xorl %edi, %edi
testl %r13d, %r13d
cmovlel %edi, %r13d
movq 0x38(%r15), %rdx
movsd 0x8a33(%rip), %xmm0     # 0xcc40
movsd 0x7e2b(%rip), %xmm1     # 0xc040
xorl %r8d, %r8d
cmpq %r8, %r13
je 0x4264
movsd (%rcx,%r8,8), %xmm2
mulsd (%r12,%r8,8), %xmm2
movsd %xmm2, (%rsi,%r8,8)
ucomisd %xmm2, %xmm0
jbe 0x425f
movsd (%rax,%r8,8), %xmm3
mulsd (%r12,%r8,8), %xmm3
addsd %xmm1, %xmm2
mulsd %xmm3, %xmm2
movslq %edi, %rdi
movsd %xmm2, (%rsi,%rdi,8)
movl %r8d, (%rdx,%rdi,4)
movl 0x40(%r15), %edi
incl %edi
movl %edi, 0x40(%r15)
incq %r8
jmp 0x4218
movq %r15, %rdi
movq %rbx, %rdx
callq 0x42c6
xorl %eax, %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpq %rax, %rcx
je 0x4299
movsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x427b
cmpl $0x0, 0x30(%r15)
jne 0x42b6
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_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %r12
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x42fc
andq $0x0, (%rbx,%rcx,8)
incq %rcx
jmp 0x42ed
xorl %r13d, %r13d
movslq 0x40(%r15), %rax
cmpq %rax, %r13
jge 0x4327
movsd (%r14,%r13,8), %xmm0
movq 0x38(%r15), %rax
movslq (%rax,%r13,4), %rax
movq (%r12,%rax,8), %rdi
movq %rbx, %rsi
callq 0xb47e
incq %r13
jmp 0x42ff
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
cmpq %rdx, %rsi
je 0x436e
movq %rdi, (%rbx,%rdx,8)
incq %rdx
jmp 0x4360
cmpl $0x0, 0x30(%r14)
jne 0x437d
cltq
andq $0x0, -0x8(%rbx,%rax,8)
movslq 0x40(%r14), %rax
movq 0x38(%r14), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x43ce
movslq (%rdx,%rsi,4), %rdi
movq (%rcx,%rdi,8), %r8
movq 0x8(%r14), %r9
movslq (%r8), %r10
cmpq $-0x1, %r10
je 0x43c9
movsd 0x8(%r8), %xmm0
mulsd %xmm0, %xmm0
mulsd (%r9,%rdi,8), %xmm0
addsd %xmm0, %xmm0
addsd -0x8(%rbx,%r10,8), %xmm0
movsd %xmm0, -0x8(%rbx,%r10,8)
addq $0x10, %r8
jmp 0x4398
incq %rsi
jmp 0x4387
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%r15), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %r13d
movl %eax, 0xc(%rsp)
cmovgl %eax, %r13d
cmpq %rcx, %r13
je 0x4421
andq $0x0, (%rbx,%rcx,8)
incq %rcx
jmp 0x4412
xorl %ebp, %ebp
movslq 0x40(%r15), %rax
cmpq %rax, %rbp
jge 0x4469
movq 0x38(%r15), %rax
movslq (%rax,%rbp,4), %rax
movq 0x10(%rsp), %rcx
movq (%rcx,%rax,8), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xb45a
movq 0x8(%r15), %rax
movq 0x38(%r15), %rcx
movslq (%rcx,%rbp,4), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb47e
incq %rbp
jmp 0x4423
xorl %eax, %eax
cmpq %rax, %r13
je 0x4489
movsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x446b
cmpl $0x0, 0x30(%r15)
jne 0x44a8
movslq 0xc(%rsp), %rax
movsd -0x8(%rbx,%rax,8), %xmm0
subsd -0x8(%r14,%rax,8), %xmm0
movsd %xmm0, -0x8(%rbx,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8777(%rip), %xmm1     # 0xcc80
xorpd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x451d
movq 0x8(%rdi), %rcx
addsd %xmm2, %xmm0
jmp 0x452f
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm0
jbe 0x453c
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_O2/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
movl (%rcx), %r13d
callq *0x18(%rax)
andl $0x0, 0x40(%r15)
movl %eax, %ebp
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rsi
movq 0x38(%r15), %rdx
xorl %edi, %edi
testl %r13d, %r13d
cmovlel %edi, %r13d
movapd 0x86f1(%rip), %xmm0     # 0xcc80
xorl %r8d, %r8d
cmpq %r8, %r13
je 0x45e8
movsd (%rcx,%r8,8), %xmm1
subsd (%r12,%r8,8), %xmm1
movsd 0x48(%r15), %xmm2
movapd %xmm2, %xmm3
xorpd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x45bd
addsd %xmm2, %xmm1
jmp 0x45c7
ucomisd %xmm2, %xmm1
jbe 0x45e3
subsd %xmm2, %xmm1
mulsd (%rax,%r8,8), %xmm1
movslq %edi, %rdi
movsd %xmm1, (%rsi,%rdi,8)
movl %r8d, (%rdx,%rdi,4)
movl 0x40(%r15), %edi
incl %edi
movl %edi, 0x40(%r15)
incq %r8
jmp 0x4592
movq %r15, %rdi
movq %rbx, %rdx
callq 0x42c6
xorl %eax, %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpq %rax, %rcx
je 0x461d
movsd (%rbx,%rax,8), %xmm0
addsd %xmm0, %xmm0
addsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x45ff
cmpl $0x0, 0x30(%r15)
jne 0x463a
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_O2/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
movq (%rsi), %xmm1
pshufd $0xe1, %xmm1, %xmm1     # xmm1 = xmm1[1,0,2,3]
movq %xmm1, 0x18(%rdi)
movl %edx, 0x20(%rdi)
movsd %xmm0, 0x28(%rdi)
movl %r8d, 0x24(%rdi)
movq %rsi, 0x30(%rdi)
movl %edx, %eax
shlq $0x3, %rax
testl %edx, %edx
pushq $-0x1
popq %r15
cmovnsq %rax, %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
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %r14d
movsd %xmm1, 0x10(%rsp)
movl %esi, 0x4(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq (%rdi), %r12
movslq %edx, %r13
leaq (,%r13,8), %rbp
testl %r13d, %r13d
pushq $-0x1
popq %rdi
cmovnsq %rbp, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl 0x4(%rsp), %ebp
callq 0x20f0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
cmpl %r13d, %ebp
jge 0x4761
movslq %ebp, %rax
movsd (%r15,%rax,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%r15,%rax,8)
leaq -0xa2(%rip), %rcx       # 0x46c6
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
movsd %xmm1, 0x18(%rsp)
callq 0x22e0
movsd (%r15), %xmm0
subsd 0x18(%rsp), %xmm0
cmpl $0x2, %r13d
pushq $0x1
popq %rax
cmovgel %r14d, %eax
pushq $0x1
popq %rcx
movsd 0x10(%rsp), %xmm4
movsd 0x8(%rsp), %xmm5
cmpq %r13, %rcx
jge 0x47c7
cvtsi2sd %ecx, %xmm1
movsd (%r15,%rcx,8), %xmm2
movapd %xmm2, %xmm3
mulsd %xmm1, %xmm3
ucomisd %xmm0, %xmm3
jbe 0x47cb
addsd %xmm2, %xmm0
incq %rcx
jmp 0x47a1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl %ebp, %ecx
xorl %edx, %edx
testl %r14d, %r14d
cmovlel %edx, %r14d
cmpq %rdx, %r14
je 0x480f
movapd %xmm4, %xmm1
cmpq %rdx, %rcx
je 0x47f4
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
subsd (%rax,%rdx,8), %xmm2
divsd %xmm5, %xmm2
minsd %xmm2, %xmm1
movsd %xmm1, (%rbx,%rdx,8)
incq %rdx
jmp 0x47e2
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4849
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 0x4861
jp 0x4861
movq 0x10(%rdi), %rcx
movslq %edx, %rdx
movb $0x1, %al
ucomisd (%rcx,%rdx,8), %xmm1
ja 0x4863
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x8dc4
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa268
movq %r14, %rdi
callq 0x21a0
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl (%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
xorpd %xmm1, %xmm1
cmpq %rax, %rdx
je 0x92af
movq 0x10(%rdi), %r8
movq (%r8,%rdx,8), %r8
xorpd %xmm0, %xmm0
cmpl $-0x1, (%r8)
je 0x92a2
movsd 0x8(%r8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
addq $0x10, %r8
jmp 0x9288
maxsd %xmm1, %xmm0
incq %rdx
movapd %xmm0, %xmm1
jmp 0x9277
movl (%rsi), %edx
testl %edx, %edx
je 0x9307
cmpl $0x2, %edx
je 0x9305
cmpl $0xb, %edx
jne 0x931d
xorpd %xmm3, %xmm3
xorl %ecx, %ecx
movapd 0x39a3(%rip), %xmm4     # 0xcc70
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x9327
movq 0x8(%rdi), %rdx
movsd (%rdx,%rcx,8), %xmm5
andpd %xmm4, %xmm5
addsd %xmm5, %xmm2
movsd 0x30(%rsi), %xmm6
subsd %xmm6, %xmm5
maxsd %xmm3, %xmm5
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm0
incq %rcx
jmp 0x92d5
addl %ecx, %ecx
cvtsi2sd %ecx, %xmm0
mulsd %xmm0, %xmm1
movsd 0x3929(%rip), %xmm0     # 0xcc40
divsd %xmm1, %xmm0
jmp 0x9357
movsd 0x391b(%rip), %xmm0     # 0xcc40
jmp 0x9357
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jbe 0x934f
mulsd 0x3aef(%rip), %xmm0     # 0xce28
movsd 0x3aef(%rip), %xmm3     # 0xce30
mulsd %xmm2, %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
jmp 0x9317
movsd 0x2cd9(%rip), %xmm0     # 0xc030
callq 0x20e0
divsd 0x3ad4(%rip), %xmm0     # 0xce38
callq 0x2280
popq %rax
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movsd 0x68(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl 0x54(%rdi), %ecx
sbbl $-0x1, %ecx
movslq 0x50(%rdi), %rax
cmpq $0x2, %rax
jne 0x9812
cmpl $0x4, (%rbx)
jne 0x9816
movl %eax, %edx
jmp 0x9819
pushq $0x1
popq %rdx
movq 0x58(%rbx), %rdi
xorl %r9d, %r9d
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
cmpq %r9, %r8
je 0x9878
andq $0x0, (%r14,%r9,8)
incq %r9
jmp 0x982c
cmpl %ecx, %r9d
jle 0x9846
addq $0x10, %rsi
jmp 0x9878
decl %r9d
imull %edx, %r9d
movslq %r9d, %r9
leaq (%rdi,%r9,8), %r9
xorl %r10d, %r10d
cmpq %r10, %r8
je 0x9840
movsd (%r9,%r10,8), %xmm0
mulsd 0x8(%rsi), %xmm0
addsd (%r14,%r10,8), %xmm0
movsd %xmm0, (%r14,%r10,8)
incq %r10
jmp 0x9857
movl (%rsi), %r9d
cmpl $-0x1, %r9d
jne 0x983b
movl (%rbx), %ebp
cmpl $0x15, %ebp
jne 0x9897
movsd (%r14), %xmm0
subsd 0x70(%rbx), %xmm0
movsd %xmm0, (%r14)
cmpl $0x2, %eax
jne 0x98cd
movq %rbx, %rdi
callq 0x64dc
movsd (%r14), %xmm0
testl %eax, %eax
jne 0x98fc
xorpd %xmm1, %xmm1
xorl %eax, %eax
cmpl $0x15, %ebp
jne 0x9901
ucomisd %xmm1, %xmm0
seta %al
leaq 0x359a(%rip), %rcx      # 0xce60
movsd (%rcx,%rax,8), %xmm0
jmp 0x98fc
xorl %edx, %edx
pushq $0x1
popq %rcx
movslq %edx, %rsi
cmpq %rax, %rcx
jge 0x98f3
movsd (%r14,%rcx,8), %xmm0
ucomisd (%r14,%rsi,8), %xmm0
movl %ecx, %esi
ja 0x98ec
movl %edx, %esi
incq %rcx
movl %esi, %edx
jmp 0x98d2
movq 0x60(%rbx), %rax
cvtsi2sdl (%rax,%rsi,4), %xmm0
popq %rbx
popq %r14
popq %rbp
retq
ucomisd %xmm1, %xmm0
setbe %al
movq 0x60(%rbx), %rcx
cvtsi2sdl (%rcx,%rax,4), %xmm0
jmp 0x98fc