diff --git a/Modules/stropmodule.c b/Modules/stropmodule.c
index 2d88474..090b07e 100644
--- a/Modules/stropmodule.c
+++ b/Modules/stropmodule.c
@@ -14,8 +14,8 @@
    XXX are defined for all 8-bit characters! */
 
 #define WARN if (PyErr_Warn(PyExc_DeprecationWarning, \
-		       "strop functions are obsolete; use string methods")) \
-	     return NULL
+               "strop functions are obsolete; use string methods")) \
+         return NULL
 
 /* The lstrip(), rstrip() and strip() functions are implemented
    in do_strip(), which uses an additional parameter to indicate what
@@ -29,56 +29,56 @@
 static PyObject *
 split_whitespace(char *s, Py_ssize_t len, Py_ssize_t maxsplit)
 {
-	Py_ssize_t i = 0, j;
-	int err;
-	Py_ssize_t countsplit = 0;
-	PyObject* item;
-	PyObject *list = PyList_New(0);
+    Py_ssize_t i = 0, j;
+    int err;
+    Py_ssize_t countsplit = 0;
+    PyObject* item;
+    PyObject *list = PyList_New(0);
 
-	if (list == NULL)
-		return NULL;
+    if (list == NULL)
+        return NULL;
 
-	while (i < len) {
-		while (i < len && isspace(Py_CHARMASK(s[i]))) {
-			i = i+1;
-		}
-		j = i;
-		while (i < len && !isspace(Py_CHARMASK(s[i]))) {
-			i = i+1;
-		}
-		if (j < i) {
-			item = PyString_FromStringAndSize(s+j, i-j);
-			if (item == NULL)
-				goto finally;
+    while (i < len) {
+        while (i < len && isspace(Py_CHARMASK(s[i]))) {
+            i = i+1;
+        }
+        j = i;
+        while (i < len && !isspace(Py_CHARMASK(s[i]))) {
+            i = i+1;
+        }
+        if (j < i) {
+            item = PyString_FromStringAndSize(s+j, i-j);
+            if (item == NULL)
+                goto finally;
 
-			err = PyList_Append(list, item);
-			Py_DECREF(item);
-			if (err < 0)
-				goto finally;
+            err = PyList_Append(list, item);
+            Py_DECREF(item);
+            if (err < 0)
+                goto finally;
 
-			countsplit++;
-			while (i < len && isspace(Py_CHARMASK(s[i]))) {
-				i = i+1;
-			}
-			if (maxsplit && (countsplit >= maxsplit) && i < len) {
-				item = PyString_FromStringAndSize(
-                                        s+i, len - i);
-				if (item == NULL)
-					goto finally;
+            countsplit++;
+            while (i < len && isspace(Py_CHARMASK(s[i]))) {
+                i = i+1;
+            }
+            if (maxsplit && (countsplit >= maxsplit) && i < len) {
+                item = PyString_FromStringAndSize(
+                    s+i, len - i);
+                if (item == NULL)
+                    goto finally;
 
-				err = PyList_Append(list, item);
-				Py_DECREF(item);
-				if (err < 0)
-					goto finally;
+                err = PyList_Append(list, item);
+                Py_DECREF(item);
+                if (err < 0)
+                    goto finally;
 
-				i = len;
-			}
-		}
-	}
-	return list;
+                i = len;
+            }
+        }
+    }
+    return list;
   finally:
-	Py_DECREF(list);
-	return NULL;
+    Py_DECREF(list);
+    return NULL;
 }
 
 
@@ -96,60 +96,60 @@
 static PyObject *
 strop_splitfields(PyObject *self, PyObject *args)
 {
-	Py_ssize_t len, n, i, j, err;
-	Py_ssize_t splitcount, maxsplit;
-	char *s, *sub;
-	PyObject *list, *item;
+    Py_ssize_t len, n, i, j, err;
+    Py_ssize_t splitcount, maxsplit;
+    char *s, *sub;
+    PyObject *list, *item;
 
-	WARN;
-	sub = NULL;
-	n = 0;
-	splitcount = 0;
-	maxsplit = 0;
-	if (!PyArg_ParseTuple(args, "t#|z#n:split", &s, &len, &sub, &n, &maxsplit))
-		return NULL;
-	if (sub == NULL)
-		return split_whitespace(s, len, maxsplit);
-	if (n == 0) {
-		PyErr_SetString(PyExc_ValueError, "empty separator");
-		return NULL;
-	}
+    WARN;
+    sub = NULL;
+    n = 0;
+    splitcount = 0;
+    maxsplit = 0;
+    if (!PyArg_ParseTuple(args, "t#|z#n:split", &s, &len, &sub, &n, &maxsplit))
+        return NULL;
+    if (sub == NULL)
+        return split_whitespace(s, len, maxsplit);
+    if (n == 0) {
+        PyErr_SetString(PyExc_ValueError, "empty separator");
+        return NULL;
+    }
 
-	list = PyList_New(0);
-	if (list == NULL)
-		return NULL;
+    list = PyList_New(0);
+    if (list == NULL)
+        return NULL;
 
-	i = j = 0;
-	while (i+n <= len) {
-		if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
-			item = PyString_FromStringAndSize(s+j, i-j);
-			if (item == NULL)
-				goto fail;
-			err = PyList_Append(list, item);
-			Py_DECREF(item);
-			if (err < 0)
-				goto fail;
-			i = j = i + n;
-			splitcount++;
-			if (maxsplit && (splitcount >= maxsplit))
-				break;
-		}
-		else
-			i++;
-	}
-	item = PyString_FromStringAndSize(s+j, len-j);
-	if (item == NULL)
-		goto fail;
-	err = PyList_Append(list, item);
-	Py_DECREF(item);
-	if (err < 0)
-		goto fail;
+    i = j = 0;
+    while (i+n <= len) {
+        if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
+            item = PyString_FromStringAndSize(s+j, i-j);
+            if (item == NULL)
+                goto fail;
+            err = PyList_Append(list, item);
+            Py_DECREF(item);
+            if (err < 0)
+                goto fail;
+            i = j = i + n;
+            splitcount++;
+            if (maxsplit && (splitcount >= maxsplit))
+                break;
+        }
+        else
+            i++;
+    }
+    item = PyString_FromStringAndSize(s+j, len-j);
+    if (item == NULL)
+        goto fail;
+    err = PyList_Append(list, item);
+    Py_DECREF(item);
+    if (err < 0)
+        goto fail;
 
-	return list;
+    return list;
 
  fail:
-	Py_DECREF(list);
-	return NULL;
+    Py_DECREF(list);
+    return NULL;
 }
 
 
@@ -166,128 +166,128 @@
 static PyObject *
 strop_joinfields(PyObject *self, PyObject *args)
 {
-	PyObject *seq;
-	char *sep = NULL;
-	Py_ssize_t seqlen, seplen = 0;
-	Py_ssize_t i, reslen = 0, slen = 0, sz = 100;
-	PyObject *res = NULL;
-	char* p = NULL;
-	ssizeargfunc getitemfunc;
+    PyObject *seq;
+    char *sep = NULL;
+    Py_ssize_t seqlen, seplen = 0;
+    Py_ssize_t i, reslen = 0, slen = 0, sz = 100;
+    PyObject *res = NULL;
+    char* p = NULL;
+    ssizeargfunc getitemfunc;
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "O|t#:join", &seq, &sep, &seplen))
-		return NULL;
-	if (sep == NULL) {
-		sep = " ";
-		seplen = 1;
-	}
+    WARN;
+    if (!PyArg_ParseTuple(args, "O|t#:join", &seq, &sep, &seplen))
+        return NULL;
+    if (sep == NULL) {
+        sep = " ";
+        seplen = 1;
+    }
 
-	seqlen = PySequence_Size(seq);
-	if (seqlen < 0 && PyErr_Occurred())
-		return NULL;
+    seqlen = PySequence_Size(seq);
+    if (seqlen < 0 && PyErr_Occurred())
+        return NULL;
 
-	if (seqlen == 1) {
-		/* Optimization if there's only one item */
-		PyObject *item = PySequence_GetItem(seq, 0);
-		if (item && !PyString_Check(item)) {
-			PyErr_SetString(PyExc_TypeError,
-				 "first argument must be sequence of strings");
-			Py_DECREF(item);
-			return NULL;
-		}
-		return item;
-	}
+    if (seqlen == 1) {
+        /* Optimization if there's only one item */
+        PyObject *item = PySequence_GetItem(seq, 0);
+        if (item && !PyString_Check(item)) {
+            PyErr_SetString(PyExc_TypeError,
+                     "first argument must be sequence of strings");
+            Py_DECREF(item);
+            return NULL;
+        }
+        return item;
+    }
 
