diff --git a/Modules/cPickle.c b/Modules/cPickle.c
index 937329b..d9bfceb 100644
--- a/Modules/cPickle.c
+++ b/Modules/cPickle.c
@@ -72,7 +72,7 @@
 #define SETITEMS    'u'
 
 /* Protocol 2. */
-#define PROTO	 '\x80' /* identify pickle protocol */
+#define PROTO    '\x80' /* identify pickle protocol */
 #define NEWOBJ   '\x81' /* build object by applying cls.__new__ to argtuple */
 #define EXT1     '\x82' /* push object from extension registry; 1-byte index */
 #define EXT2     '\x83' /* ditto, but 2-byte index */
@@ -131,37 +131,37 @@
   *__getstate___str, *__setstate___str, *__name___str, *__reduce___str,
   *__reduce_ex___str,
   *write_str, *append_str,
-  *read_str, *readline_str, *__main___str, 
+  *read_str, *readline_str, *__main___str,
   *dispatch_table_str;
 
 /*************************************************************************
  Internal Data type for pickle data.                                     */
 
 typedef struct {
-	PyObject_HEAD
-	int length;	/* number of initial slots in data currently used */
-	int size;	/* number of slots in data allocated */
-	PyObject **data;
+    PyObject_HEAD
+    int length;         /* number of initial slots in data currently used */
+    int size;           /* number of slots in data allocated */
+    PyObject **data;
 } Pdata;
 
 static void
 Pdata_dealloc(Pdata *self)
 {
-	int i;
-	PyObject **p;
+    int i;
+    PyObject **p;
 
-	for (i = self->length, p = self->data; --i >= 0; p++) {
-		Py_DECREF(*p);
-	}
-	if (self->data)
-		free(self->data);
-	PyObject_Del(self);
+    for (i = self->length, p = self->data; --i >= 0; p++) {
+        Py_DECREF(*p);
+    }
+    if (self->data)
+        free(self->data);
+    PyObject_Del(self);
 }
 
 static PyTypeObject PdataType = {
-	PyVarObject_HEAD_INIT(NULL, 0) "cPickle.Pdata", sizeof(Pdata), 0,
-	(destructor)Pdata_dealloc,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, ""
+    PyVarObject_HEAD_INIT(NULL, 0) "cPickle.Pdata", sizeof(Pdata), 0,
+    (destructor)Pdata_dealloc,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, ""
 };
 
 #define Pdata_Check(O) (Py_TYPE(O) == &PdataType)
@@ -169,24 +169,24 @@
 static PyObject *
 Pdata_New(void)
 {
-	Pdata *self;
+    Pdata *self;
 
-	if (!(self = PyObject_New(Pdata, &PdataType)))
-		return NULL;
-	self->size = 8;
-	self->length = 0;
-	self->data = malloc(self->size * sizeof(PyObject*));
-	if (self->data)
-		return (PyObject*)self;
-	Py_DECREF(self);
-	return PyErr_NoMemory();
+    if (!(self = PyObject_New(Pdata, &PdataType)))
+        return NULL;
+    self->size = 8;
+    self->length = 0;
+    self->data = malloc(self->size * sizeof(PyObject*));
+    if (self->data)
+        return (PyObject*)self;
+    Py_DECREF(self);
+    return PyErr_NoMemory();
 }
 
 static int
 stackUnderflow(void)
 {
-	PyErr_SetString(UnpicklingError, "unpickling stack underflow");
-	return -1;
+    PyErr_SetString(UnpicklingError, "unpickling stack underflow");
+    return -1;
 }
 
 /* Retain only the initial clearto items.  If clearto >= the current
@@ -195,60 +195,60 @@
 static int
 Pdata_clear(Pdata *self, int clearto)
 {
-	int i;
-	PyObject **p;
+    int i;
+    PyObject **p;
 
-	if (clearto < 0) return stackUnderflow();
-	if (clearto >= self->length) return 0;
+    if (clearto < 0) return stackUnderflow();
+    if (clearto >= self->length) return 0;
 
-	for (i = self->length, p = self->data + clearto;
-	     --i >= clearto;
-	     p++) {
-		Py_CLEAR(*p);
-	}
-	self->length = clearto;
+    for (i = self->length, p = self->data + clearto;
+         --i >= clearto;
+         p++) {
+        Py_CLEAR(*p);
+    }
+    self->length = clearto;
 
-	return 0;
+    return 0;
 }
 
 static int
 Pdata_grow(Pdata *self)
 {
-	int bigger;
-	size_t nbytes;
-	PyObject **tmp;
+    int bigger;
+    size_t nbytes;
+    PyObject **tmp;
 
-	bigger = self->size << 1;
-	if (bigger <= 0)	/* was 0, or new value overflows */
-		goto nomemory;
-	if ((int)(size_t)bigger != bigger)
-		goto nomemory;
-	nbytes = (size_t)bigger * sizeof(PyObject *);
-	if (nbytes / sizeof(PyObject *) != (size_t)bigger)
-		goto nomemory;
-	tmp = realloc(self->data, nbytes);
-	if (tmp == NULL)
-		goto nomemory;
-	self->data = tmp;
-	self->size = bigger;
-	return 0;
+    bigger = self->size << 1;
+    if (bigger <= 0)            /* was 0, or new value overflows */
+        goto nomemory;
+    if ((int)(size_t)bigger != bigger)
+        goto nomemory;
+    nbytes = (size_t)bigger * sizeof(PyObject *);
+    if (nbytes / sizeof(PyObject *) != (size_t)bigger)
+        goto nomemory;
+    tmp = realloc(self->data, nbytes);
+    if (tmp == NULL)
+        goto nomemory;
+    self->data = tmp;
+    self->size = bigger;
+    return 0;
 
   nomemory:
-	PyErr_NoMemory();
-	return -1;
+    PyErr_NoMemory();
+    return -1;
 }
 
 /* D is a Pdata*.  Pop the topmost element and store it into V, which
  * must be an lvalue holding PyObject*.  On stack underflow, UnpicklingError
  * is raised and V is set to NULL.  D and V may be evaluated several times.
  */
-#define PDATA_POP(D, V) {					\
-	if ((D)->length)					\
-		(V) = (D)->data[--((D)->length)];		\
-	else {							\
-		PyErr_SetString(UnpicklingError, "bad pickle data");	\
-		(V) = NULL;					\
-	}							\
+#define PDATA_POP(D, V) {                                       \
+    if ((D)->length)                                            \
+        (V) = (D)->data[--((D)->length)];                       \
+    else {                                                      \
+        PyErr_SetString(UnpicklingError, "bad pickle data");            \
+        (V) = NULL;                                             \
+    }                                                           \
 }
 
 /* PDATA_PUSH and PDATA_APPEND both push rvalue PyObject* O on to Pdata*
@@ -260,55 +260,55 @@
  */
 
 /* Push O on stack D, giving ownership of O to the stack. */
-#define PDATA_PUSH(D, O, ER) {					\
-	if (((Pdata*)(D))->length == ((Pdata*)(D))->size &&	\
-	    Pdata_grow((Pdata*)(D)) < 0) {			\
-		Py_DECREF(O);					\
-		return ER;					\
-	}							\
-	((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O);	\
+#define PDATA_PUSH(D, O, ER) {                                  \
+    if (((Pdata*)(D))->length == ((Pdata*)(D))->size &&         \
+        Pdata_grow((Pdata*)(D)) < 0) {                          \
+        Py_DECREF(O);                                           \
+        return ER;                                              \
+    }                                                           \
+    ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O);         \
 }
 
 /* Push O on stack D, pushing a new reference. */
-#define PDATA_APPEND(D, O, ER) {				\
-	if (((Pdata*)(D))->length == ((Pdata*)(D))->size &&	\
-	    Pdata_grow((Pdata*)(D)) < 0)			\
-		return ER;					\
-	Py_INCREF(O);						\
-	((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O);	\
+#define PDATA_APPEND(D, O, ER) {                                \
+    if (((Pdata*)(D))->length == ((Pdata*)(D))->size &&         \
+        Pdata_grow((Pdata*)(D)) < 0)                            \
+        return ER;                                              \
+    Py_INCREF(O);                                               \
+    ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O);         \
 }
 
 
 static PyObject *
 Pdata_popTuple(Pdata *self, int start)
 {
-	PyObject *r;
-	int i, j, l;
+    PyObject *r;
+    int i, j, l;
 
-	l = self->length-start;
-	r = PyTuple_New(l);
-	if (r == NULL)
-		return NULL;
-	for (i = start, j = 0 ; j < l; i++, j++)
-		PyTuple_SET_ITEM(r, j, self->data[i]);
+    l = self->length-start;
+    r = PyTuple_New(l);
+    if (r == NULL)
+        return NULL;
+    for (i = start, j = 0 ; j < l; i++, j++)
+        PyTuple_SET_ITEM(r, j, self->data[i]);
 
-	self->length = start;
-	return r;
+    self->length = start;
+    return r;
 }
 
 static PyObject *
 Pdata_popList(Pdata *self, int start)
 {
-	PyObject *r;
-	int i, j, l;
+    PyObject *r;
+    int i, j, l;
 
-	l=self->length-start;
-	if (!( r=PyList_New(l)))  return NULL;
-	for (i=start, j=0 ; j < l; i++, j++)
-		PyList_SET_ITEM(r, j, self->data[i]);
+    l=self->length-start;
+    if (!( r=PyList_New(l)))  return NULL;
+    for (i=start, j=0 ; j < l; i++, j++)
+        PyList_SET_ITEM(r, j, self->data[i]);
 
-	self->length=start;
-	return r;
+    self->length=start;
+    return r;
 }
 
 /*************************************************************************/
@@ -331,28 +331,28 @@
   }
 
 typedef struct Picklerobject {
-	PyObject_HEAD
-	FILE *fp;
-	PyObject *write;
-	PyObject *file;
-	PyObject *memo;
-	PyObject *arg;
-	PyObject *pers_func;
-	PyObject *inst_pers_func;
+    PyObject_HEAD
+    FILE *fp;
+    PyObject *write;
+    PyObject *file;
+    PyObject *memo;
+    PyObject *arg;
+    PyObject *pers_func;
+    PyObject *inst_pers_func;
 
-	/* pickle protocol number, >= 0 */
-	int proto;
+    /* pickle protocol number, >= 0 */
+    int proto;
 
-	/* bool, true if proto > 0 */
-	int bin;
+    /* bool, true if proto > 0 */
+    int bin;
 
-	int fast; /* Fast mode doesn't save in memo, don't use if circ ref */
-	int (*write_func)(struct Picklerobject *, const char *, Py_ssize_t);
-	char *write_buf;
-	int buf_size;
-	PyObject *dispatch_table;
-	int fast_container; /* count nested container dumps */
-	PyObject *fast_memo;
+    int fast; /* Fast mode doesn't save in memo, don't use if circ ref */
+    int (*write_func)(struct Picklerobject *, const char *, Py_ssize_t);
+    char *write_buf;
+    int buf_size;
+    PyObject *dispatch_table;
+    int fast_container; /* count nested container dumps */
+    PyObject *fast_memo;
 } Picklerobject;
 
 #ifndef PY_CPICKLE_FAST_LIMIT
@@ -362,25 +362,25 @@
 static PyTypeObject Picklertype;
 
 typedef struct Unpicklerobject {
-	PyObject_HEAD
-	FILE *fp;
-	PyObject *file;
-	PyObject *readline;
-	PyObject *read;
-	PyObject *memo;
-	PyObject *arg;
-	Pdata *stack;
-	PyObject *mark;
-	PyObject *pers_func;
-	PyObject *last_string;
-	int *marks;
-	int num_marks;
-	int marks_size;
-	Py_ssize_t (*read_func)(struct Unpicklerobject *, char **, Py_ssize_t);
-	Py_ssize_t (*readline_func)(struct Unpicklerobject *, char **);
-	int buf_size;
-	char *buf;
-	PyObject *find_class;
+    PyObject_HEAD
+    FILE *fp;
+    PyObject *file;
+    PyObject *readline;
+    PyObject *read;
+    PyObject *memo;
+    PyObject *arg;
+    Pdata *stack;
+    PyObject *mark;
+    PyObject *pers_func;
+    PyObject *last_string;
+    int *marks;
+    int num_marks;
+    int marks_size;
+    Py_ssize_t (*read_func)(struct Unpicklerobject *, char **, Py_ssize_t);
+    Py_ssize_t (*readline_func)(struct Unpicklerobject *, char **);
+    int buf_size;
+    char *buf;
+    PyObject *find_class;
 } Unpicklerobject;
 
 static PyTypeObject Unpicklertype;
@@ -393,306 +393,306 @@
 PyObject *
 cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...)
 {
-	va_list va;
-	PyObject *args=0, *retval=0;
-	va_start(va, format);
+    va_list va;
+    PyObject *args=0, *retval=0;
+    va_start(va, format);
 
-	if (format) args = Py_VaBuildValue(format, va);
-	va_end(va);
-	if (format && ! args) return NULL;
-	if (stringformat && !(retval=PyString_FromString(stringformat)))
-		return NULL;
+    if (format) args = Py_VaBuildValue(format, va);
+    va_end(va);
+    if (format && ! args) return NULL;
+    if (stringformat && !(retval=PyString_FromString(stringformat)))
+        return NULL;
 
-	if (retval) {
-		if (args) {
-			PyObject *v;
-			v=PyString_Format(retval, args);
-			Py_DECREF(retval);
-			Py_DECREF(args);
-			if (! v) return NULL;
-			retval=v;
-		}
-	}
-	else
-		if (args) retval=args;
-		else {
-			PyErr_SetObject(ErrType,Py_None);
-			return NULL;
-		}
-	PyErr_SetObject(ErrType,retval);
-	Py_DECREF(retval);
-	return NULL;
+    if (retval) {
+        if (args) {
+            PyObject *v;
+            v=PyString_Format(retval, args);
+            Py_DECREF(retval);
+            Py_DECREF(args);
+            if (! v) return NULL;
+            retval=v;
+        }
+    }
+    else
+        if (args) retval=args;
+        else {
+            PyErr_SetObject(ErrType,Py_None);
+            return NULL;
+        }
+    PyErr_SetObject(ErrType,retval);
+    Py_DECREF(retval);
+    return NULL;
 }
 
 static int
 write_file(Picklerobject *self, const char *s, Py_ssize_t  n)
 {
-	size_t nbyteswritten;
+    size_t nbyteswritten;
 
-	if (s == NULL) {
-		return 0;
-	}
+    if (s == NULL) {
+        return 0;
+    }
 
-	if (n > INT_MAX) {
-		/* String too large */
-		return -1;
-	}
+    if (n > INT_MAX) {
+        /* String too large */
+        return -1;
+    }
 
-	PyFile_IncUseCount((PyFileObject *)self->file);
-	Py_BEGIN_ALLOW_THREADS
-	nbyteswritten = fwrite(s, sizeof(char), n, self->fp);
-	Py_END_ALLOW_THREADS
-	PyFile_DecUseCount((PyFileObject *)self->file);
-	if (nbyteswritten != (size_t)n) {
-		PyErr_SetFromErrno(PyExc_IOError);
-		return -1;
-	}
+    PyFile_IncUseCount((PyFileObject *)self->file);
+    Py_BEGIN_ALLOW_THREADS
+    nbyteswritten = fwrite(s, sizeof(char), n, self->fp);
+    Py_END_ALLOW_THREADS
+    PyFile_DecUseCount((PyFileObject *)self->file);
+    if (nbyteswritten != (size_t)n) {
+        PyErr_SetFromErrno(PyExc_IOError);
+        return -1;
+    }
 
-	return (int)n;
+    return (int)n;
 }
 
 static int
 write_cStringIO(Picklerobject *self, const char *s, Py_ssize_t  n)
 {
-	if (s == NULL) {
-		return 0;
-	}
+    if (s == NULL) {
+        return 0;
+    }
 
-	if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {
-		return -1;
-	}
+    if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {
+        return -1;
+    }
 
-	return (int)n;
+    return (int)n;
 }
 
 static int
 write_none(Picklerobject *self, const char *s, Py_ssize_t  n)
 {
-	if (s == NULL) return 0;
-	if (n > INT_MAX) return -1;
-	return (int)n;
+    if (s == NULL) return 0;
+    if (n > INT_MAX) return -1;
+    return (int)n;
 }
 
 static int
 write_other(Picklerobject *self, const char *s, Py_ssize_t  _n)
 {
-	PyObject *py_str = 0, *junk = 0;
-	int n;
+    PyObject *py_str = 0, *junk = 0;
+    int n;
 
-	if (_n > INT_MAX)
-		return -1;
-	n = (int)_n;
-	if (s == NULL) {
-		if (!( self->buf_size ))  return 0;
-		py_str = PyString_FromStringAndSize(self->write_buf,
-						    self->buf_size);
-		if (!py_str)
-			return -1;
-	}
-	else {
-		if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) {
-			if (write_other(self, NULL, 0) < 0)
-				return -1;
-		}
+    if (_n > INT_MAX)
+        return -1;
+    n = (int)_n;
+    if (s == NULL) {
+        if (!( self->buf_size ))  return 0;
+        py_str = PyString_FromStringAndSize(self->write_buf,
+                                            self->buf_size);
+        if (!py_str)
+            return -1;
+    }
+    else {
+        if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) {
+            if (write_other(self, NULL, 0) < 0)
+                return -1;
+        }
 
-		if (n > WRITE_BUF_SIZE) {
-			if (!( py_str =
-			       PyString_FromStringAndSize(s, n)))
-				return -1;
-		}
-		else {
-			memcpy(self->write_buf + self->buf_size, s, n);
-			self->buf_size += n;
-			return n;
-		}
-	}
+        if (n > WRITE_BUF_SIZE) {
+            if (!( py_str =
+                   PyString_FromStringAndSize(s, n)))
+                return -1;
+        }
+        else {
+            memcpy(self->write_buf + self->buf_size, s, n);
+            self->buf_size += n;
+            return n;
+        }
+    }
 
-	if (self->write) {
-		/* object with write method */
-		ARG_TUP(self, py_str);
-		if (self->arg) {
-			junk = PyObject_Call(self->write, self->arg, NULL);
-			FREE_ARG_TUP(self);
-		}
-		if (junk) Py_DECREF(junk);
-		else return -1;
-	}
-	else
-	    PDATA_PUSH(self->file, py_str, -1);
+    if (self->write) {
+        /* object with write method */
+        ARG_TUP(self, py_str);
+        if (self->arg) {
+            junk = PyObject_Call(self->write, self->arg, NULL);
+            FREE_ARG_TUP(self);
+        }
+        if (junk) Py_DECREF(junk);
+        else return -1;
+    }
+    else
+        PDATA_PUSH(self->file, py_str, -1);
 
-	self->buf_size = 0;
-	return n;
+    self->buf_size = 0;
+    return n;
 }
 
 
 static Py_ssize_t
 read_file(Unpicklerobject *self, char **s, Py_ssize_t n)
 {
-	size_t nbytesread;
+    size_t nbytesread;
 
-	if (self->buf_size == 0) {
-		int size;
+    if (self->buf_size == 0) {
+        int size;
 
-		size = ((n < 32) ? 32 : n);
-		if (!( self->buf = (char *)malloc(size))) {
-			PyErr_NoMemory();
-			return -1;
-		}
+        size = ((n < 32) ? 32 : n);
+        if (!( self->buf = (char *)malloc(size))) {
+            PyErr_NoMemory();
+            return -1;
+        }
 
-		self->buf_size = size;
-	}
-	else if (n > self->buf_size) {
-		char *newbuf = (char *)realloc(self->buf, n);
-		if (!newbuf)  {
-			PyErr_NoMemory();
-			return -1;
-		}
-		self->buf = newbuf;
-		self->buf_size = n;
-	}
+        self->buf_size = size;
+    }
+    else if (n > self->buf_size) {
+        char *newbuf = (char *)realloc(self->buf, n);
+        if (!newbuf)  {
+            PyErr_NoMemory();
+            return -1;
+        }
+        self->buf = newbuf;
+        self->buf_size = n;
+    }
 
-	PyFile_IncUseCount((PyFileObject *)self->file);
-	Py_BEGIN_ALLOW_THREADS
-	nbytesread = fread(self->buf, sizeof(char), n, self->fp);
-	Py_END_ALLOW_THREADS
-	PyFile_DecUseCount((PyFileObject *)self->file);
-	if (nbytesread != (size_t)n) {
-		if (feof(self->fp)) {
-			PyErr_SetNone(PyExc_EOFError);
-			return -1;
-		}
+    PyFile_IncUseCount((PyFileObject *)self->file);
+    Py_BEGIN_ALLOW_THREADS
+    nbytesread = fread(self->buf, sizeof(char), n, self->fp);
+    Py_END_ALLOW_THREADS
+    PyFile_DecUseCount((PyFileObject *)self->file);
+    if (nbytesread != (size_t)n) {
+        if (feof(self->fp)) {
+            PyErr_SetNone(PyExc_EOFError);
+            return -1;
+        }
 
-		PyErr_SetFromErrno(PyExc_IOError);
-		return -1;
-	}
+        PyErr_SetFromErrno(PyExc_IOError);
+        return -1;
+    }
 
-	*s = self->buf;
+    *s = self->buf;
 
-	return n;
+    return n;
 }
 
 
 static Py_ssize_t
 readline_file(Unpicklerobject *self, char **s)
 {
-	int i;
+    int i;
 
-	if (self->buf_size == 0) {
-		if (!( self->buf = (char *)malloc(40))) {
-			PyErr_NoMemory();
-			return -1;
-		}
-		self->buf_size = 40;
-	}
+    if (self->buf_size == 0) {
+        if (!( self->buf = (char *)malloc(40))) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        self->buf_size = 40;
+    }
 
-	i = 0;
-	while (1) {
-		int bigger;
-		char *newbuf;
-		for (; i < (self->buf_size - 1); i++) {
-			if (feof(self->fp) ||
-			    (self->buf[i] = getc(self->fp)) == '\n') {
-				self->buf[i + 1] = '\0';
-				*s = self->buf;
-				return i + 1;
-			}
-		}
-		bigger = self->buf_size << 1;
-		if (bigger <= 0) {	/* overflow */
-			PyErr_NoMemory();
-			return -1;
-		}
-		newbuf = (char *)realloc(self->buf, bigger);
-		if (!newbuf)  {
-			PyErr_NoMemory();
-			return -1;
-		}
-		self->buf = newbuf;
-		self->buf_size = bigger;
-	}
+    i = 0;
+    while (1) {
+        int bigger;
+        char *newbuf;
+        for (; i < (self->buf_size - 1); i++) {
+            if (feof(self->fp) ||
+                (self->buf[i] = getc(self->fp)) == '\n') {
+                self->buf[i + 1] = '\0';
+                *s = self->buf;
+                return i + 1;
+            }
+        }
+        bigger = self->buf_size << 1;
+        if (bigger <= 0) {              /* overflow */
+            PyErr_NoMemory();
+            return -1;
+        }
+        newbuf = (char *)realloc(self->buf, bigger);
+        if (!newbuf)  {
+            PyErr_NoMemory();
+            return -1;
+        }
+        self->buf = newbuf;
+        self->buf_size = bigger;
+    }
 }
 
 
 static Py_ssize_t
 read_cStringIO(Unpicklerobject *self, char **s, Py_ssize_t  n)
 {
-	char *ptr;
+    char *ptr;
 
-	if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) {
-		PyErr_SetNone(PyExc_EOFError);
-		return -1;
-	}
+    if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) {
+        PyErr_SetNone(PyExc_EOFError);
+        return -1;
+    }
 
-	*s = ptr;
+    *s = ptr;
 
-	return n;
+    return n;
 }
 
 
 static Py_ssize_t
 readline_cStringIO(Unpicklerobject *self, char **s)
 {
-	Py_ssize_t n;
-	char *ptr;
+    Py_ssize_t n;
+    char *ptr;
 
-	if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {
-		return -1;
-	}
+    if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {
+        return -1;
+    }
 
-	*s = ptr;
+    *s = ptr;
 
-	return n;
+    return n;
 }
 
 
 static Py_ssize_t
 read_other(Unpicklerobject *self, char **s, Py_ssize_t  n)
 {
-	PyObject *bytes, *str=0;
+    PyObject *bytes, *str=0;
 
-	if (!( bytes = PyInt_FromSsize_t(n)))  return -1;
+    if (!( bytes = PyInt_FromSsize_t(n)))  return -1;
 
-	ARG_TUP(self, bytes);
-	if (self->arg) {
-		str = PyObject_Call(self->read, self->arg, NULL);
-		FREE_ARG_TUP(self);
-	}
-	if (! str) return -1;
+    ARG_TUP(self, bytes);
+    if (self->arg) {
+        str = PyObject_Call(self->read, self->arg, NULL);
+        FREE_ARG_TUP(self);
+    }
+    if (! str) return -1;
 
-	Py_XDECREF(self->last_string);
-	self->last_string = str;
+    Py_XDECREF(self->last_string);
+    self->last_string = str;
 
-	if (! (*s = PyString_AsString(str))) return -1;
+    if (! (*s = PyString_AsString(str))) return -1;
 
-	if (PyString_GET_SIZE(str) != n) {
-		PyErr_SetNone(PyExc_EOFError);
-		return -1;
-	}
+    if (PyString_GET_SIZE(str) != n) {
+        PyErr_SetNone(PyExc_EOFError);
+        return -1;
+    }
 
-	return n;
+    return n;
 }
 
 
 static Py_ssize_t
 readline_other(Unpicklerobject *self, char **s)
 {
-	PyObject *str;
-	Py_ssize_t str_size;
+    PyObject *str;
+    Py_ssize_t str_size;
 
-	if (!( str = PyObject_CallObject(self->readline, empty_tuple)))  {
-		return -1;
-	}
+    if (!( str = PyObject_CallObject(self->readline, empty_tuple)))  {
+        return -1;
+    }
 
-	if ((str_size = PyString_Size(str)) < 0)
-		return -1;
+    if ((str_size = PyString_Size(str)) < 0)
+        return -1;
 
-	Py_XDECREF(self->last_string);
-	self->last_string = str;
+    Py_XDECREF(self->last_string);
+    self->last_string = str;
 
-	if (! (*s = PyString_AsString(str)))
-		return -1;
+    if (! (*s = PyString_AsString(str)))
+        return -1;
 
-	return str_size;
+    return str_size;
 }
 
 /* Copy the first n bytes from s into newly malloc'ed memory, plus a
@@ -702,566 +702,566 @@
 static char *
 pystrndup(const char *s, int n)
 {
-	char *r = (char *)malloc(n+1);
-	if (r == NULL)
-		return (char*)PyErr_NoMemory();
-	memcpy(r, s, n);
-	r[n] = 0;
-	return r;
+    char *r = (char *)malloc(n+1);
+    if (r == NULL)
+        return (char*)PyErr_NoMemory();
+    memcpy(r, s, n);
+    r[n] = 0;
+    return r;
 }
 
 
 static int
 get(Picklerobject *self, PyObject *id)
 {
-	PyObject *value, *mv;
-	long c_value;
-	char s[30];
-	size_t len;
+    PyObject *value, *mv;
+    long c_value;
+    char s[30];
+    size_t len;
 
-	if (!( mv = PyDict_GetItem(self->memo, id)))  {
-		PyErr_SetObject(PyExc_KeyError, id);
-		return -1;
-	}
+    if (!( mv = PyDict_GetItem(self->memo, id)))  {
+        PyErr_SetObject(PyExc_KeyError, id);
+        return -1;
+    }
 
-	if (!( value = PyTuple_GetItem(mv, 0)))
-		return -1;
+    if (!( value = PyTuple_GetItem(mv, 0)))
+        return -1;
 
-	if (!( PyInt_Check(value)))  {
-		PyErr_SetString(PicklingError, "no int where int expected in memo");
-		return -1;
-	}
-	c_value = PyInt_AS_LONG((PyIntObject*)value);
+    if (!( PyInt_Check(value)))  {
+        PyErr_SetString(PicklingError, "no int where int expected in memo");
+        return -1;
+    }
+    c_value = PyInt_AS_LONG((PyIntObject*)value);
 
-	if (!self->bin) {
-		s[0] = GET;
-		PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", c_value);
-		len = strlen(s);
-	}
-	else if (Pdata_Check(self->file)) {
-		if (write_other(self, NULL, 0) < 0) return -1;
-		PDATA_APPEND(self->file, mv, -1);
-		return 0;
-	}
-	else {
-		if (c_value < 256) {
-			s[0] = BINGET;
-			s[1] = (int)(c_value & 0xff);
-			len = 2;
-		}
-		else {
-			s[0] = LONG_BINGET;
-			s[1] = (int)(c_value & 0xff);
-			s[2] = (int)((c_value >> 8)  & 0xff);
-			s[3] = (int)((c_value >> 16) & 0xff);
-			s[4] = (int)((c_value >> 24) & 0xff);
-			len = 5;
-		}
-	}
+    if (!self->bin) {
+        s[0] = GET;
+        PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", c_value);
+        len = strlen(s);
+    }
+    else if (Pdata_Check(self->file)) {
+        if (write_other(self, NULL, 0) < 0) return -1;
+        PDATA_APPEND(self->file, mv, -1);
+        return 0;
+    }
+    else {
+        if (c_value < 256) {
+            s[0] = BINGET;
+            s[1] = (int)(c_value & 0xff);
+            len = 2;
+        }
+        else {
+            s[0] = LONG_BINGET;
+            s[1] = (int)(c_value & 0xff);
+            s[2] = (int)((c_value >> 8)  & 0xff);
+            s[3] = (int)((c_value >> 16) & 0xff);
+            s[4] = (int)((c_value >> 24) & 0xff);
+            len = 5;
+        }
+    }
 
-	if (self->write_func(self, s, len) < 0)
-		return -1;
+    if (self->write_func(self, s, len) < 0)
+        return -1;
 
-	return 0;
+    return 0;
 }
 
 
 static int
 put(Picklerobject *self, PyObject *ob)
 {
-	if (Py_REFCNT(ob) < 2 || self->fast)
-		return 0;
+    if (Py_REFCNT(ob) < 2 || self->fast)
+        return 0;
 
-	return put2(self, ob);
+    return put2(self, ob);
 }
 
 
 static int
 put2(Picklerobject *self, PyObject *ob)
 {
-	char c_str[30];
-	int p;
-	size_t len;
-	int res = -1;
-	PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;
+    char c_str[30];
+    int p;
+    size_t len;
+    int res = -1;
+    PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;
 
-	if (self->fast)
-		return 0;
+    if (self->fast)
+        return 0;
 
-	if ((p = PyDict_Size(self->memo)) < 0)
-		goto finally;
+    if ((p = PyDict_Size(self->memo)) < 0)
+        goto finally;
 
-	/* Make sure memo keys are positive! */
-	/* XXX Why?
-	 * XXX And does "positive" really mean non-negative?
-	 * XXX pickle.py starts with PUT index 0, not 1.  This makes for
-	 * XXX gratuitous differences between the pickling modules.
-	 */
-	p++;
+    /* Make sure memo keys are positive! */
+    /* XXX Why?
+     * XXX And does "positive" really mean non-negative?
+     * XXX pickle.py starts with PUT index 0, not 1.  This makes for
+     * XXX gratuitous differences between the pickling modules.
+     */
+    p++;
 
-	if (!( py_ob_id = PyLong_FromVoidPtr(ob)))
-		goto finally;
+    if (!( py_ob_id = PyLong_FromVoidPtr(ob)))
+        goto finally;
 
-	if (!( memo_len = PyInt_FromLong(p)))
-		goto finally;
+    if (!( memo_len = PyInt_FromLong(p)))
+        goto finally;
 
-	if (!( t = PyTuple_New(2)))
-		goto finally;
+    if (!( t = PyTuple_New(2)))
+        goto finally;
 
-	PyTuple_SET_ITEM(t, 0, memo_len);
-	Py_INCREF(memo_len);
-	PyTuple_SET_ITEM(t, 1, ob);
-	Py_INCREF(ob);
+    PyTuple_SET_ITEM(t, 0, memo_len);
+    Py_INCREF(memo_len);
+    PyTuple_SET_ITEM(t, 1, ob);
+    Py_INCREF(ob);
 
-	if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)
-		goto finally;
+    if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)
+        goto finally;
 
-	if (!self->bin) {
-		c_str[0] = PUT;
-		PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%d\n", p);
-		len = strlen(c_str);
-	}
-	else if (Pdata_Check(self->file)) {
-		if (write_other(self, NULL, 0) < 0) return -1;
-		PDATA_APPEND(self->file, memo_len, -1);
-		res=0;          /* Job well done ;) */
-		goto finally;
-	}
-	else {
-		if (p >= 256) {
-			c_str[0] = LONG_BINPUT;
-			c_str[1] = (int)(p & 0xff);
-			c_str[2] = (int)((p >> 8)  & 0xff);
-			c_str[3] = (int)((p >> 16) & 0xff);
-			c_str[4] = (int)((p >> 24) & 0xff);
-			len = 5;
-		}
-		else {
-			c_str[0] = BINPUT;
-			c_str[1] = p;
-			len = 2;
-		}
-	}
+    if (!self->bin) {
+        c_str[0] = PUT;
+        PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%d\n", p);
+        len = strlen(c_str);
+    }
+    else if (Pdata_Check(self->file)) {
+        if (write_other(self, NULL, 0) < 0) return -1;
+        PDATA_APPEND(self->file, memo_len, -1);
+        res=0;          /* Job well done ;) */
+        goto finally;
+    }
+    else {
+        if (p >= 256) {
+            c_str[0] = LONG_BINPUT;
+            c_str[1] = (int)(p & 0xff);
+            c_str[2] = (int)((p >> 8)  & 0xff);
+            c_str[3] = (int)((p >> 16) & 0xff);
+            c_str[4] = (int)((p >> 24) & 0xff);
+            len = 5;
+        }
+        else {
+            c_str[0] = BINPUT;
+            c_str[1] = p;
+            len = 2;
+        }
+    }
 
-	if (self->write_func(self, c_str, len) < 0)
-		goto finally;
+    if (self->write_func(self, c_str, len) < 0)
+        goto finally;
 
-	res = 0;
+    res = 0;
 
   finally:
-	Py_XDECREF(py_ob_id);
-	Py_XDECREF(memo_len);
-	Py_XDECREF(t);
+    Py_XDECREF(py_ob_id);
+    Py_XDECREF(memo_len);
+    Py_XDECREF(t);
 
