LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: GouMinghao[P]graspnms/./graspnms.cpp
// Function: double_array::print_data()
void double_array::print_data()
{
    cout << "print data" << endl;
    for (int i = 0; i < this->r; i++)
    {
        for (int j = 0; j < this->c; j++)
        {
            printf("%.4f\t", (this->data)[i * (this->c) + j]);
        }
        cout << endl;
    }
    // argsort_grasp(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1663d(%rip), %rdi     # 0x22f88
leaq 0xf8cb(%rip), %rsi      # 0x1c21d
callq 0xb3b0
movq %rax, %rdi
movq 0x165cf(%rip), %rsi     # 0x22f30
callq 0xb400
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0xc9dc
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xc9be
movq -0x18(%rbp), %rdx
movq (%rdx), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xf87c(%rip), %rdi      # 0x1c228
movb $0x1, %al
callq 0xb050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc980
movq 0x165c3(%rip), %rdi     # 0x22f88
movq 0x16564(%rip), %rsi     # 0x22f30
callq 0xb400
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc96d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/./graspnms.cpp
// Function: argsort_grasp(double_array const&)
vector<unsigned int> argsort_grasp(const double_array &grasps)
{
    vector<double> grasp_scores;
    vector<unsigned int> sorted_arg;
    grasp_scores.reserve(grasps.r);
    for (int i = 0; i < grasps.r; i++)
    {
        grasp_scores.push_back(grasps.data[i * grasps.c + SCORE_PLACE]);
    }
    sorted_arg = reverse_argsort(grasp_scores);
    return sorted_arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x161c0
movq -0x68(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0x16860
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0x161e0
jmp 0xce78
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xceda
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movl -0x40(%rbp), %ecx
movl 0xc(%rdx), %edx
imull %edx, %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x28(%rbp), %rdi
callq 0x162e0
jmp 0xcead
jmp 0xceaf
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xce7f
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x16800
leaq -0x28(%rbp), %rdi
callq 0x16350
jmp 0xcf25
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x16880
jmp 0xcee9
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x16a00
leaq -0x58(%rbp), %rdi
callq 0x16800
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0xcf12
movq -0x68(%rbp), %rdi
callq 0x16800
leaq -0x28(%rbp), %rdi
callq 0x16350
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xb5d0
nop
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_check_single_interpreter()
static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
    #if PY_VERSION_HEX >= 0x030700A1
    static PY_INT64_T main_interpreter_id = -1;
    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
    if (main_interpreter_id == -1) {
        main_interpreter_id = current_id;
        return (unlikely(current_id == -1)) ? -1 : 0;
    } else if (unlikely(main_interpreter_id != current_id))
    #else
    static PyInterpreterState *main_interpreter = NULL;
    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
    if (!main_interpreter) {
        main_interpreter = current_interpreter;
    } else if (unlikely(main_interpreter != current_interpreter))
    #endif
    {
        PyErr_SetString(
            PyExc_ImportError,
            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb450
movq 0x10(%rax), %rdi
callq 0xb230
movq %rax, -0x10(%rbp)
cmpq $-0x1, 0x157be(%rip)    # 0x23400
jne 0xdc6f
movq -0x10(%rbp), %rax
movq %rax, 0x157b1(%rip)     # 0x23400
cmpq $-0x1, -0x10(%rbp)
sete %dl
xorb $-0x1, %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xdcaf
movq 0x1578a(%rip), %rax     # 0x23400
cmpq -0x10(%rbp), %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdc87
jmp 0xdca6
movq 0x1534a(%rip), %rax     # 0x22fd8
movq (%rax), %rdi
leaq 0xe5f4(%rip), %rsi      # 0x1c28c
callq 0xb430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdcaf
jmp 0xdca8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_copy_spec_to_module(_object*, _object*, char const*, char const*, int)
static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
    PyObject *value = PyObject_GetAttrString(spec, from_name);
    int result = 0;
    if (likely(value)) {
        if (allow_none || value != Py_None) {
            result = PyDict_SetItemString(moddict, to_name, value);
        }
        Py_DECREF(value);
    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Clear();
    } else {
        result = -1;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb100
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdd66
jmp 0xdd98
cmpl $0x0, -0x24(%rbp)
jne 0xdd79
movq 0x151cd(%rip), %rax     # 0x22f40
cmpq %rax, -0x30(%rbp)
je 0xdd8d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xb1f0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0xdce0
jmp 0xddbc
movq 0x151a9(%rip), %rax     # 0x22f48
movq (%rax), %rdi
callq 0xb2f0
cmpl $0x0, %eax
je 0xddb3
callq 0xb3a0
jmp 0xddba
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
jmp 0xddbc
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_check_binary_version()
static int __Pyx_check_binary_version(void) {
    char ctversion[4], rtversion[4];
    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
        char message[200];
        PyOS_snprintf(message, sizeof(message),
                      "compiletime version %s of module '%.100s' "
                      "does not match runtime version %s",
                      ctversion, __Pyx_MODULE_NAME, rtversion);
        return PyErr_WarnEx(NULL, message, 1);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq 0xe556(%rip), %rdx      # 0x1c371
movl $0x3, %ecx
movl $0xa, %r8d
movb $0x0, %al
callq 0xb410
leaq -0xc(%rbp), %rax
movq %rax, -0xe8(%rbp)
callq 0xb360
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movl $0x4, %esi
leaq 0xe56d(%rip), %rdx      # 0x1c3c0
movb $0x0, %al
callq 0xb410
movsbl -0x8(%rbp), %eax
movsbl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jne 0xde72
movsbl -0x6(%rbp), %eax
movsbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
je 0xdeb5
leaq -0xe0(%rbp), %rdi
leaq -0x8(%rbp), %rcx
leaq -0xc(%rbp), %r9
movl $0xc8, %esi
leaq 0xe4ea(%rip), %rdx      # 0x1c377
leaq 0xe4d3(%rip), %r8       # 0x1c367
movb $0x0, %al
callq 0xb410
leaq -0xe0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %edx
callq 0xb1a0
movl %eax, -0x4(%rbp)
jmp 0xdebc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_InitGlobals()
static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x155b1(%rip), %rdi     # 0x23490
callq 0xf110
cmpl $0x0, %eax
jge 0xdf10
movq 0x15520(%rip), %rax     # 0x23410
movq %rax, 0x15ce9(%rip)     # 0x23be0
movl $0x1, 0x15ce7(%rip)     # 0x23be8
movl $0xf58, 0x15ce1(%rip)   # imm = 0xF58
jmp 0xe09f
xorl %eax, %eax
movl %eax, %edi
callq 0xb4f0
movq %rax, 0x15cd0(%rip)     # 0x23bf0
cmpq $0x0, 0x15cc8(%rip)     # 0x23bf0
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdf37
jmp 0xdf5e
movq 0x154d2(%rip), %rax     # 0x23410
movq %rax, 0x15c9b(%rip)     # 0x23be0
movl $0x1, 0x15c99(%rip)     # 0x23be8
movl $0xf59, 0x15c93(%rip)   # imm = 0xF59
jmp 0xe09f
movl $0x1, %edi
callq 0xb4f0
movq %rax, 0x15c89(%rip)     # 0x23bf8
cmpq $0x0, 0x15c81(%rip)     # 0x23bf8
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdf86
jmp 0xdfad
movq 0x15483(%rip), %rax     # 0x23410
movq %rax, 0x15c4c(%rip)     # 0x23be0
movl $0x1, 0x15c4a(%rip)     # 0x23be8
movl $0xf5a, 0x15c44(%rip)   # imm = 0xF5A
jmp 0xe09f
movl $0x2, %edi
callq 0xb4f0
movq %rax, 0x15c42(%rip)     # 0x23c00
cmpq $0x0, 0x15c3a(%rip)     # 0x23c00
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdfd5
jmp 0xdffc
movq 0x15434(%rip), %rax     # 0x23410
movq %rax, 0x15bfd(%rip)     # 0x23be0
movl $0x1, 0x15bfb(%rip)     # 0x23be8
movl $0xf5b, 0x15bf5(%rip)   # imm = 0xF5B
jmp 0xe09f
movl $0x3, %edi
callq 0xb4f0
movq %rax, 0x15bfb(%rip)     # 0x23c08
cmpq $0x0, 0x15bf3(%rip)     # 0x23c08
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe024
jmp 0xe048
movq 0x153e5(%rip), %rax     # 0x23410
movq %rax, 0x15bae(%rip)     # 0x23be0
movl $0x1, 0x15bac(%rip)     # 0x23be8
movl $0xf5c, 0x15ba6(%rip)   # imm = 0xF5C
jmp 0xe09f
movq $-0x1, %rdi
callq 0xb4f0
movq %rax, 0x15bb5(%rip)     # 0x23c10
cmpq $0x0, 0x15bad(%rip)     # 0x23c10
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe072
jmp 0xe096
movq 0x15397(%rip), %rax     # 0x23410
movq %rax, 0x15b60(%rip)     # 0x23be0
movl $0x1, 0x15b5e(%rip)     # 0x23be8
movl $0xf5d, 0x15b58(%rip)   # imm = 0xF5D
jmp 0xe09f
movl $0x0, -0x4(%rbp)
jmp 0xe0a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_InitCachedBuiltins()
static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 947, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x15b59(%rip), %rdi     # 0x23c18
callq 0xf250
movq %rax, 0x15c25(%rip)     # 0x23cf0
cmpq $0x0, 0x15c1d(%rip)     # 0x23cf0
jne 0xe0f9
movq 0x1533c(%rip), %rax     # 0x23418
movq %rax, 0x15afd(%rip)     # 0x23be0
movl $0x3b3, 0x15afb(%rip)   # imm = 0x3B3
movl $0xee4, 0x15af5(%rip)   # imm = 0xEE4
jmp 0xe102
movl $0x0, -0x4(%rbp)
jmp 0xe109
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_modinit_function_export_code()
static int __Pyx_modinit_function_export_code(void) {
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
  /*--- Function export code ---*/
  if (__Pyx_ExportFunction("np2array", (void (*)(void))__pyx_f_9grasp_nms_np2array, "double_array (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("array2np", (void (*)(void))__pyx_f_9grasp_nms_array2np, "PyObject *(double_array)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0xdc9b(%rip), %rdi      # 0x1c4b0
leaq 0xc04(%rip), %rsi       # 0xf420
leaq 0xdbdd(%rip), %rdx      # 0x1c400
callq 0xf320
cmpl $0x0, %eax
jge 0xe848
movq 0x14bdc(%rip), %rax     # 0x23410
movq %rax, -0x10(%rbp)
movl $0x1, -0x8(%rbp)
movl $0xf82, -0x14(%rbp)     # imm = 0xF82
jmp 0xe88b
leaq 0xe04d(%rip), %rdi      # 0x1c89c
leaq 0x15ea(%rip), %rsi      # 0xfe40
leaq 0xdbc2(%rip), %rdx      # 0x1c41f
callq 0xf320
cmpl $0x0, %eax
jge 0xe882
movq 0x14ba2(%rip), %rax     # 0x23410
movq %rax, -0x10(%rbp)
movl $0x1, -0x8(%rbp)
movl $0xf83, -0x14(%rbp)     # imm = 0xF83
jmp 0xe88b
movl $0x0, -0x4(%rbp)
jmp 0xe892
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_AddTraceback(char const*, int, int, char const*)
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    if (c_line) {
        c_line = __Pyx_CLineForTraceback(tstate, c_line);
    }
    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
    if (!py_code) {
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) goto bad;
        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
    }
    py_frame = PyFrame_New(
        tstate,            /*PyThreadState *tstate,*/
        py_code,           /*PyCodeObject *code,*/
        __pyx_d,    /*PyObject *globals,*/
        0                  /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
callq 0xb580
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xf054
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x15aa0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xf064
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xf06a
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x15c50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf0bf
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x15d20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf09d
jmp 0xf0f7
cmpl $0x0, -0xc(%rbp)
je 0xf0ad
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xf0b3
movl -0x10(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x15e90
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x14aaa(%rip), %rdx     # 0x23b78
xorl %eax, %eax
movl %eax, %ecx
callq 0xb5a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf0e4
jmp 0xf0f7
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x28(%rbp), %rdi
callq 0xb160
movq -0x20(%rbp), %rdi
callq 0xddd0
movq -0x28(%rbp), %rdi
callq 0xddd0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_InitStrings(__Pyx_StringTabEntry*)
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
    while (t->p) {
        #if PY_MAJOR_VERSION < 3
        if (t->is_unicode) {
            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
        } else if (t->intern) {
            *t->p = PyString_InternFromString(t->s);
        } else {
            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
        }
        #else
        if (t->is_unicode | t->is_str) {
            if (t->intern) {
                *t->p = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
            } else {
                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        #endif
        if (!*t->p)
            return -1;
        if (PyObject_Hash(*t->p) == -1)
            return -1;
        ++t;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf23f
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movsbl 0x21(%rcx), %ecx
orl %ecx, %eax
cmpl $0x0, %eax
je 0xf1d4
movq -0x10(%rbp), %rax
cmpb $0x0, 0x22(%rax)
je 0xf16b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb1c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0xf1d2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf1aa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
subq $0x1, %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xb4b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0xf1d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
subq $0x1, %rsi
callq 0xb680
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0xf1d2
jmp 0xf1fa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
subq $0x1, %rsi
callq 0xb240
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0xf210
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf246
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xb040
cmpq $-0x1, %rax
jne 0xf22e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf246
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x10(%rbp)
jmp 0xf11c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_GetBuiltinName(_object*)
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
            "name '%U' is not defined", name);
#else
            "name '%.200s' is not defined", PyString_AS_STRING(name));
#endif
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1491d(%rip), %rdi     # 0x23b80
movq -0x8(%rbp), %rsi
callq 0xf2b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xf284
jmp 0xf2a0
movq 0x13ced(%rip), %rax     # 0x22f78
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xd14e(%rip), %rsi      # 0x1c3e7
movb $0x0, %al
callq 0xb290
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyObject_GetAttrStr(_object*, _object*)
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_getattr))
        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
    return PyObject_GetAttr(obj, attr_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xf2e5
jmp 0xf300
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0xf311
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb090
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_ExportFunction(char const*, void (*)(), char const*)
static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {
    PyObject *d = 0;
    PyObject *cobj = 0;
    union {
        void (*fp)(void);
        void *p;
    } tmp;
    d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__");
    if (!d) {
        PyErr_Clear();
        d = PyDict_New();
        if (!d)
            goto bad;
        Py_INCREF(d);
        if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0)
            goto bad;
    }
    tmp.fp = f;
#if PY_VERSION_HEX >= 0x02070000
    cobj = PyCapsule_New(tmp.p, sig, 0);
#else
    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
#endif
    if (!cobj)
        goto bad;
    if (PyDict_SetItemString(d, name, cobj) < 0)
        goto bad;
    Py_DECREF(cobj);
    Py_DECREF(d);
    return 0;
bad:
    Py_XDECREF(cobj);
    Py_XDECREF(d);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x14805(%rip), %rdi     # 0x23b50
leaq 0xd0e6(%rip), %rsi      # 0x1c438
callq 0xb100
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf3a5
callq 0xb3a0
callq 0xb420
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf37c
jmp 0xf3fe
movq -0x28(%rbp), %rdi
callq 0xdcc0
movq 0x147c4(%rip), %rdi     # 0x23b50
movq -0x28(%rbp), %rdx
leaq 0xd0a1(%rip), %rsi      # 0x1c438
callq 0xb190
cmpl $0x0, %eax
jge 0xf3a3
jmp 0xf3fe
jmp 0xf3a5
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb460
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xf3cb
jmp 0xf3fe
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xb1f0
cmpl $0x0, %eax
jge 0xf3e3
jmp 0xf3fe
movq -0x30(%rbp), %rdi
callq 0xdce0
movq -0x28(%rbp), %rdi
callq 0xdce0
movl $0x0, -0x4(%rbp)
jmp 0xf417
movq -0x30(%rbp), %rdi
callq 0xddd0
movq -0x28(%rbp), %rdi
callq 0xddd0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx__GetModuleGlobalName(_object*, unsigned long*, _object**)
static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
#endif
{
    PyObject *result;
#if !CYTHON_AVOID_BORROWED_REFS
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return __Pyx_NewRef(result);
    } else if (unlikely(PyErr_Occurred())) {
        return NULL;
    }
#else
    result = PyDict_GetItem(__pyx_d, name);
    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return __Pyx_NewRef(result);
    }
#endif
#else
    result = PyObject_GetItem(__pyx_d, name);
    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return __Pyx_NewRef(result);
    }
    PyErr_Clear();
#endif
    return __Pyx_GetBuiltinName(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x1202d(%rip), %rdi     # 0x23b78
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xb470
movq %rax, -0x28(%rbp)
movq 0x12011(%rip), %rax     # 0x23b78
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11b8f
jmp 0x11ba2
movq -0x28(%rbp), %rdi
callq 0xdcc0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11bd1
callq 0xb540
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11bb8
jmp 0x11bc2
movq $0x0, -0x8(%rbp)
jmp 0x11bd1
jmp 0x11bc4
movq -0x10(%rbp), %rdi
callq 0xf250
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyObject_CallOneArg(_object*, _object*)
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
#if CYTHON_FAST_PYCALL
    if (PyFunction_Check(func)) {
        return __Pyx_PyFunction_FastCall(func, &arg, 1);
    }
#endif
    if (likely(PyCFunction_Check(func))) {
        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
            return __Pyx_PyObject_CallMethO(func, arg);
#if CYTHON_FAST_PYCCALL
        } else if (__Pyx_PyFastCFunction_Check(func)) {
            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
#endif
        }
    }
    return __Pyx__PyObject_CallOneArg(func, arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x11335(%rip), %rsi     # 0x22f60
callq 0x11be0
cmpl $0x0, %eax
je 0x11c54
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x125b0
movq %rax, -0x8(%rbp)
jmp 0x11cfe
movq -0x10(%rbp), %rdi
movq 0x11309(%rip), %rsi     # 0x22f68
callq 0x129f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11c74
jmp 0x11ced
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11c92
jmp 0x11ca5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12a50
movq %rax, -0x8(%rbp)
jmp 0x11cfe
movq -0x10(%rbp), %rdi
movq 0x112b8(%rip), %rsi     # 0x22f68
callq 0x129f0
cmpl $0x0, %eax
je 0x11ce9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %ecx
andl $-0x73, %ecx
movl $0x80, %eax
cmpl %ecx, %eax
jne 0x11ce9
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x12b30
movq %rax, -0x8(%rbp)
jmp 0x11cfe
jmp 0x11ceb
jmp 0x11ced
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12cf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyObject_CallNoArg(_object*)
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
#if CYTHON_FAST_PYCALL
    if (PyFunction_Check(func)) {
        return __Pyx_PyFunction_FastCall(func, NULL, 0);
    }
#endif
#ifdef __Pyx_CyFunction_USED
    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
#else
    if (likely(PyCFunction_Check(func)))
#endif
    {
        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
            return __Pyx_PyObject_CallMethO(func, NULL);
        }
    }
    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x11239(%rip), %rsi     # 0x22f60
callq 0x11be0
cmpl $0x0, %eax
je 0x11d4a
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x125b0
movq %rax, -0x8(%rbp)
jmp 0x11db5
movq -0x10(%rbp), %rdi
movq 0x11213(%rip), %rsi     # 0x22f68
callq 0x129f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11d6a
jmp 0x11d9d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11d88
jmp 0x11d9b
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12a50
movq %rax, -0x8(%rbp)
jmp 0x11db5
jmp 0x11d9d
movq -0x10(%rbp), %rdi
movq 0x11db8(%rip), %rsi     # 0x23b60
xorl %eax, %eax
movl %eax, %edx
callq 0x11e00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyObject_Call(_object*, _object*, _object*)
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = func->ob_type->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = (*call)(func, arg, kw);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11e3b
jmp 0x11e55
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb0c0
movq %rax, -0x8(%rbp)
jmp 0x11ee0
leaq 0xa6dd(%rip), %rdi      # 0x1c539
callq 0xb530
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11e71
jmp 0x11e7b
movq $0x0, -0x8(%rbp)
jmp 0x11ee0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x28(%rbp)
callq 0xb300
cmpq $0x0, -0x28(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11eaa
jmp 0x11ed8
callq 0xb540
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11ec2
jmp 0x11ed8
movq 0x11107(%rip), %rax     # 0x22fd0
movq (%rax), %rdi
leaq 0xa74f(%rip), %rsi      # 0x1c622
callq 0xb430
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_TypeTest(_object*, _typeobject*)
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (likely(__Pyx_TypeCheck(obj, type)))
        return 1;
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11f14
jmp 0x11f33
movq 0x110b5(%rip), %rax     # 0x22fd0
movq (%rax), %rdi
leaq 0xa87a(%rip), %rsi      # 0x1c79f
callq 0xb430
movl $0x0, -0x4(%rbp)
jmp 0x11f90
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 0x11f54
jmp 0x11f5d
movl $0x1, -0x4(%rbp)
jmp 0x11f90
movq 0x1103c(%rip), %rax     # 0x22fa0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xa831(%rip), %rsi      # 0x1c7b3
movb $0x0, %al
callq 0xb290
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_WriteUnraisable(char const*, int, int, char const*, int, int)
static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
                                  CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
                                  int full_traceback, CYTHON_UNUSED int nogil) {
    PyObject *old_exc, *old_val, *old_tb;
    PyObject *ctx;
    __Pyx_PyThreadState_declare
#ifdef WITH_THREAD
    PyGILState_STATE state;
    if (nogil)
        state = PyGILState_Ensure();
#ifdef _MSC_VER
    else state = (PyGILState_STATE)-1;
#endif
#endif
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
    if (full_traceback) {
        Py_XINCREF(old_exc);
        Py_XINCREF(old_val);
        Py_XINCREF(old_tb);
        __Pyx_ErrRestore(old_exc, old_val, old_tb);
        PyErr_PrintEx(1);
    }
    #if PY_MAJOR_VERSION < 3
    ctx = PyString_FromString(name);
    #else
    ctx = PyUnicode_FromString(name);
    #endif
    __Pyx_ErrRestore(old_exc, old_val, old_tb);
    if (!ctx) {
        PyErr_WriteUnraisable(Py_None);
    } else {
        PyErr_WriteUnraisable(ctx);
        Py_DECREF(ctx);
    }
#ifdef WITH_THREAD
    if (nogil)
        PyGILState_Release(state);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x124dc
callq 0xb620
movl %eax, -0x4c(%rbp)
callq 0xb580
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x130c0
cmpl $0x0, -0x1c(%rbp)
je 0x1253a
movq -0x28(%rbp), %rdi
callq 0x13130
movq -0x30(%rbp), %rdi
callq 0x13130
movq -0x38(%rbp), %rdi
callq 0x13130
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x13160
movl $0x1, %edi
callq 0xb380
movq -0x8(%rbp), %rdi
callq 0xb350
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x13160
cmpq $0x0, -0x40(%rbp)
jne 0x12571
movq 0x109d6(%rip), %rdi     # 0x22f40
callq 0xb500
jmp 0x12583
movq -0x40(%rbp), %rdi
callq 0xb500
movq -0x40(%rbp), %rdi
callq 0xdce0
cmpl $0x0, -0x20(%rbp)
je 0x12591
movl -0x4c(%rbp), %edi
callq 0xb490
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyObject_CallMethO(_object*, _object*)
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
    PyObject *self, *result;
    PyCFunction cfunc;
    cfunc = PyCFunction_GET_FUNCTION(func);
    self = PyCFunction_GET_SELF(func);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = cfunc(self, arg);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x12a8b
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x12a97
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x9a93(%rip), %rdi      # 0x1c539
callq 0xb530
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12abb
jmp 0x12ac5
movq $0x0, -0x8(%rbp)
jmp 0x12b26
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
callq 0xb300
cmpq $0x0, -0x28(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12af0
jmp 0x12b1e
callq 0xb540
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12b08
jmp 0x12b1e
movq 0x104c1(%rip), %rax     # 0x22fd0
movq (%rax), %rdi
leaq 0x9b09(%rip), %rsi      # 0x1c622
callq 0xb430
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx__PyObject_CallOneArg(_object*, _object*)
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_New(1);
    if (unlikely(!args)) return NULL;
    Py_INCREF(arg);
    PyTuple_SET_ITEM(args, 0, arg);
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
callq 0xb1d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12d22
jmp 0x12d2c
movq $0x0, -0x8(%rbp)
jmp 0x12da7
movq -0x18(%rbp), %rdi
callq 0xdcc0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x11dc0
cmpl $0x0, %eax
je 0x12d56
jmp 0x12d75
leaq 0x99f1(%rip), %rdi      # 0x1c74e
leaq 0x96fa(%rip), %rsi      # 0x1c45e
movl $0x124d, %edx           # imm = 0x124D
leaq 0x99f2(%rip), %rcx      # 0x1c762
callq 0xb280
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11e00
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdce0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyFunction_FastCallNoKw(PyCodeObject*, _object**, long, _object*)
static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                               PyObject *globals) {
    PyFrameObject *f;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject **fastlocals;
    Py_ssize_t i;
    PyObject *result;
    assert(globals != NULL);
    /* XXX Perhaps we should create a specialized
       PyFrame_New() that doesn't take locals, but does
       take builtins without sanity checking them.
       */
    assert(tstate != NULL);
    f = PyFrame_New(tstate, co, globals, NULL);
    if (f == NULL) {
        return NULL;
    }
    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
    for (i = 0; i < na; i++) {
        Py_INCREF(*args);
        fastlocals[i] = *args++;
    }
    result = PyEval_EvalFrameEx(f,0);
    ++tstate->recursion_depth;
    Py_DECREF(f);
    --tstate->recursion_depth;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
callq 0xb580
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12dea
jmp 0x12e09
leaq 0x9795(%rip), %rdi      # 0x1c586
leaq 0x9666(%rip), %rsi      # 0x1c45e
movl $0x1183, %edx           # imm = 0x1183
leaq 0x9792(%rip), %rcx      # 0x1c596
callq 0xb280
cmpq $0x0, -0x38(%rbp)
je 0x12e12
jmp 0x12e31
leaq 0x97da(%rip), %rdi      # 0x1c5f3
leaq 0x963e(%rip), %rsi      # 0x1c45e
movl $0x1188, %edx           # imm = 0x1188
leaq 0x976a(%rip), %rcx      # 0x1c596
callq 0xb280
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xb5a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x12e5e
movq $0x0, -0x8(%rbp)
jmp 0x12f1c
cmpq $0x0, 0x10cf2(%rip)     # 0x23b58
je 0x12e6a
jmp 0x12e89
leaq 0x9791(%rip), %rdi      # 0x1c602
leaq 0x95e6(%rip), %rsi      # 0x1c45e
movl $0x118d, %edx           # imm = 0x118D
leaq 0x9712(%rip), %rcx      # 0x1c596
callq 0xb280
movq -0x30(%rbp), %rax
addq 0x10cc4(%rip), %rax     # 0x23b58
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x12ee2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xdcc0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdx
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x12ea0
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xb5e0
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rdi
callq 0xdce0
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_IsSubtype(_typeobject*, _typeobject*)
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
    PyObject *mro;
    if (a == b) return 1;
    mro = a->tp_mro;
    if (likely(mro)) {
        Py_ssize_t i, n;
        n = PyTuple_GET_SIZE(mro);
        for (i = 0; i < n; i++) {
            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
                return 1;
        }
        return 0;
    }
    return __Pyx_InBases(a, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x12f56
movl $0x1, -0x4(%rbp)
jmp 0x1304d
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12f7a
jmp 0x1303d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x11dc0
cmpl $0x0, %eax
je 0x12f93
jmp 0x12fb2
leaq 0x9839(%rip), %rdi      # 0x1c7d3
leaq 0x94bd(%rip), %rsi      # 0x1c45e
movl $0x1a4a, %edx           # imm = 0x1A4A
leaq 0x9839(%rip), %rcx      # 0x1c7e6
callq 0xb280
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x13034
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x11dc0
cmpl $0x0, %eax
je 0x12fe9
jmp 0x13008
leaq 0x97e3(%rip), %rdi      # 0x1c7d3
leaq 0x9467(%rip), %rsi      # 0x1c45e
movl $0x1a4c, %edx           # imm = 0x1A4C
leaq 0x97e3(%rip), %rcx      # 0x1c7e6
callq 0xb280
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x13024
movl $0x1, -0x4(%rbp)
jmp 0x1304d
jmp 0x13026
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12fc6
movl $0x0, -0x4(%rbp)
jmp 0x1304d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13060
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_InBases(_typeobject*, _typeobject*)
static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
    while (a) {
        a = a->tp_base;
        if (a == b)
            return 1;
    }
    return b == &PyBaseObject_Type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13097
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x13095
movl $0x1, -0x4(%rbp)
jmp 0x130ad
jmp 0x1306c
movq 0xfefa(%rip), %rax      # 0x22f98
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_ErrFetchInState(_ts*, _object**, _object**, _object**)
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    *type = tstate->curexc_type;
    *value = tstate->curexc_value;
    *tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_ErrRestoreInState(_ts*, _object*, _object*, _object*)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    tmp_type = tstate->curexc_type;
    tmp_value = tstate->curexc_value;
    tmp_tb = tstate->curexc_traceback;
    tstate->curexc_type = type;
    tstate->curexc_value = value;
    tstate->curexc_traceback = tb;
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rdi
callq 0xddd0
movq -0x30(%rbp), %rdi
callq 0xddd0
movq -0x38(%rbp), %rdi
callq 0xddd0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_PyObject_GetItem(_object*, _object*)
static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) {
    PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping;
    if (likely(m && m->mp_subscript)) {
        return m->mp_subscript(obj, key);
    }
    return __Pyx_PyObject_GetIndex(obj, key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x13a0b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13a18
jmp 0x13a30
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x13a41
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13ea0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/grasp_nms.cpp
// Function: _Pyx_GetItemInt_Generic(_object*, _object*)
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
    PyObject *r;
    if (!j) return NULL;
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13e71
movq $0x0, -0x8(%rbp)
jmp 0x13e93
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb4c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdce0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)