-	if (!(res = PyString_FromStringAndSize((char*)NULL, sz)))
-		return NULL;
-	p = PyString_AsString(res);
+    if (!(res = PyString_FromStringAndSize((char*)NULL, sz)))
+        return NULL;
+    p = PyString_AsString(res);
 
-	/* optimize for lists, since it's the most common case.  all others
-	 * (tuples and arbitrary sequences) just use the sequence abstract
-	 * interface.
-	 */
-	if (PyList_Check(seq)) {
-		for (i = 0; i < seqlen; i++) {
-			PyObject *item = PyList_GET_ITEM(seq, i);
-			if (!PyString_Check(item)) {
-				PyErr_SetString(PyExc_TypeError,
-				"first argument must be sequence of strings");
-				Py_DECREF(res);
-				return NULL;
-			}
-			slen = PyString_GET_SIZE(item);
-			if (slen > PY_SSIZE_T_MAX - reslen ||
-			    seplen > PY_SSIZE_T_MAX - reslen - seplen) {
-				PyErr_SetString(PyExc_OverflowError,
-						"input too long");
-				Py_DECREF(res);
-				return NULL;
-			}
-			while (reslen + slen + seplen >= sz) {
-				if (_PyString_Resize(&res, sz * 2) < 0)
-					return NULL;
-				sz *= 2;
-				p = PyString_AsString(res) + reslen;
-			}
-			if (i > 0) {
-				memcpy(p, sep, seplen);
-				p += seplen;
-				reslen += seplen;
-			}
-			memcpy(p, PyString_AS_STRING(item), slen);
-			p += slen;
-			reslen += slen;
-		}
-		_PyString_Resize(&res, reslen);
-		return res;
-	}
+    /* optimize for lists, since it's the most common case.  all others
+     * (tuples and arbitrary sequences) just use the sequence abstract
+     * interface.
+     */
+    if (PyList_Check(seq)) {
+        for (i = 0; i < seqlen; i++) {
+            PyObject *item = PyList_GET_ITEM(seq, i);
+            if (!PyString_Check(item)) {
+                PyErr_SetString(PyExc_TypeError,
+                "first argument must be sequence of strings");
+                Py_DECREF(res);
+                return NULL;
+            }
+            slen = PyString_GET_SIZE(item);
+            if (slen > PY_SSIZE_T_MAX - reslen ||
+                seplen > PY_SSIZE_T_MAX - reslen - seplen) {
+                PyErr_SetString(PyExc_OverflowError,
+                                "input too long");
+                Py_DECREF(res);
+                return NULL;
+            }
+            while (reslen + slen + seplen >= sz) {
+                if (_PyString_Resize(&res, sz * 2) < 0)
+                    return NULL;
+                sz *= 2;
+                p = PyString_AsString(res) + reslen;
+            }
+            if (i > 0) {
+                memcpy(p, sep, seplen);
+                p += seplen;
+                reslen += seplen;
+            }
+            memcpy(p, PyString_AS_STRING(item), slen);
+            p += slen;
+            reslen += slen;
+        }
+        _PyString_Resize(&res, reslen);
+        return res;
+    }
 
-	if (seq->ob_type->tp_as_sequence == NULL ||
-		 (getitemfunc = seq->ob_type->tp_as_sequence->sq_item) == NULL)
-	{
-		PyErr_SetString(PyExc_TypeError,
-				"first argument must be a sequence");
-		return NULL;
-	}
-	/* This is now type safe */
-	for (i = 0; i < seqlen; i++) {
-		PyObject *item = getitemfunc(seq, i);
-		if (!item || !PyString_Check(item)) {
-			PyErr_SetString(PyExc_TypeError,
-				 "first argument must be sequence of strings");
-			Py_DECREF(res);
-			Py_XDECREF(item);
-			return NULL;
-		}
-		slen = PyString_GET_SIZE(item);
-		if (slen > PY_SSIZE_T_MAX - reslen ||
-		    seplen > PY_SSIZE_T_MAX - reslen - seplen) {
-			PyErr_SetString(PyExc_OverflowError,
-					"input too long");
-			Py_DECREF(res);
-			Py_XDECREF(item);
-			return NULL;
-		}
-		while (reslen + slen + seplen >= sz) {
-			if (_PyString_Resize(&res, sz * 2) < 0) {
-				Py_DECREF(item);
-				return NULL;
-			}
-			sz *= 2;
-			p = PyString_AsString(res) + reslen;
-		}
-		if (i > 0) {
-			memcpy(p, sep, seplen);
-			p += seplen;
-			reslen += seplen;
-		}
-		memcpy(p, PyString_AS_STRING(item), slen);
-		p += slen;
-		reslen += slen;
-		Py_DECREF(item);
-	}
-	_PyString_Resize(&res, reslen);
-	return res;
+    if (seq->ob_type->tp_as_sequence == NULL ||
+             (getitemfunc = seq->ob_type->tp_as_sequence->sq_item) == NULL)
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "first argument must be a sequence");
+        return NULL;
+    }
+    /* This is now type safe */
+    for (i = 0; i < seqlen; i++) {
+        PyObject *item = getitemfunc(seq, i);
+        if (!item || !PyString_Check(item)) {
+            PyErr_SetString(PyExc_TypeError,
+                     "first argument must be sequence of strings");
+            Py_DECREF(res);
+            Py_XDECREF(item);
+            return NULL;
+        }
+        slen = PyString_GET_SIZE(item);
+        if (slen > PY_SSIZE_T_MAX - reslen ||
+            seplen > PY_SSIZE_T_MAX - reslen - seplen) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "input too long");
+            Py_DECREF(res);
+            Py_XDECREF(item);
+            return NULL;
+        }
+        while (reslen + slen + seplen >= sz) {
+            if (_PyString_Resize(&res, sz * 2) < 0) {
+                Py_DECREF(item);
+                return NULL;
+            }
+            sz *= 2;
+            p = PyString_AsString(res) + reslen;
+        }
+        if (i > 0) {
+            memcpy(p, sep, seplen);
+            p += seplen;
+            reslen += seplen;
+        }
+        memcpy(p, PyString_AS_STRING(item), slen);
+        p += slen;
+        reslen += slen;
+        Py_DECREF(item);
+    }
+    _PyString_Resize(&res, reslen);
+    return res;
 }
 
 
@@ -303,34 +303,34 @@
 static PyObject *
 strop_find(PyObject *self, PyObject *args)
 {
-	char *s, *sub;
-	Py_ssize_t len, n, i = 0, last = PY_SSIZE_T_MAX;
+    char *s, *sub;
+    Py_ssize_t len, n, i = 0, last = PY_SSIZE_T_MAX;
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "t#t#|nn:find", &s, &len, &sub, &n, &i, &last))
-		return NULL;
+    WARN;
+    if (!PyArg_ParseTuple(args, "t#t#|nn:find", &s, &len, &sub, &n, &i, &last))
+        return NULL;
 