-	return res;
+    return res;
 }
 
 static PyObject *
 whichmodule(PyObject *global, PyObject *global_name)
 {
-	Py_ssize_t i, j;
-	PyObject *module = 0, *modules_dict = 0,
-		*global_name_attr = 0, *name = 0;
+    Py_ssize_t i, j;
+    PyObject *module = 0, *modules_dict = 0,
+        *global_name_attr = 0, *name = 0;
 
-	module = PyObject_GetAttrString(global, "__module__");
-	if (module) 
-		return module;
-	if (PyErr_ExceptionMatches(PyExc_AttributeError))
-		PyErr_Clear();
-	else
-		return NULL;
+    module = PyObject_GetAttrString(global, "__module__");
+    if (module)
+        return module;
+    if (PyErr_ExceptionMatches(PyExc_AttributeError))
+        PyErr_Clear();
+    else
+        return NULL;
 
-	if (!( modules_dict = PySys_GetObject("modules")))
-		return NULL;
+    if (!( modules_dict = PySys_GetObject("modules")))
+        return NULL;
 
-	i = 0;
-	while ((j = PyDict_Next(modules_dict, &i, &name, &module))) {
+    i = 0;
+    while ((j = PyDict_Next(modules_dict, &i, &name, &module))) {
 
-		if (PyObject_Compare(name, __main___str)==0) continue;
+        if (PyObject_Compare(name, __main___str)==0) continue;
 
-		global_name_attr = PyObject_GetAttr(module, global_name);
-		if (!global_name_attr)  {
-			if (PyErr_ExceptionMatches(PyExc_AttributeError))
-				PyErr_Clear();
-			else
-				return NULL;
-			continue;
-		}
+        global_name_attr = PyObject_GetAttr(module, global_name);
+        if (!global_name_attr)  {
+            if (PyErr_ExceptionMatches(PyExc_AttributeError))
+                PyErr_Clear();
+            else
+                return NULL;
+            continue;
+        }
 
-		if (global_name_attr != global) {
-			Py_DECREF(global_name_attr);
-			continue;
-		}
+        if (global_name_attr != global) {
+            Py_DECREF(global_name_attr);
+            continue;
+        }
 
-		Py_DECREF(global_name_attr);
+        Py_DECREF(global_name_attr);
 
-		break;
-	}
+        break;
+    }
 
-	/* The following implements the rule in pickle.py added in 1.5
-	   that used __main__ if no module is found.  I don't actually
-	   like this rule. jlf
-	*/
-	if (!j) {
-		j=1;
-		name=__main___str;
-	}
+    /* The following implements the rule in pickle.py added in 1.5
+       that used __main__ if no module is found.  I don't actually
+       like this rule. jlf
+    */
+    if (!j) {
+        j=1;
+        name=__main___str;
+    }
 
-	Py_INCREF(name);
-	return name;
+    Py_INCREF(name);
+    return name;
 }
 
 
 static int
 fast_save_enter(Picklerobject *self, PyObject *obj)
 {
-	/* if fast_container < 0, we're doing an error exit. */
-	if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) {
-		PyObject *key = NULL;
-		if (self->fast_memo == NULL) {
-			self->fast_memo = PyDict_New();
-			if (self->fast_memo == NULL) {
-				self->fast_container = -1;
-				return 0;
-			}
-		}
-		key = PyLong_FromVoidPtr(obj);
-		if (key == NULL)
-			return 0;
-		if (PyDict_GetItem(self->fast_memo, key)) {
-			Py_DECREF(key);
-			PyErr_Format(PyExc_ValueError,
-				     "fast mode: can't pickle cyclic objects "
-				     "including object type %s at %p",
-				     Py_TYPE(obj)->tp_name, obj);
-			self->fast_container = -1;
-			return 0;
-		}
-		if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) {
-			Py_DECREF(key);
-			self->fast_container = -1;
-			return 0;
-		}
-		Py_DECREF(key);
-	}
-	return 1;
+    /* if fast_container < 0, we're doing an error exit. */
+    if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) {
+        PyObject *key = NULL;
+        if (self->fast_memo == NULL) {
+            self->fast_memo = PyDict_New();
+            if (self->fast_memo == NULL) {
+                self->fast_container = -1;
+                return 0;
+            }
+        }
+        key = PyLong_FromVoidPtr(obj);
+        if (key == NULL)
+            return 0;
+        if (PyDict_GetItem(self->fast_memo, key)) {
+            Py_DECREF(key);
+            PyErr_Format(PyExc_ValueError,
+                         "fast mode: can't pickle cyclic objects "
+                         "including object type %s at %p",
+                         Py_TYPE(obj)->tp_name, obj);
+            self->fast_container = -1;
+            return 0;
+        }
+        if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) {
+            Py_DECREF(key);
+            self->fast_container = -1;
+            return 0;
+        }
+        Py_DECREF(key);
+    }
+    return 1;
 }
 
 int
 fast_save_leave(Picklerobject *self, PyObject *obj)
 {
-	if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) {
-		PyObject *key = PyLong_FromVoidPtr(obj);
-		if (key == NULL)
-			return 0;
-		if (PyDict_DelItem(self->fast_memo, key) < 0) {
-			Py_DECREF(key);
-			return 0;
-		}
-		Py_DECREF(key);
-	}
-	return 1;
+    if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) {
+        PyObject *key = PyLong_FromVoidPtr(obj);
+        if (key == NULL)
+            return 0;
+        if (PyDict_DelItem(self->fast_memo, key) < 0) {
+            Py_DECREF(key);
+            return 0;
+        }
+        Py_DECREF(key);
+    }
+    return 1;
 }
 
 static int
 save_none(Picklerobject *self, PyObject *args)
 {
-	static char none = NONE;
-	if (self->write_func(self, &none, 1) < 0)
-		return -1;
+    static char none = NONE;
+    if (self->write_func(self, &none, 1) < 0)
+        return -1;
 
-	return 0;
+    return 0;
 }
 
 static int
 save_bool(Picklerobject *self, PyObject *args)
 {
-	static const char *buf[2] = {FALSE, TRUE};
-	static char len[2] = {sizeof(FALSE)-1, sizeof(TRUE)-1};
-	long l = PyInt_AS_LONG((PyIntObject *)args);
+    static const char *buf[2] = {FALSE, TRUE};
+    static char len[2] = {sizeof(FALSE)-1, sizeof(TRUE)-1};
+    long l = PyInt_AS_LONG((PyIntObject *)args);
 
-	if (self->proto >= 2) {
-		char opcode = l ? NEWTRUE : NEWFALSE;
-		if (self->write_func(self, &opcode, 1) < 0)
-			return -1;
-	}
-	else if (self->write_func(self, buf[l], len[l]) < 0)
-		return -1;
-	return 0;
+    if (self->proto >= 2) {
+        char opcode = l ? NEWTRUE : NEWFALSE;
+        if (self->write_func(self, &opcode, 1) < 0)
+            return -1;
+    }
+    else if (self->write_func(self, buf[l], len[l]) < 0)
+        return -1;
+    return 0;
 }
 
 static int
 save_int(Picklerobject *self, PyObject *args)
 {
-	char c_str[32];
-	long l = PyInt_AS_LONG((PyIntObject *)args);
-	int len = 0;
+    char c_str[32];
+    long l = PyInt_AS_LONG((PyIntObject *)args);
+    int len = 0;
 
-	if (!self->bin
+    if (!self->bin
 #if SIZEOF_LONG > 4
-	    || l >  0x7fffffffL
-	    || l < -0x80000000L
+        || l >  0x7fffffffL
+        || l < -0x80000000L
 #endif
-		) {
-		/* Text-mode pickle, or long too big to fit in the 4-byte
-		 * signed BININT format:  store as a string.
-		 */
-		c_str[0] = INT;
-		PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l);
-		if (self->write_func(self, c_str, strlen(c_str)) < 0)
-			return -1;
-	}
-	else {
-		/* Binary pickle and l fits in a signed 4-byte int. */
-		c_str[1] = (int)( l        & 0xff);
-		c_str[2] = (int)((l >> 8)  & 0xff);
-		c_str[3] = (int)((l >> 16) & 0xff);
-		c_str[4] = (int)((l >> 24) & 0xff);
+        ) {
+        /* Text-mode pickle, or long too big to fit in the 4-byte
+         * signed BININT format:  store as a string.
+         */
+        c_str[0] = INT;
+        PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l);
+        if (self->write_func(self, c_str, strlen(c_str)) < 0)
+            return -1;
+    }
+    else {
+        /* Binary pickle and l fits in a signed 4-byte int. */
+        c_str[1] = (int)( l        & 0xff);
+        c_str[2] = (int)((l >> 8)  & 0xff);
+        c_str[3] = (int)((l >> 16) & 0xff);
+        c_str[4] = (int)((l >> 24) & 0xff);
 
-		if ((c_str[4] == 0) && (c_str[3] == 0)) {
-			if (c_str[2] == 0) {
-				c_str[0] = BININT1;
-				len = 2;
-			}
-			else {
-				c_str[0] = BININT2;
-				len = 3;
-			}
-		}
-		else {
-			c_str[0] = BININT;
-			len = 5;
-		}
+        if ((c_str[4] == 0) && (c_str[3] == 0)) {
+            if (c_str[2] == 0) {
+                c_str[0] = BININT1;
+                len = 2;
+            }
+            else {
+                c_str[0] = BININT2;
+                len = 3;
+            }
+        }
+        else {
+            c_str[0] = BININT;
+            len = 5;
+        }
 
-		if (self->write_func(self, c_str, len) < 0)
-			return -1;
-	}
+        if (self->write_func(self, c_str, len) < 0)
+            return -1;
+    }
 
-	return 0;
+    return 0;
 }
 
 
 static int
 save_long(Picklerobject *self, PyObject *args)
 {
-	Py_ssize_t size;
-	int res = -1;
-	PyObject *repr = NULL;
+    Py_ssize_t size;
+    int res = -1;
+    PyObject *repr = NULL;
 
-	static char l = LONG;
+    static char l = LONG;
 
-	if (self->proto >= 2) {
-		/* Linear-time pickling. */
-		size_t nbits;
-		size_t nbytes;
-		unsigned char *pdata;
-		char c_str[5];
-		int i;
-		int sign = _PyLong_Sign(args);
+    if (self->proto >= 2) {
+        /* Linear-time pickling. */
+        size_t nbits;
+        size_t nbytes;
+        unsigned char *pdata;
+        char c_str[5];
+        int i;
+        int sign = _PyLong_Sign(args);
 
-		if (sign == 0) {
-			/* It's 0 -- an empty bytestring. */
-			c_str[0] = LONG1;
-			c_str[1] = 0;
-			i = self->write_func(self, c_str, 2);
-			if (i < 0) goto finally;
-			res = 0;
-			goto finally;
-		}
-		nbits = _PyLong_NumBits(args);
-		if (nbits == (size_t)-1 && PyErr_Occurred())
-			goto finally;
-		/* How many bytes do we need?  There are nbits >> 3 full
-		 * bytes of data, and nbits & 7 leftover bits.  If there
-		 * are any leftover bits, then we clearly need another
-		 * byte.  Wnat's not so obvious is that we *probably*
-		 * need another byte even if there aren't any leftovers:
-		 * the most-significant bit of the most-significant byte
-		 * acts like a sign bit, and it's usually got a sense
-		 * opposite of the one we need.  The exception is longs
-		 * of the form -(2**(8*j-1)) for j > 0.  Such a long is
-		 * its own 256's-complement, so has the right sign bit
-		 * even without the extra byte.  That's a pain to check
-		 * for in advance, though, so we always grab an extra
-		 * byte at the start, and cut it back later if possible.
-		 */
-		nbytes = (nbits >> 3) + 1;
-		if (nbytes > INT_MAX) {
-			PyErr_SetString(PyExc_OverflowError, "long too large "
-				"to pickle");
-			goto finally;
-		}
-		repr = PyString_FromStringAndSize(NULL, (int)nbytes);
-		if (repr == NULL) goto finally;
-		pdata = (unsigned char *)PyString_AS_STRING(repr);
-		i = _PyLong_AsByteArray((PyLongObject *)args,
-	 			pdata, nbytes,
-				1 /* little endian */, 1 /* signed */);
-		if (i < 0) goto finally;
-		/* If the long is negative, this may be a byte more than
-		 * needed.  This is so iff the MSB is all redundant sign
-		 * bits.
-		 */
-		if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff &&
-		    (pdata[nbytes - 2] & 0x80) != 0)
-			--nbytes;
+        if (sign == 0) {
+            /* It's 0 -- an empty bytestring. */
+            c_str[0] = LONG1;
+            c_str[1] = 0;
+            i = self->write_func(self, c_str, 2);
+            if (i < 0) goto finally;
+            res = 0;
+            goto finally;
+        }
+        nbits = _PyLong_NumBits(args);
+        if (nbits == (size_t)-1 && PyErr_Occurred())
+            goto finally;
+        /* How many bytes do we need?  There are nbits >> 3 full
+         * bytes of data, and nbits & 7 leftover bits.  If there
+         * are any leftover bits, then we clearly need another
+         * byte.  Wnat's not so obvious is that we *probably*
+         * need another byte even if there aren't any leftovers:
+         * the most-significant bit of the most-significant byte
+         * acts like a sign bit, and it's usually got a sense
+         * opposite of the one we need.  The exception is longs
+         * of the form -(2**(8*j-1)) for j > 0.  Such a long is
+         * its own 256's-complement, so has the right sign bit
+         * even without the extra byte.  That's a pain to check
+         * for in advance, though, so we always grab an extra
+         * byte at the start, and cut it back later if possible.
+         */
+        nbytes = (nbits >> 3) + 1;
+        if (nbytes > INT_MAX) {
+            PyErr_SetString(PyExc_OverflowError, "long too large "
+                "to pickle");
+            goto finally;
+        }
+        repr = PyString_FromStringAndSize(NULL, (int)nbytes);
+        if (repr == NULL) goto finally;
+        pdata = (unsigned char *)PyString_AS_STRING(repr);
+        i = _PyLong_AsByteArray((PyLongObject *)args,
+                        pdata, nbytes,
+                        1 /* little endian */, 1 /* signed */);
+        if (i < 0) goto finally;
+        /* If the long is negative, this may be a byte more than
+         * needed.  This is so iff the MSB is all redundant sign
+         * bits.
+         */
+        if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff &&
+            (pdata[nbytes - 2] & 0x80) != 0)
+            --nbytes;
 
-		if (nbytes < 256) {
-			c_str[0] = LONG1;
-			c_str[1] = (char)nbytes;
-			size = 2;
-		}
-		else {
-			c_str[0] = LONG4;
-			size = (int)nbytes;
-			for (i = 1; i < 5; i++) {
-				c_str[i] = (char)(size & 0xff);
-				size >>= 8;
-			}
-			size = 5;
-		}
-		i = self->write_func(self, c_str, size);
-		if (i < 0) goto finally;
-		i = self->write_func(self, (char *)pdata, (int)nbytes);
-		if (i < 0) goto finally;
-		res = 0;
-		goto finally;
-	}
+        if (nbytes < 256) {
+            c_str[0] = LONG1;
+            c_str[1] = (char)nbytes;
+            size = 2;
+        }
+        else {
+            c_str[0] = LONG4;
+            size = (int)nbytes;
+            for (i = 1; i < 5; i++) {
+                c_str[i] = (char)(size & 0xff);
+                size >>= 8;
+            }
+            size = 5;
+        }
+        i = self->write_func(self, c_str, size);
+        if (i < 0) goto finally;
+        i = self->write_func(self, (char *)pdata, (int)nbytes);
+        if (i < 0) goto finally;
+        res = 0;
+        goto finally;
+    }
 
-	/* proto < 2:  write the repr and newline.  This is quadratic-time
-	 * (in the number of digits), in both directions.
-	 */
-	if (!( repr = PyObject_Repr(args)))
-		goto finally;
+    /* proto < 2:  write the repr and newline.  This is quadratic-time
+     * (in the number of digits), in both directions.
+     */
+    if (!( repr = PyObject_Repr(args)))
+        goto finally;
 
-	if ((size = PyString_Size(repr)) < 0)
-		goto finally;
+    if ((size = PyString_Size(repr)) < 0)
+        goto finally;
 
-	if (self->write_func(self, &l, 1) < 0)
-		goto finally;
+    if (self->write_func(self, &l, 1) < 0)
+        goto finally;
 
-	if (self->write_func(self,
-			     PyString_AS_STRING((PyStringObject *)repr),
-			     			size) < 0)
-		goto finally;
+    if (self->write_func(self,
+                         PyString_AS_STRING((PyStringObject *)repr),
+                                            size) < 0)
+        goto finally;
 
-	if (self->write_func(self, "\n", 1) < 0)
-		goto finally;
+    if (self->write_func(self, "\n", 1) < 0)
+        goto finally;
 
-	res = 0;
+    res = 0;
 
   finally:
-	Py_XDECREF(repr);
-	return res;
+    Py_XDECREF(repr);
+    return res;
 }
 
 
 static int
 save_float(Picklerobject *self, PyObject *args)
 {
-	double x = PyFloat_AS_DOUBLE((PyFloatObject *)args);
+    double x = PyFloat_AS_DOUBLE((PyFloatObject *)args);
 
-	if (self->bin) {
-		char str[9];
-		str[0] = BINFLOAT;
-		if (_PyFloat_Pack8(x, (unsigned char *)&str[1], 0) < 0)
-			return -1;
-		if (self->write_func(self, str, 9) < 0)
-			return -1;
-	}
-	else {
-		char c_str[250];
-		c_str[0] = FLOAT;
-		PyOS_ascii_formatd(c_str + 1, sizeof(c_str) - 2, "%.17g", x);
-		/* Extend the formatted string with a newline character */
-		strcat(c_str, "\n");
+    if (self->bin) {
+        char str[9];
+        str[0] = BINFLOAT;
+        if (_PyFloat_Pack8(x, (unsigned char *)&str[1], 0) < 0)
+            return -1;
+        if (self->write_func(self, str, 9) < 0)
+            return -1;
+    }
+    else {
+        char c_str[250];
+        c_str[0] = FLOAT;
+        PyOS_ascii_formatd(c_str + 1, sizeof(c_str) - 2, "%.17g", x);
+        /* Extend the formatted string with a newline character */
+        strcat(c_str, "\n");
 
-		if (self->write_func(self, c_str, strlen(c_str)) < 0)
-			return -1;
-	}
+        if (self->write_func(self, c_str, strlen(c_str)) < 0)
+            return -1;
+    }
 
-	return 0;
+    return 0;
 }
 
 
 static int
 save_string(Picklerobject *self, PyObject *args, int doput)
 {
-	int size, len;
-	PyObject *repr=0;
+    int size, len;
+    PyObject *repr=0;
 
-	if ((size = PyString_Size(args)) < 0)
-		return -1;
+    if ((size = PyString_Size(args)) < 0)
+        return -1;
 
-	if (!self->bin) {
-		char *repr_str;
+    if (!self->bin) {
+        char *repr_str;
 
-		static char string = STRING;
+        static char string = STRING;
 
-		if (!( repr = PyObject_Repr(args)))
-			return -1;
+        if (!( repr = PyObject_Repr(args)))
+            return -1;
 
-		if ((len = PyString_Size(repr)) < 0)
-			goto err;
-		repr_str = PyString_AS_STRING((PyStringObject *)repr);
+        if ((len = PyString_Size(repr)) < 0)
+            goto err;
+        repr_str = PyString_AS_STRING((PyStringObject *)repr);
 
-		if (self->write_func(self, &string, 1) < 0)
-			goto err;
+        if (self->write_func(self, &string, 1) < 0)
+            goto err;
 
-		if (self->write_func(self, repr_str, len) < 0)
-			goto err;
+        if (self->write_func(self, repr_str, len) < 0)
+            goto err;
 
-		if (self->write_func(self, "\n", 1) < 0)
-			goto err;
+        if (self->write_func(self, "\n", 1) < 0)
+            goto err;
 
-		Py_XDECREF(repr);
-	}
-	else {
-		int i;
-		char c_str[5];
+        Py_XDECREF(repr);
+    }
+    else {
+        int i;
+        char c_str[5];
 
-		if ((size = PyString_Size(args)) < 0)
-			return -1;
+        if ((size = PyString_Size(args)) < 0)
+            return -1;
 
-		if (size < 256) {
-			c_str[0] = SHORT_BINSTRING;
-			c_str[1] = size;
-			len = 2;
-		}
-		else if (size <= INT_MAX) {
-			c_str[0] = BINSTRING;
-			for (i = 1; i < 5; i++)
-				c_str[i] = (int)(size >> ((i - 1) * 8));
-			len = 5;
-		}
-		else
-			return -1;    /* string too large */
+        if (size < 256) {
+            c_str[0] = SHORT_BINSTRING;
+            c_str[1] = size;
+            len = 2;
+        }
+        else if (size <= INT_MAX) {
+            c_str[0] = BINSTRING;
+            for (i = 1; i < 5; i++)
+                c_str[i] = (int)(size >> ((i - 1) * 8));
+            len = 5;
+        }
+        else
+            return -1;    /* string too large */
 
-		if (self->write_func(self, c_str, len) < 0)
-			return -1;
+        if (self->write_func(self, c_str, len) < 0)
+            return -1;
 
-		if (size > 128 && Pdata_Check(self->file)) {
-			if (write_other(self, NULL, 0) < 0) return -1;
-			PDATA_APPEND(self->file, args, -1);
-		}
-		else {
-			if (self->write_func(self,
-					     PyString_AS_STRING(
-					     	(PyStringObject *)args),
-					     size) < 0)
-				return -1;
-		}
-	}
+        if (size > 128 && Pdata_Check(self->file)) {
+            if (write_other(self, NULL, 0) < 0) return -1;
+            PDATA_APPEND(self->file, args, -1);
+        }
+        else {
+            if (self->write_func(self,
+                                 PyString_AS_STRING(
+                                    (PyStringObject *)args),
+                                 size) < 0)
+                return -1;
+        }
+    }
 
-	if (doput)
-		if (put(self, args) < 0)
-			return -1;
+    if (doput)
+        if (put(self, args) < 0)
+            return -1;
 
-	return 0;
+    return 0;
 
   err:
-	Py_XDECREF(repr);
-	return -1;
+    Py_XDECREF(repr);
+    return -1;
 }
 
 
@@ -1283,71 +1283,71 @@
 #endif
 
     if (size > PY_SSIZE_T_MAX / expandsize)
-        return PyErr_NoMemory();
+    return PyErr_NoMemory();
 
     repr = PyString_FromStringAndSize(NULL, expandsize * size);
     if (repr == NULL)
-        return NULL;
+    return NULL;
     if (size == 0)
-	return repr;
+    return repr;
 
     p = q = PyString_AS_STRING(repr);
     while (size-- > 0) {
-        Py_UNICODE ch = *s++;
+    Py_UNICODE ch = *s++;
 #ifdef Py_UNICODE_WIDE
-	/* Map 32-bit characters to '\Uxxxxxxxx' */
-	if (ch >= 0x10000) {
-            *p++ = '\\';
-            *p++ = 'U';
-            *p++ = hexdigit[(ch >> 28) & 0xf];
-            *p++ = hexdigit[(ch >> 24) & 0xf];
-            *p++ = hexdigit[(ch >> 20) & 0xf];
-            *p++ = hexdigit[(ch >> 16) & 0xf];
-            *p++ = hexdigit[(ch >> 12) & 0xf];
-            *p++ = hexdigit[(ch >> 8) & 0xf];
-            *p++ = hexdigit[(ch >> 4) & 0xf];
-            *p++ = hexdigit[ch & 15];
-        }
-        else
+    /* Map 32-bit characters to '\Uxxxxxxxx' */
+    if (ch >= 0x10000) {
+        *p++ = '\\';
+        *p++ = 'U';
+        *p++ = hexdigit[(ch >> 28) & 0xf];
+        *p++ = hexdigit[(ch >> 24) & 0xf];
+        *p++ = hexdigit[(ch >> 20) & 0xf];
+        *p++ = hexdigit[(ch >> 16) & 0xf];
+        *p++ = hexdigit[(ch >> 12) & 0xf];
+        *p++ = hexdigit[(ch >> 8) & 0xf];
+        *p++ = hexdigit[(ch >> 4) & 0xf];
+        *p++ = hexdigit[ch & 15];
+    }
+    else
 #else
-	/* Map UTF-16 surrogate pairs to '\U00xxxxxx' */
-	if (ch >= 0xD800 && ch < 0xDC00) {
-	    Py_UNICODE ch2;
-	    Py_UCS4 ucs;
+    /* Map UTF-16 surrogate pairs to '\U00xxxxxx' */
+    if (ch >= 0xD800 && ch < 0xDC00) {
+        Py_UNICODE ch2;
+        Py_UCS4 ucs;
 
-	    ch2 = *s++;
-	    size--;
-	    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
-		ucs = (((ch & 0x03FF) << 10) | (ch2 & 0x03FF)) + 0x00010000;
-		*p++ = '\\';
-		*p++ = 'U';
-		*p++ = hexdigit[(ucs >> 28) & 0xf];
-		*p++ = hexdigit[(ucs >> 24) & 0xf];
-		*p++ = hexdigit[(ucs >> 20) & 0xf];
-		*p++ = hexdigit[(ucs >> 16) & 0xf];
-		*p++ = hexdigit[(ucs >> 12) & 0xf];
-		*p++ = hexdigit[(ucs >> 8) & 0xf];
-		*p++ = hexdigit[(ucs >> 4) & 0xf];
-		*p++ = hexdigit[ucs & 0xf];
-		continue;
-	    }
-	    /* Fall through: isolated surrogates are copied as-is */
-	    s--;
-	    size++;
-	}
-#endif
-	/* Map 16-bit characters to '\uxxxx' */
-	if (ch >= 256 || ch == '\\' || ch == '\n') {
-            *p++ = '\\';
-            *p++ = 'u';
-            *p++ = hexdigit[(ch >> 12) & 0xf];
-            *p++ = hexdigit[(ch >> 8) & 0xf];
-            *p++ = hexdigit[(ch >> 4) & 0xf];
-            *p++ = hexdigit[ch & 15];
+        ch2 = *s++;
+        size--;
+        if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
+        ucs = (((ch & 0x03FF) << 10) | (ch2 & 0x03FF)) + 0x00010000;
+        *p++ = '\\';
+        *p++ = 'U';
+        *p++ = hexdigit[(ucs >> 28) & 0xf];
+        *p++ = hexdigit[(ucs >> 24) & 0xf];
+        *p++ = hexdigit[(ucs >> 20) & 0xf];
+        *p++ = hexdigit[(ucs >> 16) & 0xf];
+        *p++ = hexdigit[(ucs >> 12) & 0xf];
+        *p++ = hexdigit[(ucs >> 8) & 0xf];
+        *p++ = hexdigit[(ucs >> 4) & 0xf];
+        *p++ = hexdigit[ucs & 0xf];
+        continue;
         }
-	/* Copy everything else as-is */
-	else
-            *p++ = (char) ch;
+        /* Fall through: isolated surrogates are copied as-is */
+        s--;
+        size++;
+    }
+#endif
+    /* Map 16-bit characters to '\uxxxx' */
+    if (ch >= 256 || ch == '\\' || ch == '\n') {
+        *p++ = '\\';
+        *p++ = 'u';
+        *p++ = hexdigit[(ch >> 12) & 0xf];
+        *p++ = hexdigit[(ch >> 8) & 0xf];
+        *p++ = hexdigit[(ch >> 4) & 0xf];
+        *p++ = hexdigit[ch & 15];
+    }
+    /* Copy everything else as-is */
+    else
+        *p++ = (char) ch;
     }
     *p = '\0';
     _PyString_Resize(&repr, p - q);
@@ -1357,79 +1357,79 @@
 static int
 save_unicode(Picklerobject *self, PyObject *args, int doput)
 {
-	Py_ssize_t size, len;
-	PyObject *repr=0;
+    Py_ssize_t size, len;
+    PyObject *repr=0;
 
-	if (!PyUnicode_Check(args))
-		return -1;
+    if (!PyUnicode_Check(args))
+        return -1;
 
-	if (!self->bin) {
-		char *repr_str;
-		static char string = UNICODE;
+    if (!self->bin) {
+        char *repr_str;
+        static char string = UNICODE;
 
-		repr = modified_EncodeRawUnicodeEscape(
-			PyUnicode_AS_UNICODE(args), PyUnicode_GET_SIZE(args));
-		if (!repr)
-			return -1;
+        repr = modified_EncodeRawUnicodeEscape(
+            PyUnicode_AS_UNICODE(args), PyUnicode_GET_SIZE(args));
+        if (!repr)
+            return -1;
 
-		if ((len = PyString_Size(repr)) < 0)
-			goto err;
-		repr_str = PyString_AS_STRING((PyStringObject *)repr);
+        if ((len = PyString_Size(repr)) < 0)
+            goto err;
+        repr_str = PyString_AS_STRING((PyStringObject *)repr);
 
-		if (self->write_func(self, &string, 1) < 0)
-			goto err;
+        if (self->write_func(self, &string, 1) < 0)
+            goto err;
 
-		if (self->write_func(self, repr_str, len) < 0)
-			goto err;
+        if (self->write_func(self, repr_str, len) < 0)
+            goto err;
 
-		if (self->write_func(self, "\n", 1) < 0)
-			goto err;
+        if (self->write_func(self, "\n", 1) < 0)
+            goto err;
 
-		Py_XDECREF(repr);
-	}
-	else {
-		int i;
-		char c_str[5];
+        Py_XDECREF(repr);
+    }
+    else {
+        int i;
+        char c_str[5];
 
-		if (!( repr = PyUnicode_AsUTF8String(args)))
-			return -1;
+        if (!( repr = PyUnicode_AsUTF8String(args)))
+            return -1;
 
-		if ((size = PyString_Size(repr)) < 0)
-			goto err;
-		if (size > INT_MAX)
-			return -1;   /* string too large */
+        if ((size = PyString_Size(repr)) < 0)
+            goto err;
+        if (size > INT_MAX)
+            return -1;   /* string too large */
 
-		c_str[0] = BINUNICODE;
-		for (i = 1; i < 5; i++)
-			c_str[i] = (int)(size >> ((i - 1) * 8));
-		len = 5;
+        c_str[0] = BINUNICODE;
+        for (i = 1; i < 5; i++)
+            c_str[i] = (int)(size >> ((i - 1) * 8));
+        len = 5;
 
-		if (self->write_func(self, c_str, len) < 0)
-			goto err;
+        if (self->write_func(self, c_str, len) < 0)
+            goto err;
 
-		if (size > 128 && Pdata_Check(self->file)) {
-			if (write_other(self, NULL, 0) < 0)
-				goto err;
-			PDATA_APPEND(self->file, repr, -1);
-		}
-		else {
-			if (self->write_func(self, PyString_AS_STRING(repr),
-					     size) < 0)
-				goto err;
-		}
+        if (size > 128 && Pdata_Check(self->file)) {
+            if (write_other(self, NULL, 0) < 0)
+                goto err;
+            PDATA_APPEND(self->file, repr, -1);
+        }
+        else {
+            if (self->write_func(self, PyString_AS_STRING(repr),
+                                 size) < 0)
+                goto err;
+        }
 
-		Py_DECREF(repr);
-	}
+        Py_DECREF(repr);
+    }
 
-	if (doput)
-		if (put(self, args) < 0)
-			return -1;
+    if (doput)
+        if (put(self, args) < 0)
+            return -1;
 
-	return 0;
+    return 0;
 
   err:
-	Py_XDECREF(repr);
-	return -1;
+    Py_XDECREF(repr);
+    return -1;
 }
 #endif
 
@@ -1437,23 +1437,23 @@
 static int
 store_tuple_elements(Picklerobject *self, PyObject *t, int len)
 {
-	int i;
-	int res = -1;	/* guilty until proved innocent */
+    int i;
+    int res = -1;       /* guilty until proved innocent */
 
-	assert(PyTuple_Size(t) == len);
+    assert(PyTuple_Size(t) == len);
 
-	for (i = 0; i < len; i++) {
-		PyObject *element = PyTuple_GET_ITEM(t, i);
+    for (i = 0; i < len; i++) {
+        PyObject *element = PyTuple_GET_ITEM(t, i);
 
-		if (element == NULL)
-			goto finally;
-		if (save(self, element, 0) < 0)
-			goto finally;
-	}
-	res = 0;
+        if (element == NULL)
+            goto finally;
+        if (save(self, element, 0) < 0)
+            goto finally;
+    }
+    res = 0;
 
   finally:
-	return res;
+    return res;
 }
 
 /* Tuples are ubiquitous in the pickle protocols, so many techniques are
@@ -1465,108 +1465,108 @@
 static int
 save_tuple(Picklerobject *self, PyObject *args)
 {
-	PyObject *py_tuple_id = NULL;
-	int len, i;
-	int res = -1;
+    PyObject *py_tuple_id = NULL;
+    int len, i;
+    int res = -1;
 
-	static char tuple = TUPLE;
-	static char pop = POP;
-	static char pop_mark = POP_MARK;
-	static char len2opcode[] = {EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3};
+    static char tuple = TUPLE;
+    static char pop = POP;
+    static char pop_mark = POP_MARK;
+    static char len2opcode[] = {EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3};
 
-	if ((len = PyTuple_Size(args)) < 0)
-		goto finally;
+    if ((len = PyTuple_Size(args)) < 0)
+        goto finally;
 
-	if (len == 0) {
-		char c_str[2];
+    if (len == 0) {
+        char c_str[2];
 
-		if (self->proto) {
-			c_str[0] = EMPTY_TUPLE;
-			len = 1;
-		}
-		else {
-			c_str[0] = MARK;
-			c_str[1] = TUPLE;
-			len = 2;
-		}
-		if (self->write_func(self, c_str, len) >= 0)
-			res = 0;
-		/* Don't memoize an empty tuple. */
-		goto finally;
-	}
+        if (self->proto) {
+            c_str[0] = EMPTY_TUPLE;
+            len = 1;
+        }
+        else {
+            c_str[0] = MARK;
+            c_str[1] = TUPLE;
+            len = 2;
+        }
+        if (self->write_func(self, c_str, len) >= 0)
+            res = 0;
+        /* Don't memoize an empty tuple. */
+        goto finally;
+    }
 
-	/* A non-empty tuple. */
+    /* A non-empty tuple. */
 
-	/* id(tuple) isn't in the memo now.  If it shows up there after
-	 * saving the tuple elements, the tuple must be recursive, in
-	 * which case we'll pop everything we put on the stack, and fetch
-	 * its value from the memo.
-	 */
-	py_tuple_id = PyLong_FromVoidPtr(args);
-	if (py_tuple_id == NULL)
-		goto finally;
+    /* id(tuple) isn't in the memo now.  If it shows up there after
+     * saving the tuple elements, the tuple must be recursive, in
+     * which case we'll pop everything we put on the stack, and fetch
+     * its value from the memo.
+     */
+    py_tuple_id = PyLong_FromVoidPtr(args);
+    if (py_tuple_id == NULL)
+        goto finally;
 
-	if (len <= 3 && self->proto >= 2) {
-		/* Use TUPLE{1,2,3} opcodes. */
-		if (store_tuple_elements(self, args, len) < 0)
-			goto finally;
-		if (PyDict_GetItem(self->memo, py_tuple_id)) {
-			/* pop the len elements */
-			for (i = 0; i < len; ++i)
-				if (self->write_func(self, &pop, 1) < 0)
-					goto finally;
-			/* fetch from memo */
-			if (get(self, py_tuple_id) < 0)
-				goto finally;
-			res = 0;
-			goto finally;
-		}
-		/* Not recursive. */
-		if (self->write_func(self, len2opcode + len, 1) < 0)
-			goto finally;
-		goto memoize;
-	}
+    if (len <= 3 && self->proto >= 2) {
+        /* Use TUPLE{1,2,3} opcodes. */
+        if (store_tuple_elements(self, args, len) < 0)
+            goto finally;
+        if (PyDict_GetItem(self->memo, py_tuple_id)) {
+            /* pop the len elements */
+            for (i = 0; i < len; ++i)
+                if (self->write_func(self, &pop, 1) < 0)
+                    goto finally;
+            /* fetch from memo */
+            if (get(self, py_tuple_id) < 0)
+                goto finally;
+            res = 0;
+            goto finally;
+        }
+        /* Not recursive. */
+        if (self->write_func(self, len2opcode + len, 1) < 0)
+            goto finally;
+        goto memoize;
+    }
 
