static PyObject *Triton_getRegValue(PyObject *self, PyObject *regId) {
  RegisterOperand reg;
  uint64 tritonReg;

  if (!PyLong_Check(regId) && !PyInt_Check(regId))
    return PyErr_Format(PyExc_TypeError, "getRegValue(): expected a register id (IDREF.REG) as argument");

  if (!ap.getCurrentCtxH())
    return PyErr_Format(PyExc_TypeError, "getRegValue(): Can't call getRegValue() right now. You must run the program before.");

  tritonReg = PyLong_AsLong(regId);
  reg = createTmpReg(tritonReg);

  if (tritonReg >= ID_XMM0 && tritonReg <= ID_XMM15){
    uint128 value = ap.getSSERegisterValue(reg);
    return uint128ToPyLongObject(value);
  }

  return Py_BuildValue("k", ap.getRegisterValue(reg));
}

static int validItem(rpmTagClass tclass, PyObject *item)
{
    int rc;

    switch (tclass) {
    case RPM_NUMERIC_CLASS:
	rc = (PyLong_Check(item) || PyInt_Check(item));
	break;
    case RPM_STRING_CLASS:
	rc = (PyBytes_Check(item) || PyUnicode_Check(item));
	break;
    case RPM_BINARY_CLASS:
	rc = PyBytes_Check(item);
	break;
    default:
	rc = 0;
	break;
    }
    return rc;
}

/* adapted from Python source, floatobject.c:convert_to_double */
int
convert_to_double(PyObject *obj, double *dbl)
{
    if (PyFloat_Check(obj)) {
        *dbl = PyFloat_AS_DOUBLE(obj);
#ifndef IS_PY3K
    } else if (PyInt_Check(obj)) {
        *dbl = (double)PyInt_AS_LONG(obj);
#endif
    } else if (PyLong_Check(obj)) {
        *dbl = PyLong_AsDouble(obj);
        if (*dbl == -1.0 && PyErr_Occurred()) {
            return 0;
        }
    } else {
        PyErr_SetString(PyExc_ValueError, "Expected a number");
        return 0;
    }
    return 1;
}

static PyObject * AerospikePredicates_Equals(PyObject * self, PyObject * args)
{
	PyObject * py_bin = NULL;
	PyObject * py_val = NULL;

	if (PyArg_ParseTuple(args, "OO:equals", 
			&py_bin, &py_val) == false) {
		goto exit;
	}

	if (PyInt_Check(py_val) || PyLong_Check(py_val)) {
		return Py_BuildValue("iiOO", AS_PREDICATE_EQUAL, AS_INDEX_NUMERIC, py_bin, py_val);
	} else if (PyString_Check(py_val) || PyUnicode_Check(py_val)) {
		return Py_BuildValue("iiOO", AS_PREDICATE_EQUAL, AS_INDEX_STRING, py_bin, py_val);
	}

exit:
	Py_INCREF(Py_None);
	return Py_None;
}

static int
get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
{
    unsigned PY_LONG_LONG x;

    v = get_pylong(v);
    if (v == NULL)
        return -1;
    assert(PyLong_Check(v));
    x = PyLong_AsUnsignedLongLong(v);
    Py_DECREF(v);
    if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_OverflowError))
            PyErr_SetString(StructError,
                            "argument out of range");
        return -1;
    }
    *p = x;
    return 0;
}

VALUE ptorLong(PyObject* pNum)
{
	if(!PyLong_Check(pNum)) return Qnil;

	VALUE rNum;
	long cNum;

	cNum = PyLong_AsLong(pNum);

	if(PyErr_ExceptionMatches(PyExc_OverflowError))
	{
		rpPythonError();
		return Qnil;
	}

	rNum = INT2NUM(cNum);

	return rNum;
	
}

static int BufferObj_set_cfa(Buffer *self, PyObject *value, void *_)
{
	long cfa_id;

	if (PyInt_Check(value))
		cfa_id = PyInt_AS_LONG(value);
	else if (PyLong_Check(value))
		cfa_id = PyLong_AsLong(value);
	else
		return -1;

	if (cfa_id >= _PLDRAW_CFA_N_) {
		PyErr_SetString(PyExc_ValueError, "Invalid CFA identifier");
		return -1;
	}

	pldraw_set_cfa(self->pldraw, cfa_id);

	return Buffer_update_cached_colors(self);
}