-	if (last > len)
-		last = len;
-	if (last < 0)
-		last += len;
-	if (last < 0)
-		last = 0;
-	if (i < 0)
-		i += len;
-	if (i < 0)
-		i = 0;
+    if (last > len)
+        last = len;
+    if (last < 0)
+        last += len;
+    if (last < 0)
+        last = 0;
+    if (i < 0)
+        i += len;
+    if (i < 0)
+        i = 0;
 
-	if (n == 0 && i <= last)
-		return PyInt_FromLong((long)i);
+    if (n == 0 && i <= last)
+        return PyInt_FromLong((long)i);
 
-	last -= n;
-	for (; i <= last; ++i)
-		if (s[i] == sub[0] &&
-		    (n == 1 || memcmp(&s[i+1], &sub[1], n-1) == 0))
-			return PyInt_FromLong((long)i);
+    last -= n;
+    for (; i <= last; ++i)
+        if (s[i] == sub[0] &&
+            (n == 1 || memcmp(&s[i+1], &sub[1], n-1) == 0))
+            return PyInt_FromLong((long)i);
 
-	return PyInt_FromLong(-1L);
+    return PyInt_FromLong(-1L);
 }
 
 
@@ -346,68 +346,68 @@
 static PyObject *
 strop_rfind(PyObject *self, PyObject *args)
 {
-	char *s, *sub;
-	Py_ssize_t len, n, j;
-	Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
+    char *s, *sub;
+    Py_ssize_t len, n, j;
+    Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "t#t#|nn:rfind", &s, &len, &sub, &n, &i, &last))
-		return NULL;
+    WARN;
+    if (!PyArg_ParseTuple(args, "t#t#|nn:rfind", &s, &len, &sub, &n, &i, &last))
+        return NULL;
 
-	if (last > len)
-		last = len;
-	if (last < 0)
-		last += len;
-	if (last < 0)
-		last = 0;
-	if (i < 0)
-		i += len;
-	if (i < 0)
-		i = 0;
+    if (last > len)
+        last = len;
+    if (last < 0)
+        last += len;
+    if (last < 0)
+        last = 0;
+    if (i < 0)
+        i += len;
+    if (i < 0)
+        i = 0;
 
-	if (n == 0 && i <= last)
-		return PyInt_FromLong((long)last);
+    if (n == 0 && i <= last)
+        return PyInt_FromLong((long)last);
 
-	for (j = last-n; j >= i; --j)
-		if (s[j] == sub[0] &&
-		    (n == 1 || memcmp(&s[j+1], &sub[1], n-1) == 0))
-			return PyInt_FromLong((long)j);
+    for (j = last-n; j >= i; --j)
+        if (s[j] == sub[0] &&
+            (n == 1 || memcmp(&s[j+1], &sub[1], n-1) == 0))
+            return PyInt_FromLong((long)j);
 
-	return PyInt_FromLong(-1L);
+    return PyInt_FromLong(-1L);
 }
 
 
 static PyObject *
 do_strip(PyObject *args, int striptype)
 {
-	char *s;
-	Py_ssize_t len, i, j;
+    char *s;
+    Py_ssize_t len, i, j;
 
 
-	if (PyString_AsStringAndSize(args, &s, &len))
-		return NULL;
+    if (PyString_AsStringAndSize(args, &s, &len))
+        return NULL;
 
-	i = 0;
-	if (striptype != RIGHTSTRIP) {
-		while (i < len && isspace(Py_CHARMASK(s[i]))) {
-			i++;
-		}
-	}
+    i = 0;
+    if (striptype != RIGHTSTRIP) {
+        while (i < len && isspace(Py_CHARMASK(s[i]))) {
+            i++;
+        }
+    }
 
-	j = len;
-	if (striptype != LEFTSTRIP) {
-		do {
-			j--;
-		} while (j >= i && isspace(Py_CHARMASK(s[j])));
-		j++;
-	}
+    j = len;
+    if (striptype != LEFTSTRIP) {
+        do {
+            j--;
+        } while (j >= i && isspace(Py_CHARMASK(s[j])));
+        j++;
+    }
 
-	if (i == 0 && j == len) {
-		Py_INCREF(args);
-		return args;
-	}
-	else
-		return PyString_FromStringAndSize(s+i, j-i);
+    if (i == 0 && j == len) {
+        Py_INCREF(args);
+        return args;
+    }
+    else
+        return PyString_FromStringAndSize(s+i, j-i);
 }
 
 
@@ -420,8 +420,8 @@
 static PyObject *
 strop_strip(PyObject *self, PyObject *args)
 {
-	WARN;
-	return do_strip(args, BOTHSTRIP);
+    WARN;
+    return do_strip(args, BOTHSTRIP);
 }
 
 
@@ -433,8 +433,8 @@
 static PyObject *
 strop_lstrip(PyObject *self, PyObject *args)
 {
-	WARN;
-	return do_strip(args, LEFTSTRIP);
+    WARN;
+    return do_strip(args, LEFTSTRIP);
 }
 
 
@@ -446,8 +446,8 @@
 static PyObject *
 strop_rstrip(PyObject *self, PyObject *args)
 {
-	WARN;
-	return do_strip(args, RIGHTSTRIP);
+    WARN;
+    return do_strip(args, RIGHTSTRIP);
 }
 
 
@@ -459,34 +459,34 @@
 static PyObject *
 strop_lower(PyObject *self, PyObject *args)
 {
-	char *s, *s_new;
-	Py_ssize_t i, n;
-	PyObject *newstr;
-	int changed;
+    char *s, *s_new;
+    Py_ssize_t i, n;
+    PyObject *newstr;
+    int changed;
 
-	WARN;
-	if (PyString_AsStringAndSize(args, &s, &n))
-		return NULL;
-	newstr = PyString_FromStringAndSize(NULL, n);
-	if (newstr == NULL)
-		return NULL;
-	s_new = PyString_AsString(newstr);
-	changed = 0;
-	for (i = 0; i < n; i++) {
-		int c = Py_CHARMASK(*s++);
-		if (isupper(c)) {
-			changed = 1;
-			*s_new = tolower(c);
-		} else
-			*s_new = c;
-		s_new++;
-	}
-	if (!changed) {
-		Py_DECREF(newstr);
-		Py_INCREF(args);
-		return args;
-	}
-	return newstr;
+    WARN;
+    if (PyString_AsStringAndSize(args, &s, &n))
+        return NULL;
+    newstr = PyString_FromStringAndSize(NULL, n);
+    if (newstr == NULL)
+        return NULL;
+    s_new = PyString_AsString(newstr);
+    changed = 0;
+    for (i = 0; i < n; i++) {
+        int c = Py_CHARMASK(*s++);
+        if (isupper(c)) {
+            changed = 1;
+            *s_new = tolower(c);
+        } else
+            *s_new = c;
+        s_new++;
+    }
+    if (!changed) {
+        Py_DECREF(newstr);
+        Py_INCREF(args);
+        return args;
+    }
+    return newstr;
 }
 
 
@@ -498,34 +498,34 @@
 static PyObject *
 strop_upper(PyObject *self, PyObject *args)
 {
-	char *s, *s_new;
-	Py_ssize_t i, n;
-	PyObject *newstr;
-	int changed;
+    char *s, *s_new;
+    Py_ssize_t i, n;
+    PyObject *newstr;
+    int changed;
 
-	WARN;
-	if (PyString_AsStringAndSize(args, &s, &n))
-		return NULL;
-	newstr = PyString_FromStringAndSize(NULL, n);
-	if (newstr == NULL)
-		return NULL;
-	s_new = PyString_AsString(newstr);
-	changed = 0;
-	for (i = 0; i < n; i++) {
-		int c = Py_CHARMASK(*s++);
-		if (islower(c)) {
-			changed = 1;
-			*s_new = toupper(c);
-		} else
-			*s_new = c;
-		s_new++;
-	}
-	if (!changed) {
-		Py_DECREF(newstr);
-		Py_INCREF(args);
-		return args;
-	}
-	return newstr;
+    WARN;
+    if (PyString_AsStringAndSize(args, &s, &n))
+        return NULL;
+    newstr = PyString_FromStringAndSize(NULL, n);
+    if (newstr == NULL)
+        return NULL;
+    s_new = PyString_AsString(newstr);
+    changed = 0;
+    for (i = 0; i < n; i++) {
+        int c = Py_CHARMASK(*s++);
+        if (islower(c)) {
+            changed = 1;
+            *s_new = toupper(c);
+        } else
+            *s_new = c;
+        s_new++;
+    }
+    if (!changed) {
+        Py_DECREF(newstr);
+        Py_INCREF(args);
+        return args;
+    }
+    return newstr;
 }
 
 