-	/* proto < 2 and len > 0, or proto >= 2 and len > 3.
-	 * Generate MARK elt1 elt2 ... TUPLE
-	 */
-	if (self->write_func(self, &MARKv, 1) < 0)
-		goto finally;
+    /* proto < 2 and len > 0, or proto >= 2 and len > 3.
+     * Generate MARK elt1 elt2 ... TUPLE
+     */
+    if (self->write_func(self, &MARKv, 1) < 0)
+        goto finally;
 
-	if (store_tuple_elements(self, args, len) < 0)
-		goto finally;
+    if (store_tuple_elements(self, args, len) < 0)
+        goto finally;
 
-	if (PyDict_GetItem(self->memo, py_tuple_id)) {
-		/* pop the stack stuff we pushed */
-		if (self->bin) {
-			if (self->write_func(self, &pop_mark, 1) < 0)
-				goto finally;
-		}
-		else {
-			/* Note that we pop one more than len, to remove
-			 * the MARK too.
-			 */
-			for (i = 0; i <= len; i++)
-				if (self->write_func(self, &pop, 1) < 0)
-					goto finally;
-		}
-		/* fetch from memo */
-		if (get(self, py_tuple_id) >= 0)
-			res = 0;
-		goto finally;
-	}
+    if (PyDict_GetItem(self->memo, py_tuple_id)) {
+        /* pop the stack stuff we pushed */
+        if (self->bin) {
+            if (self->write_func(self, &pop_mark, 1) < 0)
+                goto finally;
+        }
+        else {
+            /* Note that we pop one more than len, to remove
+             * the MARK too.
+             */
+            for (i = 0; i <= len; i++)
+                if (self->write_func(self, &pop, 1) < 0)
+                    goto finally;
+        }
+        /* fetch from memo */
+        if (get(self, py_tuple_id) >= 0)
+            res = 0;
+        goto finally;
+    }
 
-	/* Not recursive. */
-	if (self->write_func(self, &tuple, 1) < 0)
-		goto finally;
+    /* Not recursive. */
+    if (self->write_func(self, &tuple, 1) < 0)
+        goto finally;
 
   memoize:
-	if (put(self, args) >= 0)
-		res = 0;
+    if (put(self, args) >= 0)
+        res = 0;
 
   finally:
-	Py_XDECREF(py_tuple_id);
-	return res;
+    Py_XDECREF(py_tuple_id);
+    return res;
 }
 
 /* iter is an iterator giving items, and we batch up chunks of
@@ -1578,157 +1578,157 @@
 static int
 batch_list(Picklerobject *self, PyObject *iter)
 {
-	PyObject *obj = NULL;
-	PyObject *firstitem = NULL;
-	int i, n;
+    PyObject *obj = NULL;
+    PyObject *firstitem = NULL;
+    int i, n;
 
-	static char append = APPEND;
-	static char appends = APPENDS;
+    static char append = APPEND;
+    static char appends = APPENDS;
 
-	assert(iter != NULL);
+    assert(iter != NULL);
 
-	if (self->proto == 0) {
-		/* APPENDS isn't available; do one at a time. */
-		for (;;) {
-			obj = PyIter_Next(iter);
-			if (obj == NULL) {
-				if (PyErr_Occurred())
-					return -1;
-				break;
-			}
-			i = save(self, obj, 0);
-			Py_DECREF(obj);
-			if (i < 0)
-				return -1;
-			if (self->write_func(self, &append, 1) < 0)
-				return -1;
-		}
-		return 0;
-	}
+    if (self->proto == 0) {
+        /* APPENDS isn't available; do one at a time. */
+        for (;;) {
+            obj = PyIter_Next(iter);
+            if (obj == NULL) {
+                if (PyErr_Occurred())
+                    return -1;
+                break;
+            }
+            i = save(self, obj, 0);
+            Py_DECREF(obj);
+            if (i < 0)
+                return -1;
+            if (self->write_func(self, &append, 1) < 0)
+                return -1;
+        }
+        return 0;
+    }
 
-	/* proto > 0:  write in batches of BATCHSIZE. */
-	do {
-		/* Get first item */
-		firstitem = PyIter_Next(iter);
-		if (firstitem == NULL) {
-			if (PyErr_Occurred())
-				goto BatchFailed;
+    /* proto > 0:  write in batches of BATCHSIZE. */
+    do {
+        /* Get first item */
+        firstitem = PyIter_Next(iter);
+        if (firstitem == NULL) {
+            if (PyErr_Occurred())
+                goto BatchFailed;
 
-			/* nothing more to add */
-			break;
-		}
+            /* nothing more to add */
+            break;
+        }
 
-		/* Try to get a second item */
-		obj = PyIter_Next(iter);
-		if (obj == NULL) {
-			if (PyErr_Occurred())
-				goto BatchFailed;
+        /* Try to get a second item */
+        obj = PyIter_Next(iter);
+        if (obj == NULL) {
+            if (PyErr_Occurred())
+                goto BatchFailed;
 
-			/* Only one item to write */
-			if (save(self, firstitem, 0) < 0)
-				goto BatchFailed;
-			if (self->write_func(self, &append, 1) < 0)
-				goto BatchFailed;
-			Py_CLEAR(firstitem);
-			break;
-		}
+            /* Only one item to write */
+            if (save(self, firstitem, 0) < 0)
+                goto BatchFailed;
+            if (self->write_func(self, &append, 1) < 0)
+                goto BatchFailed;
+            Py_CLEAR(firstitem);
+            break;
+        }
 
-		/* More than one item to write */
+        /* More than one item to write */
 
-		/* Pump out MARK, items, APPENDS. */
-		if (self->write_func(self, &MARKv, 1) < 0)
-			goto BatchFailed;
-		
-		if (save(self, firstitem, 0) < 0)
-			goto BatchFailed;
-		Py_CLEAR(firstitem);
-		n = 1;
-		
-		/* Fetch and save up to BATCHSIZE items */
-		while (obj) {
-			if (save(self, obj, 0) < 0)
-				goto BatchFailed;
-			Py_CLEAR(obj);
-			n += 1;
-			
-			if (n == BATCHSIZE)
-				break;
+        /* Pump out MARK, items, APPENDS. */
+        if (self->write_func(self, &MARKv, 1) < 0)
+            goto BatchFailed;
 
-			obj = PyIter_Next(iter);
-			if (obj == NULL) {
-				if (PyErr_Occurred())
-					goto BatchFailed;
-				break;
-			}
-		}
+        if (save(self, firstitem, 0) < 0)
+            goto BatchFailed;
+        Py_CLEAR(firstitem);
+        n = 1;
 
-		if (self->write_func(self, &appends, 1) < 0)
-			goto BatchFailed;
+        /* Fetch and save up to BATCHSIZE items */
+        while (obj) {
+            if (save(self, obj, 0) < 0)
+                goto BatchFailed;
+            Py_CLEAR(obj);
+            n += 1;
 
-	} while (n == BATCHSIZE);
-	return 0;
+            if (n == BATCHSIZE)
+                break;
+
+            obj = PyIter_Next(iter);
+            if (obj == NULL) {
+                if (PyErr_Occurred())
+                    goto BatchFailed;
+                break;
+            }
+        }
+
+        if (self->write_func(self, &appends, 1) < 0)
+            goto BatchFailed;
+
+    } while (n == BATCHSIZE);
+    return 0;
 
 BatchFailed:
-	Py_XDECREF(firstitem);
-	Py_XDECREF(obj);
-	return -1;
+    Py_XDECREF(firstitem);
+    Py_XDECREF(obj);
+    return -1;
 }
 
 static int
 save_list(Picklerobject *self, PyObject *args)
 {
-	int res = -1;
-	char s[3];
-	int len;
-	PyObject *iter;
+    int res = -1;
+    char s[3];
+    int len;
+    PyObject *iter;
 
-	if (self->fast && !fast_save_enter(self, args))
-		goto finally;
+    if (self->fast && !fast_save_enter(self, args))
+        goto finally;
 
-	/* Create an empty list. */
-	if (self->bin) {
-		s[0] = EMPTY_LIST;
-		len = 1;
-	}
-	else {
-		s[0] = MARK;
-		s[1] = LIST;
-		len = 2;
-	}
+    /* Create an empty list. */
+    if (self->bin) {
+        s[0] = EMPTY_LIST;
+        len = 1;
+    }
+    else {
+        s[0] = MARK;
+        s[1] = LIST;
+        len = 2;
+    }
 
-	if (self->write_func(self, s, len) < 0)
-		goto finally;
+    if (self->write_func(self, s, len) < 0)
+        goto finally;
 
-	/* Get list length, and bow out early if empty. */
-	if ((len = PyList_Size(args)) < 0)
-		goto finally;
+    /* Get list length, and bow out early if empty. */
+    if ((len = PyList_Size(args)) < 0)
+        goto finally;
 
-	/* Memoize. */
-	if (len == 0) {
-		if (put(self, args) >= 0)
-			res = 0;
-		goto finally;
-	}
-	if (put2(self, args) < 0)
-		goto finally;
+    /* Memoize. */
+    if (len == 0) {
+        if (put(self, args) >= 0)
+            res = 0;
+        goto finally;
+    }
+    if (put2(self, args) < 0)
+        goto finally;
 
-	/* Materialize the list elements. */
-	iter = PyObject_GetIter(args);
-	if (iter == NULL)
-		goto finally;
+    /* Materialize the list elements. */
+    iter = PyObject_GetIter(args);
+    if (iter == NULL)
+        goto finally;
 
-	if (Py_EnterRecursiveCall(" while pickling an object") == 0)
-	{
-		res = batch_list(self, iter);
-		Py_LeaveRecursiveCall();
-	}
-	Py_DECREF(iter);
+    if (Py_EnterRecursiveCall(" while pickling an object") == 0)
+    {
+        res = batch_list(self, iter);
+        Py_LeaveRecursiveCall();
+    }
+    Py_DECREF(iter);
 
   finally:
-	if (self->fast && !fast_save_leave(self, args))
-		res = -1;
+    if (self->fast && !fast_save_leave(self, args))
+        res = -1;
 
-	return res;
+    return res;
 }
 
 
@@ -1746,523 +1746,523 @@
 static int
 batch_dict(Picklerobject *self, PyObject *iter)
 {
-	PyObject *p = NULL;
-	PyObject *firstitem = NULL;
-	int i, n;
+    PyObject *p = NULL;
+    PyObject *firstitem = NULL;
+    int i, n;
 
-	static char setitem = SETITEM;
-	static char setitems = SETITEMS;
+    static char setitem = SETITEM;
+    static char setitems = SETITEMS;
 
-	assert(iter != NULL);
+    assert(iter != NULL);
 
-	if (self->proto == 0) {
-		/* SETITEMS isn't available; do one at a time. */
-		for (;;) {
-			p = PyIter_Next(iter);
-			if (p == NULL) {
-				if (PyErr_Occurred())
-					return -1;
-				break;
-			}
-			if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
-				PyErr_SetString(PyExc_TypeError, "dict items "
-					"iterator must return 2-tuples");
-				return -1;
-			}
-			i = save(self, PyTuple_GET_ITEM(p, 0), 0);
-			if (i >= 0)
-				i = save(self, PyTuple_GET_ITEM(p, 1), 0);
-			Py_DECREF(p);
-			if (i < 0)
-				return -1;
-			if (self->write_func(self, &setitem, 1) < 0)
-				return -1;
-		}
-		return 0;
-	}
+    if (self->proto == 0) {
+        /* SETITEMS isn't available; do one at a time. */
+        for (;;) {
+            p = PyIter_Next(iter);
+            if (p == NULL) {
+                if (PyErr_Occurred())
+                    return -1;
+                break;
+            }
+            if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
+                PyErr_SetString(PyExc_TypeError, "dict items "
+                    "iterator must return 2-tuples");
+                return -1;
+            }
+            i = save(self, PyTuple_GET_ITEM(p, 0), 0);
+            if (i >= 0)
+                i = save(self, PyTuple_GET_ITEM(p, 1), 0);
+            Py_DECREF(p);
+            if (i < 0)
+                return -1;
+            if (self->write_func(self, &setitem, 1) < 0)
+                return -1;
+        }
+        return 0;
+    }
 
-	/* proto > 0:  write in batches of BATCHSIZE. */
-	do {
-		/* Get first item */
-		firstitem = PyIter_Next(iter);
-		if (firstitem == NULL) {
-			if (PyErr_Occurred())
-				goto BatchFailed;
+    /* proto > 0:  write in batches of BATCHSIZE. */
+    do {
+        /* Get first item */
+        firstitem = PyIter_Next(iter);
+        if (firstitem == NULL) {
+            if (PyErr_Occurred())
+                goto BatchFailed;
 
-			/* nothing more to add */
-			break;
-		}
-		if (!PyTuple_Check(firstitem) || PyTuple_Size(firstitem) != 2) {
-			PyErr_SetString(PyExc_TypeError, "dict items "
-					"iterator must return 2-tuples");
-			goto BatchFailed;
-		}
+            /* nothing more to add */
+            break;
+        }
+        if (!PyTuple_Check(firstitem) || PyTuple_Size(firstitem) != 2) {
+            PyErr_SetString(PyExc_TypeError, "dict items "
+                            "iterator must return 2-tuples");
+            goto BatchFailed;
+        }
 
-		/* Try to get a second item */
-		p = PyIter_Next(iter);
-		if (p == NULL) {
-			if (PyErr_Occurred())
-				goto BatchFailed;
+        /* Try to get a second item */
+        p = PyIter_Next(iter);
+        if (p == NULL) {
+            if (PyErr_Occurred())
+                goto BatchFailed;
 
-			/* Only one item to write */
-			if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
-				goto BatchFailed;
-			if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
-				goto BatchFailed;
-			if (self->write_func(self, &setitem, 1) < 0)
-				goto BatchFailed;
-			Py_CLEAR(firstitem);
-			break;
-		}
+            /* Only one item to write */
+            if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
+                goto BatchFailed;
+            if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
+                goto BatchFailed;
+            if (self->write_func(self, &setitem, 1) < 0)
+                goto BatchFailed;
+            Py_CLEAR(firstitem);
+            break;
+        }
 
-		/* More than one item to write */
+        /* More than one item to write */
 
-		/* Pump out MARK, items, SETITEMS. */
-		if (self->write_func(self, &MARKv, 1) < 0)
-			goto BatchFailed;
+        /* Pump out MARK, items, SETITEMS. */
+        if (self->write_func(self, &MARKv, 1) < 0)
+            goto BatchFailed;
 
-		if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
-			goto BatchFailed;
-		if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
-			goto BatchFailed;
-		Py_CLEAR(firstitem);
-		n = 1;
+        if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
+            goto BatchFailed;
+        if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
+            goto BatchFailed;
+        Py_CLEAR(firstitem);
+        n = 1;
 
-		/* Fetch and save up to BATCHSIZE items */
-		while (p) {
-			if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
-				PyErr_SetString(PyExc_TypeError, "dict items "
-					"iterator must return 2-tuples");
-				goto BatchFailed;
-			}
-			if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)
-				goto BatchFailed;
-			if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)
-				goto BatchFailed;
-			Py_CLEAR(p);
-			n += 1;
+        /* Fetch and save up to BATCHSIZE items */
+        while (p) {
+            if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
+                PyErr_SetString(PyExc_TypeError, "dict items "
+                    "iterator must return 2-tuples");
+                goto BatchFailed;
+            }
+            if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)
+                goto BatchFailed;
+            if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)
+                goto BatchFailed;
+            Py_CLEAR(p);
+            n += 1;
 
-			if (n == BATCHSIZE)
-				break;
+            if (n == BATCHSIZE)
+                break;
 
-			p = PyIter_Next(iter);
-			if (p == NULL) {
-				if (PyErr_Occurred())
-					goto BatchFailed;
-				break;
-			}
-		}
+            p = PyIter_Next(iter);
+            if (p == NULL) {
+                if (PyErr_Occurred())
+                    goto BatchFailed;
+                break;
+            }
+        }
 
-		if (self->write_func(self, &setitems, 1) < 0)
-			goto BatchFailed;
+        if (self->write_func(self, &setitems, 1) < 0)
+            goto BatchFailed;
 
-	} while (n == BATCHSIZE);
-	return 0;
+    } while (n == BATCHSIZE);
+    return 0;
 
 BatchFailed:
-	Py_XDECREF(firstitem);
-	Py_XDECREF(p);
-	return -1;
+    Py_XDECREF(firstitem);
+    Py_XDECREF(p);
+    return -1;
 }
 
 static int
 save_dict(Picklerobject *self, PyObject *args)
 {
-	int res = -1;
-	char s[3];
-	int len;
-	PyObject *iter;
+    int res = -1;
+    char s[3];
+    int len;
+    PyObject *iter;
 
-	if (self->fast && !fast_save_enter(self, args))
-		goto finally;
+    if (self->fast && !fast_save_enter(self, args))
+        goto finally;
 
-	/* Create an empty dict. */
-	if (self->bin) {
-		s[0] = EMPTY_DICT;
-		len = 1;
-	}
-	else {
-		s[0] = MARK;
-		s[1] = DICT;
-		len = 2;
-	}
+    /* Create an empty dict. */
+    if (self->bin) {
+        s[0] = EMPTY_DICT;
+        len = 1;
+    }
+    else {
+        s[0] = MARK;
+        s[1] = DICT;
+        len = 2;
+    }
 
-	if (self->write_func(self, s, len) < 0)
-		goto finally;
+    if (self->write_func(self, s, len) < 0)
+        goto finally;
 
-	/* Get dict size, and bow out early if empty. */
-	if ((len = PyDict_Size(args)) < 0)
-		goto finally;
+    /* Get dict size, and bow out early if empty. */
+    if ((len = PyDict_Size(args)) < 0)
+        goto finally;
 
-	if (len == 0) {
-		if (put(self, args) >= 0)
-			res = 0;
-		goto finally;
-	}
-	if (put2(self, args) < 0)
-		goto finally;
+    if (len == 0) {
+        if (put(self, args) >= 0)
+            res = 0;
+        goto finally;
+    }
+    if (put2(self, args) < 0)
+        goto finally;
 
-	/* Materialize the dict items. */
-	iter = PyObject_CallMethod(args, "iteritems", "()");
-	if (iter == NULL)
-		goto finally;
-	if (Py_EnterRecursiveCall(" while pickling an object") == 0)
-	{
-		res = batch_dict(self, iter);
-		Py_LeaveRecursiveCall();
-	}
-	Py_DECREF(iter);
+    /* Materialize the dict items. */
+    iter = PyObject_CallMethod(args, "iteritems", "()");
+    if (iter == NULL)
+        goto finally;
+    if (Py_EnterRecursiveCall(" while pickling an object") == 0)
+    {
+        res = batch_dict(self, iter);
+        Py_LeaveRecursiveCall();
+    }
+    Py_DECREF(iter);
 
   finally:
-	if (self->fast && !fast_save_leave(self, args))
-		res = -1;
+    if (self->fast && !fast_save_leave(self, args))
+        res = -1;
 
-	return res;
+    return res;
 }
 
 
 static int
 save_inst(Picklerobject *self, PyObject *args)
 {
-	PyObject *class = 0, *module = 0, *name = 0, *state = 0,
-		*getinitargs_func = 0, *getstate_func = 0, *class_args = 0;
-	char *module_str, *name_str;
-	int module_size, name_size, res = -1;
+    PyObject *class = 0, *module = 0, *name = 0, *state = 0,
+        *getinitargs_func = 0, *getstate_func = 0, *class_args = 0;
+    char *module_str, *name_str;
+    int module_size, name_size, res = -1;
 
-	static char inst = INST, obj = OBJ, build = BUILD;
+    static char inst = INST, obj = OBJ, build = BUILD;
 
-	if (self->fast && !fast_save_enter(self, args))
-		goto finally;
+    if (self->fast && !fast_save_enter(self, args))
+        goto finally;
 
-	if (self->write_func(self, &MARKv, 1) < 0)
-		goto finally;
+    if (self->write_func(self, &MARKv, 1) < 0)
+        goto finally;
 
-	if (!( class = PyObject_GetAttr(args, __class___str)))
-		goto finally;
+    if (!( class = PyObject_GetAttr(args, __class___str)))
+        goto finally;
 
-	if (self->bin) {
-		if (save(self, class, 0) < 0)
-			goto finally;
-	}
+    if (self->bin) {
+        if (save(self, class, 0) < 0)
+            goto finally;
+    }
 
-	if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) {
-		PyObject *element = 0;
-		int i, len;
+    if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) {
+        PyObject *element = 0;
+        int i, len;
 
-		if (!( class_args =
-		       PyObject_Call(getinitargs_func, empty_tuple, NULL)))
-			goto finally;
+        if (!( class_args =
+               PyObject_Call(getinitargs_func, empty_tuple, NULL)))
+            goto finally;
 
-		if ((len = PyObject_Size(class_args)) < 0)
-			goto finally;
+        if ((len = PyObject_Size(class_args)) < 0)
+            goto finally;
 
-		for (i = 0; i < len; i++) {
-			if (!( element = PySequence_GetItem(class_args, i)))
-				goto finally;
+        for (i = 0; i < len; i++) {
+            if (!( element = PySequence_GetItem(class_args, i)))
+                goto finally;
 
-			if (save(self, element, 0) < 0) {
-				Py_DECREF(element);
-				goto finally;
-			}
+            if (save(self, element, 0) < 0) {
+                Py_DECREF(element);
+                goto finally;
+            }
 
-			Py_DECREF(element);
-		}
-	}
-	else {
-		if (PyErr_ExceptionMatches(PyExc_AttributeError))
-			PyErr_Clear();
-		else
-			goto finally;
-	}
+            Py_DECREF(element);
+        }
+    }
+    else {
+        if (PyErr_ExceptionMatches(PyExc_AttributeError))
+            PyErr_Clear();
+        else
+            goto finally;
+    }
 
-	if (!self->bin) {
-		if (!( name = ((PyClassObject *)class)->cl_name ))  {
-			PyErr_SetString(PicklingError, "class has no name");
-			goto finally;
-		}
+    if (!self->bin) {
+        if (!( name = ((PyClassObject *)class)->cl_name ))  {
+            PyErr_SetString(PicklingError, "class has no name");
+            goto finally;
+        }
 
-		if (!( module = whichmodule(class, name)))
-			goto finally;
+        if (!( module = whichmodule(class, name)))
+            goto finally;
 
 
-		if ((module_size = PyString_Size(module)) < 0 ||
-		    (name_size = PyString_Size(name)) < 0)
-			goto finally;
+        if ((module_size = PyString_Size(module)) < 0 ||
+            (name_size = PyString_Size(name)) < 0)
+            goto finally;
 
-		module_str = PyString_AS_STRING((PyStringObject *)module);
-		name_str   = PyString_AS_STRING((PyStringObject *)name);
+        module_str = PyString_AS_STRING((PyStringObject *)module);
+        name_str   = PyString_AS_STRING((PyStringObject *)name);
 
-		if (self->write_func(self, &inst, 1) < 0)
-			goto finally;
+        if (self->write_func(self, &inst, 1) < 0)
+            goto finally;
 
-		if (self->write_func(self, module_str, module_size) < 0)
-			goto finally;
+        if (self->write_func(self, module_str, module_size) < 0)
+            goto finally;
 
-		if (self->write_func(self, "\n", 1) < 0)
-			goto finally;
+        if (self->write_func(self, "\n", 1) < 0)
+            goto finally;
 
-		if (self->write_func(self, name_str, name_size) < 0)
-			goto finally;
+        if (self->write_func(self, name_str, name_size) < 0)
+            goto finally;
 
-		if (self->write_func(self, "\n", 1) < 0)
-			goto finally;
-	}
-	else if (self->write_func(self, &obj, 1) < 0) {
-		goto finally;
-	}
+        if (self->write_func(self, "\n", 1) < 0)
+            goto finally;
+    }
+    else if (self->write_func(self, &obj, 1) < 0) {
+        goto finally;
+    }
 
-	if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) {
-		state = PyObject_Call(getstate_func, empty_tuple, NULL);
-		if (!state)
-			goto finally;
-	}
-	else {
-		if (PyErr_ExceptionMatches(PyExc_AttributeError))
-			PyErr_Clear();
-		else
-			goto finally;
+    if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) {
+        state = PyObject_Call(getstate_func, empty_tuple, NULL);
+        if (!state)
+            goto finally;
+    }
+    else {
+        if (PyErr_ExceptionMatches(PyExc_AttributeError))
+            PyErr_Clear();
+        else
+            goto finally;
 
-		if (!( state = PyObject_GetAttr(args, __dict___str)))  {
-			if (PyErr_ExceptionMatches(PyExc_AttributeError))
-				PyErr_Clear();
-			else
-				goto finally;
-			res = 0;
-			goto finally;
-		}
-	}
+        if (!( state = PyObject_GetAttr(args, __dict___str)))  {
+            if (PyErr_ExceptionMatches(PyExc_AttributeError))
+                PyErr_Clear();
+            else
+                goto finally;
+            res = 0;
+            goto finally;
+        }
+    }
 
-	if (!PyDict_Check(state)) {
-		if (put2(self, args) < 0)
-			goto finally;
-	}
-	else {
-		if (put(self, args) < 0)
-			goto finally;
-	}
+    if (!PyDict_Check(state)) {
+        if (put2(self, args) < 0)
+            goto finally;
+    }
+    else {
+        if (put(self, args) < 0)
+            goto finally;
+    }
 
-	if (save(self, state, 0) < 0)
-		goto finally;
+    if (save(self, state, 0) < 0)
+        goto finally;
 
-	if (self->write_func(self, &build, 1) < 0)
-		goto finally;
+    if (self->write_func(self, &build, 1) < 0)
+        goto finally;
 
-	res = 0;
+    res = 0;
 
   finally:
-	if (self->fast && !fast_save_leave(self, args))
-		res = -1;
+    if (self->fast && !fast_save_leave(self, args))
+        res = -1;
 
-	Py_XDECREF(module);
-	Py_XDECREF(class);
-	Py_XDECREF(state);
-	Py_XDECREF(getinitargs_func);
-	Py_XDECREF(getstate_func);
-	Py_XDECREF(class_args);
+    Py_XDECREF(module);
+    Py_XDECREF(class);
+    Py_XDECREF(state);
+    Py_XDECREF(getinitargs_func);
+    Py_XDECREF(getstate_func);
+    Py_XDECREF(class_args);
 
-	return res;
+    return res;
 }
 
 
 static int
 save_global(Picklerobject *self, PyObject *args, PyObject *name)
 {
-	PyObject *global_name = 0, *module = 0, *mod = 0, *klass = 0;
-	char *name_str, *module_str;
-	int module_size, name_size, res = -1;
+    PyObject *global_name = 0, *module = 0, *mod = 0, *klass = 0;
+    char *name_str, *module_str;
+    int module_size, name_size, res = -1;
 
-	static char global = GLOBAL;
+    static char global = GLOBAL;
 
-	if (name) {
-		global_name = name;
-		Py_INCREF(global_name);
-	}
-	else {
-		if (!( global_name = PyObject_GetAttr(args, __name___str)))
-			goto finally;
-	}
+    if (name) {
+        global_name = name;
+        Py_INCREF(global_name);
+    }
+    else {
+        if (!( global_name = PyObject_GetAttr(args, __name___str)))
+            goto finally;
+    }
 
-	if (!( module = whichmodule(args, global_name)))
-		goto finally;
+    if (!( module = whichmodule(args, global_name)))
+        goto finally;
 
-	if ((module_size = PyString_Size(module)) < 0 ||
-	    (name_size = PyString_Size(global_name)) < 0)
-		goto finally;
+    if ((module_size = PyString_Size(module)) < 0 ||
+        (name_size = PyString_Size(global_name)) < 0)
+        goto finally;
 
-	module_str = PyString_AS_STRING((PyStringObject *)module);
-	name_str   = PyString_AS_STRING((PyStringObject *)global_name);
+    module_str = PyString_AS_STRING((PyStringObject *)module);
+    name_str   = PyString_AS_STRING((PyStringObject *)global_name);
 
-	/* XXX This can be doing a relative import.  Clearly it shouldn't,
-	   but I don't know how to stop it. :-( */
-	mod = PyImport_ImportModule(module_str);
-	if (mod == NULL) {
-		cPickle_ErrFormat(PicklingError,
-				  "Can't pickle %s: import of module %s "
-				  "failed",
-				  "OS", args, module);
-		goto finally;
-	}
-	klass = PyObject_GetAttrString(mod, name_str);
-	if (klass == NULL) {
-		cPickle_ErrFormat(PicklingError,
-				  "Can't pickle %s: attribute lookup %s.%s "
-				  "failed",
-				  "OSS", args, module, global_name);
-		goto finally;
-	}
-	if (klass != args) {
-		Py_DECREF(klass);
-		cPickle_ErrFormat(PicklingError,
-				  "Can't pickle %s: it's not the same object "
-				  	"as %s.%s",
-				  "OSS", args, module, global_name);
-		goto finally;
-	}
-	Py_DECREF(klass);
+    /* XXX This can be doing a relative import.  Clearly it shouldn't,
+       but I don't know how to stop it. :-( */
+    mod = PyImport_ImportModule(module_str);
+    if (mod == NULL) {
+        cPickle_ErrFormat(PicklingError,
+                          "Can't pickle %s: import of module %s "
+                          "failed",
+                          "OS", args, module);
+        goto finally;
+    }
+    klass = PyObject_GetAttrString(mod, name_str);
+    if (klass == NULL) {
+        cPickle_ErrFormat(PicklingError,
+                          "Can't pickle %s: attribute lookup %s.%s "
+                          "failed",
+                          "OSS", args, module, global_name);
+        goto finally;
+    }
+    if (klass != args) {
+        Py_DECREF(klass);
+        cPickle_ErrFormat(PicklingError,
+                          "Can't pickle %s: it's not the same object "
+                                "as %s.%s",
+                          "OSS", args, module, global_name);
+        goto finally;
+    }
+    Py_DECREF(klass);
 
-	if (self->proto >= 2) {
-		/* See whether this is in the extension registry, and if
-		 * so generate an EXT opcode.
-		 */
-		PyObject *py_code;	/* extension code as Python object */
-		long code;		/* extension code as C value */
-		char c_str[5];
-		int n;
+    if (self->proto >= 2) {
+        /* See whether this is in the extension registry, and if
+         * so generate an EXT opcode.
+         */
+        PyObject *py_code;              /* extension code as Python object */
+        long code;                      /* extension code as C value */
+        char c_str[5];
+        int n;
 
-		PyTuple_SET_ITEM(two_tuple, 0, module);
-		PyTuple_SET_ITEM(two_tuple, 1, global_name);
-		py_code = PyDict_GetItem(extension_registry, two_tuple);
-		if (py_code == NULL)
-			goto gen_global;	/* not registered */
+        PyTuple_SET_ITEM(two_tuple, 0, module);
+        PyTuple_SET_ITEM(two_tuple, 1, global_name);
+        py_code = PyDict_GetItem(extension_registry, two_tuple);
+        if (py_code == NULL)
+            goto gen_global;                    /* not registered */
 
-		/* Verify py_code has the right type and value. */
-		if (!PyInt_Check(py_code)) {
-			cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
-				"extension code %s isn't an integer",
-				"OO", args, py_code);
-			goto finally;
-		}
-		code = PyInt_AS_LONG(py_code);
-		if (code <= 0 ||  code > 0x7fffffffL) {
-			cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
-				"extension code %ld is out of range",
-				"Ol", args, code);
-			goto finally;
-		}
+        /* Verify py_code has the right type and value. */
+        if (!PyInt_Check(py_code)) {
+            cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
+                "extension code %s isn't an integer",
+                "OO", args, py_code);
+            goto finally;
+        }
+        code = PyInt_AS_LONG(py_code);
+        if (code <= 0 ||  code > 0x7fffffffL) {
+            cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
+                "extension code %ld is out of range",
+                "Ol", args, code);
+            goto finally;
+        }
 
-		/* Generate an EXT opcode. */
-		if (code <= 0xff) {
-			c_str[0] = EXT1;
-			c_str[1] = (char)code;
-			n = 2;
-		}
-		else if (code <= 0xffff) {
-			c_str[0] = EXT2;
-			c_str[1] = (char)(code & 0xff);
-			c_str[2] = (char)((code >> 8) & 0xff);
-			n = 3;
-		}
-		else {
-			c_str[0] = EXT4;
-			c_str[1] = (char)(code & 0xff);
-			c_str[2] = (char)((code >> 8) & 0xff);
-			c_str[3] = (char)((code >> 16) & 0xff);
-			c_str[4] = (char)((code >> 24) & 0xff);
-			n = 5;
-		}
+        /* Generate an EXT opcode. */
+        if (code <= 0xff) {
+            c_str[0] = EXT1;
+            c_str[1] = (char)code;
+            n = 2;
+        }
+        else if (code <= 0xffff) {
+            c_str[0] = EXT2;
+            c_str[1] = (char)(code & 0xff);
+            c_str[2] = (char)((code >> 8) & 0xff);
+            n = 3;
+        }
+        else {
+            c_str[0] = EXT4;
+            c_str[1] = (char)(code & 0xff);
+            c_str[2] = (char)((code >> 8) & 0xff);
+            c_str[3] = (char)((code >> 16) & 0xff);
+            c_str[4] = (char)((code >> 24) & 0xff);
+            n = 5;
+        }
 
-		if (self->write_func(self, c_str, n) >= 0)
-			res = 0;
-		goto finally;	/* and don't memoize */
-	}
+        if (self->write_func(self, c_str, n) >= 0)
+            res = 0;
+        goto finally;           /* and don't memoize */
+    }
 
   gen_global:
-	if (self->write_func(self, &global, 1) < 0)
-		goto finally;
+    if (self->write_func(self, &global, 1) < 0)
+        goto finally;
 
-	if (self->write_func(self, module_str, module_size) < 0)
-		goto finally;
+    if (self->write_func(self, module_str, module_size) < 0)
+        goto finally;
 
-	if (self->write_func(self, "\n", 1) < 0)
-		goto finally;
+    if (self->write_func(self, "\n", 1) < 0)
+        goto finally;
 
-	if (self->write_func(self, name_str, name_size) < 0)
-		goto finally;
+    if (self->write_func(self, name_str, name_size) < 0)
+        goto finally;
 
-	if (self->write_func(self, "\n", 1) < 0)
-		goto finally;
+    if (self->write_func(self, "\n", 1) < 0)
+        goto finally;
 
-	if (put(self, args) < 0)
-		goto finally;
+    if (put(self, args) < 0)
+        goto finally;
 
-	res = 0;
+    res = 0;
 
   finally:
-	Py_XDECREF(module);
-	Py_XDECREF(global_name);
-	Py_XDECREF(mod);
+    Py_XDECREF(module);
+    Py_XDECREF(global_name);
+    Py_XDECREF(mod);
 
