LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyObject_GetIndex(_object*, _object*)
static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) {
    PyObject *runerr;
    Py_ssize_t key_value;
    PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence;
    if (unlikely(!(m && m->sq_item))) {
        PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name);
        return NULL;
    }
    key_value = __Pyx_PyIndex_AsSsize_t(index);
    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
    }
    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
        PyErr_Clear();
        PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x31(%rbp)
je 0x13edb
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13eea
jmp 0x13f1b
movq 0xf0af(%rip), %rax      # 0x22fa0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdx
leaq 0x8a06(%rip), %rsi      # 0x1c90d
movb $0x0, %al
callq 0xb290
movq $0x0, -0x8(%rbp)
jmp 0x13fbd
movq -0x18(%rbp), %rdi
callq 0x13fd0
movq %rax, -0x28(%rbp)
movb $0x1, %al
cmpq $-0x1, -0x28(%rbp)
movb %al, -0x32(%rbp)
jne 0x13f49
callq 0xb540
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13f56
jmp 0x13f74
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x135a0
movq %rax, -0x8(%rbp)
jmp 0x13fbd
movq -0x20(%rbp), %rdi
movq 0xeff1(%rip), %rax      # 0x22f70
movq (%rax), %rsi
callq 0xb660
cmpl $0x0, %eax
je 0x13fb5
callq 0xb3a0
movq 0xef78(%rip), %rax      # 0x22f10
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdx
leaq 0x8984(%rip), %rsi      # 0x1c932
movb $0x0, %al
callq 0xb290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _pyx_pw_9grasp_nms_1arg_sort_grasp(_object*, _object*)
static PyObject *__pyx_pw_9grasp_nms_1arg_sort_grasp(PyObject *__pyx_self, PyObject *__pyx_v_grasps) {
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("arg_sort_grasp (wrapper)", 0);
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_grasps), __pyx_ptype_5numpy_ndarray, 1, "grasps", 0))) __PYX_ERR(0, 18, __pyx_L1_error)
  __pyx_r = __pyx_pf_9grasp_nms_arg_sort_grasp(__pyx_self, ((PyArrayObject *)__pyx_v_grasps));

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq 0xfa4b(%rip), %rax      # 0x23d88
sete %al
andb $0x1, %al
movzbl %al, %eax
movq 0xebf4(%rip), %rcx      # 0x22f40
cmpq %rcx, -0x10(%rbp)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1436b
jmp 0x14375
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14391
movq -0x10(%rbp), %rdi
movq 0xfa08(%rip), %rsi      # 0x23d88
leaq 0x87b9(%rip), %rdx      # 0x1cb40
xorl %ecx, %ecx
callq 0x143f0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x143a6
jmp 0x143c1
movq 0xf063(%rip), %rax      # 0x23410
movq %rax, -0x20(%rbp)
movl $0x12, -0x14(%rbp)
movl $0x7d3, -0x24(%rbp)     # imm = 0x7D3
jmp 0x143d4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x144b0
movq %rax, -0x30(%rbp)
jmp 0x143dc
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx__ArgTypeTest(_object*, _typeobject*, char const*, int)
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
{
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    else if (exact) {
        #if PY_MAJOR_VERSION == 2
        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
        #endif
    }
    else {
        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
    }
    PyErr_Format(PyExc_TypeError,
        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
        name, type->tp_name, Py_TYPE(obj)->tp_name);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1441b
jmp 0x1443a
movq 0xebae(%rip), %rax      # 0x22fd0
movq (%rax), %rdi
leaq 0x8373(%rip), %rsi      # 0x1c79f
callq 0xb430
movl $0x0, -0x4(%rbp)
jmp 0x144a7
cmpl $0x0, -0x24(%rbp)
je 0x14442
jmp 0x1446e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12f30
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14463
jmp 0x1446c
movl $0x1, -0x4(%rbp)
jmp 0x144a7
jmp 0x1446e
jmp 0x14470
movq 0xeb29(%rip), %rax      # 0x22fa0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %r8
leaq 0x86ae(%rip), %rsi      # 0x1cb47
movb $0x0, %al
callq 0xb290
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _pyx_pw_9grasp_nms_3print_data(_object*, _object*)
static PyObject *__pyx_pw_9grasp_nms_3print_data(PyObject *__pyx_self, PyObject *__pyx_v_ary) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("print_data (wrapper)", 0);
  __pyx_r = __pyx_pf_9grasp_nms_2print_data(__pyx_self, ((PyObject *)__pyx_v_ary));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _pyx_pf_9grasp_nms_2print_data(_object*, _object*)
static PyObject *__pyx_pf_9grasp_nms_2print_data(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ary) {
  double_array __pyx_v_a;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("print_data", 0);

  /* "grasp_nms.pyx":25
 * 
 * def print_data(ary):
 *     a = np2array(ary)             # <<<<<<<<<<<<<<
 *     a.print_data()
 * 
 */
  if (!(likely(((__pyx_v_ary) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_ary, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 25, __pyx_L1_error)
  __pyx_v_a = __pyx_f_9grasp_nms_np2array(((PyArrayObject *)__pyx_v_ary));

  /* "grasp_nms.pyx":26
 * def print_data(ary):
 *     a = np2array(ary)
 *     a.print_data()             # <<<<<<<<<<<<<<
 * 
 * def nms_grasp(np.ndarray grasps,double t,double r):
 */
  __pyx_v_a.print_data();

  /* "grasp_nms.pyx":24
 *     return sorted_arg
 * 
 * def print_data(ary):             # <<<<<<<<<<<<<<
 *     a = np2array(ary)
 *     a.print_data()
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("grasp_nms.print_data", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc870
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movb $0x1, %al
movq 0xe5e0(%rip), %rcx      # 0x22f40
cmpq %rcx, -0x10(%rbp)
movb %al, -0x61(%rbp)
je 0x1498e
movq -0x10(%rbp), %rdi
movq 0xf414(%rip), %rsi      # 0x23d88
callq 0x11ef0
movl %eax, -0x68(%rbp)
jmp 0x1497e
movl -0x68(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x149cb
movq 0xea70(%rip), %rax      # 0x23410
movq %rax, -0x38(%rbp)
movl $0x19, -0x2c(%rbp)
movl $0x86b, -0x3c(%rbp)     # imm = 0x86B
jmp 0x14a0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc900
jmp 0x14a4a
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xf420
jmp 0x149da
movups -0x60(%rbp), %xmm0
movaps %xmm0, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xc900
leaq -0x20(%rbp), %rdi
callq 0xc930
jmp 0x149f6
movq 0xe543(%rip), %rax      # 0x22f40
movq %rax, -0x28(%rbp)
movq 0xe538(%rip), %rdi      # 0x22f40
callq 0xdcc0
jmp 0x14a2f
movl -0x3c(%rbp), %esi
movl -0x2c(%rbp), %edx
movq -0x38(%rbp), %rcx
leaq 0x8183(%rip), %rdi      # 0x1cba3
callq 0xf010
jmp 0x14a27
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc900
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xb5d0
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_RaiseArgtupleInvalid(char const*, int, long, long, long)
static void __Pyx_RaiseArgtupleInvalid(
    const char* func_name,
    int exact,
    Py_ssize_t num_min,
    Py_ssize_t num_max,
    Py_ssize_t num_found)
{
    Py_ssize_t num_expected;
    const char *more_or_less;
    if (num_found < num_min) {
        num_expected = num_min;
        more_or_less = "at least";
    } else {
        num_expected = num_max;
        more_or_less = "at most";
    }
    if (exact) {
        more_or_less = "exactly";
    }
    PyErr_Format(PyExc_TypeError,
                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 func_name, more_or_less, num_expected,
                 (num_expected == 1) ? "" : "s", num_found);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x1520a
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x7a2f(%rip), %rax      # 0x1cc33
movq %rax, -0x38(%rbp)
jmp 0x1521d
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x7a23(%rip), %rax      # 0x1cc3c
movq %rax, -0x38(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1522e
leaq 0x7a1a(%rip), %rax      # 0x1cc44
movq %rax, -0x38(%rbp)
movq 0xdd6b(%rip), %rax      # 0x22fa0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x30(%rbp), %rsi
leaq 0x7172(%rip), %r9       # 0x1c3c1
leaq 0x6fd7(%rip), %rax      # 0x1c22d
cmpq $0x1, %rsi
cmoveq %rax, %r9
movq -0x28(%rbp), %rax
leaq 0x79e3(%rip), %rsi      # 0x1cc4c
movq %rax, (%rsp)
movb $0x0, %al
callq 0xb290
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _pyx_find_code_object(int)
static PyCodeObject *__pyx_find_code_object(int code_line) {
    PyCodeObject* code_object;
    int pos;
    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
        return NULL;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
        return NULL;
    }
    code_object = __pyx_code_cache.entries[pos].code_object;
    Py_INCREF(code_object);
    return code_object;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15c83
cmpq $0x0, 0xe1fc(%rip)      # 0x23e70
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15c83
jmp 0x15c90
movq $0x0, -0x8(%rbp)
jmp 0x15d15
movq 0xe1d9(%rip), %rdi      # 0x23e70
movl 0xe1cb(%rip), %esi      # 0x23e68
movl -0xc(%rbp), %edx
callq 0x160b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xe1b7(%rip), %eax      # 0x23e68
setge %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15ce1
movq 0xe1ad(%rip), %rax      # 0x23e70
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15ce1
jmp 0x15ceb
movq $0x0, -0x8(%rbp)
jmp 0x15d15
movq 0xe17e(%rip), %rax      # 0x23e70
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdcc0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry*, int, int)
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
    int start = 0, mid = 0, end = count - 1;
    if (end >= 0 && code_line > entries[end].code_line) {
        return count;
    }
    while (start < end) {
        mid = start + (end - start) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x160fd
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jle 0x160fd
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1619a
jmp 0x160ff
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x16172
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
subl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0x16144
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x16170
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jle 0x16166
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1616e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1619a
jmp 0x16170
jmp 0x160ff
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jg 0x16191
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1619a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/./graspnms.cpp
// Function: std::vector<unsigned int, std::allocator<unsigned int>> reverse_argsort<double>(std::vector<double, std::allocator<double>> const&)
std::vector<unsigned int> reverse_argsort(const std::vector<T> &array)
{
    const int array_len(array.size());
    std::vector<arg_value> array_index;
    array_index.reserve(array_len);

    for (int i = 0; i < array_len; ++i)
    {
        arg_value arg_value_struct;
        arg_value_struct.arg = i;
        arg_value_struct.score = array[i];
        array_index.push_back(arg_value_struct);
    }
    std::sort(array_index.begin(), array_index.end(), array_gt);
    std::vector<unsigned int> index;
    index.reserve(array_len);
    for (int i = 0; i < array_len; i++)
    {
        index.push_back(array_index[i].arg);
    }
    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x164d0
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x185c0
movq -0x70(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x185e0
jmp 0x168c6
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1691e
movl -0x40(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x186e0
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x18700
jmp 0x16900
jmp 0x16902
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x168cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x169eb
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x187c0
movq -0x88(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x187f0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x9831(%rip), %rdx     # 0xd120
callq 0x18770
jmp 0x16958
movq -0x80(%rbp), %rdi
movb $0x0, -0x61(%rbp)
callq 0x16860
movq -0x80(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x18820
jmp 0x16974
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x169c2
movslq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x18990
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x18920
jmp 0x1699e
jmp 0x169a0
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x1697b
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x16800
jmp 0x169eb
movb $0x1, -0x61(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x169d5
movq -0x80(%rbp), %rdi
callq 0x16800
leaq -0x30(%rbp), %rdi
callq 0x189b0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x189b0
movq -0x38(%rbp), %rdi
callq 0xb5d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x410(%rbp), %rdx
leaq -0x810(%rbp), %rcx
callq 0x2580
leaq -0x410(%rbp), %rdi
callq 0x2b10
leaq 0x13e42(%rip), %rdi     # 0x162a8
leaq 0x13deb(%rip), %rsi     # 0x16258
callq 0xbf30
movq %rax, -0x818(%rbp)
cmpq $0x0, -0x818(%rbp)
je 0x24ac
movq 0x13b56(%rip), %rax     # 0x15fe0
movq (%rax), %rdi
movq -0x818(%rbp), %rdx
leaq 0x105e1(%rip), %rsi     # 0x12a7c
movb $0x0, %al
callq 0x21f0
movl $0x1, %edi
callq 0x2190
cmpl $0x0, 0x13e21(%rip)     # 0x162d4
je 0x24bc
callq 0x2f80
jmp 0x2535
cmpl $0x0, 0x13e0d(%rip)     # 0x162d0
je 0x24cc
callq 0x3080
jmp 0x2533
leaq 0x13dd5(%rip), %rdi     # 0x162a8
leaq 0x13d7e(%rip), %rsi     # 0x16258
callq 0x7200
movq %rax, 0x13de2(%rip)     # 0x162c8
leaq -0x810(%rbp), %rdi
movq 0x13dd4(%rip), %rsi     # 0x162c8
callq 0xb080
cmpl $0x0, %eax
je 0x2527
movq 0x13adb(%rip), %rax     # 0x15fe0
movq (%rax), %rdi
leaq -0x810(%rbp), %rdx
leaq 0x10571(%rip), %rsi     # 0x12a87
movb $0x0, %al
callq 0x21f0
movl $0x1, %edi
callq 0x2190
leaq 0x13d9a(%rip), %rdi     # 0x162c8
callq 0x9ba0
jmp 0x2535
leaq 0x13d1c(%rip), %rdi     # 0x16258
callq 0xbed0
movq 0x13d68(%rip), %rdi     # 0x162b0
callq 0x2180
movq 0x13d64(%rip), %rdi     # 0x162b8
callq 0x2180
movq 0x13cf0(%rip), %rdi     # 0x16250
callq 0x2180
movq 0x13d84(%rip), %rdi     # 0x162f0
callq 0x2180
xorl %eax, %eax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpl $0x0, 0x13349(%rip)     # 0x162d8
je 0x2fa0
movsd 0x132cf(%rip), %xmm0    # 0x16268
movsd %xmm0, -0x8(%rbp)
jmp 0x2fad
movsd 0xf060(%rip), %xmm0     # 0x12008
movsd %xmm0, -0x8(%rbp)
cmpl $0x0, 0x13328(%rip)     # 0x162dc
je 0x2fc5
movsd 0x132ca(%rip), %xmm0    # 0x16288
movsd %xmm0, -0x10(%rbp)
jmp 0x2fd2
movsd 0xf03b(%rip), %xmm0     # 0x12008
movsd %xmm0, -0x10(%rbp)
movl 0x1330c(%rip), %esi     # 0x162e4
leaq 0xfac5(%rip), %rdi      # 0x12aa4
movb $0x0, %al
callq 0x2050
movl 0x132f8(%rip), %edx     # 0x162e4
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
leaq 0x132ab(%rip), %rdi     # 0x162a8
leaq 0x13254(%rip), %rsi     # 0x16258
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x28(%rbp), %r9
callq 0x9bf0
cmpl $0x0, 0x1323c(%rip)     # 0x16258
je 0x3027
cmpl $0x2, 0x13233(%rip)     # 0x16258
jne 0x3049
movsd -0x18(%rbp), %xmm0
movsd 0xf00c(%rip), %xmm1     # 0x12040
mulsd -0x28(%rbp), %xmm1
leaq 0xfa9b(%rip), %rdi      # 0x12adb
movb $0x2, %al
callq 0x2050
jmp 0x3071
cmpl $0xb, 0x13208(%rip)     # 0x16258
jne 0x306f
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
leaq 0xfa94(%rip), %rdi      # 0x12afc
movb $0x3, %al
callq 0x2050
jmp 0x3071
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x12f4d(%rip), %rdi     # 0x162f0
movl 0x12f4f(%rip), %esi     # 0x162f8
movq -0x10(%rbp), %rdx
callq 0x2220
cmpq $0x0, %rax
jne 0x33c5
movq $0x0, -0x8(%rbp)
jmp 0x344a
jmp 0x33c7
movq 0x12f22(%rip), %rdi     # 0x162f0
movl $0xa, %esi
callq 0x2140
cmpq $0x0, %rax
jne 0x343f
movl 0x12f14(%rip), %eax     # 0x162f8
shll %eax
movl %eax, 0x12f0c(%rip)     # 0x162f8
movq 0x12efd(%rip), %rdi     # 0x162f0
movslq 0x12efe(%rip), %rsi     # 0x162f8
callq 0x2230
movq %rax, 0x12eea(%rip)     # 0x162f0
movq 0x12ee3(%rip), %rdi     # 0x162f0
callq 0x20a0
movl %eax, -0x14(%rbp)
movq 0x12ed4(%rip), %rdi     # 0x162f0
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl 0x12ecf(%rip), %esi     # 0x162f8
subl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2220
cmpq $0x0, %rax
jne 0x343d
jmp 0x343f
jmp 0x33c7
movq 0x12eaa(%rip), %rax     # 0x162f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x10(%rax)
leaq 0xb(%rip), %rcx         # 0x3790
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x11500
movq -0x48(%rbp), %rax
leaq 0x11928(%rip), %rcx     # 0x15c08
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movslq -0x24(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, -0x40(%rbp)
jmp 0x4319
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movslq -0x24(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, -0x50(%rbp)
jmp 0x434a
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x4290
movq -0x30(%rbp), %rdi
callq 0x2260
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rdi
movl %eax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rdi)
movq -0x10(%rbp), %rsi
movq 0x18(%rdi), %rdx
callq 0x4570
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x44a5
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movsd 0x28(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4462
movq -0x30(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4500
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm2
movsd 0x28(%rax), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x453e
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq 0x18(%rdi), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq (%rdi), %rax
callq *0x40(%rax)
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4507
movq -0x30(%rbp), %rax
movsd -0x20(%rbp), %xmm1
movsd 0x28(%rax), %xmm0
movsd 0xdac4(%rip), %xmm2     # 0x12018
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x45d9
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x11520
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x45a4
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4a7a
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a57
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4ab6
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x11590
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a81
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4c83
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x2270
movaps %xmm0, %xmm1
movsd 0xd3c1(%rip), %xmm0     # 0x12028
addsd %xmm1, %xmm0
callq 0x20e0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4cf2
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x2270
movaps %xmm0, %xmm1
movsd 0xd359(%rip), %xmm0     # 0x12028
addsd %xmm1, %xmm0
callq 0x20e0
movsd -0x48(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x4e35
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
callq 0x2270
movq -0x38(%rbp), %rax
movsd 0xd295(%rip), %xmm1     # 0x12028
addsd %xmm0, %xmm1
movsd 0xd289(%rip), %xmm0     # 0x12028
divsd %xmm1, %xmm0
movq 0x20(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x20(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd 0xd25b(%rip), %xmm1     # 0x12028
subsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm0
movq 0x38(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movsd 0xd223(%rip), %xmm2     # 0x12028
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4d41
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rsi
movq -0x18(%rbp), %rdx
callq 0x4a10
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x4e87
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e4d
movq -0x38(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4ebe
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4f3b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd 0xd0fd(%rip), %xmm0     # 0x12028
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f13
movq -0x38(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4f5a
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4ff6
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x4fe6
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movq -0x30(%rbp), %rcx
mulsd 0x8(%rcx), %xmm0
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x4f7d
jmp 0x4fe8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f61
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x506a
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5047
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x50e0
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11520
movq -0x48(%rbp), %rax
movsd %xmm0, -0x40(%rbp)
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11590
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5071
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5121
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x50e7
movq -0x48(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5158
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x20(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0xcd57(%rip), %xmm1     # 0x12028
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x530a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5312
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rdi), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x30(%rbp)
movl $0x0, 0x40(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x542b
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd 0xcc73(%rip), %xmm0     # 0x12028
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x541b
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm1
movsd 0xcc39(%rip), %xmm2     # 0x12028
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq 0x20(%rax), %rcx
movslq 0x40(%rax), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movl -0x1c(%rbp), %esi
movq 0x38(%rax), %rcx
movslq 0x40(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x541d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x536e
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rsi
movq -0x18(%rbp), %rdx
callq 0x54d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x5485
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5443
movq -0x38(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x54bc
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5531
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x550e
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x40(%rcx), %eax
jge 0x557d
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm0
movq -0x28(%rbp), %rax
movq 0x38(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x11590
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5538
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x55f2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd 0xca46(%rip), %xmm0     # 0x12028
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55ca
movq -0x38(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x5611
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x14(%rbp)
movq -0x38(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x40(%rcx), %eax
jge 0x56b6
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x56a6
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movq -0x30(%rbp), %rcx
mulsd 0x8(%rcx), %xmm0
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x564a
jmp 0x56a8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5618
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)