//-----------------------------------------------------------------------------
// NumberVar_SetValue()
//   Set the value of the variable.
//-----------------------------------------------------------------------------
static int NumberVar_SetValue(
    udt_NumberVar *var,                 // variable to set value for
    unsigned pos,                       // array position to set
    PyObject *value)                    // value to set
{
#if PY_MAJOR_VERSION < 3
    if (PyInt_Check(value))
        return NumberVar_SetValueFromInteger(var, pos, value);
#endif
    if (PyLong_Check(value))
        return NumberVar_SetValueFromLong(var, pos, value);
    if (PyBool_Check(value))
        return NumberVar_SetValueFromBoolean(var, pos, value);
    if (PyFloat_Check(value))
        return NumberVar_SetValueFromFloat(var, pos, value);
    if (Py_TYPE(value) == g_DecimalType)
        return NumberVar_SetValueFromDecimal(var, pos, value);
    PyErr_SetString(PyExc_TypeError, "expecting numeric data");
    return -1;
}

static int
get_size_t(PyObject *v, size_t *p)
{
    size_t x;

    v = get_pylong(v);
    if (v == NULL)
        return -1;
    assert(PyLong_Check(v));
    x = PyLong_AsSize_t(v);
    Py_DECREF(v);
    if (x == (size_t)-1 && PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_OverflowError))
            PyErr_SetString(StructError,
                            "argument out of range");
        return -1;
    }
    *p = x;
    return 0;
}

bool ChPythonEngine::GetInteger(const char* variable, int& return_val)
{
	PyObject * module = PyImport_AddModule("__main__"); // borrowed reference
	assert(module);                                     // __main__ should always exist

	PyObject * dictionary = PyModule_GetDict(module);   // borrowed reference
	assert(dictionary);                                 // __main__ should have a dictionary

	PyObject * result = PyDict_GetItemString(dictionary, variable);   // borrowed reference
	if (!result) 
		return false;

	if (PyLong_Check(result)) 
	{
		return_val = PyLong_AsLong(result); 
		return true;
	}

	return false;
}

/*static*/ PyObject *
ReplicateAttributes_SetNewPeriodicOrigin(PyObject *self, PyObject *args)
{
    ReplicateAttributesObject *obj = (ReplicateAttributesObject *)self;

    double *dvals = obj->data->GetNewPeriodicOrigin();
    if(!PyArg_ParseTuple(args, "ddd", &dvals[0], &dvals[1], &dvals[2]))
    {
        PyObject     *tuple;
        if(!PyArg_ParseTuple(args, "O", &tuple))
            return NULL;

        if(PyTuple_Check(tuple))
        {
            if(PyTuple_Size(tuple) != 3)
                return NULL;

            PyErr_Clear();
            for(int i = 0; i < PyTuple_Size(tuple); ++i)
            {
                PyObject *item = PyTuple_GET_ITEM(tuple, i);
                if(PyFloat_Check(item))
                    dvals[i] = PyFloat_AS_DOUBLE(item);
                else if(PyInt_Check(item))
                    dvals[i] = double(PyInt_AS_LONG(item));
                else if(PyLong_Check(item))
                    dvals[i] = PyLong_AsDouble(item);
                else
                    dvals[i] = 0.;
            }
        }
        else
            return NULL;
    }

    // Mark the newPeriodicOrigin in the object as modified.
    obj->data->SelectNewPeriodicOrigin();

    Py_INCREF(Py_None);
    return Py_None;
}

int
get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
{
  if (gdbpy_is_value_object (obj))
    *addr = value_as_address (value_object_to_value (obj));
  else if (PyLong_Check (obj))
    {
      /* Assume CORE_ADDR corresponds to unsigned long.  */
      *addr = PyLong_AsUnsignedLong (obj);
      if (PyErr_Occurred () != NULL)
	return 0;
    }
  else if (PyInt_Check (obj))
    {
      long val;

      /* Assume CORE_ADDR corresponds to unsigned long.  */
      val = PyInt_AsLong (obj);

      if (val >= 0)
	*addr = val;
      else
      {
	/* If no error ocurred, VAL is indeed negative.  */
	if (PyErr_Occurred () != NULL)
	  return 0;

	PyErr_SetString (PyExc_ValueError,
			 _("Supplied address is negative."));
	return 0;
      }
    }
  else
    {
      PyErr_SetString (PyExc_TypeError,
		       _("Invalid type for address."));
      return 0;
    }

  return 1;
}