-	return res;
+    return res;
 }
 
 static int
 save_pers(Picklerobject *self, PyObject *args, PyObject *f)
 {
-	PyObject *pid = 0;
-	int size, res = -1;
+    PyObject *pid = 0;
+    int size, res = -1;
 
-	static char persid = PERSID, binpersid = BINPERSID;
+    static char persid = PERSID, binpersid = BINPERSID;
 
-	Py_INCREF(args);
-	ARG_TUP(self, args);
-	if (self->arg) {
-		pid = PyObject_Call(f, self->arg, NULL);
-		FREE_ARG_TUP(self);
-	}
-	if (! pid) return -1;
+    Py_INCREF(args);
+    ARG_TUP(self, args);
+    if (self->arg) {
+        pid = PyObject_Call(f, self->arg, NULL);
+        FREE_ARG_TUP(self);
+    }
+    if (! pid) return -1;
 
-	if (pid != Py_None) {
-		if (!self->bin) {
-			if (!PyString_Check(pid)) {
-				PyErr_SetString(PicklingError,
-						"persistent id must be string");
-				goto finally;
-			}
+    if (pid != Py_None) {
+        if (!self->bin) {
+            if (!PyString_Check(pid)) {
+                PyErr_SetString(PicklingError,
+                                "persistent id must be string");
+                goto finally;
+            }
 
-			if (self->write_func(self, &persid, 1) < 0)
-				goto finally;
+            if (self->write_func(self, &persid, 1) < 0)
+                goto finally;
 
-			if ((size = PyString_Size(pid)) < 0)
-				goto finally;
+            if ((size = PyString_Size(pid)) < 0)
+                goto finally;
 
-			if (self->write_func(self,
-					     PyString_AS_STRING(
-					     	(PyStringObject *)pid),
-					     size) < 0)
-				goto finally;
+            if (self->write_func(self,
+                                 PyString_AS_STRING(
+                                    (PyStringObject *)pid),
+                                 size) < 0)
+                goto finally;
 
-			if (self->write_func(self, "\n", 1) < 0)
-				goto finally;
+            if (self->write_func(self, "\n", 1) < 0)
+                goto finally;
 
-			res = 1;
-			goto finally;
-		}
-		else if (save(self, pid, 1) >= 0) {
-			if (self->write_func(self, &binpersid, 1) < 0)
-				res = -1;
-			else
-				res = 1;
-		}
+            res = 1;
+            goto finally;
+        }
+        else if (save(self, pid, 1) >= 0) {
+            if (self->write_func(self, &binpersid, 1) < 0)
+                res = -1;
+            else
+                res = 1;
+        }
 
-		goto finally;
-	}
+        goto finally;
+    }
 
-	res = 0;
+    res = 0;
 
   finally:
-	Py_XDECREF(pid);
+    Py_XDECREF(pid);
 
-	return res;
+    return res;
 }
 
 /* We're saving ob, and args is the 2-thru-5 tuple returned by the
@@ -2271,621 +2271,621 @@
 static int
 save_reduce(Picklerobject *self, PyObject *args, PyObject *fn, PyObject *ob)
 {
-	PyObject *callable;
-	PyObject *argtup;
-	PyObject *state = NULL;
-	PyObject *listitems = Py_None;
-	PyObject *dictitems = Py_None;
-	Py_ssize_t size;
+    PyObject *callable;
+    PyObject *argtup;
+    PyObject *state = NULL;
+    PyObject *listitems = Py_None;
+    PyObject *dictitems = Py_None;
+    Py_ssize_t size;
 
-	int use_newobj = self->proto >= 2;
+    int use_newobj = self->proto >= 2;
 
-	static char reduce = REDUCE;
-	static char build = BUILD;
-	static char newobj = NEWOBJ;
+    static char reduce = REDUCE;
+    static char build = BUILD;
+    static char newobj = NEWOBJ;
 
-	size = PyTuple_Size(args);
-	if (size < 2 || size > 5) {
-		cPickle_ErrFormat(PicklingError, "tuple returned by "
-			"%s must contain 2 through 5 elements",
-			"O", fn);
-		return -1;
-	}
+    size = PyTuple_Size(args);
+    if (size < 2 || size > 5) {
+        cPickle_ErrFormat(PicklingError, "tuple returned by "
+            "%s must contain 2 through 5 elements",
+            "O", fn);
+        return -1;
+    }
 
-	if (! PyArg_UnpackTuple(args, "save_reduce", 2, 5,
-				&callable,
-				&argtup,
-				&state,
-				&listitems,
-				&dictitems))
-		return -1;
+    if (! PyArg_UnpackTuple(args, "save_reduce", 2, 5,
+                            &callable,
+                            &argtup,
+                            &state,
+                            &listitems,
+                            &dictitems))
+        return -1;
 
-	if (!PyTuple_Check(argtup)) {
-		cPickle_ErrFormat(PicklingError, "Second element of "
-			"tuple returned by %s must be a tuple",
-			"O", fn);
-		return -1;
-	}
+    if (!PyTuple_Check(argtup)) {
+        cPickle_ErrFormat(PicklingError, "Second element of "
+            "tuple returned by %s must be a tuple",
+            "O", fn);
+        return -1;
+    }
 
-	if (state == Py_None)
-		state = NULL;
+    if (state == Py_None)
+        state = NULL;
 
-	if (listitems == Py_None)
-		listitems = NULL;
-	else if (!PyIter_Check(listitems)) {
-		cPickle_ErrFormat(PicklingError, "Fourth element of "
-			"tuple returned by %s must be an iterator, not %s",
-			"Os", fn, Py_TYPE(listitems)->tp_name);
-		return -1;
-	}
+    if (listitems == Py_None)
+        listitems = NULL;
+    else if (!PyIter_Check(listitems)) {
+        cPickle_ErrFormat(PicklingError, "Fourth element of "
+            "tuple returned by %s must be an iterator, not %s",
+            "Os", fn, Py_TYPE(listitems)->tp_name);
+        return -1;
+    }
 
-	if (dictitems == Py_None)
-		dictitems = NULL;
-	else if (!PyIter_Check(dictitems)) {
-		cPickle_ErrFormat(PicklingError, "Fifth element of "
-			"tuple returned by %s must be an iterator, not %s",
-			"Os", fn, Py_TYPE(dictitems)->tp_name);
-		return -1;
-	}
+    if (dictitems == Py_None)
+        dictitems = NULL;
+    else if (!PyIter_Check(dictitems)) {
+        cPickle_ErrFormat(PicklingError, "Fifth element of "
+            "tuple returned by %s must be an iterator, not %s",
+            "Os", fn, Py_TYPE(dictitems)->tp_name);
+        return -1;
+    }
 
-        /* Protocol 2 special case: if callable's name is __newobj__, use
-         * NEWOBJ.  This consumes a lot of code.
-         */
-        if (use_newobj) {
-        	PyObject *temp = PyObject_GetAttr(callable, __name___str);
+    /* Protocol 2 special case: if callable's name is __newobj__, use
+     * NEWOBJ.  This consumes a lot of code.
+     */
+    if (use_newobj) {
+        PyObject *temp = PyObject_GetAttr(callable, __name___str);
 
-		if (temp == NULL) {
-			if (PyErr_ExceptionMatches(PyExc_AttributeError))
-				PyErr_Clear();
-			else
-				return -1;
-			use_newobj = 0;
-		}
-		else {
-			use_newobj = PyString_Check(temp) &&
-				     strcmp(PyString_AS_STRING(temp),
-				     	    "__newobj__") == 0;
-			Py_DECREF(temp);
-		}
-	}
-	if (use_newobj) {
-		PyObject *cls;
-		PyObject *newargtup;
-		int n, i;
+        if (temp == NULL) {
+            if (PyErr_ExceptionMatches(PyExc_AttributeError))
+                PyErr_Clear();
+            else
+                return -1;
+            use_newobj = 0;
+        }
+        else {
+            use_newobj = PyString_Check(temp) &&
+                         strcmp(PyString_AS_STRING(temp),
+                                "__newobj__") == 0;
+            Py_DECREF(temp);
+        }
+    }
+    if (use_newobj) {
+        PyObject *cls;
+        PyObject *newargtup;
+        int n, i;
 
-		/* Sanity checks. */
-		n = PyTuple_Size(argtup);
-		if (n < 1) {
-			PyErr_SetString(PicklingError, "__newobj__ arglist "
-				"is empty");
-			return -1;
-		}
+        /* Sanity checks. */
+        n = PyTuple_Size(argtup);
+        if (n < 1) {
+            PyErr_SetString(PicklingError, "__newobj__ arglist "
+                "is empty");
+            return -1;
+        }
 
-		cls = PyTuple_GET_ITEM(argtup, 0);
-		if (! PyObject_HasAttrString(cls, "__new__")) {
-			PyErr_SetString(PicklingError, "args[0] from "
-				"__newobj__ args has no __new__");
-			return -1;
-		}
+        cls = PyTuple_GET_ITEM(argtup, 0);
+        if (! PyObject_HasAttrString(cls, "__new__")) {
+            PyErr_SetString(PicklingError, "args[0] from "
+                "__newobj__ args has no __new__");
+            return -1;
+        }
 
-		/* XXX How could ob be NULL? */
-		if (ob != NULL) {
-			PyObject *ob_dot_class;
+        /* XXX How could ob be NULL? */
+        if (ob != NULL) {
+            PyObject *ob_dot_class;
 
-			ob_dot_class = PyObject_GetAttr(ob, __class___str);
-			if (ob_dot_class == NULL) {
-				if (PyErr_ExceptionMatches(
-					    PyExc_AttributeError))
-					PyErr_Clear();
-				else
-					return -1;
-			}
-			i = ob_dot_class != cls; /* true iff a problem */
-			Py_XDECREF(ob_dot_class);
-			if (i) {
-				PyErr_SetString(PicklingError, "args[0] from "
-					"__newobj__ args has the wrong class");
-				return -1;
-			}
-		}
+            ob_dot_class = PyObject_GetAttr(ob, __class___str);
+            if (ob_dot_class == NULL) {
+                if (PyErr_ExceptionMatches(
+                            PyExc_AttributeError))
+                    PyErr_Clear();
+                else
+                    return -1;
+            }
+            i = ob_dot_class != cls; /* true iff a problem */
+            Py_XDECREF(ob_dot_class);
+            if (i) {
+                PyErr_SetString(PicklingError, "args[0] from "
+                    "__newobj__ args has the wrong class");
+                return -1;
+            }
+        }
 
-		/* Save the class and its __new__ arguments. */
-		if (save(self, cls, 0) < 0)
-			return -1;
+        /* Save the class and its __new__ arguments. */
+        if (save(self, cls, 0) < 0)
+            return -1;
 
-		newargtup = PyTuple_New(n-1);  /* argtup[1:] */
-		if (newargtup == NULL)
-			return -1;
-		for (i = 1; i < n; ++i) {
-			PyObject *temp = PyTuple_GET_ITEM(argtup, i);
-			Py_INCREF(temp);
-			PyTuple_SET_ITEM(newargtup, i-1, temp);
-		}
-		i = save(self, newargtup, 0);
-		Py_DECREF(newargtup);
-		if (i < 0)
-			return -1;
+        newargtup = PyTuple_New(n-1);  /* argtup[1:] */
+        if (newargtup == NULL)
+            return -1;
+        for (i = 1; i < n; ++i) {
+            PyObject *temp = PyTuple_GET_ITEM(argtup, i);
+            Py_INCREF(temp);
+            PyTuple_SET_ITEM(newargtup, i-1, temp);
+        }
+        i = save(self, newargtup, 0);
+        Py_DECREF(newargtup);
+        if (i < 0)
+            return -1;
 
-		/* Add NEWOBJ opcode. */
-		if (self->write_func(self, &newobj, 1) < 0)
-			return -1;
-	}
-	else {
-		/* Not using NEWOBJ. */
-		if (save(self, callable, 0) < 0 ||
-		    save(self, argtup, 0) < 0 ||
-		    self->write_func(self, &reduce, 1) < 0)
-			return -1;
-	}
+        /* Add NEWOBJ opcode. */
+        if (self->write_func(self, &newobj, 1) < 0)
+            return -1;
+    }
+    else {
+        /* Not using NEWOBJ. */
+        if (save(self, callable, 0) < 0 ||
+            save(self, argtup, 0) < 0 ||
+            self->write_func(self, &reduce, 1) < 0)
+            return -1;
+    }
 
-	/* Memoize. */
-	/* XXX How can ob be NULL? */
-	if (ob != NULL) {
-		if (state && !PyDict_Check(state)) {
-			if (put2(self, ob) < 0)
-				return -1;
-		}
-		else if (put(self, ob) < 0)
-				return -1;
-	}
+    /* Memoize. */
+    /* XXX How can ob be NULL? */
+    if (ob != NULL) {
+        if (state && !PyDict_Check(state)) {
+            if (put2(self, ob) < 0)
+                return -1;
+        }
+        else if (put(self, ob) < 0)
+                        return -1;
+    }
 
 
-        if (listitems && batch_list(self, listitems) < 0)
-        	return -1;
+    if (listitems && batch_list(self, listitems) < 0)
+        return -1;
 
-        if (dictitems && batch_dict(self, dictitems) < 0)
-        	return -1;
+    if (dictitems && batch_dict(self, dictitems) < 0)
+        return -1;
 
-	if (state) {
-		if (save(self, state, 0) < 0 ||
-		    self->write_func(self, &build, 1) < 0)
-			return -1;
-	}
+    if (state) {
+        if (save(self, state, 0) < 0 ||
+            self->write_func(self, &build, 1) < 0)
+            return -1;
+    }
 
-	return 0;
+    return 0;
 }
 
 static int
 save(Picklerobject *self, PyObject *args, int pers_save)
 {
-	PyTypeObject *type;
-	PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0;
-	int res = -1;
-	int tmp;
+    PyTypeObject *type;
+    PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0;
+    int res = -1;
+    int tmp;
 
-	if (Py_EnterRecursiveCall(" while pickling an object"))
-		return -1;
+    if (Py_EnterRecursiveCall(" while pickling an object"))
+        return -1;
 
-	if (!pers_save && self->pers_func) {
-		if ((tmp = save_pers(self, args, self->pers_func)) != 0) {
-			res = tmp;
-			goto finally;
-		}
-	}
+    if (!pers_save && self->pers_func) {
+        if ((tmp = save_pers(self, args, self->pers_func)) != 0) {
+            res = tmp;
+            goto finally;
+        }
+    }
 
-	if (args == Py_None) {
-		res = save_none(self, args);
-		goto finally;
-	}
+    if (args == Py_None) {
+        res = save_none(self, args);
+        goto finally;
+    }
 
-	type = Py_TYPE(args);
+    type = Py_TYPE(args);
 
-	switch (type->tp_name[0]) {
-	case 'b':
-		if (args == Py_False || args == Py_True) {
-			res = save_bool(self, args);
-			goto finally;
-		}
-		break;
-        case 'i':
-		if (type == &PyInt_Type) {
-			res = save_int(self, args);
-			goto finally;
-		}
-		break;
+    switch (type->tp_name[0]) {
+    case 'b':
+        if (args == Py_False || args == Py_True) {
+            res = save_bool(self, args);
+            goto finally;
+        }
+        break;
+    case 'i':
+        if (type == &PyInt_Type) {
+            res = save_int(self, args);
+            goto finally;
+        }
+        break;
 
-        case 'l':
-		if (type == &PyLong_Type) {
-			res = save_long(self, args);
-			goto finally;
-		}
-		break;
+    case 'l':
+        if (type == &PyLong_Type) {
+            res = save_long(self, args);
+            goto finally;
+        }
+        break;
 
-        case 'f':
-		if (type == &PyFloat_Type) {
-			res = save_float(self, args);
-			goto finally;
-		}
-		break;
+    case 'f':
+        if (type == &PyFloat_Type) {
+            res = save_float(self, args);
+            goto finally;
+        }
+        break;
 
-        case 't':
-		if (type == &PyTuple_Type && PyTuple_Size(args) == 0) {
-			res = save_tuple(self, args);
-			goto finally;
-		}
-		break;
+    case 't':
+        if (type == &PyTuple_Type && PyTuple_Size(args) == 0) {
+            res = save_tuple(self, args);
+            goto finally;
+        }
+        break;
 
-        case 's':
-		if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) {
-			res = save_string(self, args, 0);
-			goto finally;
-		}
-		break;
+    case 's':
+        if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) {
+            res = save_string(self, args, 0);
+            goto finally;
+        }
+        break;
 
 #ifdef Py_USING_UNICODE
-        case 'u':
-		if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) {
-			res = save_unicode(self, args, 0);
-			goto finally;
-		}
-		break;
+    case 'u':
+        if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) {
+            res = save_unicode(self, args, 0);
+            goto finally;
+        }
+        break;
 #endif
-	}
+    }
 
-	if (Py_REFCNT(args) > 1) {
-		if (!( py_ob_id = PyLong_FromVoidPtr(args)))
-			goto finally;
+    if (Py_REFCNT(args) > 1) {
+        if (!( py_ob_id = PyLong_FromVoidPtr(args)))
+            goto finally;
 
-		if (PyDict_GetItem(self->memo, py_ob_id)) {
-			if (get(self, py_ob_id) < 0)
-				goto finally;
+        if (PyDict_GetItem(self->memo, py_ob_id)) {
+            if (get(self, py_ob_id) < 0)
+                goto finally;
 
-			res = 0;
-			goto finally;
-		}
-	}
+            res = 0;
+            goto finally;
+        }
+    }
 
-	switch (type->tp_name[0]) {
-        case 's':
-		if (type == &PyString_Type) {
-			res = save_string(self, args, 1);
-			goto finally;
-		}
-		break;
+    switch (type->tp_name[0]) {
+    case 's':
+        if (type == &PyString_Type) {
+            res = save_string(self, args, 1);
+            goto finally;
+        }
+        break;
 
 #ifdef Py_USING_UNICODE
-        case 'u':
-		if (type == &PyUnicode_Type) {
-			res = save_unicode(self, args, 1);
-			goto finally;
-		}
-		break;
+    case 'u':
+        if (type == &PyUnicode_Type) {
+            res = save_unicode(self, args, 1);
+            goto finally;
+        }
+        break;
 #endif
 
-        case 't':
-		if (type == &PyTuple_Type) {
-			res = save_tuple(self, args);
-			goto finally;
-		}
-		if (type == &PyType_Type) {
-			res = save_global(self, args, NULL);
-			goto finally;
-		}
-		break;
+    case 't':
+        if (type == &PyTuple_Type) {
+            res = save_tuple(self, args);
+            goto finally;
+        }
+        if (type == &PyType_Type) {
+            res = save_global(self, args, NULL);
+            goto finally;
+        }
+        break;
 
-        case 'l':
-		if (type == &PyList_Type) {
-			res = save_list(self, args);
-			goto finally;
-		}
-		break;
+    case 'l':
+        if (type == &PyList_Type) {
+            res = save_list(self, args);
+            goto finally;
+        }
+        break;
 
-        case 'd':
-		if (type == &PyDict_Type) {
-			res = save_dict(self, args);
-			goto finally;
-		}
-		break;
+    case 'd':
+        if (type == &PyDict_Type) {
+            res = save_dict(self, args);
+            goto finally;
+        }
+        break;
 
-        case 'i':
-		if (type == &PyInstance_Type) {
-			res = save_inst(self, args);
-			goto finally;
-		}
-		break;
+    case 'i':
+        if (type == &PyInstance_Type) {
+            res = save_inst(self, args);
+            goto finally;
+        }
+        break;
 
-        case 'c':
-		if (type == &PyClass_Type) {
-			res = save_global(self, args, NULL);
-			goto finally;
-		}
-		break;
+    case 'c':
+        if (type == &PyClass_Type) {
+            res = save_global(self, args, NULL);
+            goto finally;
+        }
+        break;
 
-        case 'f':
-		if (type == &PyFunction_Type) {
-			res = save_global(self, args, NULL);
-			if (res && PyErr_ExceptionMatches(PickleError)) {
-				/* fall back to reduce */
-				PyErr_Clear();
-				break;
-			}
-			goto finally;
-		}
-		break;
+    case 'f':
+        if (type == &PyFunction_Type) {
+            res = save_global(self, args, NULL);
+            if (res && PyErr_ExceptionMatches(PickleError)) {
+                /* fall back to reduce */
+                PyErr_Clear();
+                break;
+            }
+            goto finally;
+        }
+        break;
 
-        case 'b':
-		if (type == &PyCFunction_Type) {
-			res = save_global(self, args, NULL);
-			goto finally;
-		}
-	}
+    case 'b':
+        if (type == &PyCFunction_Type) {
+            res = save_global(self, args, NULL);
+            goto finally;
+        }
+    }
 
-	if (!pers_save && self->inst_pers_func) {
-		if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {
-			res = tmp;
-			goto finally;
-		}
-	}
+    if (!pers_save && self->inst_pers_func) {
+        if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {
+            res = tmp;
+            goto finally;
+        }
+    }
 
-	if (PyType_IsSubtype(type, &PyType_Type)) {
-		res = save_global(self, args, NULL);
-		goto finally;
-	}
+    if (PyType_IsSubtype(type, &PyType_Type)) {
+        res = save_global(self, args, NULL);
+        goto finally;
+    }
 
-	/* Get a reduction callable, and call it.  This may come from
-	 * copy_reg.dispatch_table, the object's __reduce_ex__ method,
-	 * or the object's __reduce__ method.
-	 */
-	__reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type);
-	if (__reduce__ != NULL) {
-		Py_INCREF(__reduce__);
-		Py_INCREF(args);
-		ARG_TUP(self, args);
-		if (self->arg) {
-			t = PyObject_Call(__reduce__, self->arg, NULL);
-			FREE_ARG_TUP(self);
-		}
-	}
-	else {
-		/* Check for a __reduce_ex__ method. */
-		__reduce__ = PyObject_GetAttr(args, __reduce_ex___str);
-		if (__reduce__ != NULL) {
-			t = PyInt_FromLong(self->proto);
-			if (t != NULL) {
-				ARG_TUP(self, t);
-				t = NULL;
-				if (self->arg) {
-					t = PyObject_Call(__reduce__,
-							  self->arg, NULL);
-					FREE_ARG_TUP(self);
-				}
-			}
-		}
-		else {
-			if (PyErr_ExceptionMatches(PyExc_AttributeError))
-				PyErr_Clear();
-			else
-				goto finally;
-			/* Check for a __reduce__ method. */
-			__reduce__ = PyObject_GetAttr(args, __reduce___str);
-			if (__reduce__ != NULL) {
-				t = PyObject_Call(__reduce__,
-						  empty_tuple, NULL);
-			}
-			else {
-				PyErr_SetObject(UnpickleableError, args);
-				goto finally;
-			}
-		}
-	}
+    /* Get a reduction callable, and call it.  This may come from
+     * copy_reg.dispatch_table, the object's __reduce_ex__ method,
+     * or the object's __reduce__ method.
+     */
+    __reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type);
+    if (__reduce__ != NULL) {
+        Py_INCREF(__reduce__);
+        Py_INCREF(args);
+        ARG_TUP(self, args);
+        if (self->arg) {
+            t = PyObject_Call(__reduce__, self->arg, NULL);
+            FREE_ARG_TUP(self);
+        }
+    }
+    else {
+        /* Check for a __reduce_ex__ method. */
+        __reduce__ = PyObject_GetAttr(args, __reduce_ex___str);
+        if (__reduce__ != NULL) {
+            t = PyInt_FromLong(self->proto);
+            if (t != NULL) {
+                ARG_TUP(self, t);
+                t = NULL;
+                if (self->arg) {
+                    t = PyObject_Call(__reduce__,
+                                      self->arg, NULL);
+                    FREE_ARG_TUP(self);
+                }
+            }
+        }
+        else {
+            if (PyErr_ExceptionMatches(PyExc_AttributeError))
+                PyErr_Clear();
+            else
+                goto finally;
+            /* Check for a __reduce__ method. */
+            __reduce__ = PyObject_GetAttr(args, __reduce___str);
+            if (__reduce__ != NULL) {
+                t = PyObject_Call(__reduce__,
+                                  empty_tuple, NULL);
+            }
+            else {
+                PyErr_SetObject(UnpickleableError, args);
+                goto finally;
+            }
+        }
+    }
 
-	if (t == NULL)
-		goto finally;
+    if (t == NULL)
+        goto finally;
 
-	if (PyString_Check(t)) {
-		res = save_global(self, args, t);
-		goto finally;
-	}
+    if (PyString_Check(t)) {
+        res = save_global(self, args, t);
+        goto finally;
+    }
 
-	if (!PyTuple_Check(t)) {
-		cPickle_ErrFormat(PicklingError, "Value returned by "
-				"%s must be string or tuple",
-				"O", __reduce__);
-		goto finally;
-	}
+    if (!PyTuple_Check(t)) {
+        cPickle_ErrFormat(PicklingError, "Value returned by "
+                        "%s must be string or tuple",
+                        "O", __reduce__);
+        goto finally;
+    }
 
-	res = save_reduce(self, t, __reduce__, args);
+    res = save_reduce(self, t, __reduce__, args);
 
   finally:
-	Py_LeaveRecursiveCall();
-	Py_XDECREF(py_ob_id);
-	Py_XDECREF(__reduce__);
-	Py_XDECREF(t);
+    Py_LeaveRecursiveCall();
+    Py_XDECREF(py_ob_id);
+    Py_XDECREF(__reduce__);
+    Py_XDECREF(t);
 
-	return res;
+    return res;
 }
 
 
 static int
 dump(Picklerobject *self, PyObject *args)
 {
-	static char stop = STOP;
+    static char stop = STOP;
 
-	if (self->proto >= 2) {
-		char bytes[2];
+    if (self->proto >= 2) {
+        char bytes[2];
 
-		bytes[0] = PROTO;
-		assert(self->proto >= 0 && self->proto < 256);
-		bytes[1] = (char)self->proto;
-		if (self->write_func(self, bytes, 2) < 0)
-			return -1;
-	}
+        bytes[0] = PROTO;
+        assert(self->proto >= 0 && self->proto < 256);
+        bytes[1] = (char)self->proto;
+        if (self->write_func(self, bytes, 2) < 0)
+            return -1;
+    }
 
-	if (save(self, args, 0) < 0)
-		return -1;
+    if (save(self, args, 0) < 0)
+        return -1;
 
-	if (self->write_func(self, &stop, 1) < 0)
-		return -1;
+    if (self->write_func(self, &stop, 1) < 0)
+        return -1;
 
-	if (self->write_func(self, NULL, 0) < 0)
-		return -1;
+    if (self->write_func(self, NULL, 0) < 0)
+        return -1;
 
-	return 0;
+    return 0;
 }
 
 static PyObject *
 Pickle_clear_memo(Picklerobject *self, PyObject *args)
 {
-	if (self->memo)
-		PyDict_Clear(self->memo);
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (self->memo)
+        PyDict_Clear(self->memo);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 Pickle_getvalue(Picklerobject *self, PyObject *args)
 {
-	int l, i, rsize, ssize, clear=1, lm;
-	long ik;
-	PyObject *k, *r;
-	char *s, *p, *have_get;
-	Pdata *data;
+    int l, i, rsize, ssize, clear=1, lm;
+    long ik;
+    PyObject *k, *r;
+    char *s, *p, *have_get;
+    Pdata *data;
 
-	/* Can be called by Python code or C code */
-	if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear))
-		return NULL;
+    /* Can be called by Python code or C code */
+    if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear))
+        return NULL;
 
-	/* Check to make sure we are based on a list */
-	if (! Pdata_Check(self->file)) {
-		PyErr_SetString(PicklingError,
-				"Attempt to getvalue() a non-list-based pickler");
-		return NULL;
-	}
+    /* Check to make sure we are based on a list */
+    if (! Pdata_Check(self->file)) {
+        PyErr_SetString(PicklingError,
+                        "Attempt to getvalue() a non-list-based pickler");
+        return NULL;
+    }
 
-	/* flush write buffer */
-	if (write_other(self, NULL, 0) < 0) return NULL;
+    /* flush write buffer */
+    if (write_other(self, NULL, 0) < 0) return NULL;
 
-	data=(Pdata*)self->file;
-	l=data->length;
+    data=(Pdata*)self->file;
+    l=data->length;
 
-	/* set up an array to hold get/put status */
-	lm = PyDict_Size(self->memo);
-	if (lm < 0) return NULL;
-	lm++;
-	have_get = malloc(lm);
-	if (have_get == NULL) return PyErr_NoMemory();
-	memset(have_get, 0, lm);
+    /* set up an array to hold get/put status */
+    lm = PyDict_Size(self->memo);
+    if (lm < 0) return NULL;
+    lm++;
+    have_get = malloc(lm);
+    if (have_get == NULL) return PyErr_NoMemory();
+    memset(have_get, 0, lm);
 
-	/* Scan for gets. */
-	for (rsize = 0, i = l; --i >= 0; ) {
-		k = data->data[i];
+    /* Scan for gets. */
+    for (rsize = 0, i = l; --i >= 0; ) {
+        k = data->data[i];
 
-		if (PyString_Check(k))
-			rsize += PyString_GET_SIZE(k);
+        if (PyString_Check(k))
+            rsize += PyString_GET_SIZE(k);
 
-		else if (PyInt_Check(k)) { /* put */
-			ik = PyInt_AS_LONG((PyIntObject*)k);
-			if (ik >= lm || ik == 0) {
-				PyErr_SetString(PicklingError,
-						"Invalid get data");
-				goto err;
-			}
-			if (have_get[ik]) /* with matching get */
-				rsize += ik < 256 ? 2 : 5;
-		}
+        else if (PyInt_Check(k)) { /* put */
+            ik = PyInt_AS_LONG((PyIntObject*)k);
+            if (ik >= lm || ik == 0) {
+                PyErr_SetString(PicklingError,
+                                "Invalid get data");
+                goto err;
+            }
+            if (have_get[ik]) /* with matching get */
+                rsize += ik < 256 ? 2 : 5;
+        }
 
-		else if (! (PyTuple_Check(k) &&
-			    PyTuple_GET_SIZE(k) == 2 &&
-			    PyInt_Check((k = PyTuple_GET_ITEM(k, 0))))
-			) {
-			PyErr_SetString(PicklingError,
-					"Unexpected data in internal list");
-			goto err;
-		}
+        else if (! (PyTuple_Check(k) &&
+                    PyTuple_GET_SIZE(k) == 2 &&
+                    PyInt_Check((k = PyTuple_GET_ITEM(k, 0))))
+            ) {
+            PyErr_SetString(PicklingError,
+                            "Unexpected data in internal list");
+            goto err;
+        }
 
-		else { /* put */
-			ik = PyInt_AS_LONG((PyIntObject *)k);
-			if (ik >= lm || ik == 0) {
-				PyErr_SetString(PicklingError,
-						"Invalid get data");
-				return NULL;
-			}
-			have_get[ik] = 1;
-			rsize += ik < 256 ? 2 : 5;
-		}
-	}
+        else { /* put */
+            ik = PyInt_AS_LONG((PyIntObject *)k);
+            if (ik >= lm || ik == 0) {
+                PyErr_SetString(PicklingError,
+                                "Invalid get data");
+                return NULL;
+            }
+            have_get[ik] = 1;
+            rsize += ik < 256 ? 2 : 5;
+        }
+    }
 
-	/* Now generate the result */
-	r = PyString_FromStringAndSize(NULL, rsize);
-	if (r == NULL) goto err;
-	s = PyString_AS_STRING((PyStringObject *)r);
+    /* Now generate the result */
+    r = PyString_FromStringAndSize(NULL, rsize);
+    if (r == NULL) goto err;
+    s = PyString_AS_STRING((PyStringObject *)r);
 
-	for (i = 0; i < l; i++) {
-		k = data->data[i];
+    for (i = 0; i < l; i++) {
+        k = data->data[i];
 
-		if (PyString_Check(k)) {
-			ssize = PyString_GET_SIZE(k);
-			if (ssize) {
-				p=PyString_AS_STRING((PyStringObject *)k);
-				while (--ssize >= 0)
-					*s++ = *p++;
-			}
-		}
+        if (PyString_Check(k)) {
+            ssize = PyString_GET_SIZE(k);
+            if (ssize) {
+                p=PyString_AS_STRING((PyStringObject *)k);
+                while (--ssize >= 0)
+                    *s++ = *p++;
+            }
+        }
 
-		else if (PyTuple_Check(k)) { /* get */
-			ik = PyInt_AS_LONG((PyIntObject *)
-					    PyTuple_GET_ITEM(k, 0));
-			if (ik < 256) {
-				*s++ = BINGET;
-				*s++ = (int)(ik & 0xff);
-			}
-			else {
-				*s++ = LONG_BINGET;
-				*s++ = (int)(ik & 0xff);
-				*s++ = (int)((ik >> 8)  & 0xff);
-				*s++ = (int)((ik >> 16) & 0xff);
-				*s++ = (int)((ik >> 24) & 0xff);
-			}
-		}
+        else if (PyTuple_Check(k)) { /* get */
+            ik = PyInt_AS_LONG((PyIntObject *)
+                                PyTuple_GET_ITEM(k, 0));
+            if (ik < 256) {
+                *s++ = BINGET;
+                *s++ = (int)(ik & 0xff);
+            }
+            else {
+                *s++ = LONG_BINGET;
+                *s++ = (int)(ik & 0xff);
+                *s++ = (int)((ik >> 8)  & 0xff);
+                *s++ = (int)((ik >> 16) & 0xff);
+                *s++ = (int)((ik >> 24) & 0xff);
+            }
+        }
 
-		else { /* put */
-			ik = PyInt_AS_LONG((PyIntObject*)k);
+        else { /* put */
+            ik = PyInt_AS_LONG((PyIntObject*)k);
 
-			if (have_get[ik]) { /* with matching get */
-				if (ik < 256) {
-					*s++ = BINPUT;
-					*s++ = (int)(ik & 0xff);
-				}
-				else {
-					*s++ = LONG_BINPUT;
-					*s++ = (int)(ik & 0xff);
-					*s++ = (int)((ik >> 8)  & 0xff);
-					*s++ = (int)((ik >> 16) & 0xff);
-					*s++ = (int)((ik >> 24) & 0xff);
-				}
-			}
-		}
-	}
+            if (have_get[ik]) { /* with matching get */
+                if (ik < 256) {
+                    *s++ = BINPUT;
+                    *s++ = (int)(ik & 0xff);
+                }
+                else {
+                    *s++ = LONG_BINPUT;
+                    *s++ = (int)(ik & 0xff);
+                    *s++ = (int)((ik >> 8)  & 0xff);
+                    *s++ = (int)((ik >> 16) & 0xff);
+                    *s++ = (int)((ik >> 24) & 0xff);
+                }
+            }
+        }
+    }
 
-	if (clear) {
-		PyDict_Clear(self->memo);
-		Pdata_clear(data, 0);
-	}
+    if (clear) {
+        PyDict_Clear(self->memo);
+        Pdata_clear(data, 0);
+    }
 
-	free(have_get);
-	return r;
+    free(have_get);
+    return r;
   err:
-	free(have_get);
-	return NULL;
+    free(have_get);
+    return NULL;
 }
 
 static PyObject *
 Pickler_dump(Picklerobject *self, PyObject *args)
 {
-	PyObject *ob;
-	int get=0;
+    PyObject *ob;
+    int get=0;
 
-	if (!( PyArg_ParseTuple(args, "O|i:dump", &ob, &get)))
-		return NULL;
+    if (!( PyArg_ParseTuple(args, "O|i:dump", &ob, &get)))
+        return NULL;
 
-	if (dump(self, ob) < 0)
-		return NULL;
+    if (dump(self, ob) < 0)
+        return NULL;
 
-	if (get) return Pickle_getvalue(self, NULL);
+    if (get) return Pickle_getvalue(self, NULL);
 
-	/* XXX Why does dump() return self? */
-	Py_INCREF(self);
-	return (PyObject*)self;
+    /* XXX Why does dump() return self? */
+    Py_INCREF(self);
+    return (PyObject*)self;
 }
 
 