@@ -538,43 +538,43 @@
 static PyObject *
 strop_capitalize(PyObject *self, PyObject *args)
 {
-	char *s, *s_new;
-	Py_ssize_t i, n;
-	PyObject *newstr;
-	int changed;
+    char *s, *s_new;
+    Py_ssize_t i, n;
+    PyObject *newstr;
+    int changed;
 
-	WARN;
-	if (PyString_AsStringAndSize(args, &s, &n))
-		return NULL;
-	newstr = PyString_FromStringAndSize(NULL, n);
-	if (newstr == NULL)
-		return NULL;
-	s_new = PyString_AsString(newstr);
-	changed = 0;
-	if (0 < n) {
-		int c = Py_CHARMASK(*s++);
-		if (islower(c)) {
-			changed = 1;
-			*s_new = toupper(c);
-		} else
-			*s_new = c;
-		s_new++;
-	}
-	for (i = 1; i < n; i++) {
-		int c = Py_CHARMASK(*s++);
-		if (isupper(c)) {
-			changed = 1;
-			*s_new = tolower(c);
-		} else
-			*s_new = c;
-		s_new++;
-	}
-	if (!changed) {
-		Py_DECREF(newstr);
-		Py_INCREF(args);
-		return args;
-	}
-	return newstr;
+    WARN;
+    if (PyString_AsStringAndSize(args, &s, &n))
+        return NULL;
+    newstr = PyString_FromStringAndSize(NULL, n);
+    if (newstr == NULL)
+        return NULL;
+    s_new = PyString_AsString(newstr);
+    changed = 0;
+    if (0 < n) {
+        int c = Py_CHARMASK(*s++);
+        if (islower(c)) {
+            changed = 1;
+            *s_new = toupper(c);
+        } else
+            *s_new = c;
+        s_new++;
+    }
+    for (i = 1; i < n; i++) {
+        int c = Py_CHARMASK(*s++);
+        if (isupper(c)) {
+            changed = 1;
+            *s_new = tolower(c);
+        } else
+            *s_new = c;
+        s_new++;
+    }
+    if (!changed) {
+        Py_DECREF(newstr);
+        Py_INCREF(args);
+        return args;
+    }
+    return newstr;
 }
 
 
@@ -589,75 +589,75 @@
 static PyObject *
 strop_expandtabs(PyObject *self, PyObject *args)
 {
-	/* Original by Fredrik Lundh */
-	char* e;
-	char* p;
-	char* q;
-	Py_ssize_t i, j, old_j;
-	PyObject* out;
-	char* string;
-	Py_ssize_t stringlen;
-	int tabsize = 8;
+    /* Original by Fredrik Lundh */
+    char* e;
+    char* p;
+    char* q;
+    Py_ssize_t i, j, old_j;
+    PyObject* out;
+    char* string;
+    Py_ssize_t stringlen;
+    int tabsize = 8;
 
-	WARN;
-	/* Get arguments */
-	if (!PyArg_ParseTuple(args, "s#|i:expandtabs", &string, &stringlen, &tabsize))
-		return NULL;
-	if (tabsize < 1) {
-		PyErr_SetString(PyExc_ValueError,
-				"tabsize must be at least 1");
-		return NULL;
-	}
+    WARN;
+    /* Get arguments */
+    if (!PyArg_ParseTuple(args, "s#|i:expandtabs", &string, &stringlen, &tabsize))
+        return NULL;
+    if (tabsize < 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "tabsize must be at least 1");
+        return NULL;
+    }
 
-	/* First pass: determine size of output string */
-	i = j = old_j = 0; /* j: current column; i: total of previous lines */
-	e = string + stringlen;
-	for (p = string; p < e; p++) {
-		if (*p == '\t') {
-			j += tabsize - (j%tabsize);
-			if (old_j > j) {
-				PyErr_SetString(PyExc_OverflowError,
-						"new string is too long");
-				return NULL;
-			}
-			old_j = j;
-		} else {
-			j++;
-			if (*p == '\n') {
-				i += j;
-				j = 0;
-			}
-		}
-	}
+    /* First pass: determine size of output string */
+    i = j = old_j = 0; /* j: current column; i: total of previous lines */
+    e = string + stringlen;
+    for (p = string; p < e; p++) {
+        if (*p == '\t') {
+            j += tabsize - (j%tabsize);
+            if (old_j > j) {
+                PyErr_SetString(PyExc_OverflowError,
+                                "new string is too long");
+                return NULL;
+            }
+            old_j = j;
+        } else {
+            j++;
+            if (*p == '\n') {
+                i += j;
+                j = 0;
+            }
+        }
+    }
 
-	if ((i + j) < 0) {
-		PyErr_SetString(PyExc_OverflowError, "new string is too long");
-		return NULL;
-	}
+    if ((i + j) < 0) {
+        PyErr_SetString(PyExc_OverflowError, "new string is too long");
+        return NULL;
+    }
 
-	/* Second pass: create output string and fill it */
-	out = PyString_FromStringAndSize(NULL, i+j);
-	if (out == NULL)
-		return NULL;
+    /* Second pass: create output string and fill it */
+    out = PyString_FromStringAndSize(NULL, i+j);
+    if (out == NULL)
+        return NULL;
 
-	i = 0;
-	q = PyString_AS_STRING(out);
+    i = 0;
+    q = PyString_AS_STRING(out);
 
-	for (p = string; p < e; p++) {
-		if (*p == '\t') {
-			j = tabsize - (i%tabsize);
-			i += j;
-			while (j-- > 0)
-				*q++ = ' ';
-		} else {
-			*q++ = *p;
-			i++;
-			if (*p == '\n')
-				i = 0;
-		}
-	}
+    for (p = string; p < e; p++) {
+        if (*p == '\t') {
+            j = tabsize - (i%tabsize);
+            i += j;
+            while (j-- > 0)
+                *q++ = ' ';
+        } else {
+            *q++ = *p;
+            i++;
+            if (*p == '\n')
+                i = 0;
+        }
+    }
 
-	return out;
+    return out;
 }
 
 
@@ -671,38 +671,38 @@
 static PyObject *
 strop_count(PyObject *self, PyObject *args)
 {
-	char *s, *sub;
-	Py_ssize_t len, n;
-	Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
-	Py_ssize_t m, r;
+    char *s, *sub;
+    Py_ssize_t len, n;
+    Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
+    Py_ssize_t m, r;
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "t#t#|nn:count", &s, &len, &sub, &n, &i, &last))
-		return NULL;
-	if (last > len)
-		last = len;
-	if (last < 0)
-		last += len;
-	if (last < 0)
-		last = 0;
-	if (i < 0)
-		i += len;
-	if (i < 0)
-		i = 0;
-	m = last + 1 - n;
-	if (n == 0)
-		return PyInt_FromLong((long) (m-i));
+    WARN;
+    if (!PyArg_ParseTuple(args, "t#t#|nn:count", &s, &len, &sub, &n, &i, &last))
+        return NULL;
+    if (last > len)
+        last = len;
+    if (last < 0)
+        last += len;
+    if (last < 0)
+        last = 0;
+    if (i < 0)
+        i += len;
+    if (i < 0)
+        i = 0;
+    m = last + 1 - n;
+    if (n == 0)
+        return PyInt_FromLong((long) (m-i));
 