/*static*/ PyObject *
TransferFunctionWidget_SetPosition(PyObject *self, PyObject *args)
{
    TransferFunctionWidgetObject *obj = (TransferFunctionWidgetObject *)self;

    float *fvals = obj->data->GetPosition();
    if(!PyArg_ParseTuple(args, "ffffffff", &fvals[0], &fvals[1], &fvals[2], &fvals[3], &fvals[4], &fvals[5], &fvals[6], &fvals[7]))
    {
        PyObject     *tuple;
        if(!PyArg_ParseTuple(args, "O", &tuple))
            return NULL;

        if(PyTuple_Check(tuple))
        {
            if(PyTuple_Size(tuple) != 8)
                return NULL;

            PyErr_Clear();
            for(int i = 0; i < PyTuple_Size(tuple); ++i)
            {
                PyObject *item = PyTuple_GET_ITEM(tuple, i);
                if(PyFloat_Check(item))
                    fvals[i] = float(PyFloat_AS_DOUBLE(item));
                else if(PyInt_Check(item))
                    fvals[i] = float(PyInt_AS_LONG(item));
                else if(PyLong_Check(item))
                    fvals[i] = float(PyLong_AsDouble(item));
                else
                    fvals[i] = 0.;
            }
        }
        else
            return NULL;
    }

    // Mark the Position in the object as modified.
    obj->data->SelectPosition();

    Py_INCREF(Py_None);
    return Py_None;
}

static int
music_delivery(sp_session * session, const sp_audioformat * format,
               const void *frames, int num_frames)
{
    PyGILState_STATE gstate;
    PyObject *res, *method;

#ifdef DEBUG
        fprintf(stderr, "[DEBUG]-session- >> music_delivery called\n");
#endif
    gstate = PyGILState_Ensure();
    int siz = frame_size(format);
    PyObject *pyframes = PyBuffer_FromMemory((void *)frames, num_frames * siz);
    Session *psession =
        (Session *) PyObject_CallObject((PyObject *)&SessionType, NULL);
    psession->_session = session;
    PyObject *client = (PyObject *)sp_session_userdata(session);
    method = PyObject_GetAttrString(client, "music_delivery");
    res =
        PyObject_CallFunction(method, "OOiiiii", psession,
                              pyframes, siz, num_frames, format->sample_type,
                              format->sample_rate, format->channels);
    int consumed = num_frames;  // assume all consumed
    if (!res)
        PyErr_WriteUnraisable(method);
    if (PyInt_Check(res))
        consumed = (int)PyInt_AsLong(res);
    else if (PyLong_Check(res))
        consumed = (int)PyLong_AsLong(res);
    else {
        PyErr_SetString(PyExc_TypeError,
                        "music_delivery must return an integer");
        PyErr_WriteUnraisable(method);
    }
    Py_DECREF(pyframes);
    Py_DECREF(psession);
    Py_XDECREF(res);
    Py_DECREF(method);
    PyGILState_Release(gstate);
    return consumed;
}

/*static*/ PyObject *
RadialResampleAttributes_SetCenter(PyObject *self, PyObject *args)
{
    RadialResampleAttributesObject *obj = (RadialResampleAttributesObject *)self;

    float *fvals = obj->data->GetCenter();
    if(!PyArg_ParseTuple(args, "fff", &fvals[0], &fvals[1], &fvals[2]))
    {
        PyObject     *tuple;
        if(!PyArg_ParseTuple(args, "O", &tuple))
            return NULL;

        if(PyTuple_Check(tuple))
        {
            if(PyTuple_Size(tuple) != 3)
                return NULL;

            PyErr_Clear();
            for(int i = 0; i < PyTuple_Size(tuple); ++i)
            {
                PyObject *item = PyTuple_GET_ITEM(tuple, i);
                if(PyFloat_Check(item))
                    fvals[i] = float(PyFloat_AS_DOUBLE(item));
                else if(PyInt_Check(item))
                    fvals[i] = float(PyInt_AS_LONG(item));
                else if(PyLong_Check(item))
                    fvals[i] = float(PyLong_AsDouble(item));
                else
                    fvals[i] = 0.;
            }
        }
        else
            return NULL;
    }

    // Mark the center in the object as modified.
    obj->data->SelectCenter();

    Py_INCREF(Py_None);
    return Py_None;
}