@@ -2905,250 +2905,250 @@
 static Picklerobject *
 newPicklerobject(PyObject *file, int proto)
 {
-	Picklerobject *self;
+    Picklerobject *self;
 
-	if (proto < 0)
-		proto = HIGHEST_PROTOCOL;
-	if (proto > HIGHEST_PROTOCOL) {
-		PyErr_Format(PyExc_ValueError, "pickle protocol %d asked for; "
-			     "the highest available protocol is %d",
-			     proto, HIGHEST_PROTOCOL);
-		return NULL;
-	}
+    if (proto < 0)
+        proto = HIGHEST_PROTOCOL;
+    if (proto > HIGHEST_PROTOCOL) {
+        PyErr_Format(PyExc_ValueError, "pickle protocol %d asked for; "
+                     "the highest available protocol is %d",
+                     proto, HIGHEST_PROTOCOL);
+        return NULL;
+    }
 
-	self = PyObject_GC_New(Picklerobject, &Picklertype);
-	if (self == NULL)
-		return NULL;
-	self->proto = proto;
-	self->bin = proto > 0;
-	self->fp = NULL;
-	self->write = NULL;
-	self->memo = NULL;
-	self->arg = NULL;
-	self->pers_func = NULL;
-	self->inst_pers_func = NULL;
-	self->write_buf = NULL;
-	self->fast = 0;
-	self->fast_container = 0;
-	self->fast_memo = NULL;
-	self->buf_size = 0;
-	self->dispatch_table = NULL;
+    self = PyObject_GC_New(Picklerobject, &Picklertype);
+    if (self == NULL)
+        return NULL;
+    self->proto = proto;
+    self->bin = proto > 0;
+    self->fp = NULL;
+    self->write = NULL;
+    self->memo = NULL;
+    self->arg = NULL;
+    self->pers_func = NULL;
+    self->inst_pers_func = NULL;
+    self->write_buf = NULL;
+    self->fast = 0;
+    self->fast_container = 0;
+    self->fast_memo = NULL;
+    self->buf_size = 0;
+    self->dispatch_table = NULL;
 
-	self->file = NULL;
-	if (file)
-		Py_INCREF(file);
-	else {
-		file = Pdata_New();
-		if (file == NULL)
-			goto err;
-	}
-	self->file = file;
+    self->file = NULL;
+    if (file)
+        Py_INCREF(file);
+    else {
+        file = Pdata_New();
+        if (file == NULL)
+            goto err;
+    }
+    self->file = file;
 
-	if (!( self->memo = PyDict_New()))
-		goto err;
+    if (!( self->memo = PyDict_New()))
+        goto err;
 
-	if (PyFile_Check(file)) {
-		self->fp = PyFile_AsFile(file);
-		if (self->fp == NULL) {
-			PyErr_SetString(PyExc_ValueError,
-					"I/O operation on closed file");
-			goto err;
-		}
-		self->write_func = write_file;
-	}
-	else if (PycStringIO_OutputCheck(file)) {
-		self->write_func = write_cStringIO;
-	}
-	else if (file == Py_None) {
-		self->write_func = write_none;
-	}
-	else {
-		self->write_func = write_other;
+    if (PyFile_Check(file)) {
+        self->fp = PyFile_AsFile(file);
+        if (self->fp == NULL) {
+            PyErr_SetString(PyExc_ValueError,
+                            "I/O operation on closed file");
+            goto err;
+        }
+        self->write_func = write_file;
+    }
+    else if (PycStringIO_OutputCheck(file)) {
+        self->write_func = write_cStringIO;
+    }
+    else if (file == Py_None) {
+        self->write_func = write_none;
+    }
+    else {
+        self->write_func = write_other;
 
-		if (! Pdata_Check(file)) {
-			self->write = PyObject_GetAttr(file, write_str);
-			if (!self->write)  {
-				PyErr_Clear();
-				PyErr_SetString(PyExc_TypeError,
-						"argument must have 'write' "
-						"attribute");
-				goto err;
-			}
-		}
+        if (! Pdata_Check(file)) {
+            self->write = PyObject_GetAttr(file, write_str);
+            if (!self->write)  {
+                PyErr_Clear();
+                PyErr_SetString(PyExc_TypeError,
+                                "argument must have 'write' "
+                                "attribute");
+                goto err;
+            }
+        }
 
-		self->write_buf = (char *)PyMem_Malloc(WRITE_BUF_SIZE);
-		if (self->write_buf == NULL) {
-			PyErr_NoMemory();
-			goto err;
-		}
-	}
+        self->write_buf = (char *)PyMem_Malloc(WRITE_BUF_SIZE);
+        if (self->write_buf == NULL) {
+            PyErr_NoMemory();
+            goto err;
+        }
+    }
 
-	if (PyEval_GetRestricted()) {
-		/* Restricted execution, get private tables */
-		PyObject *m = PyImport_ImportModule("copy_reg");
+    if (PyEval_GetRestricted()) {
+        /* Restricted execution, get private tables */
+        PyObject *m = PyImport_ImportModule("copy_reg");
 
-		if (m == NULL)
-			goto err;
-		self->dispatch_table = PyObject_GetAttr(m, dispatch_table_str);
-		Py_DECREF(m);
-		if (self->dispatch_table == NULL)
-			goto err;
-	}
-	else {
-		self->dispatch_table = dispatch_table;
-		Py_INCREF(dispatch_table);
-	}
-	PyObject_GC_Track(self);
+        if (m == NULL)
+            goto err;
+        self->dispatch_table = PyObject_GetAttr(m, dispatch_table_str);
+        Py_DECREF(m);
+        if (self->dispatch_table == NULL)
+            goto err;
+    }
+    else {
+        self->dispatch_table = dispatch_table;
+        Py_INCREF(dispatch_table);
+    }
+    PyObject_GC_Track(self);
 
-	return self;
+    return self;
 
   err:
-	Py_DECREF(self);
-	return NULL;
+    Py_DECREF(self);
+    return NULL;
 }
 
 
 static PyObject *
 get_Pickler(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	static char *kwlist[] = {"file", "protocol", NULL};
-	PyObject *file = NULL;
-	int proto = 0;
+    static char *kwlist[] = {"file", "protocol", NULL};
+    PyObject *file = NULL;
+    int proto = 0;
 
-	/* XXX
-	 * The documented signature is Pickler(file, protocol=0), but this
-	 * accepts Pickler() and Pickler(integer) too.  The meaning then
-	 * is clear as mud, undocumented, and not supported by pickle.py.
-	 * I'm told Zope uses this, but I haven't traced into this code
-	 * far enough to figure out what it means.
-	 */
-	if (!PyArg_ParseTuple(args, "|i:Pickler", &proto)) {
-		PyErr_Clear();
-		proto = 0;
-		if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:Pickler",
-			    kwlist, &file, &proto))
-			return NULL;
-	}
-	return (PyObject *)newPicklerobject(file, proto);
+    /* XXX
+     * The documented signature is Pickler(file, protocol=0), but this
+     * accepts Pickler() and Pickler(integer) too.  The meaning then
+     * is clear as mud, undocumented, and not supported by pickle.py.
+     * I'm told Zope uses this, but I haven't traced into this code
+     * far enough to figure out what it means.
+     */
+    if (!PyArg_ParseTuple(args, "|i:Pickler", &proto)) {
+        PyErr_Clear();
+        proto = 0;
+        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:Pickler",
+                    kwlist, &file, &proto))
+            return NULL;
+    }
+    return (PyObject *)newPicklerobject(file, proto);
 }
 
 
 static void
 Pickler_dealloc(Picklerobject *self)
 {
-	PyObject_GC_UnTrack(self);
-	Py_XDECREF(self->write);
-	Py_XDECREF(self->memo);
-	Py_XDECREF(self->fast_memo);
-	Py_XDECREF(self->arg);
-	Py_XDECREF(self->file);
-	Py_XDECREF(self->pers_func);
-	Py_XDECREF(self->inst_pers_func);
-	Py_XDECREF(self->dispatch_table);
-	PyMem_Free(self->write_buf);
-	Py_TYPE(self)->tp_free((PyObject *)self);
+    PyObject_GC_UnTrack(self);
+    Py_XDECREF(self->write);
+    Py_XDECREF(self->memo);
+    Py_XDECREF(self->fast_memo);
+    Py_XDECREF(self->arg);
+    Py_XDECREF(self->file);
+    Py_XDECREF(self->pers_func);
+    Py_XDECREF(self->inst_pers_func);
+    Py_XDECREF(self->dispatch_table);
+    PyMem_Free(self->write_buf);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
 Pickler_traverse(Picklerobject *self, visitproc visit, void *arg)
 {
-	Py_VISIT(self->write);
-	Py_VISIT(self->memo);
-	Py_VISIT(self->fast_memo);
-	Py_VISIT(self->arg);
-	Py_VISIT(self->file);
-	Py_VISIT(self->pers_func);
-	Py_VISIT(self->inst_pers_func);
-	Py_VISIT(self->dispatch_table);
-	return 0;
+    Py_VISIT(self->write);
+    Py_VISIT(self->memo);
+    Py_VISIT(self->fast_memo);
+    Py_VISIT(self->arg);
+    Py_VISIT(self->file);
+    Py_VISIT(self->pers_func);
+    Py_VISIT(self->inst_pers_func);
+    Py_VISIT(self->dispatch_table);
+    return 0;
 }
 
 static int
 Pickler_clear(Picklerobject *self)
 {
-	Py_CLEAR(self->write);
-	Py_CLEAR(self->memo);
-	Py_CLEAR(self->fast_memo);
-	Py_CLEAR(self->arg);
-	Py_CLEAR(self->file);
-	Py_CLEAR(self->pers_func);
-	Py_CLEAR(self->inst_pers_func);
-	Py_CLEAR(self->dispatch_table);
-	return 0;
+    Py_CLEAR(self->write);
+    Py_CLEAR(self->memo);
+    Py_CLEAR(self->fast_memo);
+    Py_CLEAR(self->arg);
+    Py_CLEAR(self->file);
+    Py_CLEAR(self->pers_func);
+    Py_CLEAR(self->inst_pers_func);
+    Py_CLEAR(self->dispatch_table);
+    return 0;
 }
 
 static PyObject *
 Pickler_get_pers_func(Picklerobject *p)
 {
-	if (p->pers_func == NULL)
-		PyErr_SetString(PyExc_AttributeError, "persistent_id");
-	else
-		Py_INCREF(p->pers_func);
-	return p->pers_func;
+    if (p->pers_func == NULL)
+        PyErr_SetString(PyExc_AttributeError, "persistent_id");
+    else
+        Py_INCREF(p->pers_func);
+    return p->pers_func;
 }
 
 static int
 Pickler_set_pers_func(Picklerobject *p, PyObject *v)
 {
-	if (v == NULL) {
-		PyErr_SetString(PyExc_TypeError,
-				"attribute deletion is not supported");
-		return -1;
-	}
-	Py_XDECREF(p->pers_func);
-	Py_INCREF(v);
-	p->pers_func = v;
-	return 0;
+    if (v == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "attribute deletion is not supported");
+        return -1;
+    }
+    Py_XDECREF(p->pers_func);
+    Py_INCREF(v);
+    p->pers_func = v;
+    return 0;
 }
 
 static int
 Pickler_set_inst_pers_func(Picklerobject *p, PyObject *v)
 {
-	if (v == NULL) {
-		PyErr_SetString(PyExc_TypeError,
-				"attribute deletion is not supported");
-		return -1;
-	}
-	Py_XDECREF(p->inst_pers_func);
-	Py_INCREF(v);
-	p->inst_pers_func = v;
-	return 0;
+    if (v == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "attribute deletion is not supported");
+        return -1;
+    }
+    Py_XDECREF(p->inst_pers_func);
+    Py_INCREF(v);
+    p->inst_pers_func = v;
+    return 0;
 }
 
 static PyObject *
 Pickler_get_memo(Picklerobject *p)
 {
-	if (p->memo == NULL)
-		PyErr_SetString(PyExc_AttributeError, "memo");
-	else
-		Py_INCREF(p->memo);
-	return p->memo;
+    if (p->memo == NULL)
+        PyErr_SetString(PyExc_AttributeError, "memo");
+    else
+        Py_INCREF(p->memo);
+    return p->memo;
 }
 
 static int
 Pickler_set_memo(Picklerobject *p, PyObject *v)
 {
-	if (v == NULL) {
-		PyErr_SetString(PyExc_TypeError,
-				"attribute deletion is not supported");
-		return -1;
-	}
-	if (!PyDict_Check(v)) {
-		PyErr_SetString(PyExc_TypeError, "memo must be a dictionary");
-		return -1;
-	}
-	Py_XDECREF(p->memo);
-	Py_INCREF(v);
-	p->memo = v;
-	return 0;
+    if (v == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                        "attribute deletion is not supported");
+        return -1;
+    }
+    if (!PyDict_Check(v)) {
+        PyErr_SetString(PyExc_TypeError, "memo must be a dictionary");
+        return -1;
+    }
+    Py_XDECREF(p->memo);
+    Py_INCREF(v);
+    p->memo = v;
+    return 0;
 }
 
 static PyObject *
 Pickler_get_error(Picklerobject *p)
 {
-	/* why is this an attribute on the Pickler? */
-	Py_INCREF(PicklingError);
-	return PicklingError;
+    /* why is this an attribute on the Pickler? */
+    Py_INCREF(PicklingError);
+    return PicklingError;
 }
 
 static PyMemberDef Pickler_members[] = {
@@ -3174,143 +3174,143 @@
     "cPickle.Pickler",            /*tp_name*/
     sizeof(Picklerobject),              /*tp_basicsize*/
     0,
-    (destructor)Pickler_dealloc,	/* tp_dealloc */
-    0,					/* tp_print */
-    0,			 		/* tp_getattr */
-    0,			 		/* tp_setattr */
-    0,					/* tp_compare */
-    0,		 			/* tp_repr */
-    0,					/* tp_as_number */
-    0,					/* tp_as_sequence */
-    0,					/* tp_as_mapping */
-    0,					/* tp_hash */
-    0,					/* tp_call */
-    0,					/* tp_str */
-    PyObject_GenericGetAttr,		/* tp_getattro */
-    PyObject_GenericSetAttr,		/* tp_setattro */
-    0,					/* tp_as_buffer */
+    (destructor)Pickler_dealloc,        /* tp_dealloc */
+    0,                                  /* tp_print */
+    0,                                  /* tp_getattr */
+    0,                                  /* tp_setattr */
+    0,                                  /* tp_compare */
+    0,                                  /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    0,                                  /* tp_hash */
+    0,                                  /* tp_call */
+    0,                                  /* tp_str */
+    PyObject_GenericGetAttr,            /* tp_getattro */
+    PyObject_GenericSetAttr,            /* tp_setattro */
+    0,                                  /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
-    Picklertype__doc__,			/* tp_doc */
-    (traverseproc)Pickler_traverse,	/* tp_traverse */
-    (inquiry)Pickler_clear,		/* tp_clear */
-    0,					/* tp_richcompare */
-    0,					/* tp_weaklistoffset */
-    0,					/* tp_iter */
-    0,					/* tp_iternext */
-    Pickler_methods,			/* tp_methods */
-    Pickler_members,			/* tp_members */
-    Pickler_getsets,			/* tp_getset */
+    Picklertype__doc__,                 /* tp_doc */
+    (traverseproc)Pickler_traverse,     /* tp_traverse */
+    (inquiry)Pickler_clear,             /* tp_clear */
+    0,                                  /* tp_richcompare */
+    0,                                  /* tp_weaklistoffset */
+    0,                                  /* tp_iter */
+    0,                                  /* tp_iternext */
+    Pickler_methods,                    /* tp_methods */
+    Pickler_members,                    /* tp_members */
+    Pickler_getsets,                    /* tp_getset */
 };
 
 static PyObject *
 find_class(PyObject *py_module_name, PyObject *py_global_name, PyObject *fc)
 {
-	PyObject *global = 0, *module;
+    PyObject *global = 0, *module;
 
-	if (fc) {
-		if (fc==Py_None) {
-			PyErr_SetString(UnpicklingError, "Global and instance "
-					"pickles are not supported.");
-			return NULL;
-		}
-		return PyObject_CallFunctionObjArgs(fc, py_module_name,
-					            py_global_name, NULL);
-	}
+    if (fc) {
+        if (fc==Py_None) {
+            PyErr_SetString(UnpicklingError, "Global and instance "
+                            "pickles are not supported.");
+            return NULL;
+        }
+        return PyObject_CallFunctionObjArgs(fc, py_module_name,
+                                            py_global_name, NULL);
+    }
 
-	module = PySys_GetObject("modules");
-	if (module == NULL)
-		return NULL;
+    module = PySys_GetObject("modules");
+    if (module == NULL)
+        return NULL;
 
-	module = PyDict_GetItem(module, py_module_name);
-	if (module == NULL) {
-		module = PyImport_Import(py_module_name);
-		if (!module)
-			return NULL;
-		global = PyObject_GetAttr(module, py_global_name);
-		Py_DECREF(module);
-	}
-	else
-		global = PyObject_GetAttr(module, py_global_name);
-	return global;
+    module = PyDict_GetItem(module, py_module_name);
+    if (module == NULL) {
+        module = PyImport_Import(py_module_name);
+        if (!module)
+            return NULL;
+        global = PyObject_GetAttr(module, py_global_name);
+        Py_DECREF(module);
+    }
+    else
+        global = PyObject_GetAttr(module, py_global_name);
+    return global;
 }
 
 static int
 marker(Unpicklerobject *self)
 {
-	if (self->num_marks < 1) {
-		PyErr_SetString(UnpicklingError, "could not find MARK");
-		return -1;
-	}
+    if (self->num_marks < 1) {
+        PyErr_SetString(UnpicklingError, "could not find MARK");
+        return -1;
+    }
 
-	return self->marks[--self->num_marks];
+    return self->marks[--self->num_marks];
 }
 
 
 static int
 load_none(Unpicklerobject *self)
 {
-	PDATA_APPEND(self->stack, Py_None, -1);
-	return 0;
+    PDATA_APPEND(self->stack, Py_None, -1);
+    return 0;
 }
 
 static int
 bad_readline(void)
 {
-	PyErr_SetString(UnpicklingError, "pickle data was truncated");
-	return -1;
+    PyErr_SetString(UnpicklingError, "pickle data was truncated");
+    return -1;
 }
 
 static int
 load_int(Unpicklerobject *self)
 {
-	PyObject *py_int = 0;
-	char *endptr, *s;
-	int len, res = -1;
-	long l;
+    PyObject *py_int = 0;
+    char *endptr, *s;
+    int len, res = -1;
+    long l;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 2) return bad_readline();
-	if (!( s=pystrndup(s,len)))  return -1;
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 2) return bad_readline();
+    if (!( s=pystrndup(s,len)))  return -1;
 
-	errno = 0;
-	l = strtol(s, &endptr, 0);
+    errno = 0;
+    l = strtol(s, &endptr, 0);
 
-	if (errno || (*endptr != '\n') || (endptr[1] != '\0')) {
-		/* Hm, maybe we've got something long.  Let's try reading
-		   it as a Python long object. */
-		errno = 0;
-		py_int = PyLong_FromString(s, NULL, 0);
-		if (py_int == NULL) {
-			PyErr_SetString(PyExc_ValueError,
-					"could not convert string to int");
-			goto finally;
-		}
-	}
-	else {
-		if (len == 3 && (l == 0 || l == 1)) {
-			if (!( py_int = PyBool_FromLong(l)))  goto finally;
-		}
-		else {
-			if (!( py_int = PyInt_FromLong(l)))  goto finally;
-		}
-	}
+    if (errno || (*endptr != '\n') || (endptr[1] != '\0')) {
+        /* Hm, maybe we've got something long.  Let's try reading
+           it as a Python long object. */
+        errno = 0;
+        py_int = PyLong_FromString(s, NULL, 0);
+        if (py_int == NULL) {
+            PyErr_SetString(PyExc_ValueError,
+                            "could not convert string to int");
+            goto finally;
+        }
+    }
+    else {
+        if (len == 3 && (l == 0 || l == 1)) {
+            if (!( py_int = PyBool_FromLong(l)))  goto finally;
+        }
+        else {
+            if (!( py_int = PyInt_FromLong(l)))  goto finally;
+        }
+    }
 
-	free(s);
-	PDATA_PUSH(self->stack, py_int, -1);
-	return 0;
+    free(s);
+    PDATA_PUSH(self->stack, py_int, -1);
+    return 0;
 
   finally:
-	free(s);
+    free(s);
 
-	return res;
+    return res;
 }
 
 static int
 load_bool(Unpicklerobject *self, PyObject *boolean)
 {
-	assert(boolean == Py_True || boolean == Py_False);
-	PDATA_APPEND(self->stack, boolean, -1);
-	return 0;
+    assert(boolean == Py_True || boolean == Py_False);
+    PDATA_APPEND(self->stack, boolean, -1);
+    return 0;
 }
 
 /* s contains x bytes of a little-endian integer.  Return its value as a
@@ -3321,99 +3321,99 @@
 static long
 calc_binint(char *s, int x)
 {
-	unsigned char c;
-	int i;
-	long l;
+    unsigned char c;
+    int i;
+    long l;
 
-	for (i = 0, l = 0L; i < x; i++) {
-		c = (unsigned char)s[i];
-		l |= (long)c << (i * 8);
-	}
+    for (i = 0, l = 0L; i < x; i++) {
+        c = (unsigned char)s[i];
+        l |= (long)c << (i * 8);
+    }
 #if SIZEOF_LONG > 4
-	/* Unlike BININT1 and BININT2, BININT (more accurately BININT4)
-	 * is signed, so on a box with longs bigger than 4 bytes we need
-	 * to extend a BININT's sign bit to the full width.
-	 */
-	if (x == 4 && l & (1L << 31))
-		l |= (~0L) << 32;
+    /* Unlike BININT1 and BININT2, BININT (more accurately BININT4)
+     * is signed, so on a box with longs bigger than 4 bytes we need
+     * to extend a BININT's sign bit to the full width.
+     */
+    if (x == 4 && l & (1L << 31))
+        l |= (~0L) << 32;
 #endif
-	return l;
+    return l;
 }
 
 
 static int
 load_binintx(Unpicklerobject *self, char *s, int  x)
 {
-	PyObject *py_int = 0;
-	long l;
+    PyObject *py_int = 0;
+    long l;
 
-	l = calc_binint(s, x);
+    l = calc_binint(s, x);
 
-	if (!( py_int = PyInt_FromLong(l)))
-		return -1;
+    if (!( py_int = PyInt_FromLong(l)))
+        return -1;
 
-	PDATA_PUSH(self->stack, py_int, -1);
-	return 0;
+    PDATA_PUSH(self->stack, py_int, -1);
+    return 0;
 }
 
 
 static int
 load_binint(Unpicklerobject *self)
 {
-	char *s;
+    char *s;
 
-	if (self->read_func(self, &s, 4) < 0)
-		return -1;
+    if (self->read_func(self, &s, 4) < 0)
+        return -1;
 
-	return load_binintx(self, s, 4);
+    return load_binintx(self, s, 4);
 }
 
 
 static int
 load_binint1(Unpicklerobject *self)
 {
-	char *s;
+    char *s;
 
-	if (self->read_func(self, &s, 1) < 0)
-		return -1;
+    if (self->read_func(self, &s, 1) < 0)
+        return -1;
 
-	return load_binintx(self, s, 1);
+    return load_binintx(self, s, 1);
 }
 
 
 static int
 load_binint2(Unpicklerobject *self)
 {
-	char *s;
+    char *s;
 
-	if (self->read_func(self, &s, 2) < 0)
-		return -1;
+    if (self->read_func(self, &s, 2) < 0)
+        return -1;
 
-	return load_binintx(self, s, 2);
+    return load_binintx(self, s, 2);
 }
 
 static int
 load_long(Unpicklerobject *self)
 {
-	PyObject *l = 0;
-	char *end, *s;
-	int len, res = -1;
+    PyObject *l = 0;
+    char *end, *s;
+    int len, res = -1;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 2) return bad_readline();
-	if (!( s=pystrndup(s,len)))  return -1;
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 2) return bad_readline();
+    if (!( s=pystrndup(s,len)))  return -1;
 
-	if (!( l = PyLong_FromString(s, &end, 0)))
-		goto finally;
+    if (!( l = PyLong_FromString(s, &end, 0)))
+        goto finally;
 
-	free(s);
-	PDATA_PUSH(self->stack, l, -1);
-	return 0;
+    free(s);
+    PDATA_PUSH(self->stack, l, -1);
+    return 0;
 
   finally:
-	free(s);
+    free(s);
 
-	return res;
+    return res;
 }
 
 /* 'size' bytes contain the # of bytes of little-endian 256's-complement
@@ -3422,187 +3422,187 @@
 static int
 load_counted_long(Unpicklerobject *self, int size)
 {
-	Py_ssize_t i;
-	char *nbytes;
-	unsigned char *pdata;
-	PyObject *along;
+    Py_ssize_t i;
+    char *nbytes;
+    unsigned char *pdata;
+    PyObject *along;
 
-	assert(size == 1 || size == 4);
-	i = self->read_func(self, &nbytes, size);
-	if (i < 0) return -1;
+    assert(size == 1 || size == 4);
+    i = self->read_func(self, &nbytes, size);
+    if (i < 0) return -1;
 
-	size = calc_binint(nbytes, size);
-	if (size < 0) {
-		/* Corrupt or hostile pickle -- we never write one like
-		 * this.
-		 */
-		PyErr_SetString(UnpicklingError, "LONG pickle has negative "
-				"byte count");
-		return -1;
-	}
+    size = calc_binint(nbytes, size);
+    if (size < 0) {
+        /* Corrupt or hostile pickle -- we never write one like
+         * this.
+         */
+        PyErr_SetString(UnpicklingError, "LONG pickle has negative "
+                        "byte count");
+        return -1;
+    }
 
-	if (size == 0)
-		along = PyLong_FromLong(0L);
-	else {
-		/* Read the raw little-endian bytes & convert. */
-		i = self->read_func(self, (char **)&pdata, size);
-		if (i < 0) return -1;
-		along = _PyLong_FromByteArray(pdata, (size_t)size,
-				1 /* little endian */, 1 /* signed */);
-	}
-	if (along == NULL)
-		return -1;
-	PDATA_PUSH(self->stack, along, -1);
-	return 0;
+    if (size == 0)
+        along = PyLong_FromLong(0L);
+    else {
+        /* Read the raw little-endian bytes & convert. */
+        i = self->read_func(self, (char **)&pdata, size);
+        if (i < 0) return -1;
+        along = _PyLong_FromByteArray(pdata, (size_t)size,
+                        1 /* little endian */, 1 /* signed */);
+    }
+    if (along == NULL)
+        return -1;
+    PDATA_PUSH(self->stack, along, -1);
+    return 0;
 }
 
 static int
 load_float(Unpicklerobject *self)
 {
-	PyObject *py_float = 0;
-	char *endptr, *s;
-	int len, res = -1;
-	double d;
+    PyObject *py_float = 0;
+    char *endptr, *s;
+    int len, res = -1;
+    double d;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 2) return bad_readline();
-	if (!( s=pystrndup(s,len)))  return -1;
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 2) return bad_readline();
+    if (!( s=pystrndup(s,len)))  return -1;
 
-	errno = 0;
-	d = PyOS_ascii_strtod(s, &endptr);
+    errno = 0;
+    d = PyOS_ascii_strtod(s, &endptr);
 
-	if ((errno == ERANGE && !(fabs(d) <= 1.0)) ||
-	    (endptr[0] != '\n') || (endptr[1] != '\0')) {
-		PyErr_SetString(PyExc_ValueError,
-				"could not convert string to float");
-		goto finally;
-	}
+    if ((errno == ERANGE && !(fabs(d) <= 1.0)) ||
+        (endptr[0] != '\n') || (endptr[1] != '\0')) {
+        PyErr_SetString(PyExc_ValueError,
+                        "could not convert string to float");
+        goto finally;
+    }
 
-	if (!( py_float = PyFloat_FromDouble(d)))
-		goto finally;
+    if (!( py_float = PyFloat_FromDouble(d)))
+        goto finally;
 
-	free(s);
-	PDATA_PUSH(self->stack, py_float, -1);
-	return 0;
+    free(s);
+    PDATA_PUSH(self->stack, py_float, -1);
+    return 0;
 
   finally:
-	free(s);
+    free(s);
 
-	return res;
+    return res;
 }
 
 static int
 load_binfloat(Unpicklerobject *self)
 {
-	PyObject *py_float;
-	double x;
-	char *p;
+    PyObject *py_float;
+    double x;
+    char *p;
 
-	if (self->read_func(self, &p, 8) < 0)
-		return -1;
+    if (self->read_func(self, &p, 8) < 0)
+        return -1;
 
-	x = _PyFloat_Unpack8((unsigned char *)p, 0);
-	if (x == -1.0 && PyErr_Occurred())
-		return -1;
+    x = _PyFloat_Unpack8((unsigned char *)p, 0);
+    if (x == -1.0 && PyErr_Occurred())
+        return -1;
 
-	py_float = PyFloat_FromDouble(x);
-	if (py_float == NULL)
-		return -1;
+    py_float = PyFloat_FromDouble(x);
+    if (py_float == NULL)
+        return -1;
 
-	PDATA_PUSH(self->stack, py_float, -1);
-	return 0;
+    PDATA_PUSH(self->stack, py_float, -1);
+    return 0;
 }
 
 static int
 load_string(Unpicklerobject *self)
 {
-	PyObject *str = 0;
-	int len, res = -1;
-	char *s, *p;
+    PyObject *str = 0;
+    int len, res = -1;
+    char *s, *p;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 2) return bad_readline();
-	if (!( s=pystrndup(s,len)))  return -1;
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 2) return bad_readline();
+    if (!( s=pystrndup(s,len)))  return -1;
 
 
-	/* Strip outermost quotes */
-	while (s[len-1] <= ' ')
-		len--;
-	if(s[0]=='"' && s[len-1]=='"'){
-		s[len-1] = '\0';
-		p = s + 1 ;
-		len -= 2;
-	} else if(s[0]=='\'' && s[len-1]=='\''){
-		s[len-1] = '\0';
-		p = s + 1 ;
-		len -= 2;
-	} else
-		goto insecure;
-	/********************************************/
+    /* Strip outermost quotes */
+    while (s[len-1] <= ' ')
+        len--;
+    if(s[0]=='"' && s[len-1]=='"'){
+        s[len-1] = '\0';
+        p = s + 1 ;
+        len -= 2;
+    } else if(s[0]=='\'' && s[len-1]=='\''){
+        s[len-1] = '\0';
+        p = s + 1 ;
+        len -= 2;
+    } else
+        goto insecure;
+    /********************************************/
 
-	str = PyString_DecodeEscape(p, len, NULL, 0, NULL);
-	free(s);
-	if (str) {
-		PDATA_PUSH(self->stack, str, -1);
-		res = 0;
-	}
-	return res;
+    str = PyString_DecodeEscape(p, len, NULL, 0, NULL);
+    free(s);
+    if (str) {
+        PDATA_PUSH(self->stack, str, -1);
+        res = 0;
+    }
+    return res;
 
   insecure:
-	free(s);
-	PyErr_SetString(PyExc_ValueError,"insecure string pickle");
-	return -1;
+    free(s);
+    PyErr_SetString(PyExc_ValueError,"insecure string pickle");
+    return -1;
 }
 
 
 static int
 load_binstring(Unpicklerobject *self)
 {
-	PyObject *py_string = 0;
-	long l;
-	char *s;
+    PyObject *py_string = 0;
+    long l;
+    char *s;
 
-	if (self->read_func(self, &s, 4) < 0) return -1;
+    if (self->read_func(self, &s, 4) < 0) return -1;
 
-	l = calc_binint(s, 4);
-	if (l < 0) {
-		/* Corrupt or hostile pickle -- we never write one like
-		 * this.
-		 */
-		PyErr_SetString(UnpicklingError,
-				"BINSTRING pickle has negative byte count");
-		return -1;
-	}
+    l = calc_binint(s, 4);
+    if (l < 0) {
+        /* Corrupt or hostile pickle -- we never write one like
+         * this.
+         */
+        PyErr_SetString(UnpicklingError,
+                        "BINSTRING pickle has negative byte count");
+        return -1;
+    }
 
-	if (self->read_func(self, &s, l) < 0)
-		return -1;
+    if (self->read_func(self, &s, l) < 0)
+        return -1;
 
-	if (!( py_string = PyString_FromStringAndSize(s, l)))
-		return -1;
+    if (!( py_string = PyString_FromStringAndSize(s, l)))
+        return -1;
 
-	PDATA_PUSH(self->stack, py_string, -1);
-	return 0;
+    PDATA_PUSH(self->stack, py_string, -1);
+    return 0;
 }
 
 
 static int
 load_short_binstring(Unpicklerobject *self)
 {
-	PyObject *py_string = 0;
-	unsigned char l;
-	char *s;
+    PyObject *py_string = 0;
+    unsigned char l;
+    char *s;
 
-	if (self->read_func(self, &s, 1) < 0)
-		return -1;
+    if (self->read_func(self, &s, 1) < 0)
+        return -1;
 
-	l = (unsigned char)s[0];
+    l = (unsigned char)s[0];
 
-	if (self->read_func(self, &s, l) < 0) return -1;
+    if (self->read_func(self, &s, l) < 0) return -1;
 
-	if (!( py_string = PyString_FromStringAndSize(s, l)))  return -1;
+    if (!( py_string = PyString_FromStringAndSize(s, l)))  return -1;
 
-	PDATA_PUSH(self->stack, py_string, -1);
-	return 0;
+    PDATA_PUSH(self->stack, py_string, -1);
+    return 0;
 }
 
 
@@ -3610,21 +3610,21 @@
 static int
 load_unicode(Unpicklerobject *self)
 {
-	PyObject *str = 0;
-	int len, res = -1;
-	char *s;
+    PyObject *str = 0;
+    int len, res = -1;
+    char *s;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 1) return bad_readline();
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 1) return bad_readline();
 
-	if (!( str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL)))
-		goto finally;
+    if (!( str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL)))
+        goto finally;
 
-	PDATA_PUSH(self->stack, str, -1);
-	return 0;
+    PDATA_PUSH(self->stack, str, -1);
+    return 0;
 
   finally:
-	return res;
+    return res;
 }
 #endif
 