-	r = 0;
-	while (i < m) {
-		if (!memcmp(s+i, sub, n)) {
-			r++;
-			i += n;
-		} else {
-			i++;
-		}
-	}
-	return PyInt_FromLong((long) r);
+    r = 0;
+    while (i < m) {
+        if (!memcmp(s+i, sub, n)) {
+            r++;
+            i += n;
+        } else {
+            i++;
+        }
+    }
+    return PyInt_FromLong((long) r);
 }
 
 
@@ -715,39 +715,39 @@
 static PyObject *
 strop_swapcase(PyObject *self, PyObject *args)
 {
-	char *s, *s_new;
-	Py_ssize_t i, n;
-	PyObject *newstr;
-	int changed;
+    char *s, *s_new;
+    Py_ssize_t i, n;
+    PyObject *newstr;
+    int changed;
 
-	WARN;
-	if (PyString_AsStringAndSize(args, &s, &n))
-		return NULL;
-	newstr = PyString_FromStringAndSize(NULL, n);
-	if (newstr == NULL)
-		return NULL;
-	s_new = PyString_AsString(newstr);
-	changed = 0;
-	for (i = 0; i < n; i++) {
-		int c = Py_CHARMASK(*s++);
-		if (islower(c)) {
-			changed = 1;
-			*s_new = toupper(c);
-		}
-		else if (isupper(c)) {
-			changed = 1;
-			*s_new = tolower(c);
-		}
-		else
-			*s_new = c;
-		s_new++;
-	}
-	if (!changed) {
-		Py_DECREF(newstr);
-		Py_INCREF(args);
-		return args;
-	}
-	return newstr;
+    WARN;
+    if (PyString_AsStringAndSize(args, &s, &n))
+        return NULL;
+    newstr = PyString_FromStringAndSize(NULL, n);
+    if (newstr == NULL)
+        return NULL;
+    s_new = PyString_AsString(newstr);
+    changed = 0;
+    for (i = 0; i < n; i++) {
+        int c = Py_CHARMASK(*s++);
+        if (islower(c)) {
+            changed = 1;
+            *s_new = toupper(c);
+        }
+        else if (isupper(c)) {
+            changed = 1;
+            *s_new = tolower(c);
+        }
+        else
+            *s_new = c;
+        s_new++;
+    }
+    if (!changed) {
+        Py_DECREF(newstr);
+        Py_INCREF(args);
+        return args;
+    }
+    return newstr;
 }
 
 
@@ -764,45 +764,45 @@
 static PyObject *
 strop_atoi(PyObject *self, PyObject *args)
 {
-	char *s, *end;
-	int base = 10;
-	long x;
-	char buffer[256]; /* For errors */
+    char *s, *end;
+    int base = 10;
+    long x;
+    char buffer[256]; /* For errors */
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "s|i:atoi", &s, &base))
-		return NULL;
+    WARN;
+    if (!PyArg_ParseTuple(args, "s|i:atoi", &s, &base))
+        return NULL;
 
-	if ((base != 0 && base < 2) || base > 36) {
-		PyErr_SetString(PyExc_ValueError, "invalid base for atoi()");
-		return NULL;
-	}
+    if ((base != 0 && base < 2) || base > 36) {
+        PyErr_SetString(PyExc_ValueError, "invalid base for atoi()");
+        return NULL;
+    }
 
-	while (*s && isspace(Py_CHARMASK(*s)))
-		s++;
-	errno = 0;
-	if (base == 0 && s[0] == '0')
-		x = (long) PyOS_strtoul(s, &end, base);
-	else
-		x = PyOS_strtol(s, &end, base);
-	if (end == s || !isalnum(Py_CHARMASK(end[-1])))
-		goto bad;
-	while (*end && isspace(Py_CHARMASK(*end)))
-		end++;
-	if (*end != '\0') {
+    while (*s && isspace(Py_CHARMASK(*s)))
+        s++;
+    errno = 0;
+    if (base == 0 && s[0] == '0')
+        x = (long) PyOS_strtoul(s, &end, base);
+    else
+        x = PyOS_strtol(s, &end, base);
+    if (end == s || !isalnum(Py_CHARMASK(end[-1])))
+        goto bad;
+    while (*end && isspace(Py_CHARMASK(*end)))
+        end++;
+    if (*end != '\0') {
   bad:
-		PyOS_snprintf(buffer, sizeof(buffer),
-			      "invalid literal for atoi(): %.200s", s);
-		PyErr_SetString(PyExc_ValueError, buffer);
-		return NULL;
-	}
-	else if (errno != 0) {
-		PyOS_snprintf(buffer, sizeof(buffer), 
-			      "atoi() literal too large: %.200s", s);
-		PyErr_SetString(PyExc_ValueError, buffer);
-		return NULL;
-	}
-	return PyInt_FromLong(x);
+        PyOS_snprintf(buffer, sizeof(buffer),
+                      "invalid literal for atoi(): %.200s", s);
+        PyErr_SetString(PyExc_ValueError, buffer);
+        return NULL;
+    }
+    else if (errno != 0) {
+        PyOS_snprintf(buffer, sizeof(buffer),
+                      "atoi() literal too large: %.200s", s);
+        PyErr_SetString(PyExc_ValueError, buffer);
+        return NULL;
+    }
+    return PyInt_FromLong(x);
 }
 
 
@@ -820,41 +820,41 @@
 static PyObject *
 strop_atol(PyObject *self, PyObject *args)
 {
-	char *s, *end;
-	int base = 10;
-	PyObject *x;
-	char buffer[256]; /* For errors */
+    char *s, *end;
+    int base = 10;
+    PyObject *x;
+    char buffer[256]; /* For errors */
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "s|i:atol", &s, &base))
-		return NULL;
+    WARN;
+    if (!PyArg_ParseTuple(args, "s|i:atol", &s, &base))
+        return NULL;
 
-	if ((base != 0 && base < 2) || base > 36) {
-		PyErr_SetString(PyExc_ValueError, "invalid base for atol()");
-		return NULL;
-	}
+    if ((base != 0 && base < 2) || base > 36) {
+        PyErr_SetString(PyExc_ValueError, "invalid base for atol()");
+        return NULL;
+    }
 
-	while (*s && isspace(Py_CHARMASK(*s)))
-		s++;
-	if (s[0] == '\0') {
-		PyErr_SetString(PyExc_ValueError, "empty string for atol()");
-		return NULL;
-	}
-	x = PyLong_FromString(s, &end, base);
-	if (x == NULL)
-		return NULL;
-	if (base == 0 && (*end == 'l' || *end == 'L'))
-		end++;
-	while (*end && isspace(Py_CHARMASK(*end)))
-		end++;
-	if (*end != '\0') {
-		PyOS_snprintf(buffer, sizeof(buffer),
-			      "invalid literal for atol(): %.200s", s);
-		PyErr_SetString(PyExc_ValueError, buffer);
-		Py_DECREF(x);
-		return NULL;
-	}
-	return x;
+    while (*s && isspace(Py_CHARMASK(*s)))
+        s++;
+    if (s[0] == '\0') {
+        PyErr_SetString(PyExc_ValueError, "empty string for atol()");
+        return NULL;
+    }
+    x = PyLong_FromString(s, &end, base);
+    if (x == NULL)
+        return NULL;
+    if (base == 0 && (*end == 'l' || *end == 'L'))
+        end++;
+    while (*end && isspace(Py_CHARMASK(*end)))
+        end++;
+    if (*end != '\0') {
+        PyOS_snprintf(buffer, sizeof(buffer),
+                      "invalid literal for atol(): %.200s", s);
+        PyErr_SetString(PyExc_ValueError, buffer);
+        Py_DECREF(x);
+        return NULL;
+    }
+    return x;
 }
 
 
