static PyObject *
myutils_minmax(PyObject *self, PyObject *args, PyObject *kwds)
{
    const char *name = "minmax";
    PyObject *minitem, *maxitem, *item, *result, *v, *iterator;
    const int positional = PyTuple_Size(args) > 1;

    PyObject *emptytuple, *defaultval = NULL, *keyfunc = NULL;
    static char *kwlist[] = {"key", "default", NULL};
    int ret;

    if (positional) {
        v = args;
    }
    else if (!PyArg_UnpackTuple(args, name, 1, 1, &v)) {
        if (PyExceptionClass_Check(PyExc_TypeError)) {
            PyErr_Format(PyExc_TypeError, "%s expected at least 1 argument, "
                                          "got 0", name);
        }
        return NULL;
    }

    emptytuple = PyTuple_New(0);                       /* own ref (new) */
    if (emptytuple == NULL) {
        return NULL;
    }
    ret = PyArg_ParseTupleAndKeywords(emptytuple, kwds, "|$OO:minmax",
                                      kwlist, &keyfunc, &defaultval);
    Py_DECREF(emptytuple);                             /* discard ref */
    if (!ret) {
        return NULL;
    }

    if (positional && defaultval != NULL) {
        PyErr_Format(PyExc_TypeError,
            "Cannot specify a default for %s() with multiple "
            "positional arguments", name);
        return NULL;
    }

    iterator = PyObject_GetIter(v);                    /* own ref (new) */
    if (iterator == NULL) {
        return NULL;
    }
                                                       /* own ref (new) */
    if (( minitem = maxitem = PyIter_Next(iterator) ) == NULL) {
        if (defaultval != NULL) {
            Py_INCREF(defaultval); /* own it */
            Py_DECREF(iterator);
            return defaultval;
        }
        else {
            PyErr_Format(PyExc_ValueError,
                         "%s() arg is an empty sequence", name);
            Py_DECREF(iterator);
            return NULL;
        }

    }
    Py_INCREF(maxitem);

    /* two paths */
    /* (1) keyfunc is NULL or Py_None. */
    if (keyfunc == NULL || keyfunc == Py_None) {
        int cmp_max, cmp_min;
        while (( item = PyIter_Next(iterator) )) {     /* own new ref */

            cmp_max = PyObject_RichCompareBool(item, maxitem, Py_GT);
            cmp_min = PyObject_RichCompareBool(item, minitem, Py_LT);

            if (cmp_max < 0 || cmp_min < 0) {          /* error */
                goto Fail_it_item;
            }
            else if (cmp_max > 0) {                    /* item > maxitem */
                Py_DECREF(maxitem);
                maxitem = item;
            }
            else if (cmp_min > 0) {                    /* item < minitem */
                Py_DECREF(minitem);
                minitem = item;
            }
            /* neither maxitem nor minitem were assigned item */
            else {
                Py_DECREF(item);
            }
        }
        /* error indicator set? */
        if (PyErr_Occurred()) {
            goto Fail_it;
        }
        result = PyTuple_Pack(2, minitem, maxitem);    /* own ref (new) */
        Py_DECREF(maxitem);
        Py_DECREF(minitem);
        Py_DECREF(iterator);

        /* transfer ownership of reference */
        return result;

        Fail_it_item:
            Py_DECREF(item);
        Fail_it:
            Py_XDECREF(minitem);
            Py_XDECREF(maxitem);
            Py_DECREF(iterator);
            return NULL;
    }
    /* (2) keyfunc is not NULL nor Py_None. */
    else {
        int cmp_max, cmp_min;
        PyObject *minval, *maxval, *val;
                                                        /* own ref */
        minval = maxval = PyObject_CallOneArg(keyfunc, minitem);
        if (minval == NULL) {
            Py_DECREF(minitem);
            Py_DECREF(maxitem);
            Py_DECREF(iterator);
            return NULL;
        }
        Py_INCREF(maxval);

        while (( item = PyIter_Next(iterator) )) {      /* own ref (new) */
            val = PyObject_CallOneArg(keyfunc, item);   /* own ref */
            if (val == NULL) {
                goto Fail_it_item_2;
            }

            cmp_max = PyObject_RichCompareBool(val, maxval, Py_GT);
            cmp_min = PyObject_RichCompareBool(val, minval, Py_LT);

            if (cmp_max < 0 || cmp_min < 0) {           /* error */
                goto Fail_it_item_and_val_2;
            }
            else if (cmp_max > 0) {                     /* val > maxval */
                Py_DECREF(maxitem);
                Py_DECREF(maxval);
                maxitem = item;
                maxval = val;
            }
            else if (cmp_min > 0) {                     /* val < minval */
                Py_DECREF(minitem);
                Py_DECREF(minval);
                minitem = item;
                minval = val;
            }
            /* neither maxitem nor minitem were assigned item */
            else {
                Py_DECREF(item);
                Py_DECREF(val);
            }
        }
        /* error indicator set? */
        if (PyErr_Occurred()) {
            goto Fail_it_2;
        }

        result = PyTuple_Pack(2, minitem, maxitem);     /* own new ref */
        Py_DECREF(maxitem);
        Py_DECREF(minitem);
        Py_DECREF(maxval);
        Py_DECREF(minval);
        Py_DECREF(iterator);

        /* transfer ownership of reference */
        return result;

        Fail_it_item_and_val_2:
            Py_DECREF(val);
        Fail_it_item_2:
            Py_DECREF(item);
        Fail_it_2:
            Py_XDECREF(minitem);
            Py_XDECREF(maxitem);
            Py_XDECREF(minval);
            Py_XDECREF(maxval);
            Py_DECREF(iterator);
            return NULL;
    }
}

PyDoc_STRVAR(minmax_doc,
"minmax(iterable, *[, default=obj, key=func]) -> tuple\n\
minmax(arg1, arg2, *args, *[, key=func]) -> tuple\n\
\n\
With a single iterable argument, return its smallest and \n\
largest item. The default keyword-only argument specifies \n\
an object to return if the provided iterable is empty. This\n\
may not be a tuple.\n\
With two or more arguments, return the smallest and largest\n\
arguments.");