@@ -3633,30 +3633,30 @@
 static int
 load_binunicode(Unpicklerobject *self)
 {
-	PyObject *unicode;
-	long l;
-	char *s;
+    PyObject *unicode;
+    long l;
+    char *s;
 
-	if (self->read_func(self, &s, 4) < 0) return -1;
+    if (self->read_func(self, &s, 4) < 0) return -1;
 
-	l = calc_binint(s, 4);
-	if (l < 0) {
-		/* Corrupt or hostile pickle -- we never write one like
-		 * this.
-		 */
-		PyErr_SetString(UnpicklingError,
-				"BINUNICODE pickle has negative byte count");
-		return -1;
-	}
+    l = calc_binint(s, 4);
+    if (l < 0) {
+        /* Corrupt or hostile pickle -- we never write one like
+         * this.
+         */
+        PyErr_SetString(UnpicklingError,
+                        "BINUNICODE pickle has negative byte count");
+        return -1;
+    }
 
-	if (self->read_func(self, &s, l) < 0)
-		return -1;
+    if (self->read_func(self, &s, l) < 0)
+        return -1;
 
-	if (!( unicode = PyUnicode_DecodeUTF8(s, l, NULL)))
-		return -1;
+    if (!( unicode = PyUnicode_DecodeUTF8(s, l, NULL)))
+        return -1;
 
-	PDATA_PUSH(self->stack, unicode, -1);
-	return 0;
+    PDATA_PUSH(self->stack, unicode, -1);
+    return 0;
 }
 #endif
 
@@ -3664,504 +3664,504 @@
 static int
 load_tuple(Unpicklerobject *self)
 {
-	PyObject *tup;
-	int i;
+    PyObject *tup;
+    int i;
 
-	if ((i = marker(self)) < 0) return -1;
-	if (!( tup=Pdata_popTuple(self->stack, i)))  return -1;
-	PDATA_PUSH(self->stack, tup, -1);
-	return 0;
+    if ((i = marker(self)) < 0) return -1;
+    if (!( tup=Pdata_popTuple(self->stack, i)))  return -1;
+    PDATA_PUSH(self->stack, tup, -1);
+    return 0;
 }
 
 static int
 load_counted_tuple(Unpicklerobject *self, int len)
 {
-	PyObject *tup = PyTuple_New(len);
+    PyObject *tup = PyTuple_New(len);
 
-	if (tup == NULL)
-		return -1;
+    if (tup == NULL)
+        return -1;
 
-	while (--len >= 0) {
-		PyObject *element;
+    while (--len >= 0) {
+        PyObject *element;
 
-		PDATA_POP(self->stack, element);
-		if (element == NULL)
-			return -1;
-		PyTuple_SET_ITEM(tup, len, element);
-	}
-	PDATA_PUSH(self->stack, tup, -1);
-	return 0;
+        PDATA_POP(self->stack, element);
+        if (element == NULL)
+            return -1;
+        PyTuple_SET_ITEM(tup, len, element);
+    }
+    PDATA_PUSH(self->stack, tup, -1);
+    return 0;
 }
 
 static int
 load_empty_list(Unpicklerobject *self)
 {
-	PyObject *list;
+    PyObject *list;
 
-	if (!( list=PyList_New(0)))  return -1;
-	PDATA_PUSH(self->stack, list, -1);
-	return 0;
+    if (!( list=PyList_New(0)))  return -1;
+    PDATA_PUSH(self->stack, list, -1);
+    return 0;
 }
 
 static int
 load_empty_dict(Unpicklerobject *self)
 {
-	PyObject *dict;
+    PyObject *dict;
 
-	if (!( dict=PyDict_New()))  return -1;
-	PDATA_PUSH(self->stack, dict, -1);
-	return 0;
+    if (!( dict=PyDict_New()))  return -1;
+    PDATA_PUSH(self->stack, dict, -1);
+    return 0;
 }
 
 
 static int
 load_list(Unpicklerobject *self)
 {
-	PyObject *list = 0;
-	int i;
+    PyObject *list = 0;
+    int i;
 
-	if ((i = marker(self)) < 0) return -1;
-	if (!( list=Pdata_popList(self->stack, i)))  return -1;
-	PDATA_PUSH(self->stack, list, -1);
-	return 0;
+    if ((i = marker(self)) < 0) return -1;
+    if (!( list=Pdata_popList(self->stack, i)))  return -1;
+    PDATA_PUSH(self->stack, list, -1);
+    return 0;
 }
 
 static int
 load_dict(Unpicklerobject *self)
 {
-	PyObject *dict, *key, *value;
-	int i, j, k;
+    PyObject *dict, *key, *value;
+    int i, j, k;
 
-	if ((i = marker(self)) < 0) return -1;
-	j=self->stack->length;
+    if ((i = marker(self)) < 0) return -1;
+    j=self->stack->length;
 
-	if (!( dict = PyDict_New()))  return -1;
+    if (!( dict = PyDict_New()))  return -1;
 
-	for (k = i+1; k < j; k += 2) {
-		key  =self->stack->data[k-1];
-		value=self->stack->data[k  ];
-		if (PyDict_SetItem(dict, key, value) < 0) {
-			Py_DECREF(dict);
-			return -1;
-		}
-	}
-	Pdata_clear(self->stack, i);
-	PDATA_PUSH(self->stack, dict, -1);
-	return 0;
+    for (k = i+1; k < j; k += 2) {
+        key  =self->stack->data[k-1];
+        value=self->stack->data[k  ];
+        if (PyDict_SetItem(dict, key, value) < 0) {
+            Py_DECREF(dict);
+            return -1;
+        }
+    }
+    Pdata_clear(self->stack, i);
+    PDATA_PUSH(self->stack, dict, -1);
+    return 0;
 }
 
 static PyObject *
 Instance_New(PyObject *cls, PyObject *args)
 {
-	PyObject *r = 0;
+    PyObject *r = 0;
 
-	if (PyClass_Check(cls)) {
-		int l;
+    if (PyClass_Check(cls)) {
+        int l;
 
-		if ((l=PyObject_Size(args)) < 0) goto err;
-		if (!( l ))  {
-			PyObject *__getinitargs__;
+        if ((l=PyObject_Size(args)) < 0) goto err;
+        if (!( l ))  {
+            PyObject *__getinitargs__;
 
-			__getinitargs__ = PyObject_GetAttr(cls,
-						   __getinitargs___str);
-			if (!__getinitargs__)  {
-				/* We have a class with no __getinitargs__,
-				   so bypass usual construction  */
-				PyObject *inst;
+            __getinitargs__ = PyObject_GetAttr(cls,
+                                       __getinitargs___str);
+            if (!__getinitargs__)  {
+                /* We have a class with no __getinitargs__,
+                   so bypass usual construction  */
+                PyObject *inst;
 
-				PyErr_Clear();
-				if (!( inst=PyInstance_NewRaw(cls, NULL)))
-					goto err;
-				return inst;
-			}
-			Py_DECREF(__getinitargs__);
-		}
+                PyErr_Clear();
+                if (!( inst=PyInstance_NewRaw(cls, NULL)))
+                    goto err;
+                return inst;
+            }
+            Py_DECREF(__getinitargs__);
+        }
 
-		if ((r=PyInstance_New(cls, args, NULL))) return r;
-		else goto err;
-	}
+        if ((r=PyInstance_New(cls, args, NULL))) return r;
+        else goto err;
+    }
 
-	if ((r=PyObject_CallObject(cls, args))) return r;
+    if ((r=PyObject_CallObject(cls, args))) return r;
 
   err:
-	{
-		PyObject *tp, *v, *tb, *tmp_value;
+    {
+        PyObject *tp, *v, *tb, *tmp_value;
 
-		PyErr_Fetch(&tp, &v, &tb);
-		tmp_value = v;
-		/* NULL occurs when there was a KeyboardInterrupt */
-		if (tmp_value == NULL)
-			tmp_value = Py_None;
-		if ((r = PyTuple_Pack(3, tmp_value, cls, args))) {
-			Py_XDECREF(v);
-			v=r;
-		}
-		PyErr_Restore(tp,v,tb);
-	}
-	return NULL;
+        PyErr_Fetch(&tp, &v, &tb);
+        tmp_value = v;
+        /* NULL occurs when there was a KeyboardInterrupt */
+        if (tmp_value == NULL)
+            tmp_value = Py_None;
+        if ((r = PyTuple_Pack(3, tmp_value, cls, args))) {
+            Py_XDECREF(v);
+            v=r;
+        }
+        PyErr_Restore(tp,v,tb);
+    }
+    return NULL;
 }
 
 
 static int
 load_obj(Unpicklerobject *self)
 {
-	PyObject *class, *tup, *obj=0;
-	int i;
+    PyObject *class, *tup, *obj=0;
+    int i;
 
-	if ((i = marker(self)) < 0) return -1;
-	if (!( tup=Pdata_popTuple(self->stack, i+1)))  return -1;
-	PDATA_POP(self->stack, class);
-	if (class) {
-		obj = Instance_New(class, tup);
-		Py_DECREF(class);
-	}
-	Py_DECREF(tup);
+    if ((i = marker(self)) < 0) return -1;
+    if (!( tup=Pdata_popTuple(self->stack, i+1)))  return -1;
+    PDATA_POP(self->stack, class);
+    if (class) {
+        obj = Instance_New(class, tup);
+        Py_DECREF(class);
+    }
+    Py_DECREF(tup);
 
-	if (! obj) return -1;
-	PDATA_PUSH(self->stack, obj, -1);
-	return 0;
+    if (! obj) return -1;
+    PDATA_PUSH(self->stack, obj, -1);
+    return 0;
 }
 
 
 static int
 load_inst(Unpicklerobject *self)
 {
-	PyObject *tup, *class=0, *obj=0, *module_name, *class_name;
-	int i, len;
-	char *s;
+    PyObject *tup, *class=0, *obj=0, *module_name, *class_name;
+    int i, len;
+    char *s;
 
-	if ((i = marker(self)) < 0) return -1;
+    if ((i = marker(self)) < 0) return -1;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 2) return bad_readline();
-	module_name = PyString_FromStringAndSize(s, len - 1);
-	if (!module_name)  return -1;
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 2) return bad_readline();
+    module_name = PyString_FromStringAndSize(s, len - 1);
+    if (!module_name)  return -1;
 
-	if ((len = self->readline_func(self, &s)) >= 0) {
-		if (len < 2) return bad_readline();
-		if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
-			class = find_class(module_name, class_name,
-					   self->find_class);
-			Py_DECREF(class_name);
-		}
-	}
-	Py_DECREF(module_name);
+    if ((len = self->readline_func(self, &s)) >= 0) {
+        if (len < 2) return bad_readline();
+        if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
+            class = find_class(module_name, class_name,
+                               self->find_class);
+            Py_DECREF(class_name);
+        }
+    }
+    Py_DECREF(module_name);
 
-	if (! class) return -1;
+    if (! class) return -1;
 
-	if ((tup=Pdata_popTuple(self->stack, i))) {
-		obj = Instance_New(class, tup);
-		Py_DECREF(tup);
-	}
-	Py_DECREF(class);
+    if ((tup=Pdata_popTuple(self->stack, i))) {
+        obj = Instance_New(class, tup);
+        Py_DECREF(tup);
+    }
+    Py_DECREF(class);
 
-	if (! obj) return -1;
+    if (! obj) return -1;
 
-	PDATA_PUSH(self->stack, obj, -1);
-	return 0;
+    PDATA_PUSH(self->stack, obj, -1);
+    return 0;
 }
 
 static int
 load_newobj(Unpicklerobject *self)
 {
-	PyObject *args = NULL;
-	PyObject *clsraw = NULL;
-	PyTypeObject *cls;	/* clsraw cast to its true type */
-	PyObject *obj;
+    PyObject *args = NULL;
+    PyObject *clsraw = NULL;
+    PyTypeObject *cls;          /* clsraw cast to its true type */
+    PyObject *obj;
 
-	/* Stack is ... cls argtuple, and we want to call
-	 * cls.__new__(cls, *argtuple).
-	 */
-	PDATA_POP(self->stack, args);
-	if (args == NULL) goto Fail;
-	if (! PyTuple_Check(args)) {
-		PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg "
-						 "tuple.");
-		goto Fail;
-	}
+    /* Stack is ... cls argtuple, and we want to call
+     * cls.__new__(cls, *argtuple).
+     */
+    PDATA_POP(self->stack, args);
+    if (args == NULL) goto Fail;
+    if (! PyTuple_Check(args)) {
+        PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg "
+                                         "tuple.");
+        goto Fail;
+    }
 
-	PDATA_POP(self->stack, clsraw);
-	cls = (PyTypeObject *)clsraw;
-	if (cls == NULL) goto Fail;
-	if (! PyType_Check(cls)) {
-		PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
-					 	 "isn't a type object");
-		goto Fail;
-	}
-	if (cls->tp_new == NULL) {
-		PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
-						 "has NULL tp_new");
-		goto Fail;
-	}
+    PDATA_POP(self->stack, clsraw);
+    cls = (PyTypeObject *)clsraw;
+    if (cls == NULL) goto Fail;
+    if (! PyType_Check(cls)) {
+        PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
+                                         "isn't a type object");
+        goto Fail;
+    }
+    if (cls->tp_new == NULL) {
+        PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
+                                         "has NULL tp_new");
+        goto Fail;
+    }
 
-	/* Call __new__. */
-	obj = cls->tp_new(cls, args, NULL);
-	if (obj == NULL) goto Fail;
+    /* Call __new__. */
+    obj = cls->tp_new(cls, args, NULL);
+    if (obj == NULL) goto Fail;
 
- 	Py_DECREF(args);
- 	Py_DECREF(clsraw);
-	PDATA_PUSH(self->stack, obj, -1);
- 	return 0;
+    Py_DECREF(args);
+    Py_DECREF(clsraw);
+    PDATA_PUSH(self->stack, obj, -1);
+    return 0;
 
  Fail:
- 	Py_XDECREF(args);
- 	Py_XDECREF(clsraw);
- 	return -1;
+    Py_XDECREF(args);
+    Py_XDECREF(clsraw);
+    return -1;
 }
 
 static int
 load_global(Unpicklerobject *self)
 {
-	PyObject *class = 0, *module_name = 0, *class_name = 0;
-	int len;
-	char *s;
+    PyObject *class = 0, *module_name = 0, *class_name = 0;
+    int len;
+    char *s;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 2) return bad_readline();
-	module_name = PyString_FromStringAndSize(s, len - 1);
-	if (!module_name)  return -1;
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 2) return bad_readline();
+    module_name = PyString_FromStringAndSize(s, len - 1);
+    if (!module_name)  return -1;
 
-	if ((len = self->readline_func(self, &s)) >= 0) {
-		if (len < 2) {
-			Py_DECREF(module_name);
-			return bad_readline();
-		}
-		if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
-			class = find_class(module_name, class_name,
-					   self->find_class);
-			Py_DECREF(class_name);
-		}
-	}
-	Py_DECREF(module_name);
+    if ((len = self->readline_func(self, &s)) >= 0) {
+        if (len < 2) {
+            Py_DECREF(module_name);
+            return bad_readline();
+        }
+        if ((class_name = PyString_FromStringAndSize(s, len - 1))) {
+            class = find_class(module_name, class_name,
+                               self->find_class);
+            Py_DECREF(class_name);
+        }
+    }
+    Py_DECREF(module_name);
 
-	if (! class) return -1;
-	PDATA_PUSH(self->stack, class, -1);
-	return 0;
+    if (! class) return -1;
+    PDATA_PUSH(self->stack, class, -1);
+    return 0;
 }
 
 
 static int
 load_persid(Unpicklerobject *self)
 {
-	PyObject *pid = 0;
-	int len;
-	char *s;
+    PyObject *pid = 0;
+    int len;
+    char *s;
 
-	if (self->pers_func) {
-		if ((len = self->readline_func(self, &s)) < 0) return -1;
-		if (len < 2) return bad_readline();
+    if (self->pers_func) {
+        if ((len = self->readline_func(self, &s)) < 0) return -1;
+        if (len < 2) return bad_readline();
 
-		pid = PyString_FromStringAndSize(s, len - 1);
-		if (!pid)  return -1;
+        pid = PyString_FromStringAndSize(s, len - 1);
+        if (!pid)  return -1;
 
-		if (PyList_Check(self->pers_func)) {
-			if (PyList_Append(self->pers_func, pid) < 0) {
-				Py_DECREF(pid);
-				return -1;
-			}
-		}
-		else {
-			ARG_TUP(self, pid);
-			if (self->arg) {
-				pid = PyObject_Call(self->pers_func, self->arg,
-						    NULL);
-				FREE_ARG_TUP(self);
-			}
-		}
+        if (PyList_Check(self->pers_func)) {
+            if (PyList_Append(self->pers_func, pid) < 0) {
+                Py_DECREF(pid);
+                return -1;
+            }
+        }
+        else {
+            ARG_TUP(self, pid);
+            if (self->arg) {
+                pid = PyObject_Call(self->pers_func, self->arg,
+                                    NULL);
+                FREE_ARG_TUP(self);
+            }
+        }
 
-		if (! pid) return -1;
+        if (! pid) return -1;
 
-		PDATA_PUSH(self->stack, pid, -1);
-		return 0;
-	}
-	else {
-		PyErr_SetString(UnpicklingError,
-				"A load persistent id instruction was encountered,\n"
-				"but no persistent_load function was specified.");
-		return -1;
-	}
+        PDATA_PUSH(self->stack, pid, -1);
+        return 0;
+    }
+    else {
+        PyErr_SetString(UnpicklingError,
+                        "A load persistent id instruction was encountered,\n"
+                        "but no persistent_load function was specified.");
+        return -1;
+    }
 }
 
 static int
 load_binpersid(Unpicklerobject *self)
 {
-	PyObject *pid = 0;
+    PyObject *pid = 0;
 
-	if (self->pers_func) {
-		PDATA_POP(self->stack, pid);
-		if (! pid) return -1;
+    if (self->pers_func) {
+        PDATA_POP(self->stack, pid);
+        if (! pid) return -1;
 
-		if (PyList_Check(self->pers_func)) {
-			if (PyList_Append(self->pers_func, pid) < 0) {
-				Py_DECREF(pid);
-				return -1;
-			}
-		}
-		else {
-			ARG_TUP(self, pid);
-			if (self->arg) {
-				pid = PyObject_Call(self->pers_func, self->arg,
-						    NULL);
-				FREE_ARG_TUP(self);
-			}
-			if (! pid) return -1;
-		}
+        if (PyList_Check(self->pers_func)) {
+            if (PyList_Append(self->pers_func, pid) < 0) {
+                Py_DECREF(pid);
+                return -1;
+            }
+        }
+        else {
+            ARG_TUP(self, pid);
+            if (self->arg) {
+                pid = PyObject_Call(self->pers_func, self->arg,
+                                    NULL);
+                FREE_ARG_TUP(self);
+            }
+            if (! pid) return -1;
+        }
 
-		PDATA_PUSH(self->stack, pid, -1);
-		return 0;
-	}
-	else {
-		PyErr_SetString(UnpicklingError,
-				"A load persistent id instruction was encountered,\n"
-				"but no persistent_load function was specified.");
-		return -1;
-	}
+        PDATA_PUSH(self->stack, pid, -1);
+        return 0;
+    }
+    else {
+        PyErr_SetString(UnpicklingError,
+                        "A load persistent id instruction was encountered,\n"
+                        "but no persistent_load function was specified.");
+        return -1;
+    }
 }
 
 
 static int
 load_pop(Unpicklerobject *self)
 {
-	int len = self->stack->length;
+    int len = self->stack->length;
 
-	/* Note that we split the (pickle.py) stack into two stacks,
-	   an object stack and a mark stack. We have to be clever and
-	   pop the right one. We do this by looking at the top of the
-	   mark stack first, and only signalling a stack underflow if
-	   the object stack is empty and the mark stack doesn't match
-	   our expectations.
-	*/
-	if (self->num_marks > 0 && self->marks[self->num_marks - 1] == len) {
-		self->num_marks--;
-	} else if (len > 0) {
-		len--;
-		Py_DECREF(self->stack->data[len]);
-		self->stack->length = len;
-	} else {
-		return stackUnderflow();
-	}
-	return 0;
+    /* Note that we split the (pickle.py) stack into two stacks,
+       an object stack and a mark stack. We have to be clever and
+       pop the right one. We do this by looking at the top of the
+       mark stack first, and only signalling a stack underflow if
+       the object stack is empty and the mark stack doesn't match
+       our expectations.
+    */
+    if (self->num_marks > 0 && self->marks[self->num_marks - 1] == len) {
+        self->num_marks--;
+    } else if (len > 0) {
+        len--;
+        Py_DECREF(self->stack->data[len]);
+        self->stack->length = len;
+    } else {
+        return stackUnderflow();
+    }
+    return 0;
 }
 
 
 static int
 load_pop_mark(Unpicklerobject *self)
 {
-	int i;
+    int i;
 
-	if ((i = marker(self)) < 0)
-		return -1;
+    if ((i = marker(self)) < 0)
+        return -1;
 
-	Pdata_clear(self->stack, i);
+    Pdata_clear(self->stack, i);
 
-	return 0;
+    return 0;
 }
 
 
 static int
 load_dup(Unpicklerobject *self)
 {
-	PyObject *last;
-	int len;
+    PyObject *last;
+    int len;
 
-	if ((len = self->stack->length) <= 0) return stackUnderflow();
-	last=self->stack->data[len-1];
-	Py_INCREF(last);
-	PDATA_PUSH(self->stack, last, -1);
-	return 0;
+    if ((len = self->stack->length) <= 0) return stackUnderflow();
+    last=self->stack->data[len-1];
+    Py_INCREF(last);
+    PDATA_PUSH(self->stack, last, -1);
+    return 0;
 }
 
 
 static int
 load_get(Unpicklerobject *self)
 {
-	PyObject *py_str = 0, *value = 0;
-	int len;
-	char *s;
-	int rc;
+    PyObject *py_str = 0, *value = 0;
+    int len;
+    char *s;
+    int rc;
 
-	if ((len = self->readline_func(self, &s)) < 0) return -1;
-	if (len < 2) return bad_readline();
+    if ((len = self->readline_func(self, &s)) < 0) return -1;
+    if (len < 2) return bad_readline();
 
-	if (!( py_str = PyString_FromStringAndSize(s, len - 1)))  return -1;
+    if (!( py_str = PyString_FromStringAndSize(s, len - 1)))  return -1;
 
-	value = PyDict_GetItem(self->memo, py_str);
-	if (! value) {
-		PyErr_SetObject(BadPickleGet, py_str);
-		rc = -1;
-	}
-	else {
-		PDATA_APPEND(self->stack, value, -1);
-		rc = 0;
-	}
+    value = PyDict_GetItem(self->memo, py_str);
+    if (! value) {
+        PyErr_SetObject(BadPickleGet, py_str);
+        rc = -1;
+    }
+    else {
+        PDATA_APPEND(self->stack, value, -1);
+        rc = 0;
+    }
 
-	Py_DECREF(py_str);
-	return rc;
+    Py_DECREF(py_str);
+    return rc;
 }
 
 
 static int
 load_binget(Unpicklerobject *self)
 {
-	PyObject *py_key = 0, *value = 0;
-	unsigned char key;
-	char *s;
-	int rc;
+    PyObject *py_key = 0, *value = 0;
+    unsigned char key;
+    char *s;
+    int rc;
 
-	if (self->read_func(self, &s, 1) < 0) return -1;
+    if (self->read_func(self, &s, 1) < 0) return -1;
 
-	key = (unsigned char)s[0];
-	if (!( py_key = PyInt_FromLong((long)key)))  return -1;
+    key = (unsigned char)s[0];
+    if (!( py_key = PyInt_FromLong((long)key)))  return -1;
 
-	value = PyDict_GetItem(self->memo, py_key);
-	if (! value) {
-		PyErr_SetObject(BadPickleGet, py_key);
-		rc = -1;
-	}
-	else {
-		PDATA_APPEND(self->stack, value, -1);
-		rc = 0;
-	}
+    value = PyDict_GetItem(self->memo, py_key);
+    if (! value) {
+        PyErr_SetObject(BadPickleGet, py_key);
+        rc = -1;
+    }
+    else {
+        PDATA_APPEND(self->stack, value, -1);
+        rc = 0;
+    }
 
-	Py_DECREF(py_key);
-	return rc;
+    Py_DECREF(py_key);
+    return rc;
 }
 
 
 static int
 load_long_binget(Unpicklerobject *self)
 {
-	PyObject *py_key = 0, *value = 0;
-	unsigned char c;
-	char *s;
-	long key;
-	int rc;
+    PyObject *py_key = 0, *value = 0;
+    unsigned char c;
+    char *s;
+    long key;
+    int rc;
 
-	if (self->read_func(self, &s, 4) < 0) return -1;
+    if (self->read_func(self, &s, 4) < 0) return -1;
 
-	c = (unsigned char)s[0];
-	key = (long)c;
-	c = (unsigned char)s[1];
-	key |= (long)c << 8;
-	c = (unsigned char)s[2];
-	key |= (long)c << 16;
-	c = (unsigned char)s[3];
-	key |= (long)c << 24;
+    c = (unsigned char)s[0];
+    key = (long)c;
+    c = (unsigned char)s[1];
+    key |= (long)c << 8;
+    c = (unsigned char)s[2];
+    key |= (long)c << 16;
+    c = (unsigned char)s[3];
+    key |= (long)c << 24;
 
-	if (!( py_key = PyInt_FromLong((long)key)))  return -1;
+    if (!( py_key = PyInt_FromLong((long)key)))  return -1;
 
-	value = PyDict_GetItem(self->memo, py_key);
-	if (! value) {
-		PyErr_SetObject(BadPickleGet, py_key);
-		rc = -1;
-	}
-	else {
-		PDATA_APPEND(self->stack, value, -1);
-		rc = 0;
-	}
+    value = PyDict_GetItem(self->memo, py_key);
+    if (! value) {
+        PyErr_SetObject(BadPickleGet, py_key);
+        rc = -1;
+    }
+    else {
+        PDATA_APPEND(self->stack, value, -1);
+        rc = 0;
+    }
 
-	Py_DECREF(py_key);
-	return rc;
+    Py_DECREF(py_key);
+    return rc;
 }
 
 /* Push an object from the extension registry (EXT[124]).  nbytes is
@@ -4170,391 +4170,391 @@
 static int
 load_extension(Unpicklerobject *self, int nbytes)
 {
-	char *codebytes;	/* the nbytes bytes after the opcode */
-	long code;		/* calc_binint returns long */
-	PyObject *py_code;	/* code as a Python int */
-	PyObject *obj;		/* the object to push */
-	PyObject *pair;		/* (module_name, class_name) */
-	PyObject *module_name, *class_name;
+    char *codebytes;            /* the nbytes bytes after the opcode */
+    long code;                  /* calc_binint returns long */
+    PyObject *py_code;          /* code as a Python int */
+    PyObject *obj;              /* the object to push */
+    PyObject *pair;             /* (module_name, class_name) */
+    PyObject *module_name, *class_name;
 
-	assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
-	if (self->read_func(self, &codebytes, nbytes) < 0) return -1;
-	code = calc_binint(codebytes,  nbytes);
-	if (code <= 0) {		/* note that 0 is forbidden */
-		/* Corrupt or hostile pickle. */
-		PyErr_SetString(UnpicklingError, "EXT specifies code <= 0");
-		return -1;
-	}
+    assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
+    if (self->read_func(self, &codebytes, nbytes) < 0) return -1;
+    code = calc_binint(codebytes,  nbytes);
+    if (code <= 0) {                    /* note that 0 is forbidden */
+        /* Corrupt or hostile pickle. */
+        PyErr_SetString(UnpicklingError, "EXT specifies code <= 0");
+        return -1;
+    }
 
-	/* Look for the code in the cache. */
-	py_code = PyInt_FromLong(code);
-	if (py_code == NULL) return -1;
-	obj = PyDict_GetItem(extension_cache, py_code);
-	if (obj != NULL) {
-		/* Bingo. */
-		Py_DECREF(py_code);
-		PDATA_APPEND(self->stack, obj, -1);
-		return 0;
-	}
+    /* Look for the code in the cache. */
+    py_code = PyInt_FromLong(code);
+    if (py_code == NULL) return -1;
+    obj = PyDict_GetItem(extension_cache, py_code);
+    if (obj != NULL) {
+        /* Bingo. */
+        Py_DECREF(py_code);
+        PDATA_APPEND(self->stack, obj, -1);
+        return 0;
+    }
 