@@ -866,38 +866,38 @@
 static PyObject *
 strop_atof(PyObject *self, PyObject *args)
 {
-	char *s, *end;
-	double x;
-	char buffer[256]; /* For errors */
+    char *s, *end;
+    double x;
+    char buffer[256]; /* For errors */
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "s:atof", &s))
-		return NULL;
-	while (*s && isspace(Py_CHARMASK(*s)))
-		s++;
-	if (s[0] == '\0') {
-		PyErr_SetString(PyExc_ValueError, "empty string for atof()");
-		return NULL;
-	}
-	errno = 0;
-	PyFPE_START_PROTECT("strop_atof", return 0)
-	x = PyOS_ascii_strtod(s, &end);
-	PyFPE_END_PROTECT(x)
-	while (*end && isspace(Py_CHARMASK(*end)))
-		end++;
-	if (*end != '\0') {
-		PyOS_snprintf(buffer, sizeof(buffer),
-			      "invalid literal for atof(): %.200s", s);
-		PyErr_SetString(PyExc_ValueError, buffer);
-		return NULL;
-	}
-	else if (errno != 0) {
-		PyOS_snprintf(buffer, sizeof(buffer), 
-			      "atof() literal too large: %.200s", s);
-		PyErr_SetString(PyExc_ValueError, buffer);
-		return NULL;
-	}
-	return PyFloat_FromDouble(x);
+    WARN;
+    if (!PyArg_ParseTuple(args, "s:atof", &s))
+        return NULL;
+    while (*s && isspace(Py_CHARMASK(*s)))
+        s++;
+    if (s[0] == '\0') {
+        PyErr_SetString(PyExc_ValueError, "empty string for atof()");
+        return NULL;
+    }
+    errno = 0;
+    PyFPE_START_PROTECT("strop_atof", return 0)
+    x = PyOS_ascii_strtod(s, &end);
+    PyFPE_END_PROTECT(x)
+    while (*end && isspace(Py_CHARMASK(*end)))
+        end++;
+    if (*end != '\0') {
+        PyOS_snprintf(buffer, sizeof(buffer),
+                      "invalid literal for atof(): %.200s", s);
+        PyErr_SetString(PyExc_ValueError, buffer);
+        return NULL;
+    }
+    else if (errno != 0) {
+        PyOS_snprintf(buffer, sizeof(buffer),
+                      "atof() literal too large: %.200s", s);
+        PyErr_SetString(PyExc_ValueError, buffer);
+        return NULL;
+    }
+    return PyFloat_FromDouble(x);
 }
 
 
@@ -911,29 +911,29 @@
 static PyObject *
 strop_maketrans(PyObject *self, PyObject *args)
 {
-	unsigned char *c, *from=NULL, *to=NULL;
-	Py_ssize_t i, fromlen=0, tolen=0;
-	PyObject *result;
+    unsigned char *c, *from=NULL, *to=NULL;
+    Py_ssize_t i, fromlen=0, tolen=0;
+    PyObject *result;
 
-	if (!PyArg_ParseTuple(args, "t#t#:maketrans", &from, &fromlen, &to, &tolen))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "t#t#:maketrans", &from, &fromlen, &to, &tolen))
+        return NULL;
 
-	if (fromlen != tolen) {
-		PyErr_SetString(PyExc_ValueError,
-				"maketrans arguments must have same length");
-		return NULL;
-	}
+    if (fromlen != tolen) {
+        PyErr_SetString(PyExc_ValueError,
+                        "maketrans arguments must have same length");
+        return NULL;
+    }
 
-	result = PyString_FromStringAndSize((char *)NULL, 256);
-	if (result == NULL)
-		return NULL;
-	c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
-	for (i = 0; i < 256; i++)
-		c[i]=(unsigned char)i;
-	for (i = 0; i < fromlen; i++)
-		c[from[i]]=to[i];
+    result = PyString_FromStringAndSize((char *)NULL, 256);
+    if (result == NULL)
+        return NULL;
+    c = (unsigned char *) PyString_AS_STRING((PyStringObject *)result);
+    for (i = 0; i < 256; i++)
+        c[i]=(unsigned char)i;
+    for (i = 0; i < fromlen; i++)
+        c[from[i]]=to[i];
 
-	return result;
+    return result;
 }
 
 
@@ -948,69 +948,69 @@
 static PyObject *
 strop_translate(PyObject *self, PyObject *args)
 {
-	register char *input, *table, *output;
-	Py_ssize_t i; 
-	int c, changed = 0;
-	PyObject *input_obj;
-	char *table1, *output_start, *del_table=NULL;
-	Py_ssize_t inlen, tablen, dellen = 0;
-	PyObject *result;
-	int trans_table[256];
+    register char *input, *table, *output;
+    Py_ssize_t i;
+    int c, changed = 0;
+    PyObject *input_obj;
+    char *table1, *output_start, *del_table=NULL;
+    Py_ssize_t inlen, tablen, dellen = 0;
+    PyObject *result;
+    int trans_table[256];
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "St#|t#:translate", &input_obj,
-			      &table1, &tablen, &del_table, &dellen))
-		return NULL;
-	if (tablen != 256) {
-		PyErr_SetString(PyExc_ValueError,
-			      "translation table must be 256 characters long");
-		return NULL;
-	}
+    WARN;
+    if (!PyArg_ParseTuple(args, "St#|t#:translate", &input_obj,
+                          &table1, &tablen, &del_table, &dellen))
+        return NULL;
+    if (tablen != 256) {
+        PyErr_SetString(PyExc_ValueError,
+                      "translation table must be 256 characters long");
+        return NULL;
+    }
 
-	table = table1;
-	inlen = PyString_GET_SIZE(input_obj);
-	result = PyString_FromStringAndSize((char *)NULL, inlen);
-	if (result == NULL)
-		return NULL;
-	output_start = output = PyString_AsString(result);
-	input = PyString_AsString(input_obj);
+    table = table1;
+    inlen = PyString_GET_SIZE(input_obj);
+    result = PyString_FromStringAndSize((char *)NULL, inlen);
+    if (result == NULL)
+        return NULL;
+    output_start = output = PyString_AsString(result);
+    input = PyString_AsString(input_obj);
 
-	if (dellen == 0) {
-		/* If no deletions are required, use faster code */
-		for (i = inlen; --i >= 0; ) {
-			c = Py_CHARMASK(*input++);
-			if (Py_CHARMASK((*output++ = table[c])) != c)
-				changed = 1;
-		}
-		if (changed)
-			return result;
-		Py_DECREF(result);
-		Py_INCREF(input_obj);
-		return input_obj;
-	}
+    if (dellen == 0) {
+        /* If no deletions are required, use faster code */
+        for (i = inlen; --i >= 0; ) {
+            c = Py_CHARMASK(*input++);
+            if (Py_CHARMASK((*output++ = table[c])) != c)
+                changed = 1;
+        }
+        if (changed)
+            return result;
+        Py_DECREF(result);
+        Py_INCREF(input_obj);
+        return input_obj;
+    }
 
-	for (i = 0; i < 256; i++)
-		trans_table[i] = Py_CHARMASK(table[i]);
+    for (i = 0; i < 256; i++)
+        trans_table[i] = Py_CHARMASK(table[i]);
 
-	for (i = 0; i < dellen; i++)
-		trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
+    for (i = 0; i < dellen; i++)
+        trans_table[(int) Py_CHARMASK(del_table[i])] = -1;
 