PyObject* pyInfoTree::graft(pyInfoTreeObject* self, PyObject* args, PyObject* kwds) {
  const char* path = nullptr;
  PyObject* val = 0;
  static char* kwlist[] = {(char*)"path", (char*)"value", nullptr};
  if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO", kwlist, &path, &val)) {
    Py_INCREF(Py_False);
    return Py_False;
  }
  if (PyBool_Check(val)) {
    if (!self->tree->graft(path, InfoTree::make(PyObject_IsTrue(val) ? true : false))) {
      Py_INCREF(Py_False);
      return Py_False;
    }
  } else if (PyLong_Check(val)) {
    if (!self->tree->graft(path, InfoTree::make(PyLong_AsLong(val)))) {
      Py_INCREF(Py_False);
      return Py_False;
    }
  } else if (PyFloat_Check(val)) {
    if (!self->tree->graft(path, InfoTree::make(PyFloat_AsDouble(val)))) {
      Py_INCREF(Py_False);
      return Py_False;
    }
  } else if (PyUnicode_Check(val)) {
    if (!self->tree->graft(path, InfoTree::make(PyUnicode_AsUTF8(val)))) {
      Py_INCREF(Py_False);
      return Py_False;
    }
  } else if (PyObject_IsInstance(val, reinterpret_cast<PyObject*>(&pyInfoTree::pyType))) {
    if (!self->tree->graft(path, reinterpret_cast<pyInfoTree::pyInfoTreeObject*>(val)->keepAlive)) {
      Py_INCREF(Py_False);
      return Py_False;
    }
  } else {  // unsorted PyObject type
    Py_INCREF(Py_False);
    return Py_False;
  }
  // return true if everything went well
  Py_INCREF(Py_True);
  return Py_True;
}

static int
SpiDev_set_mode(SpiDevObject *self, PyObject *val, void *closure)
{
	uint8_t mode, tmp;

	if (val == NULL) {
		PyErr_SetString(PyExc_TypeError,
			"Cannot delete attribute");
		return -1;
	}
#if PY_MAJOR_VERSION < 3
	if (PyInt_Check(val)) {
		mode = PyInt_AS_LONG(val);
	} else
#endif
	{
		if (PyLong_Check(val)) {
			mode = PyLong_AS_LONG(val);
		} else {
			PyErr_SetString(PyExc_TypeError,
				"The mode attribute must be an integer");
			return -1;
		}
	}


	if ( mode > 3 ) {
		PyErr_SetString(PyExc_TypeError,
			"The mode attribute must be an integer"
				 "between 0 and 3.");
		return -1;
	}

	// clean and set CPHA and CPOL bits
	tmp = ( self->mode & ~(SPI_CPHA | SPI_CPOL) ) | mode ;

	__spidev_set_mode(self->fd, tmp);

	self->mode = tmp;
	return 0;
}

PyObject *KX_VertexProxy::PySetRGBA(PyObject *value)
{
	if (PyLong_Check(value)) {
		int rgba = PyLong_AsLong(value);
		m_vertex->SetRGBA(rgba);
		m_mesh->SetMeshModified(true);
		Py_RETURN_NONE;
	}
	else {
		MT_Vector4 vec;
		if (PyVecTo(value, vec))
		{
			m_vertex->SetRGBA(vec);
			m_mesh->SetMeshModified(true);
			Py_RETURN_NONE;
		}
	}

	PyErr_SetString(PyExc_TypeError, "vert.setRGBA(value): KX_VertexProxy, expected a 4D vector or an int");
	return NULL;
}

	Object to_object(PyObject *obj){
		if (PyBool_Check(obj))
			return AB::to_object( obj == Py_True );
		if (PyFloat_Check(obj))
			return AB::to_object( PyFloat_AsDouble(obj) );
		if (PyLong_Check(obj))
			return AB::to_object( (int)PyLong_AsLong(obj) );
		if (PyInt_Check(obj))
			return AB::to_object( (int)PyInt_AsLong(obj) );
		if (PyUnicode_Check(obj)){
			Py_ssize_t size;
			const char *str;
			PyObject_AsCharBuffer(obj, &str, &size);
			std::string str8{str};
			PyMem_Free((void*)str);

			return AB::to_object( str8 );
		}
		
		throw(AB::object_not_convertible( obj->ob_type->tp_name, "Object"));
	}

static PyObject *
RangeSubscript(PyObject *self, PyObject* idx)
{
	if (PyLong_Check(idx)) {
		long _idx = PyLong_AsLong(idx);
		return RangeItem((RangeObject *)(self), _idx);
	} else if (PySlice_Check(idx)) {
		Py_ssize_t start, stop, step, slicelen;

		if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
								 ((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
								 &start, &stop,
								 &step, &slicelen) < 0) {
			return NULL;
		}
		return RangeSlice((RangeObject *)(self), start, stop);
	} else {
		RAISE_INVALID_INDEX_TYPE(idx);
		return NULL;
	}
}