-	/* Look up the (module_name, class_name) pair. */
-	pair = PyDict_GetItem(inverted_registry, py_code);
-	if (pair == NULL) {
-		Py_DECREF(py_code);
-		PyErr_Format(PyExc_ValueError, "unregistered extension "
-			     "code %ld", code);
-		return -1;
-	}
-	/* Since the extension registry is manipulable via Python code,
-	 * confirm that pair is really a 2-tuple of strings.
-	 */
-	if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||
-	    !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
-	    !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
-		Py_DECREF(py_code);
-		PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
-			     "isn't a 2-tuple of strings", code);
-		return -1;
-	}
-	/* Load the object. */
-	obj = find_class(module_name, class_name, self->find_class);
-	if (obj == NULL) {
-		Py_DECREF(py_code);
-		return -1;
-	}
-	/* Cache code -> obj. */
-	code = PyDict_SetItem(extension_cache, py_code, obj);
-	Py_DECREF(py_code);
-	if (code < 0) {
-		Py_DECREF(obj);
-		return -1;
-	}
-	PDATA_PUSH(self->stack, obj, -1);
-	return 0;
+    /* Look up the (module_name, class_name) pair. */
+    pair = PyDict_GetItem(inverted_registry, py_code);
+    if (pair == NULL) {
+        Py_DECREF(py_code);
+        PyErr_Format(PyExc_ValueError, "unregistered extension "
+                     "code %ld", code);
+        return -1;
+    }
+    /* Since the extension registry is manipulable via Python code,
+     * confirm that pair is really a 2-tuple of strings.
+     */
+    if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||
+        !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
+        !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
+        Py_DECREF(py_code);
+        PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
+                     "isn't a 2-tuple of strings", code);
+        return -1;
+    }
+    /* Load the object. */
+    obj = find_class(module_name, class_name, self->find_class);
+    if (obj == NULL) {
+        Py_DECREF(py_code);
+        return -1;
+    }
+    /* Cache code -> obj. */
+    code = PyDict_SetItem(extension_cache, py_code, obj);
+    Py_DECREF(py_code);
+    if (code < 0) {
+        Py_DECREF(obj);
+        return -1;
+    }
+    PDATA_PUSH(self->stack, obj, -1);
+    return 0;
 }
 
 static int
 load_put(Unpicklerobject *self)
 {
-	PyObject *py_str = 0, *value = 0;
-	int len, l;
-	char *s;
+    PyObject *py_str = 0, *value = 0;
+    int len, l;
+    char *s;
 
-	if ((l = self->readline_func(self, &s)) < 0) return -1;
-	if (l < 2) return bad_readline();
-	if (!( len=self->stack->length ))  return stackUnderflow();
-	if (!( py_str = PyString_FromStringAndSize(s, l - 1)))  return -1;
-	value=self->stack->data[len-1];
-	l=PyDict_SetItem(self->memo, py_str, value);
-	Py_DECREF(py_str);
-	return l;
+    if ((l = self->readline_func(self, &s)) < 0) return -1;
+    if (l < 2) return bad_readline();
+    if (!( len=self->stack->length ))  return stackUnderflow();
+    if (!( py_str = PyString_FromStringAndSize(s, l - 1)))  return -1;
+    value=self->stack->data[len-1];
+    l=PyDict_SetItem(self->memo, py_str, value);
+    Py_DECREF(py_str);
+    return l;
 }
 
 
 static int
 load_binput(Unpicklerobject *self)
 {
-	PyObject *py_key = 0, *value = 0;
-	unsigned char key;
-	char *s;
-	int len;
+    PyObject *py_key = 0, *value = 0;
+    unsigned char key;
+    char *s;
+    int len;
 
-	if (self->read_func(self, &s, 1) < 0) return -1;
-	if (!( (len=self->stack->length) > 0 ))  return stackUnderflow();
+    if (self->read_func(self, &s, 1) < 0) return -1;
+    if (!( (len=self->stack->length) > 0 ))  return stackUnderflow();
 
-	key = (unsigned char)s[0];
+    key = (unsigned char)s[0];
 
-	if (!( py_key = PyInt_FromLong((long)key)))  return -1;
-	value=self->stack->data[len-1];
-	len=PyDict_SetItem(self->memo, py_key, value);
-	Py_DECREF(py_key);
-	return len;
+    if (!( py_key = PyInt_FromLong((long)key)))  return -1;
+    value=self->stack->data[len-1];
+    len=PyDict_SetItem(self->memo, py_key, value);
+    Py_DECREF(py_key);
+    return len;
 }
 
 
 static int
 load_long_binput(Unpicklerobject *self)
 {
-	PyObject *py_key = 0, *value = 0;
-	long key;
-	unsigned char c;
-	char *s;
-	int len;
+    PyObject *py_key = 0, *value = 0;
+    long key;
+    unsigned char c;
+    char *s;
+    int len;
 
-	if (self->read_func(self, &s, 4) < 0) return -1;
-	if (!( len=self->stack->length ))  return stackUnderflow();
+    if (self->read_func(self, &s, 4) < 0) return -1;
+    if (!( len=self->stack->length ))  return stackUnderflow();
 
-	c = (unsigned char)s[0];
-	key = (long)c;
-	c = (unsigned char)s[1];
-	key |= (long)c << 8;
-	c = (unsigned char)s[2];
-	key |= (long)c << 16;
-	c = (unsigned char)s[3];
-	key |= (long)c << 24;
+    c = (unsigned char)s[0];
+    key = (long)c;
+    c = (unsigned char)s[1];
+    key |= (long)c << 8;
+    c = (unsigned char)s[2];
+    key |= (long)c << 16;
+    c = (unsigned char)s[3];
+    key |= (long)c << 24;
 
-	if (!( py_key = PyInt_FromLong(key)))  return -1;
-	value=self->stack->data[len-1];
-	len=PyDict_SetItem(self->memo, py_key, value);
-	Py_DECREF(py_key);
-	return len;
+    if (!( py_key = PyInt_FromLong(key)))  return -1;
+    value=self->stack->data[len-1];
+    len=PyDict_SetItem(self->memo, py_key, value);
+    Py_DECREF(py_key);
+    return len;
 }
 
 
 static int
 do_append(Unpicklerobject *self, int  x)
 {
-	PyObject *value = 0, *list = 0, *append_method = 0;
-	int len, i;
+    PyObject *value = 0, *list = 0, *append_method = 0;
+    int len, i;
 
-	len=self->stack->length;
-	if (!( len >= x && x > 0 ))  return stackUnderflow();
-	/* nothing to do */
-	if (len==x) return 0;
+    len=self->stack->length;
+    if (!( len >= x && x > 0 ))  return stackUnderflow();
+    /* nothing to do */
+    if (len==x) return 0;
 
-	list=self->stack->data[x-1];
+    list=self->stack->data[x-1];
 
-	if (PyList_Check(list)) {
-		PyObject *slice;
-		int list_len;
+    if (PyList_Check(list)) {
+        PyObject *slice;
+        int list_len;
 
-		slice=Pdata_popList(self->stack, x);
-		if (! slice) return -1;
-		list_len = PyList_GET_SIZE(list);
-		i=PyList_SetSlice(list, list_len, list_len, slice);
-		Py_DECREF(slice);
-		return i;
-	}
-	else {
+        slice=Pdata_popList(self->stack, x);
+        if (! slice) return -1;
+        list_len = PyList_GET_SIZE(list);
+        i=PyList_SetSlice(list, list_len, list_len, slice);
+        Py_DECREF(slice);
+        return i;
+    }
+    else {
 
-		if (!( append_method = PyObject_GetAttr(list, append_str)))
-			return -1;
+        if (!( append_method = PyObject_GetAttr(list, append_str)))
+            return -1;
 
-		for (i = x; i < len; i++) {
-			PyObject *junk;
+        for (i = x; i < len; i++) {
+            PyObject *junk;
 
-			value=self->stack->data[i];
-			junk=0;
-			ARG_TUP(self, value);
-			if (self->arg) {
-				junk = PyObject_Call(append_method, self->arg,
-						     NULL);
-				FREE_ARG_TUP(self);
-			}
-			if (! junk) {
-				Pdata_clear(self->stack, i+1);
-				self->stack->length=x;
-				Py_DECREF(append_method);
-				return -1;
-			}
-			Py_DECREF(junk);
-		}
-		self->stack->length=x;
-		Py_DECREF(append_method);
-	}
+            value=self->stack->data[i];
+            junk=0;
+            ARG_TUP(self, value);
+            if (self->arg) {
+                junk = PyObject_Call(append_method, self->arg,
+                                     NULL);
+                FREE_ARG_TUP(self);
+            }
+            if (! junk) {
+                Pdata_clear(self->stack, i+1);
+                self->stack->length=x;
+                Py_DECREF(append_method);
+                return -1;
+            }
+            Py_DECREF(junk);
+        }
+        self->stack->length=x;
+        Py_DECREF(append_method);
+    }
 
-	return 0;
+    return 0;
 }
 
 
 static int
 load_append(Unpicklerobject *self)
 {
-	return do_append(self, self->stack->length - 1);
+    return do_append(self, self->stack->length - 1);
 }
 
 
 static int
 load_appends(Unpicklerobject *self)
 {
-	return do_append(self, marker(self));
+    return do_append(self, marker(self));
 }
 
 
 static int
 do_setitems(Unpicklerobject *self, int  x)
 {
-	PyObject *value = 0, *key = 0, *dict = 0;
-	int len, i, r=0;
+    PyObject *value = 0, *key = 0, *dict = 0;
+    int len, i, r=0;
 
-	if (!( (len=self->stack->length) >= x
-	       && x > 0 ))  return stackUnderflow();
+    if (!( (len=self->stack->length) >= x
+           && x > 0 ))  return stackUnderflow();
 
-	dict=self->stack->data[x-1];
+    dict=self->stack->data[x-1];
 
-	for (i = x+1; i < len; i += 2) {
-		key  =self->stack->data[i-1];
-		value=self->stack->data[i  ];
-		if (PyObject_SetItem(dict, key, value) < 0) {
-			r=-1;
-			break;
-		}
-	}
+    for (i = x+1; i < len; i += 2) {
+        key  =self->stack->data[i-1];
+        value=self->stack->data[i  ];
+        if (PyObject_SetItem(dict, key, value) < 0) {
+            r=-1;
+            break;
+        }
+    }
 
-	Pdata_clear(self->stack, x);
+    Pdata_clear(self->stack, x);
 
-	return r;
+    return r;
 }
 
 
 static int
 load_setitem(Unpicklerobject *self)
 {
-	return do_setitems(self, self->stack->length - 2);
+    return do_setitems(self, self->stack->length - 2);
 }
 
 static int
 load_setitems(Unpicklerobject *self)
 {
-	return do_setitems(self, marker(self));
+    return do_setitems(self, marker(self));
 }
 
 
 static int
 load_build(Unpicklerobject *self)
 {
-	PyObject *state, *inst, *slotstate;
-	PyObject *__setstate__;
-	PyObject *d_key, *d_value;
-	Py_ssize_t i;
-	int res = -1;
+    PyObject *state, *inst, *slotstate;
+    PyObject *__setstate__;
+    PyObject *d_key, *d_value;
+    Py_ssize_t i;
+    int res = -1;
 
-	/* Stack is ... instance, state.  We want to leave instance at
-	 * the stack top, possibly mutated via instance.__setstate__(state).
-	 */
-	if (self->stack->length < 2)
-		return stackUnderflow();
-	PDATA_POP(self->stack, state);
-	if (state == NULL)
-		return -1;
-	inst = self->stack->data[self->stack->length - 1];
+    /* Stack is ... instance, state.  We want to leave instance at
+     * the stack top, possibly mutated via instance.__setstate__(state).
+     */
+    if (self->stack->length < 2)
+        return stackUnderflow();
+    PDATA_POP(self->stack, state);
+    if (state == NULL)
+        return -1;
+    inst = self->stack->data[self->stack->length - 1];
 
-	__setstate__ = PyObject_GetAttr(inst, __setstate___str);
-	if (__setstate__ != NULL) {
-		PyObject *junk = NULL;
+    __setstate__ = PyObject_GetAttr(inst, __setstate___str);
+    if (__setstate__ != NULL) {
+        PyObject *junk = NULL;
 
-		/* The explicit __setstate__ is responsible for everything. */
-		ARG_TUP(self, state);
-		if (self->arg) {
-			junk = PyObject_Call(__setstate__, self->arg, NULL);
-			FREE_ARG_TUP(self);
-		}
-		Py_DECREF(__setstate__);
-		if (junk == NULL)
-			return -1;
-		Py_DECREF(junk);
-		return 0;
-	}
-	if (!PyErr_ExceptionMatches(PyExc_AttributeError))
-		return -1;
-	PyErr_Clear();
+        /* The explicit __setstate__ is responsible for everything. */
+        ARG_TUP(self, state);
+        if (self->arg) {
+            junk = PyObject_Call(__setstate__, self->arg, NULL);
+            FREE_ARG_TUP(self);
+        }
+        Py_DECREF(__setstate__);
+        if (junk == NULL)
+            return -1;
+        Py_DECREF(junk);
+        return 0;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+        return -1;
+    PyErr_Clear();
 
-	/* A default __setstate__.  First see whether state embeds a
-	 * slot state dict too (a proto 2 addition).
-	 */
-	if (PyTuple_Check(state) && PyTuple_Size(state) == 2) {
-		PyObject *temp = state;
-		state = PyTuple_GET_ITEM(temp, 0);
-		slotstate = PyTuple_GET_ITEM(temp, 1);
-		Py_INCREF(state);
-		Py_INCREF(slotstate);
-		Py_DECREF(temp);
-	}
-	else
-		slotstate = NULL;
+    /* A default __setstate__.  First see whether state embeds a
+     * slot state dict too (a proto 2 addition).
+     */
+    if (PyTuple_Check(state) && PyTuple_Size(state) == 2) {
+        PyObject *temp = state;
+        state = PyTuple_GET_ITEM(temp, 0);
+        slotstate = PyTuple_GET_ITEM(temp, 1);
+        Py_INCREF(state);
+        Py_INCREF(slotstate);
+        Py_DECREF(temp);
+    }
+    else
+        slotstate = NULL;
 
-	/* Set inst.__dict__ from the state dict (if any). */
-	if (state != Py_None) {
-		PyObject *dict;
-		if (! PyDict_Check(state)) {
-			PyErr_SetString(UnpicklingError, "state is not a "
-					"dictionary");
-			goto finally;
-		}
-		dict = PyObject_GetAttr(inst, __dict___str);
-		if (dict == NULL)
-			goto finally;
+    /* Set inst.__dict__ from the state dict (if any). */
+    if (state != Py_None) {
+        PyObject *dict;
+        if (! PyDict_Check(state)) {
+            PyErr_SetString(UnpicklingError, "state is not a "
+                            "dictionary");
+            goto finally;
+        }
+        dict = PyObject_GetAttr(inst, __dict___str);
+        if (dict == NULL)
+            goto finally;
 
-		i = 0;
-		while (PyDict_Next(state, &i, &d_key, &d_value)) {
-			if (PyObject_SetItem(dict, d_key, d_value) < 0)
-				goto finally;
-		}
-		Py_DECREF(dict);
-	}
+        i = 0;
+        while (PyDict_Next(state, &i, &d_key, &d_value)) {
+            if (PyObject_SetItem(dict, d_key, d_value) < 0)
+                goto finally;
+        }
+        Py_DECREF(dict);
+    }
 
-	/* Also set instance attributes from the slotstate dict (if any). */
-	if (slotstate != NULL) {
-		if (! PyDict_Check(slotstate)) {
-			PyErr_SetString(UnpicklingError, "slot state is not "
-					"a dictionary");
-			goto finally;
-		}
-		i = 0;
-		while (PyDict_Next(slotstate, &i, &d_key, &d_value)) {
-			if (PyObject_SetAttr(inst, d_key, d_value) < 0)
-				goto finally;
-		}
-	}
-	res = 0;
+    /* Also set instance attributes from the slotstate dict (if any). */
+    if (slotstate != NULL) {
+        if (! PyDict_Check(slotstate)) {
+            PyErr_SetString(UnpicklingError, "slot state is not "
+                            "a dictionary");
+            goto finally;
+        }
+        i = 0;
+        while (PyDict_Next(slotstate, &i, &d_key, &d_value)) {
+            if (PyObject_SetAttr(inst, d_key, d_value) < 0)
+                goto finally;
+        }
+    }
+    res = 0;
 
   finally:
-	Py_DECREF(state);
-	Py_XDECREF(slotstate);
-	return res;
+    Py_DECREF(state);
+    Py_XDECREF(slotstate);
+    return res;
 }
 
 
 static int
 load_mark(Unpicklerobject *self)
 {
-	int s;
+    int s;
 
-	/* Note that we split the (pickle.py) stack into two stacks, an
-	   object stack and a mark stack. Here we push a mark onto the
-	   mark stack.
-	*/
+    /* Note that we split the (pickle.py) stack into two stacks, an
+       object stack and a mark stack. Here we push a mark onto the
+       mark stack.
+    */
 
-	if ((self->num_marks + 1) >= self->marks_size) {
-		int *marks;
-		s=self->marks_size+20;
-		if (s <= self->num_marks) s=self->num_marks + 1;
-		if (self->marks == NULL)
-			marks=(int *)malloc(s * sizeof(int));
-		else
-			marks=(int *)realloc(self->marks,
-						   s * sizeof(int));
-		if (!marks) {
-			PyErr_NoMemory();
-			return -1;
-		}
-		self->marks = marks;
-		self->marks_size = s;
-	}
+    if ((self->num_marks + 1) >= self->marks_size) {
+        int *marks;
+        s=self->marks_size+20;
+        if (s <= self->num_marks) s=self->num_marks + 1;
+        if (self->marks == NULL)
+            marks=(int *)malloc(s * sizeof(int));
+        else
+            marks=(int *)realloc(self->marks,
+                                       s * sizeof(int));
+        if (!marks) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        self->marks = marks;
+        self->marks_size = s;
+    }
 
-	self->marks[self->num_marks++] = self->stack->length;
+    self->marks[self->num_marks++] = self->stack->length;
 
-	return 0;
+    return 0;
 }
 
 static int
 load_reduce(Unpicklerobject *self)
 {
-	PyObject *callable = 0, *arg_tup = 0, *ob = 0;
+    PyObject *callable = 0, *arg_tup = 0, *ob = 0;
 
-	PDATA_POP(self->stack, arg_tup);
-	if (! arg_tup) return -1;
-	PDATA_POP(self->stack, callable);
-	if (callable) {
-		ob = Instance_New(callable, arg_tup);
-		Py_DECREF(callable);
-	}
-	Py_DECREF(arg_tup);
+    PDATA_POP(self->stack, arg_tup);
+    if (! arg_tup) return -1;
+    PDATA_POP(self->stack, callable);
+    if (callable) {
+        ob = Instance_New(callable, arg_tup);
+        Py_DECREF(callable);
+    }
+    Py_DECREF(arg_tup);
 
-	if (! ob) return -1;
+    if (! ob) return -1;
 
-	PDATA_PUSH(self->stack, ob, -1);
-	return 0;
+    PDATA_PUSH(self->stack, ob, -1);
+    return 0;
 }
 
 /* Just raises an error if we don't know the protocol specified.  PROTO
@@ -4563,327 +4563,327 @@
 static int
 load_proto(Unpicklerobject *self)
 {
-	int i;
-	char *protobyte;
+    int i;
+    char *protobyte;
 
-	i = self->read_func(self, &protobyte, 1);
-	if (i < 0)
-		return -1;
+    i = self->read_func(self, &protobyte, 1);
+    if (i < 0)
+        return -1;
 
-	i = calc_binint(protobyte, 1);
-	/* No point checking for < 0, since calc_binint returns an unsigned
-	 * int when chewing on 1 byte.
-	 */
-	assert(i >= 0);
-	if (i <= HIGHEST_PROTOCOL)
-		return 0;
+    i = calc_binint(protobyte, 1);
+    /* No point checking for < 0, since calc_binint returns an unsigned
+     * int when chewing on 1 byte.
+     */
+    assert(i >= 0);
+    if (i <= HIGHEST_PROTOCOL)
+        return 0;
 
-	PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i);
-	return -1;
+    PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i);
+    return -1;
 }
 
 static PyObject *
 load(Unpicklerobject *self)
 {
-	PyObject *err = 0, *val = 0;
-	char *s;
+    PyObject *err = 0, *val = 0;
+    char *s;
 
-	self->num_marks = 0;
-	if (self->stack->length) Pdata_clear(self->stack, 0);
+    self->num_marks = 0;
+    if (self->stack->length) Pdata_clear(self->stack, 0);
 
-	while (1) {
-		if (self->read_func(self, &s, 1) < 0)
-			break;
+    while (1) {
+        if (self->read_func(self, &s, 1) < 0)
+            break;
 
-		switch (s[0]) {
-		case NONE:
-			if (load_none(self) < 0)
-				break;
-			continue;
+        switch (s[0]) {
+        case NONE:
+            if (load_none(self) < 0)
+                break;
+            continue;
 
-		case BININT:
-			if (load_binint(self) < 0)
-				break;
-			continue;
+        case BININT:
+            if (load_binint(self) < 0)
+                break;
+            continue;
 
-		case BININT1:
-			if (load_binint1(self) < 0)
-				break;
-			continue;
+        case BININT1:
+            if (load_binint1(self) < 0)
+                break;
+            continue;
 
-		case BININT2:
-			if (load_binint2(self) < 0)
-				break;
-			continue;
+        case BININT2:
+            if (load_binint2(self) < 0)
+                break;
+            continue;
 
-		case INT:
-			if (load_int(self) < 0)
-				break;
-			continue;
+        case INT:
+            if (load_int(self) < 0)
+                break;
+            continue;
 
-		case LONG:
-			if (load_long(self) < 0)
-				break;
-			continue;
+        case LONG:
+            if (load_long(self) < 0)
+                break;
+            continue;
 
-		case LONG1:
-			if (load_counted_long(self, 1) < 0)
-				break;
-			continue;
+        case LONG1:
+            if (load_counted_long(self, 1) < 0)
+                break;
+            continue;
 
-		case LONG4:
-			if (load_counted_long(self, 4) < 0)
-				break;
-			continue;
+        case LONG4:
+            if (load_counted_long(self, 4) < 0)
+                break;
+            continue;
 
-		case FLOAT:
-			if (load_float(self) < 0)
-				break;
-			continue;
+        case FLOAT:
+            if (load_float(self) < 0)
+                break;
+            continue;
 
-		case BINFLOAT:
-			if (load_binfloat(self) < 0)
-				break;
-			continue;
+        case BINFLOAT:
+            if (load_binfloat(self) < 0)
+                break;
+            continue;
 
-		case BINSTRING:
-			if (load_binstring(self) < 0)
-				break;
-			continue;
+        case BINSTRING:
+            if (load_binstring(self) < 0)
+                break;
+            continue;
 
-		case SHORT_BINSTRING:
-			if (load_short_binstring(self) < 0)
-				break;
-			continue;
+        case SHORT_BINSTRING:
+            if (load_short_binstring(self) < 0)
+                break;
+            continue;
 
-		case STRING:
-			if (load_string(self) < 0)
-				break;
-			continue;
+        case STRING:
+            if (load_string(self) < 0)
+                break;
+            continue;
 
 #ifdef Py_USING_UNICODE
-		case UNICODE:
-			if (load_unicode(self) < 0)
-				break;
-			continue;
+        case UNICODE:
+            if (load_unicode(self) < 0)
+                break;
+            continue;
 
-		case BINUNICODE:
-			if (load_binunicode(self) < 0)
-				break;
-			continue;
+        case BINUNICODE:
+            if (load_binunicode(self) < 0)
+                break;
+            continue;
 #endif
 
-		case EMPTY_TUPLE:
-			if (load_counted_tuple(self, 0) < 0)
-				break;
-			continue;
+        case EMPTY_TUPLE:
+            if (load_counted_tuple(self, 0) < 0)
+                break;
+            continue;
 
-		case TUPLE1:
-			if (load_counted_tuple(self, 1) < 0)
-				break;
-			continue;
+        case TUPLE1:
+            if (load_counted_tuple(self, 1) < 0)
+                break;
+            continue;
 
-		case TUPLE2:
-			if (load_counted_tuple(self, 2) < 0)
-				break;
-			continue;
+        case TUPLE2:
+            if (load_counted_tuple(self, 2) < 0)
+                break;
+            continue;
 
-		case TUPLE3:
-			if (load_counted_tuple(self, 3) < 0)
-				break;
-			continue;
+        case TUPLE3:
+            if (load_counted_tuple(self, 3) < 0)
+                break;
+            continue;
 
-		case TUPLE:
-			if (load_tuple(self) < 0)
-				break;
-			continue;
+        case TUPLE:
+            if (load_tuple(self) < 0)
+                break;
+            continue;
 
-		case EMPTY_LIST:
-			if (load_empty_list(self) < 0)
-				break;
-			continue;
+        case EMPTY_LIST:
+            if (load_empty_list(self) < 0)
+                break;
+            continue;
 
-		case LIST:
-			if (load_list(self) < 0)
-				break;
-			continue;
+        case LIST:
+            if (load_list(self) < 0)
+                break;
+            continue;
 
-		case EMPTY_DICT:
-			if (load_empty_dict(self) < 0)
-				break;
-			continue;
+        case EMPTY_DICT:
+            if (load_empty_dict(self) < 0)
+                break;
+            continue;
 
-		case DICT:
-			if (load_dict(self) < 0)
-				break;
-			continue;
+        case DICT:
+            if (load_dict(self) < 0)
+                break;
+            continue;
 
-		case OBJ:
-			if (load_obj(self) < 0)
-				break;
-			continue;
+        case OBJ:
+            if (load_obj(self) < 0)
+                break;
+            continue;
 
-		case INST:
-			if (load_inst(self) < 0)
-				break;
-			continue;
+        case INST:
+            if (load_inst(self) < 0)
+                break;
+            continue;
 
-		case NEWOBJ:
-			if (load_newobj(self) < 0)
-				break;
-			continue;
+        case NEWOBJ:
+            if (load_newobj(self) < 0)
+                break;
+            continue;
 
-		case GLOBAL:
-			if (load_global(self) < 0)
-				break;
-			continue;
+        case GLOBAL:
+            if (load_global(self) < 0)
+                break;
+            continue;
 
-		case APPEND:
-			if (load_append(self) < 0)
-				break;
-			continue;
+        case APPEND:
+            if (load_append(self) < 0)
+                break;
+            continue;
 
-		case APPENDS:
-			if (load_appends(self) < 0)
-				break;
-			continue;
+        case APPENDS:
+            if (load_appends(self) < 0)
+                break;
+            continue;
 
-		case BUILD:
-			if (load_build(self) < 0)
-				break;
-			continue;
+        case BUILD:
+            if (load_build(self) < 0)
+                break;
+            continue;
 
-		case DUP:
-			if (load_dup(self) < 0)
-				break;
-			continue;
+        case DUP:
+            if (load_dup(self) < 0)
+                break;
+            continue;
 
-		case BINGET:
-			if (load_binget(self) < 0)
-				break;
-			continue;
+        case BINGET:
+            if (load_binget(self) < 0)
+                break;
+            continue;
 
-		case LONG_BINGET:
-			if (load_long_binget(self) < 0)
-				break;
-			continue;
+        case LONG_BINGET:
+            if (load_long_binget(self) < 0)
+                break;
+            continue;
 
-		case GET:
-			if (load_get(self) < 0)
-				break;
-			continue;
+        case GET:
+            if (load_get(self) < 0)
+                break;
+            continue;
 
-		case EXT1:
-			if (load_extension(self, 1) < 0)
-				break;
-			continue;
+        case EXT1:
+            if (load_extension(self, 1) < 0)
+                break;
+            continue;
 
-		case EXT2:
-			if (load_extension(self, 2) < 0)
-				break;
-			continue;
+        case EXT2:
+            if (load_extension(self, 2) < 0)
+                break;
+            continue;
 
-		case EXT4:
-			if (load_extension(self, 4) < 0)
-				break;
-			continue;
-		case MARK:
-			if (load_mark(self) < 0)
-				break;
-			continue;
+        case EXT4:
+            if (load_extension(self, 4) < 0)
+                break;
+            continue;
+        case MARK:
+            if (load_mark(self) < 0)
+                break;
+            continue;
 
-		case BINPUT:
-			if (load_binput(self) < 0)
-				break;
-			continue;
+        case BINPUT:
+            if (load_binput(self) < 0)
+                break;
+            continue;
 
-		case LONG_BINPUT:
-			if (load_long_binput(self) < 0)
-				break;
-			continue;
+        case LONG_BINPUT:
+            if (load_long_binput(self) < 0)
+                break;
+            continue;
 
-		case PUT:
-			if (load_put(self) < 0)
-				break;
-			continue;
+        case PUT:
+            if (load_put(self) < 0)
+                break;
+            continue;
 
-		case POP:
-			if (load_pop(self) < 0)
-				break;
-			continue;
+        case POP:
+            if (load_pop(self) < 0)
+                break;
+            continue;
 
-		case POP_MARK:
-			if (load_pop_mark(self) < 0)
-				break;
-			continue;
+        case POP_MARK:
+            if (load_pop_mark(self) < 0)
+                break;
+            continue;
 
-		case SETITEM:
-			if (load_setitem(self) < 0)
-				break;
-			continue;
+        case SETITEM:
+            if (load_setitem(self) < 0)
+                break;
+            continue;
 
-		case SETITEMS:
-			if (load_setitems(self) < 0)
-				break;
-			continue;
+        case SETITEMS:
+            if (load_setitems(self) < 0)
+                break;
+            continue;
 
-		case STOP:
-			break;
+        case STOP:
+            break;
 
-		case PERSID:
-			if (load_persid(self) < 0)
-				break;
-			continue;
+        case PERSID:
+            if (load_persid(self) < 0)
+                break;
+            continue;
 
-		case BINPERSID:
-			if (load_binpersid(self) < 0)
-				break;
-			continue;
+        case BINPERSID:
+            if (load_binpersid(self) < 0)
+                break;
+            continue;
 
-		case REDUCE:
-			if (load_reduce(self) < 0)
-				break;
-			continue;
+        case REDUCE:
+            if (load_reduce(self) < 0)
+                break;
+            continue;
 
-		case PROTO:
-			if (load_proto(self) < 0)
-				break;
-			continue;
+        case PROTO:
+            if (load_proto(self) < 0)
+                break;
+            continue;
 
-		case NEWTRUE:
-			if (load_bool(self, Py_True) < 0)
-				break;
-			continue;
+        case NEWTRUE:
+            if (load_bool(self, Py_True) < 0)
+                break;
+            continue;
 
-		case NEWFALSE:
-			if (load_bool(self, Py_False) < 0)
-				break;
-			continue;
+        case NEWFALSE:
+            if (load_bool(self, Py_False) < 0)
+                break;
+            continue;
 
-		case '\0':
-			/* end of file */
-			PyErr_SetNone(PyExc_EOFError);
-			break;
+        case '\0':
+            /* end of file */
+            PyErr_SetNone(PyExc_EOFError);
+            break;
 
-		default:
-			cPickle_ErrFormat(UnpicklingError,
-					  "invalid load key, '%s'.",
-					  "c", s[0]);
-			return NULL;
-		}
+        default:
+            cPickle_ErrFormat(UnpicklingError,
+                              "invalid load key, '%s'.",
+                              "c", s[0]);
+            return NULL;
+        }
 
-		break;
-	}
+        break;
+    }
 
-	if ((err = PyErr_Occurred())) {
-		if (err == PyExc_EOFError) {
-			PyErr_SetNone(PyExc_EOFError);
-		}
-		return NULL;
-	}
+    if ((err = PyErr_Occurred())) {
+        if (err == PyExc_EOFError) {
+            PyErr_SetNone(PyExc_EOFError);
+        }
+        return NULL;
+    }
 
-	PDATA_POP(self->stack, val);
-	return val;
+    PDATA_POP(self->stack, val);
+    return val;
 }
 
 
@@ -4893,63 +4893,63 @@
 static int
 noload_obj(Unpicklerobject *self)
 {
-	int i;
+    int i;
 
-	if ((i = marker(self)) < 0) return -1;
-	return Pdata_clear(self->stack, i+1);
+    if ((i = marker(self)) < 0) return -1;
+    return Pdata_clear(self->stack, i+1);
 }
 
 
 static int
 noload_inst(Unpicklerobject *self)
 {
-	int i;
-	char *s;
+    int i;
+    char *s;
 
-	if ((i = marker(self)) < 0) return -1;
-	Pdata_clear(self->stack, i);
-	if (self->readline_func(self, &s) < 0) return -1;
-	if (self->readline_func(self, &s) < 0) return -1;
-	PDATA_APPEND(self->stack, Py_None, -1);
-	return 0;
+    if ((i = marker(self)) < 0) return -1;
+    Pdata_clear(self->stack, i);
+    if (self->readline_func(self, &s) < 0) return -1;
+    if (self->readline_func(self, &s) < 0) return -1;
+    PDATA_APPEND(self->stack, Py_None, -1);
+    return 0;
 }
 
 static int
 noload_newobj(Unpicklerobject *self)
 {
-	PyObject *obj;
+    PyObject *obj;
 
-	PDATA_POP(self->stack, obj);	/* pop argtuple */
-	if (obj == NULL) return -1;
-	Py_DECREF(obj);
+    PDATA_POP(self->stack, obj);        /* pop argtuple */
+    if (obj == NULL) return -1;
+    Py_DECREF(obj);
 
-	PDATA_POP(self->stack, obj);	/* pop cls */
-	if (obj == NULL) return -1;
-	Py_DECREF(obj);
+    PDATA_POP(self->stack, obj);        /* pop cls */
+    if (obj == NULL) return -1;
+    Py_DECREF(obj);
 
-	PDATA_APPEND(self->stack, Py_None, -1);
- 	return 0;
+    PDATA_APPEND(self->stack, Py_None, -1);
+    return 0;
 }
 
 static int
 noload_global(Unpicklerobject *self)
 {
-	char *s;
+    char *s;
 
-	if (self->readline_func(self, &s) < 0) return -1;
-	if (self->readline_func(self, &s) < 0) return -1;
-	PDATA_APPEND(self->stack, Py_None,-1);
-	return 0;
+    if (self->readline_func(self, &s) < 0) return -1;
+    if (self->readline_func(self, &s) < 0) return -1;
+    PDATA_APPEND(self->stack, Py_None,-1);
+    return 0;
 }
 
 static int
 noload_reduce(Unpicklerobject *self)
 {
 
-	if (self->stack->length < 2) return stackUnderflow();
-	Pdata_clear(self->stack, self->stack->length-2);
-	PDATA_APPEND(self->stack, Py_None,-1);
-	return 0;
+    if (self->stack->length < 2) return stackUnderflow();
+    Pdata_clear(self->stack, self->stack->length-2);
+    PDATA_APPEND(self->stack, Py_None,-1);
+    return 0;
 }
 
 static int
@@ -4963,325 +4963,325 @@
 static int
 noload_extension(Unpicklerobject *self, int nbytes)
 {
-	char *codebytes;
+    char *codebytes;
 
-	assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
-	if (self->read_func(self, &codebytes, nbytes) < 0) return -1;
-	PDATA_APPEND(self->stack, Py_None, -1);
-	return 0;
+    assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
+    if (self->read_func(self, &codebytes, nbytes) < 0) return -1;
+    PDATA_APPEND(self->stack, Py_None, -1);
+    return 0;
 }
 
 
 static PyObject *
 noload(Unpicklerobject *self)
 {
-	PyObject *err = 0, *val = 0;
-	char *s;
+    PyObject *err = 0, *val = 0;
+    char *s;
 
-	self->num_marks = 0;
-	Pdata_clear(self->stack, 0);
+    self->num_marks = 0;
+    Pdata_clear(self->stack, 0);
 
-	while (1) {
-		if (self->read_func(self, &s, 1) < 0)
-			break;
+    while (1) {
+        if (self->read_func(self, &s, 1) < 0)
+            break;
 
-		switch (s[0]) {
-		case NONE:
-			if (load_none(self) < 0)
-				break;
-			continue;
+        switch (s[0]) {
+        case NONE:
+            if (load_none(self) < 0)
+                break;
+            continue;
 
-		case BININT:
-			if (load_binint(self) < 0)
-				break;
-			continue;
+        case BININT:
+            if (load_binint(self) < 0)
+                break;
+            continue;
 
-		case BININT1:
-			if (load_binint1(self) < 0)
-				break;
-			continue;
+        case BININT1:
+            if (load_binint1(self) < 0)
+                break;
+            continue;
 
-		case BININT2:
-			if (load_binint2(self) < 0)
-				break;
-			continue;
+        case BININT2:
+            if (load_binint2(self) < 0)
+                break;
+            continue;
 
-		case INT:
-			if (load_int(self) < 0)
-				break;
-			continue;
+        case INT:
+            if (load_int(self) < 0)
+                break;
+            continue;
 
-		case LONG:
-			if (load_long(self) < 0)
-				break;
-			continue;
+        case LONG:
+            if (load_long(self) < 0)
+                break;
+            continue;
 
-		case LONG1:
-			if (load_counted_long(self, 1) < 0)
-				break;
-			continue;
+        case LONG1:
+            if (load_counted_long(self, 1) < 0)
+                break;
+            continue;
 
-		case LONG4:
-			if (load_counted_long(self, 4) < 0)
-				break;
-			continue;
+        case LONG4:
+            if (load_counted_long(self, 4) < 0)
+                break;
+            continue;
 
-		case FLOAT:
-			if (load_float(self) < 0)
-				break;
-			continue;
+        case FLOAT:
+            if (load_float(self) < 0)
+                break;
+            continue;
 
-		case BINFLOAT:
-			if (load_binfloat(self) < 0)
-				break;
-			continue;
+        case BINFLOAT:
+            if (load_binfloat(self) < 0)
+                break;
+            continue;
 
-		case BINSTRING:
-			if (load_binstring(self) < 0)
-				break;
-			continue;
+        case BINSTRING:
+            if (load_binstring(self) < 0)
+                break;
+            continue;
 
-		case SHORT_BINSTRING:
-			if (load_short_binstring(self) < 0)
-				break;
-			continue;
+        case SHORT_BINSTRING:
+            if (load_short_binstring(self) < 0)
+                break;
+            continue;
 
-		case STRING:
-			if (load_string(self) < 0)
-				break;
-			continue;
+        case STRING:
+            if (load_string(self) < 0)
+                break;
+            continue;
 
 #ifdef Py_USING_UNICODE
-		case UNICODE:
-			if (load_unicode(self) < 0)
-				break;
-			continue;
+        case UNICODE:
+            if (load_unicode(self) < 0)
+                break;
+            continue;
 
-		case BINUNICODE:
-			if (load_binunicode(self) < 0)
-				break;
-			continue;
+        case BINUNICODE:
+            if (load_binunicode(self) < 0)
+                break;
+            continue;
 #endif
 
-		case EMPTY_TUPLE:
-			if (load_counted_tuple(self, 0) < 0)
-				break;
-			continue;
+        case EMPTY_TUPLE:
+            if (load_counted_tuple(self, 0) < 0)
+                break;
+            continue;
 
-		case TUPLE1:
-			if (load_counted_tuple(self, 1) < 0)
-				break;
-			continue;
+        case TUPLE1:
+            if (load_counted_tuple(self, 1) < 0)
+                break;
+            continue;
 
-		case TUPLE2:
-			if (load_counted_tuple(self, 2) < 0)
-				break;
-			continue;
+        case TUPLE2:
+            if (load_counted_tuple(self, 2) < 0)
+                break;
+            continue;
 
-		case TUPLE3:
-			if (load_counted_tuple(self, 3) < 0)
-				break;
-			continue;
+        case TUPLE3:
+            if (load_counted_tuple(self, 3) < 0)
+                break;
+            continue;
 
-		case TUPLE:
-			if (load_tuple(self) < 0)
-				break;
-			continue;
+        case TUPLE:
+            if (load_tuple(self) < 0)
+                break;
+            continue;
 
-		case EMPTY_LIST:
-			if (load_empty_list(self) < 0)
-				break;
-			continue;
+        case EMPTY_LIST:
+            if (load_empty_list(self) < 0)
+                break;
+            continue;
 
-		case LIST:
-			if (load_list(self) < 0)
-				break;
-			continue;
+        case LIST:
+            if (load_list(self) < 0)
+                break;
+            continue;
 
-		case EMPTY_DICT:
-			if (load_empty_dict(self) < 0)
-				break;
-			continue;
+        case EMPTY_DICT:
+            if (load_empty_dict(self) < 0)
+                break;
+            continue;
 
-		case DICT:
-			if (load_dict(self) < 0)
-				break;
-			continue;
+        case DICT:
+            if (load_dict(self) < 0)
+                break;
+            continue;
 
-		case OBJ:
-			if (noload_obj(self) < 0)
-				break;
-			continue;
+        case OBJ:
+            if (noload_obj(self) < 0)
+                break;
+            continue;
 
-		case INST:
-			if (noload_inst(self) < 0)
-				break;
-			continue;
+        case INST:
+            if (noload_inst(self) < 0)
+                break;
+            continue;
 
-		case NEWOBJ:
-			if (noload_newobj(self) < 0)
-				break;
-			continue;
+        case NEWOBJ:
+            if (noload_newobj(self) < 0)
+                break;
+            continue;
 
-		case GLOBAL:
-			if (noload_global(self) < 0)
-				break;
-			continue;
+        case GLOBAL:
+            if (noload_global(self) < 0)
+                break;
+            continue;
 
-		case APPEND:
-			if (load_append(self) < 0)
-				break;
-			continue;
+        case APPEND:
+            if (load_append(self) < 0)
+                break;
+            continue;
 
-		case APPENDS:
-			if (load_appends(self) < 0)
-				break;
-			continue;
+        case APPENDS:
+            if (load_appends(self) < 0)
+                break;
+            continue;
 
-		case BUILD:
-			if (noload_build(self) < 0)
-				break;
-			continue;
+        case BUILD:
+            if (noload_build(self) < 0)
+                break;
+            continue;
 
-		case DUP:
-			if (load_dup(self) < 0)
-				break;
-			continue;
+        case DUP:
+            if (load_dup(self) < 0)
+                break;
+            continue;
 
-		case BINGET:
-			if (load_binget(self) < 0)
-				break;
-			continue;
+        case BINGET:
+            if (load_binget(self) < 0)
+                break;
+            continue;
 
-		case LONG_BINGET:
-			if (load_long_binget(self) < 0)
-				break;
-			continue;
+        case LONG_BINGET:
+            if (load_long_binget(self) < 0)
+                break;
+            continue;
 
-		case GET:
-			if (load_get(self) < 0)
-				break;
-			continue;
+        case GET:
+            if (load_get(self) < 0)
+                break;
+            continue;
 
-		case EXT1:
-			if (noload_extension(self, 1) < 0)
-				break;
-			continue;
+        case EXT1:
+            if (noload_extension(self, 1) < 0)
+                break;
+            continue;
 
-		case EXT2:
-			if (noload_extension(self, 2) < 0)
-				break;
-			continue;
+        case EXT2:
+            if (noload_extension(self, 2) < 0)
+                break;
+            continue;
 
-		case EXT4:
-			if (noload_extension(self, 4) < 0)
-				break;
-			continue;
+        case EXT4:
+            if (noload_extension(self, 4) < 0)
+                break;
+            continue;
 
-		case MARK:
-			if (load_mark(self) < 0)
-				break;
-			continue;
+        case MARK:
+            if (load_mark(self) < 0)
+                break;
+            continue;
 
-		case BINPUT:
-			if (load_binput(self) < 0)
-				break;
-			continue;
+        case BINPUT:
+            if (load_binput(self) < 0)
+                break;
+            continue;
 
-		case LONG_BINPUT:
-			if (load_long_binput(self) < 0)
-				break;
-			continue;
+        case LONG_BINPUT:
+            if (load_long_binput(self) < 0)
+                break;
+            continue;
 
-		case PUT:
-			if (load_put(self) < 0)
-				break;
-			continue;
+        case PUT:
+            if (load_put(self) < 0)
+                break;
+            continue;
 
-		case POP:
-			if (load_pop(self) < 0)
-				break;
-			continue;
+        case POP:
+            if (load_pop(self) < 0)
+                break;
+            continue;
 
-		case POP_MARK:
-			if (load_pop_mark(self) < 0)
-				break;
-			continue;
+        case POP_MARK:
+            if (load_pop_mark(self) < 0)
+                break;
+            continue;
 
-		case SETITEM:
-			if (load_setitem(self) < 0)
-				break;
-			continue;
+        case SETITEM:
+            if (load_setitem(self) < 0)
+                break;
+            continue;
 
-		case SETITEMS:
-			if (load_setitems(self) < 0)
-				break;
-			continue;
+        case SETITEMS:
+            if (load_setitems(self) < 0)
+                break;
+            continue;
 
-		case STOP:
-			break;
+        case STOP:
+            break;
 
-		case PERSID:
-			if (load_persid(self) < 0)
-				break;
-			continue;
+        case PERSID:
+            if (load_persid(self) < 0)
+                break;
+            continue;
 
-		case BINPERSID:
-			if (load_binpersid(self) < 0)
-				break;
-			continue;
+        case BINPERSID:
+            if (load_binpersid(self) < 0)
+                break;
+            continue;
 
-		case REDUCE:
-			if (noload_reduce(self) < 0)
-				break;
-			continue;
+        case REDUCE:
+            if (noload_reduce(self) < 0)
+                break;
+            continue;
 
-		case PROTO:
-			if (load_proto(self) < 0)
-				break;
-			continue;
+        case PROTO:
+            if (load_proto(self) < 0)
+                break;
+            continue;
 
-		case NEWTRUE:
-			if (load_bool(self, Py_True) < 0)
-				break;
-			continue;
+        case NEWTRUE:
+            if (load_bool(self, Py_True) < 0)
+                break;
+            continue;
 
-		case NEWFALSE:
-			if (load_bool(self, Py_False) < 0)
-				break;
-			continue;
-		default:
-			cPickle_ErrFormat(UnpicklingError,
-					  "invalid load key, '%s'.",
-					  "c", s[0]);
-			return NULL;
-		}
+        case NEWFALSE:
+            if (load_bool(self, Py_False) < 0)
+                break;
+            continue;
+        default:
+            cPickle_ErrFormat(UnpicklingError,
+                              "invalid load key, '%s'.",
+                              "c", s[0]);
+            return NULL;
+        }
 
-		break;
-	}
+        break;
+    }
 
-	if ((err = PyErr_Occurred())) {
-		if (err == PyExc_EOFError) {
-			PyErr_SetNone(PyExc_EOFError);
-		}
-		return NULL;
-	}
+    if ((err = PyErr_Occurred())) {
+        if (err == PyExc_EOFError) {
+            PyErr_SetNone(PyExc_EOFError);
+        }
+        return NULL;
+    }
 
-	PDATA_POP(self->stack, val);
-	return val;
+    PDATA_POP(self->stack, val);
+    return val;
 }
 
 
 static PyObject *
 Unpickler_load(Unpicklerobject *self, PyObject *unused)
 {
-	return load(self);
+    return load(self);
 }
 
 static PyObject *
 Unpickler_noload(Unpicklerobject *self, PyObject *unused)
 {
-	return noload(self);
+    return noload(self);
 }
 
 