-	for (i = inlen; --i >= 0; ) {
-		c = Py_CHARMASK(*input++);
-		if (trans_table[c] != -1)
-			if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
-				continue;
-		changed = 1;
-	}
-	if (!changed) {
-		Py_DECREF(result);
-		Py_INCREF(input_obj);
-		return input_obj;
-	}
-	/* Fix the size of the resulting string */
-	if (inlen > 0)
-		_PyString_Resize(&result, output - output_start);
-	return result;
+    for (i = inlen; --i >= 0; ) {
+        c = Py_CHARMASK(*input++);
+        if (trans_table[c] != -1)
+            if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
+                continue;
+        changed = 1;
+    }
+    if (!changed) {
+        Py_DECREF(result);
+        Py_INCREF(input_obj);
+        return input_obj;
+    }
+    /* Fix the size of the resulting string */
+    if (inlen > 0)
+        _PyString_Resize(&result, output - output_start);
+    return result;
 }
 
 
@@ -1026,22 +1026,22 @@
   found, or -1 if not found.  If len of PAT is greater than length of
   MEM, the function returns -1.
 */
-static Py_ssize_t 
+static Py_ssize_t
 mymemfind(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
 {
-	register Py_ssize_t ii;
+    register Py_ssize_t ii;
 
-	/* pattern can not occur in the last pat_len-1 chars */
-	len -= pat_len;
+    /* pattern can not occur in the last pat_len-1 chars */
+    len -= pat_len;
 
-	for (ii = 0; ii <= len; ii++) {
-		if (mem[ii] == pat[0] &&
-		    (pat_len == 1 ||
-		     memcmp(&mem[ii+1], &pat[1], pat_len-1) == 0)) {
-			return ii;
-		}
-	}
-	return -1;
+    for (ii = 0; ii <= len; ii++) {
+        if (mem[ii] == pat[0] &&
+            (pat_len == 1 ||
+             memcmp(&mem[ii+1], &pat[1], pat_len-1) == 0)) {
+            return ii;
+        }
+    }
+    return -1;
 }
 
 /*
@@ -1049,23 +1049,23 @@
 
    Return the number of distinct times PAT is found in MEM.
    meaning mem=1111 and pat==11 returns 2.
-           mem=11111 and pat==11 also return 2.
+       mem=11111 and pat==11 also return 2.
  */
-static Py_ssize_t 
+static Py_ssize_t
 mymemcnt(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len)
 {
-	register Py_ssize_t offset = 0;
-	Py_ssize_t nfound = 0;
+    register Py_ssize_t offset = 0;
+    Py_ssize_t nfound = 0;
 
-	while (len >= 0) {
-		offset = mymemfind(mem, len, pat, pat_len);
-		if (offset == -1)
-			break;
-		mem += offset + pat_len;
-		len -= offset + pat_len;
-		nfound++;
-	}
-	return nfound;
+    while (len >= 0) {
+        offset = mymemfind(mem, len, pat, pat_len);
+        if (offset == -1)
+            break;
+        mem += offset + pat_len;
+        len -= offset + pat_len;
+        nfound++;
+    }
+    return nfound;
 }
 
 /*
@@ -1088,69 +1088,69 @@
        NULL if an error occurred.
 */
 static char *
-mymemreplace(const char *str, Py_ssize_t len,		/* input string */
-             const char *pat, Py_ssize_t pat_len,	/* pattern string to find */
-             const char *sub, Py_ssize_t sub_len,	/* substitution string */
-             Py_ssize_t count,				/* number of replacements */
-	     Py_ssize_t *out_len)
+mymemreplace(const char *str, Py_ssize_t len,           /* input string */
+         const char *pat, Py_ssize_t pat_len,           /* pattern string to find */
+         const char *sub, Py_ssize_t sub_len,           /* substitution string */
+         Py_ssize_t count,                              /* number of replacements */
+         Py_ssize_t *out_len)
 {
-	char *out_s;
-	char *new_s;
-	Py_ssize_t nfound, offset, new_len;
+    char *out_s;
+    char *new_s;
+    Py_ssize_t nfound, offset, new_len;
 
-	if (len == 0 || pat_len > len)
-		goto return_same;
+    if (len == 0 || pat_len > len)
+        goto return_same;
 
-	/* find length of output string */
-	nfound = mymemcnt(str, len, pat, pat_len);
-	if (count < 0)
-		count = PY_SSIZE_T_MAX;
-	else if (nfound > count)
-		nfound = count;
-	if (nfound == 0)
-		goto return_same;
+    /* find length of output string */
+    nfound = mymemcnt(str, len, pat, pat_len);
+    if (count < 0)
+        count = PY_SSIZE_T_MAX;
+    else if (nfound > count)
+        nfound = count;
+    if (nfound == 0)
+        goto return_same;
 
-	new_len = len + nfound*(sub_len - pat_len);
-	if (new_len == 0) {
-		/* Have to allocate something for the caller to free(). */
-		out_s = (char *)PyMem_MALLOC(1);
-		if (out_s == NULL)
-			return NULL;
-		out_s[0] = '\0';
-	}
-	else {
-		assert(new_len > 0);
-		new_s = (char *)PyMem_MALLOC(new_len);
-		if (new_s == NULL)
-			return NULL;
-		out_s = new_s;
+    new_len = len + nfound*(sub_len - pat_len);
+    if (new_len == 0) {
+        /* Have to allocate something for the caller to free(). */
+        out_s = (char *)PyMem_MALLOC(1);
+        if (out_s == NULL)
+            return NULL;
+        out_s[0] = '\0';
+    }
+    else {
+        assert(new_len > 0);
+        new_s = (char *)PyMem_MALLOC(new_len);
+        if (new_s == NULL)
+            return NULL;
+        out_s = new_s;
 
-		for (; count > 0 && len > 0; --count) {
-			/* find index of next instance of pattern */
-			offset = mymemfind(str, len, pat, pat_len);
-			if (offset == -1)
-				break;
+        for (; count > 0 && len > 0; --count) {
+            /* find index of next instance of pattern */
+            offset = mymemfind(str, len, pat, pat_len);
+            if (offset == -1)
+                break;
 
-			/* copy non matching part of input string */
-			memcpy(new_s, str, offset);
-			str += offset + pat_len;
-			len -= offset + pat_len;
+            /* copy non matching part of input string */
+            memcpy(new_s, str, offset);
+            str += offset + pat_len;
+            len -= offset + pat_len;
 
-			/* copy substitute into the output string */
-			new_s += offset;
-			memcpy(new_s, sub, sub_len);
-			new_s += sub_len;
-		}
-		/* copy any remaining values into output string */
-		if (len > 0)
-			memcpy(new_s, str, len);
-	}
-	*out_len = new_len;
-	return out_s;
+            /* copy substitute into the output string */
+            new_s += offset;
+            memcpy(new_s, sub, sub_len);
+            new_s += sub_len;
+        }
+        /* copy any remaining values into output string */
+        if (len > 0)
+            memcpy(new_s, str, len);
+    }
+    *out_len = new_len;
+    return out_s;
 
   return_same:
-	*out_len = -1;
-	return (char *)str; /* cast away const */
+    *out_len = -1;
+    return (char *)str; /* cast away const */
 }
 
 
@@ -1164,41 +1164,41 @@
 static PyObject *
 strop_replace(PyObject *self, PyObject *args)
 {
-	char *str, *pat,*sub,*new_s;
-	Py_ssize_t len,pat_len,sub_len,out_len;
-	Py_ssize_t count = -1;
-	PyObject *newstr;
+    char *str, *pat,*sub,*new_s;
+    Py_ssize_t len,pat_len,sub_len,out_len;
+    Py_ssize_t count = -1;
+    PyObject *newstr;
 
-	WARN;
-	if (!PyArg_ParseTuple(args, "t#t#t#|n:replace",
-			      &str, &len, &pat, &pat_len, &sub, &sub_len,
-			      &count))
-		return NULL;
-	if (pat_len <= 0) {
-		PyErr_SetString(PyExc_ValueError, "empty pattern string");
-		return NULL;
-	}
-	/* CAUTION:  strop treats a replace count of 0 as infinity, unlke
-	 * current (2.1) string.py and string methods.  Preserve this for
-	 * ... well, hard to say for what <wink>.
-	 */
-	if (count == 0)
-		count = -1;
-	new_s = mymemreplace(str,len,pat,pat_len,sub,sub_len,count,&out_len);
-	if (new_s == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	if (out_len == -1) {
-		/* we're returning another reference to the input string */
-		newstr = PyTuple_GetItem(args, 0);
-		Py_XINCREF(newstr);
-	}
-	else {
-		newstr = PyString_FromStringAndSize(new_s, out_len);
-		PyMem_FREE(new_s);
-	}
-	return newstr;
+    WARN;
+    if (!PyArg_ParseTuple(args, "t#t#t#|n:replace",
+                          &str, &len, &pat, &pat_len, &sub, &sub_len,
+                          &count))
+        return NULL;
+    if (pat_len <= 0) {
+        PyErr_SetString(PyExc_ValueError, "empty pattern string");
+        return NULL;
+    }
+    /* CAUTION:  strop treats a replace count of 0 as infinity, unlke
+     * current (2.1) string.py and string methods.  Preserve this for
+     * ... well, hard to say for what <wink>.
+     */
+    if (count == 0)
+        count = -1;
+    new_s = mymemreplace(str,len,pat,pat_len,sub,sub_len,count,&out_len);
+    if (new_s == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    if (out_len == -1) {
+        /* we're returning another reference to the input string */
+        newstr = PyTuple_GetItem(args, 0);
+        Py_XINCREF(newstr);
+    }
+    else {
+        newstr = PyString_FromStringAndSize(new_s, out_len);
+        PyMem_FREE(new_s);
+    }
+    return newstr;
 }
 
 
@@ -1206,69 +1206,69 @@
 
 static PyMethodDef
 strop_methods[] = {
-	{"atof",	strop_atof,	   METH_VARARGS, atof__doc__},
-	{"atoi",	strop_atoi,	   METH_VARARGS, atoi__doc__},
-	{"atol",	strop_atol,	   METH_VARARGS, atol__doc__},
-	{"capitalize",	strop_capitalize,  METH_O,       capitalize__doc__},
-	{"count",	strop_count,	   METH_VARARGS, count__doc__},
-	{"expandtabs",	strop_expandtabs,  METH_VARARGS, expandtabs__doc__},
-	{"find",	strop_find,	   METH_VARARGS, find__doc__},
-	{"join",	strop_joinfields,  METH_VARARGS, joinfields__doc__},
-	{"joinfields",	strop_joinfields,  METH_VARARGS, joinfields__doc__},
-	{"lstrip",	strop_lstrip,	   METH_O,       lstrip__doc__},
-	{"lower",	strop_lower,	   METH_O,       lower__doc__},
-	{"maketrans",	strop_maketrans,   METH_VARARGS, maketrans__doc__},
-	{"replace",	strop_replace,	   METH_VARARGS, replace__doc__},
-	{"rfind",	strop_rfind,	   METH_VARARGS, rfind__doc__},
-	{"rstrip",	strop_rstrip,	   METH_O,       rstrip__doc__},
-	{"split",	strop_splitfields, METH_VARARGS, splitfields__doc__},
-	{"splitfields",	strop_splitfields, METH_VARARGS, splitfields__doc__},
-	{"strip",	strop_strip,	   METH_O,       strip__doc__},
-	{"swapcase",	strop_swapcase,    METH_O,       swapcase__doc__},
-	{"translate",	strop_translate,   METH_VARARGS, translate__doc__},
-	{"upper",	strop_upper,	   METH_O,       upper__doc__},
-	{NULL,		NULL}	/* sentinel */
+    {"atof",            strop_atof,        METH_VARARGS, atof__doc__},
+    {"atoi",            strop_atoi,        METH_VARARGS, atoi__doc__},
+    {"atol",            strop_atol,        METH_VARARGS, atol__doc__},
+    {"capitalize",      strop_capitalize,  METH_O,       capitalize__doc__},
+    {"count",           strop_count,       METH_VARARGS, count__doc__},
+    {"expandtabs",      strop_expandtabs,  METH_VARARGS, expandtabs__doc__},
+    {"find",            strop_find,        METH_VARARGS, find__doc__},
+    {"join",            strop_joinfields,  METH_VARARGS, joinfields__doc__},
+    {"joinfields",      strop_joinfields,  METH_VARARGS, joinfields__doc__},
+    {"lstrip",          strop_lstrip,      METH_O,       lstrip__doc__},
+    {"lower",           strop_lower,       METH_O,       lower__doc__},
+    {"maketrans",       strop_maketrans,   METH_VARARGS, maketrans__doc__},
+    {"replace",         strop_replace,     METH_VARARGS, replace__doc__},
+    {"rfind",           strop_rfind,       METH_VARARGS, rfind__doc__},
+    {"rstrip",          strop_rstrip,      METH_O,       rstrip__doc__},
+    {"split",           strop_splitfields, METH_VARARGS, splitfields__doc__},
+    {"splitfields",     strop_splitfields, METH_VARARGS, splitfields__doc__},
+    {"strip",           strop_strip,       METH_O,       strip__doc__},
+    {"swapcase",        strop_swapcase,    METH_O,       swapcase__doc__},
+    {"translate",       strop_translate,   METH_VARARGS, translate__doc__},
+    {"upper",           strop_upper,       METH_O,       upper__doc__},
+    {NULL,              NULL}   /* sentinel */
 };
 
 
 PyMODINIT_FUNC
 initstrop(void)
 {
-	PyObject *m, *s;
-	char buf[256];
-	int c, n;
-	m = Py_InitModule4("strop", strop_methods, strop_module__doc__,
-			   (PyObject*)NULL, PYTHON_API_VERSION);
-	if (m == NULL)
-		return;
+    PyObject *m, *s;
+    char buf[256];
+    int c, n;
+    m = Py_InitModule4("strop", strop_methods, strop_module__doc__,
+                       (PyObject*)NULL, PYTHON_API_VERSION);
+    if (m == NULL)
+        return;
 
-	/* Create 'whitespace' object */
-	n = 0;
-	for (c = 0; c < 256; c++) {
-		if (isspace(c))
-			buf[n++] = c;
-	}
-	s = PyString_FromStringAndSize(buf, n);
-	if (s)
-		PyModule_AddObject(m, "whitespace", s);
+    /* Create 'whitespace' object */
+    n = 0;
+    for (c = 0; c < 256; c++) {
+        if (isspace(c))
+            buf[n++] = c;
+    }
+    s = PyString_FromStringAndSize(buf, n);
+    if (s)
+        PyModule_AddObject(m, "whitespace", s);
 
-	/* Create 'lowercase' object */
-	n = 0;
-	for (c = 0; c < 256; c++) {
-		if (islower(c))
-			buf[n++] = c;
-	}
-	s = PyString_FromStringAndSize(buf, n);
-	if (s)
-		PyModule_AddObject(m, "lowercase", s);
+    /* Create 'lowercase' object */
+    n = 0;
+    for (c = 0; c < 256; c++) {
+        if (islower(c))
+            buf[n++] = c;
+    }
+    s = PyString_FromStringAndSize(buf, n);
+    if (s)
+        PyModule_AddObject(m, "lowercase", s);
 
-	/* Create 'uppercase' object */
-	n = 0;
-	for (c = 0; c < 256; c++) {
-		if (isupper(c))
-			buf[n++] = c;
-	}
-	s = PyString_FromStringAndSize(buf, n);
-	if (s)
-		PyModule_AddObject(m, "uppercase", s);
+    /* Create 'uppercase' object */
+    n = 0;
+    for (c = 0; c < 256; c++) {
+        if (isupper(c))
+            buf[n++] = c;
+    }
+    s = PyString_FromStringAndSize(buf, n);
+    if (s)
+        PyModule_AddObject(m, "uppercase", s);
 }