@@ -5305,175 +5305,175 @@
 static Unpicklerobject *
 newUnpicklerobject(PyObject *f)
 {
-	Unpicklerobject *self;
+    Unpicklerobject *self;
 
-	if (!( self = PyObject_GC_New(Unpicklerobject, &Unpicklertype)))
-		return NULL;
+    if (!( self = PyObject_GC_New(Unpicklerobject, &Unpicklertype)))
+        return NULL;
 
-	self->file = NULL;
-	self->arg = NULL;
-	self->stack = (Pdata*)Pdata_New();
-	self->pers_func = NULL;
-	self->last_string = NULL;
-	self->marks = NULL;
-	self->num_marks = 0;
-	self->marks_size = 0;
-	self->buf_size = 0;
-	self->read = NULL;
-	self->readline = NULL;
-	self->find_class = NULL;
+    self->file = NULL;
+    self->arg = NULL;
+    self->stack = (Pdata*)Pdata_New();
+    self->pers_func = NULL;
+    self->last_string = NULL;
+    self->marks = NULL;
+    self->num_marks = 0;
+    self->marks_size = 0;
+    self->buf_size = 0;
+    self->read = NULL;
+    self->readline = NULL;
+    self->find_class = NULL;
 
-	if (!( self->memo = PyDict_New()))
-		goto err;
+    if (!( self->memo = PyDict_New()))
+        goto err;
 
-	if (!self->stack)
-		goto err;
+    if (!self->stack)
+        goto err;
 
-	Py_INCREF(f);
-	self->file = f;
+    Py_INCREF(f);
+    self->file = f;
 
-	/* Set read, readline based on type of f */
-	if (PyFile_Check(f)) {
-		self->fp = PyFile_AsFile(f);
-		if (self->fp == NULL) {
-			PyErr_SetString(PyExc_ValueError,
-					"I/O operation on closed file");
-			goto err;
-		}
-		self->read_func = read_file;
-		self->readline_func = readline_file;
-	}
-	else if (PycStringIO_InputCheck(f)) {
-		self->fp = NULL;
-		self->read_func = read_cStringIO;
-		self->readline_func = readline_cStringIO;
-	}
-	else {
+    /* Set read, readline based on type of f */
+    if (PyFile_Check(f)) {
+        self->fp = PyFile_AsFile(f);
+        if (self->fp == NULL) {
+            PyErr_SetString(PyExc_ValueError,
+                            "I/O operation on closed file");
+            goto err;
+        }
+        self->read_func = read_file;
+        self->readline_func = readline_file;
+    }
+    else if (PycStringIO_InputCheck(f)) {
+        self->fp = NULL;
+        self->read_func = read_cStringIO;
+        self->readline_func = readline_cStringIO;
+    }
+    else {
 
-		self->fp = NULL;
-		self->read_func = read_other;
-		self->readline_func = readline_other;
+        self->fp = NULL;
+        self->read_func = read_other;
+        self->readline_func = readline_other;
 
-		if (!( (self->readline = PyObject_GetAttr(f, readline_str)) &&
-		       (self->read = PyObject_GetAttr(f, read_str))))  {
-			PyErr_Clear();
-			PyErr_SetString( PyExc_TypeError,
-					 "argument must have 'read' and "
-					 "'readline' attributes" );
-			goto err;
-		}
-	}
-	PyObject_GC_Track(self);
+        if (!( (self->readline = PyObject_GetAttr(f, readline_str)) &&
+               (self->read = PyObject_GetAttr(f, read_str))))  {
+            PyErr_Clear();
+            PyErr_SetString( PyExc_TypeError,
+                             "argument must have 'read' and "
+                             "'readline' attributes" );
+            goto err;
+        }
+    }
+    PyObject_GC_Track(self);
 
-	return self;
+    return self;
 
   err:
-	Py_DECREF((PyObject *)self);
-	return NULL;
+    Py_DECREF((PyObject *)self);
+    return NULL;
 }
 
 
 static PyObject *
 get_Unpickler(PyObject *self, PyObject *file)
 {
-	return (PyObject *)newUnpicklerobject(file);
+    return (PyObject *)newUnpicklerobject(file);
 }
 
 
 static void
 Unpickler_dealloc(Unpicklerobject *self)
 {
-	PyObject_GC_UnTrack((PyObject *)self);
-	Py_XDECREF(self->readline);
-	Py_XDECREF(self->read);
-	Py_XDECREF(self->file);
-	Py_XDECREF(self->memo);
-	Py_XDECREF(self->stack);
-	Py_XDECREF(self->pers_func);
-	Py_XDECREF(self->arg);
-	Py_XDECREF(self->last_string);
-	Py_XDECREF(self->find_class);
+    PyObject_GC_UnTrack((PyObject *)self);
+    Py_XDECREF(self->readline);
+    Py_XDECREF(self->read);
+    Py_XDECREF(self->file);
+    Py_XDECREF(self->memo);
+    Py_XDECREF(self->stack);
+    Py_XDECREF(self->pers_func);
+    Py_XDECREF(self->arg);
+    Py_XDECREF(self->last_string);
+    Py_XDECREF(self->find_class);
 
-	if (self->marks) {
-		free(self->marks);
-	}
+    if (self->marks) {
+        free(self->marks);
+    }
 
-	if (self->buf_size) {
-		free(self->buf);
-	}
+    if (self->buf_size) {
+        free(self->buf);
+    }
 
-	Py_TYPE(self)->tp_free((PyObject *)self);
+    Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int
 Unpickler_traverse(Unpicklerobject *self, visitproc visit, void *arg)
 {
-	Py_VISIT(self->readline);
-	Py_VISIT(self->read);
-	Py_VISIT(self->file);
-	Py_VISIT(self->memo);
-	Py_VISIT(self->stack);
-	Py_VISIT(self->pers_func);
-	Py_VISIT(self->arg);
-	Py_VISIT(self->last_string);
-	Py_VISIT(self->find_class);
-	return 0;
+    Py_VISIT(self->readline);
+    Py_VISIT(self->read);
+    Py_VISIT(self->file);
+    Py_VISIT(self->memo);
+    Py_VISIT(self->stack);
+    Py_VISIT(self->pers_func);
+    Py_VISIT(self->arg);
+    Py_VISIT(self->last_string);
+    Py_VISIT(self->find_class);
+    return 0;
 }
 
 static int
 Unpickler_clear(Unpicklerobject *self)
 {
-	Py_CLEAR(self->readline);
-	Py_CLEAR(self->read);
-	Py_CLEAR(self->file);
-	Py_CLEAR(self->memo);
-	Py_CLEAR(self->stack);
-	Py_CLEAR(self->pers_func);
-	Py_CLEAR(self->arg);
-	Py_CLEAR(self->last_string);
-	Py_CLEAR(self->find_class);
-	return 0;
+    Py_CLEAR(self->readline);
+    Py_CLEAR(self->read);
+    Py_CLEAR(self->file);
+    Py_CLEAR(self->memo);
+    Py_CLEAR(self->stack);
+    Py_CLEAR(self->pers_func);
+    Py_CLEAR(self->arg);
+    Py_CLEAR(self->last_string);
+    Py_CLEAR(self->find_class);
+    return 0;
 }
 
 static PyObject *
 Unpickler_getattr(Unpicklerobject *self, char *name)
 {
-	if (!strcmp(name, "persistent_load")) {
-		if (!self->pers_func) {
-			PyErr_SetString(PyExc_AttributeError, name);
-			return NULL;
-		}
+    if (!strcmp(name, "persistent_load")) {
+        if (!self->pers_func) {
+            PyErr_SetString(PyExc_AttributeError, name);
+            return NULL;
+        }
 
-		Py_INCREF(self->pers_func);
-		return self->pers_func;
-	}
+        Py_INCREF(self->pers_func);
+        return self->pers_func;
+    }
 
-	if (!strcmp(name, "find_global")) {
-		if (!self->find_class) {
-			PyErr_SetString(PyExc_AttributeError, name);
-			return NULL;
-		}
+    if (!strcmp(name, "find_global")) {
+        if (!self->find_class) {
+            PyErr_SetString(PyExc_AttributeError, name);
+            return NULL;
+        }
 
-		Py_INCREF(self->find_class);
-		return self->find_class;
-	}
+        Py_INCREF(self->find_class);
+        return self->find_class;
+    }
 
-	if (!strcmp(name, "memo")) {
-		if (!self->memo) {
-			PyErr_SetString(PyExc_AttributeError, name);
-			return NULL;
-		}
+    if (!strcmp(name, "memo")) {
+        if (!self->memo) {
+            PyErr_SetString(PyExc_AttributeError, name);
+            return NULL;
+        }
 
-		Py_INCREF(self->memo);
-		return self->memo;
-	}
+        Py_INCREF(self->memo);
+        return self->memo;
+    }
 
-	if (!strcmp(name, "UnpicklingError")) {
-		Py_INCREF(UnpicklingError);
-		return UnpicklingError;
-	}
+    if (!strcmp(name, "UnpicklingError")) {
+        Py_INCREF(UnpicklingError);
+        return UnpicklingError;
+    }
 
-	return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);
+    return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);
 }
 
 
@@ -5481,40 +5481,40 @@
 Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value)
 {
 
-	if (!strcmp(name, "persistent_load")) {
-		Py_XDECREF(self->pers_func);
-		self->pers_func = value;
-		Py_XINCREF(value);
-		return 0;
-	}
+    if (!strcmp(name, "persistent_load")) {
+        Py_XDECREF(self->pers_func);
+        self->pers_func = value;
+        Py_XINCREF(value);
+        return 0;
+    }
 
-	if (!strcmp(name, "find_global")) {
-		Py_XDECREF(self->find_class);
-		self->find_class = value;
-		Py_XINCREF(value);
-		return 0;
-	}
+    if (!strcmp(name, "find_global")) {
+        Py_XDECREF(self->find_class);
+        self->find_class = value;
+        Py_XINCREF(value);
+        return 0;
+    }
 
-	if (! value) {
-		PyErr_SetString(PyExc_TypeError,
-				"attribute deletion is not supported");
-		return -1;
-	}
+    if (! value) {
+        PyErr_SetString(PyExc_TypeError,
+                        "attribute deletion is not supported");
+        return -1;
+    }
 
-	if (strcmp(name, "memo") == 0) {
-		if (!PyDict_Check(value)) {
-			PyErr_SetString(PyExc_TypeError,
-					"memo must be a dictionary");
-			return -1;
-		}
-		Py_XDECREF(self->memo);
-		self->memo = value;
-		Py_INCREF(value);
-		return 0;
-	}
+    if (strcmp(name, "memo") == 0) {
+        if (!PyDict_Check(value)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "memo must be a dictionary");
+            return -1;
+        }
+        Py_XDECREF(self->memo);
+        self->memo = value;
+        Py_INCREF(value);
+        return 0;
+    }
 
-	PyErr_SetString(PyExc_AttributeError, name);
-	return -1;
+    PyErr_SetString(PyExc_AttributeError, name);
+    return -1;
 }
 
 /* ---------------------------------------------------------------------------
@@ -5525,28 +5525,28 @@
 static PyObject *
 cpm_dump(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	static char *kwlist[] = {"obj", "file", "protocol", NULL};
-	PyObject *ob, *file, *res = NULL;
-	Picklerobject *pickler = 0;
-	int proto = 0;
+    static char *kwlist[] = {"obj", "file", "protocol", NULL};
+    PyObject *ob, *file, *res = NULL;
+    Picklerobject *pickler = 0;
+    int proto = 0;
 
-	if (!( PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist,
-		   &ob, &file, &proto)))
-		goto finally;
+    if (!( PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist,
+               &ob, &file, &proto)))
+        goto finally;
 
-	if (!( pickler = newPicklerobject(file, proto)))
-		goto finally;
+    if (!( pickler = newPicklerobject(file, proto)))
+        goto finally;
 
-	if (dump(pickler, ob) < 0)
-		goto finally;
+    if (dump(pickler, ob) < 0)
+        goto finally;
 
-	Py_INCREF(Py_None);
-	res = Py_None;
+    Py_INCREF(Py_None);
+    res = Py_None;
 
   finally:
-	Py_XDECREF(pickler);
+    Py_XDECREF(pickler);
 
-	return res;
+    return res;
 }
 
 
@@ -5554,31 +5554,31 @@
 static PyObject *
 cpm_dumps(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	static char *kwlist[] = {"obj", "protocol", NULL};
-	PyObject *ob, *file = 0, *res = NULL;
-	Picklerobject *pickler = 0;
-	int proto = 0;
+    static char *kwlist[] = {"obj", "protocol", NULL};
+    PyObject *ob, *file = 0, *res = NULL;
+    Picklerobject *pickler = 0;
+    int proto = 0;
 
-	if (!( PyArg_ParseTupleAndKeywords(args, kwds, "O|i:dumps", kwlist,
-		   &ob, &proto)))
-		goto finally;
+    if (!( PyArg_ParseTupleAndKeywords(args, kwds, "O|i:dumps", kwlist,
+               &ob, &proto)))
+        goto finally;
 
-	if (!( file = PycStringIO->NewOutput(128)))
-		goto finally;
+    if (!( file = PycStringIO->NewOutput(128)))
+        goto finally;
 
-	if (!( pickler = newPicklerobject(file, proto)))
-		goto finally;
+    if (!( pickler = newPicklerobject(file, proto)))
+        goto finally;
 
-	if (dump(pickler, ob) < 0)
-		goto finally;
+    if (dump(pickler, ob) < 0)
+        goto finally;
 
-	res = PycStringIO->cgetvalue(file);
+    res = PycStringIO->cgetvalue(file);
 
   finally:
-	Py_XDECREF(pickler);
-	Py_XDECREF(file);
+    Py_XDECREF(pickler);
+    Py_XDECREF(file);
 
-	return res;
+    return res;
 }
 
 
@@ -5586,18 +5586,18 @@
 static PyObject *
 cpm_load(PyObject *self, PyObject *ob)
 {
-	Unpicklerobject *unpickler = 0;
-	PyObject *res = NULL;
+    Unpicklerobject *unpickler = 0;
+    PyObject *res = NULL;
 
-	if (!( unpickler = newUnpicklerobject(ob)))
-		goto finally;
+    if (!( unpickler = newUnpicklerobject(ob)))
+        goto finally;
 
-	res = load(unpickler);
+    res = load(unpickler);
 
   finally:
-	Py_XDECREF(unpickler);
+    Py_XDECREF(unpickler);
 
-	return res;
+    return res;
 }
 
 
@@ -5605,25 +5605,25 @@
 static PyObject *
 cpm_loads(PyObject *self, PyObject *args)
 {
-	PyObject *ob, *file = 0, *res = NULL;
-	Unpicklerobject *unpickler = 0;
+    PyObject *ob, *file = 0, *res = NULL;
+    Unpicklerobject *unpickler = 0;
 
-	if (!( PyArg_ParseTuple(args, "S:loads", &ob)))
-		goto finally;
+    if (!( PyArg_ParseTuple(args, "S:loads", &ob)))
+        goto finally;
 
-	if (!( file = PycStringIO->NewInput(ob)))
-		goto finally;
+    if (!( file = PycStringIO->NewInput(ob)))
+        goto finally;
 
-	if (!( unpickler = newUnpicklerobject(file)))
-		goto finally;
+    if (!( unpickler = newUnpicklerobject(file)))
+        goto finally;
 
-	res = load(unpickler);
+    res = load(unpickler);
 
   finally:
-	Py_XDECREF(file);
-	Py_XDECREF(unpickler);
+    Py_XDECREF(file);
+    Py_XDECREF(unpickler);
 
-	return res;
+    return res;
 }
 
 
@@ -5632,28 +5632,28 @@
 
 static PyTypeObject Unpicklertype = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    "cPickle.Unpickler", 	         /*tp_name*/
+    "cPickle.Unpickler",                 /*tp_name*/
     sizeof(Unpicklerobject),             /*tp_basicsize*/
     0,
-    (destructor)Unpickler_dealloc,	/* tp_dealloc */
-    0,					/* tp_print */
-    (getattrfunc)Unpickler_getattr,	/* tp_getattr */
-    (setattrfunc)Unpickler_setattr,	/* tp_setattr */
-    0,					/* tp_compare */
-    0,		 			/* tp_repr */
-    0,					/* tp_as_number */
-    0,					/* tp_as_sequence */
-    0,					/* tp_as_mapping */
-    0,					/* tp_hash */
-    0,					/* tp_call */
-    0,					/* tp_str */
-    0,					/* tp_getattro */
-    0,					/* tp_setattro */
-    0,					/* tp_as_buffer */
+    (destructor)Unpickler_dealloc,      /* tp_dealloc */
+    0,                                  /* tp_print */
+    (getattrfunc)Unpickler_getattr,     /* tp_getattr */
+    (setattrfunc)Unpickler_setattr,     /* tp_setattr */
+    0,                                  /* tp_compare */
+    0,                                  /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    0,                                  /* tp_hash */
+    0,                                  /* tp_call */
+    0,                                  /* tp_str */
+    0,                                  /* tp_getattro */
+    0,                                  /* tp_setattro */
+    0,                                  /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
-    Unpicklertype__doc__,		/* tp_doc */
-    (traverseproc)Unpickler_traverse,	/* tp_traverse */
-    (inquiry)Unpickler_clear,		/* tp_clear */
+    Unpicklertype__doc__,               /* tp_doc */
+    (traverseproc)Unpickler_traverse,   /* tp_traverse */
+    (inquiry)Unpickler_clear,           /* tp_clear */
 };
 
 static struct PyMethodDef cPickle_methods[] = {
@@ -5711,198 +5711,198 @@
 static int
 init_stuff(PyObject *module_dict)
 {
-	PyObject *copyreg, *t, *r;
+    PyObject *copyreg, *t, *r;
 
 #define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S)))  return -1;
 
-	if (PyType_Ready(&Unpicklertype) < 0)
-		return -1;
-	if (PyType_Ready(&Picklertype) < 0)
-		return -1;
+    if (PyType_Ready(&Unpicklertype) < 0)
+        return -1;
+    if (PyType_Ready(&Picklertype) < 0)
+        return -1;
 
-	INIT_STR(__class__);
-	INIT_STR(__getinitargs__);
-	INIT_STR(__dict__);
-	INIT_STR(__getstate__);
-	INIT_STR(__setstate__);
-	INIT_STR(__name__);
-	INIT_STR(__main__);
-	INIT_STR(__reduce__);
-	INIT_STR(__reduce_ex__);
-	INIT_STR(write);
-	INIT_STR(append);
-	INIT_STR(read);
-	INIT_STR(readline);
-	INIT_STR(dispatch_table);
+    INIT_STR(__class__);
+    INIT_STR(__getinitargs__);
+    INIT_STR(__dict__);
+    INIT_STR(__getstate__);
+    INIT_STR(__setstate__);
+    INIT_STR(__name__);
+    INIT_STR(__main__);
+    INIT_STR(__reduce__);
+    INIT_STR(__reduce_ex__);
+    INIT_STR(write);
+    INIT_STR(append);
+    INIT_STR(read);
+    INIT_STR(readline);
+    INIT_STR(dispatch_table);
 
-	if (!( copyreg = PyImport_ImportModule("copy_reg")))
-		return -1;
+    if (!( copyreg = PyImport_ImportModule("copy_reg")))
+        return -1;
 
-	/* This is special because we want to use a different
-	   one in restricted mode. */
-	dispatch_table = PyObject_GetAttr(copyreg, dispatch_table_str);
-	if (!dispatch_table) return -1;
+    /* This is special because we want to use a different
+       one in restricted mode. */
+    dispatch_table = PyObject_GetAttr(copyreg, dispatch_table_str);
+    if (!dispatch_table) return -1;
 
-	extension_registry = PyObject_GetAttrString(copyreg,
-				"_extension_registry");
-	if (!extension_registry) return -1;
+    extension_registry = PyObject_GetAttrString(copyreg,
+                            "_extension_registry");
+    if (!extension_registry) return -1;
 
-	inverted_registry = PyObject_GetAttrString(copyreg,
-				"_inverted_registry");
-	if (!inverted_registry) return -1;
+    inverted_registry = PyObject_GetAttrString(copyreg,
+                            "_inverted_registry");
+    if (!inverted_registry) return -1;
 
-	extension_cache = PyObject_GetAttrString(copyreg,
-				"_extension_cache");
-	if (!extension_cache) return -1;
+    extension_cache = PyObject_GetAttrString(copyreg,
+                            "_extension_cache");
+    if (!extension_cache) return -1;
 
-	Py_DECREF(copyreg);
+    Py_DECREF(copyreg);
 
-	if (!(empty_tuple = PyTuple_New(0)))
-		return -1;
+    if (!(empty_tuple = PyTuple_New(0)))
+        return -1;
 
-	two_tuple = PyTuple_New(2);
-	if (two_tuple == NULL)
-		return -1;
-	/* We use this temp container with no regard to refcounts, or to
-	 * keeping containees alive.  Exempt from GC, because we don't
-	 * want anything looking at two_tuple() by magic.
-	 */
-	PyObject_GC_UnTrack(two_tuple);
+    two_tuple = PyTuple_New(2);
+    if (two_tuple == NULL)
+        return -1;
+    /* We use this temp container with no regard to refcounts, or to
+     * keeping containees alive.  Exempt from GC, because we don't
+     * want anything looking at two_tuple() by magic.
+     */
+    PyObject_GC_UnTrack(two_tuple);
 
-	/* Ugh */
-	if (!( t=PyImport_ImportModule("__builtin__")))  return -1;
-	if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0)
-		return -1;
+    /* Ugh */
+    if (!( t=PyImport_ImportModule("__builtin__")))  return -1;
+    if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0)
+        return -1;
 
-	if (!( t=PyDict_New()))  return -1;
-	if (!( r=PyRun_String(
-		       "def __str__(self):\n"
-		       "  return self.args and ('%s' % self.args[0]) or '(what)'\n",
-		       Py_file_input,
-		       module_dict, t)  ))  return -1;
-	Py_DECREF(r);
+    if (!( t=PyDict_New()))  return -1;
+    if (!( r=PyRun_String(
+                   "def __str__(self):\n"
+                   "  return self.args and ('%s' % self.args[0]) or '(what)'\n",
+                   Py_file_input,
+                   module_dict, t)  ))  return -1;
+    Py_DECREF(r);
 
-	PickleError = PyErr_NewException("cPickle.PickleError", NULL, t);
-	if (!PickleError)
-		return -1;
+    PickleError = PyErr_NewException("cPickle.PickleError", NULL, t);
+    if (!PickleError)
+        return -1;
 
-	Py_DECREF(t);
+    Py_DECREF(t);
 
-	PicklingError = PyErr_NewException("cPickle.PicklingError",
-					   PickleError, NULL);
-	if (!PicklingError)
-		return -1;
+    PicklingError = PyErr_NewException("cPickle.PicklingError",
+                                       PickleError, NULL);
+    if (!PicklingError)
+        return -1;
 
-	if (!( t=PyDict_New()))  return -1;
-	if (!( r=PyRun_String(
-		       "def __str__(self):\n"
-		       "  a=self.args\n"
-		       "  a=a and type(a[0]) or '(what)'\n"
-		       "  return 'Cannot pickle %s objects' % a\n"
-		       , Py_file_input,
-		       module_dict, t)  ))  return -1;
-	Py_DECREF(r);
+    if (!( t=PyDict_New()))  return -1;
+    if (!( r=PyRun_String(
+                   "def __str__(self):\n"
+                   "  a=self.args\n"
+                   "  a=a and type(a[0]) or '(what)'\n"
+                   "  return 'Cannot pickle %s objects' % a\n"
+                   , Py_file_input,
+                   module_dict, t)  ))  return -1;
+    Py_DECREF(r);
 
-	if (!( UnpickleableError = PyErr_NewException(
-		       "cPickle.UnpickleableError", PicklingError, t)))
-		return -1;
+    if (!( UnpickleableError = PyErr_NewException(
+                   "cPickle.UnpickleableError", PicklingError, t)))
+        return -1;
 
-	Py_DECREF(t);
+    Py_DECREF(t);
 
-	if (!( UnpicklingError = PyErr_NewException("cPickle.UnpicklingError",
-						    PickleError, NULL)))
-		return -1;
+    if (!( UnpicklingError = PyErr_NewException("cPickle.UnpicklingError",
+                                                PickleError, NULL)))
+        return -1;
 
-        if (!( BadPickleGet = PyErr_NewException("cPickle.BadPickleGet",
-						 UnpicklingError, NULL)))
-                return -1;
+    if (!( BadPickleGet = PyErr_NewException("cPickle.BadPickleGet",
+                                             UnpicklingError, NULL)))
+        return -1;
 
-	if (PyDict_SetItemString(module_dict, "PickleError",
-				 PickleError) < 0)
-		return -1;
+    if (PyDict_SetItemString(module_dict, "PickleError",
+                             PickleError) < 0)
+        return -1;
 
-	if (PyDict_SetItemString(module_dict, "PicklingError",
-				 PicklingError) < 0)
-		return -1;
+    if (PyDict_SetItemString(module_dict, "PicklingError",
+                             PicklingError) < 0)
+        return -1;
 
-	if (PyDict_SetItemString(module_dict, "UnpicklingError",
-				 UnpicklingError) < 0)
-		return -1;
+    if (PyDict_SetItemString(module_dict, "UnpicklingError",
+                             UnpicklingError) < 0)
+        return -1;
 
-	if (PyDict_SetItemString(module_dict, "UnpickleableError",
-				 UnpickleableError) < 0)
-		return -1;
+    if (PyDict_SetItemString(module_dict, "UnpickleableError",
+                             UnpickleableError) < 0)
+        return -1;
 
-	if (PyDict_SetItemString(module_dict, "BadPickleGet",
-				 BadPickleGet) < 0)
-		return -1;
+    if (PyDict_SetItemString(module_dict, "BadPickleGet",
+                             BadPickleGet) < 0)
+        return -1;
 
-	PycString_IMPORT;
+    PycString_IMPORT;
 
-	return 0;
+    return 0;
 }
 
-#ifndef PyMODINIT_FUNC	/* declarations for DLL import/export */
+#ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */
 #define PyMODINIT_FUNC void
 #endif
 PyMODINIT_FUNC
 initcPickle(void)
 {
-	PyObject *m, *d, *di, *v, *k;
-	Py_ssize_t i;
-	char *rev = "1.71";	/* XXX when does this change? */
-	PyObject *format_version;
-	PyObject *compatible_formats;
+    PyObject *m, *d, *di, *v, *k;
+    Py_ssize_t i;
+    char *rev = "1.71";         /* XXX when does this change? */
+    PyObject *format_version;
+    PyObject *compatible_formats;
 
-	Py_TYPE(&Picklertype) = &PyType_Type;
-	Py_TYPE(&Unpicklertype) = &PyType_Type;
-	Py_TYPE(&PdataType) = &PyType_Type;
+    Py_TYPE(&Picklertype) = &PyType_Type;
+    Py_TYPE(&Unpicklertype) = &PyType_Type;
+    Py_TYPE(&PdataType) = &PyType_Type;
 
-	/* Initialize some pieces. We need to do this before module creation,
-	 * so we're forced to use a temporary dictionary. :(
-	 */
-	di = PyDict_New();
-	if (!di) return;
-	if (init_stuff(di) < 0) return;
+    /* Initialize some pieces. We need to do this before module creation,
+     * so we're forced to use a temporary dictionary. :(
+     */
+    di = PyDict_New();
+    if (!di) return;
+    if (init_stuff(di) < 0) return;
 
-	/* Create the module and add the functions */
-	m = Py_InitModule4("cPickle", cPickle_methods,
-			   cPickle_module_documentation,
-			   (PyObject*)NULL,PYTHON_API_VERSION);
-	if (m == NULL)
-		return;
+    /* Create the module and add the functions */
+    m = Py_InitModule4("cPickle", cPickle_methods,
+                       cPickle_module_documentation,
+                       (PyObject*)NULL,PYTHON_API_VERSION);
+    if (m == NULL)
+        return;
 
-	/* Add some symbolic constants to the module */
-	d = PyModule_GetDict(m);
-	v = PyString_FromString(rev);
-	PyDict_SetItemString(d, "__version__", v);
-	Py_XDECREF(v);
+    /* Add some symbolic constants to the module */
+    d = PyModule_GetDict(m);
+    v = PyString_FromString(rev);
+    PyDict_SetItemString(d, "__version__", v);
+    Py_XDECREF(v);
 
-	/* Copy data from di. Waaa. */
-	for (i=0; PyDict_Next(di, &i, &k, &v); ) {
-		if (PyObject_SetItem(d, k, v) < 0) {
-			Py_DECREF(di);
-			return;
-		}
-	}
-	Py_DECREF(di);
+    /* Copy data from di. Waaa. */
+    for (i=0; PyDict_Next(di, &i, &k, &v); ) {
+        if (PyObject_SetItem(d, k, v) < 0) {
+            Py_DECREF(di);
+            return;
+        }
+    }
+    Py_DECREF(di);
 
-	i = PyModule_AddIntConstant(m, "HIGHEST_PROTOCOL", HIGHEST_PROTOCOL);
-	if (i < 0)
-		return;
+    i = PyModule_AddIntConstant(m, "HIGHEST_PROTOCOL", HIGHEST_PROTOCOL);
+    if (i < 0)
+        return;
 
-	/* These are purely informational; no code uses them. */
-	/* File format version we write. */
-	format_version = PyString_FromString("2.0");
-	/* Format versions we can read. */
-	compatible_formats = Py_BuildValue("[sssss]",
-		"1.0",	/* Original protocol 0 */
-		"1.1",	/* Protocol 0 + INST */
-		"1.2",	/* Original protocol 1 */
-		"1.3",	/* Protocol 1 + BINFLOAT */
-		"2.0");	/* Original protocol 2 */
-	PyDict_SetItemString(d, "format_version", format_version);
-	PyDict_SetItemString(d, "compatible_formats", compatible_formats);
-	Py_XDECREF(format_version);
-	Py_XDECREF(compatible_formats);
+    /* These are purely informational; no code uses them. */
+    /* File format version we write. */
+    format_version = PyString_FromString("2.0");
+    /* Format versions we can read. */
+    compatible_formats = Py_BuildValue("[sssss]",
+        "1.0",          /* Original protocol 0 */
+        "1.1",          /* Protocol 0 + INST */
+        "1.2",          /* Original protocol 1 */
+        "1.3",          /* Protocol 1 + BINFLOAT */
+        "2.0");         /* Original protocol 2 */
+    PyDict_SetItemString(d, "format_version", format_version);
+    PyDict_SetItemString(d, "compatible_formats", compatible_formats);
+    Py_XDECREF(format_version);
+    Py_XDECREF(compatible_formats);
 }