diff --git a/Python/strtod.c b/Python/strtod.c
index a248460..6798efa 100644
--- a/Python/strtod.c
+++ b/Python/strtod.c
@@ -14,7 +14,7 @@
     Defines: double strtod (char *str, char**ptr)
 */
 
-/*  This is an implementation of the strtod() function described in the 
+/*  This is an implementation of the strtod() function described in the
     System V manuals, with a different name to avoid linker problems.
     All that str2dbl() does itself is check that the argument is well-formed
     and is in range.  It leaves the work of conversion to atof(), which is
@@ -22,18 +22,18 @@
 
     There are two reasons why this should be provided to the net:
     (a) some UNIX systems do not yet have strtod(), or do not have it
-        available in the BSD "universe" (but they do have atof()).
+    available in the BSD "universe" (but they do have atof()).
     (b) some of the UNIX systems that *do* have it get it wrong.
-	(some crash with large arguments, some assign the wrong *ptr value).
+    (some crash with large arguments, some assign the wrong *ptr value).
     There is a reason why *we* are providing it: we need a correct version
     of strtod(), and if we give this one away maybe someone will look for
     mistakes in it and fix them for us (:-).
 */
-    
+
 /*  The following constants are machine-specific.  MD{MIN,MAX}EXPT are
     integers and MD{MIN,MAX}FRAC are strings such that
-	0.${MDMAXFRAC}e${MDMAXEXPT} is the largest representable double,
-	0.${MDMINFRAC}e${MDMINEXPT} is the smallest representable +ve double
+    0.${MDMAXFRAC}e${MDMAXEXPT} is the largest representable double,
+    0.${MDMINFRAC}e${MDMINEXPT} is the smallest representable +ve double
     MD{MIN,MAX}FRAC must not have any trailing zeros.
     The values here are for IEEE-754 64-bit floats.
     It is not perfectly clear to me whether an IEEE infinity should be
@@ -44,113 +44,113 @@
     I do know about <values.h>, but the whole point of this file is that
     we can't always trust that stuff to be there or to be correct.
 */
-static	int	MDMINEXPT	= -323;
-static	char	MDMINFRAC[]	= "494065645841246544";
-static	double	ZERO		= 0.0;
+static  int     MDMINEXPT       = -323;
+static  char    MDMINFRAC[]     = "494065645841246544";
+static  double  ZERO            = 0.0;
 
-static	int	MDMAXEXPT	= 309;
-static	char	MDMAXFRAC[]	= "17976931348623157";
-static	double	HUGE		= 1.7976931348623157e308;
+static  int     MDMAXEXPT       = 309;
+static  char    MDMAXFRAC[]     = "17976931348623157";
+static  double  HUGE            = 1.7976931348623157e308;
 
-extern	double	atof(const char *);		/* Only called when result known to be ok */
+extern  double  atof(const char *);             /* Only called when result known to be ok */
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
 #endif
-extern	int	errno;
+extern  int     errno;
 
 double strtod(char *str, char **ptr)
 {
-	int sign, scale, dotseen;
-	int esign, expt;
-	char *save;
-	register char *sp, *dp;
-	register int c;
-	char *buforg, *buflim;
-	char buffer[64];		/* 45-digit significant + */
-					/* 13-digit exponent */
-	sp = str;
-	while (*sp == ' ') sp++;
-	sign = 1;
-	if (*sp == '-') sign -= 2, sp++;
-	dotseen = 0, scale = 0;
-	dp = buffer;	
-	*dp++ = '0'; *dp++ = '.';
-	buforg = dp, buflim = buffer+48;
-	for (save = sp; c = *sp; sp++)
-	    if (c == '.') {
-		if (dotseen) break;
-		dotseen++;
-	    } else
-	    if ((unsigned)(c-'0') > (unsigned)('9'-'0')) {
-		break;
-	    } else
-	    if (c == '0') {
-		if (dp != buforg) {
-		    /* This is not the first digit, so we want to keep it */
-		    if (dp < buflim) *dp++ = c;
-		    if (!dotseen) scale++;
-		} else {
-		    /* No non-zero digits seen yet */
-		    /* If a . has been seen, scale must be adjusted */
-		    if (dotseen) scale--;
-		}
-	    } else {
-		/* This is a nonzero digit, so we want to keep it */
-		if (dp < buflim) *dp++ = c;
-		/* If it precedes a ., scale must be adjusted */
-		if (!dotseen) scale++;
-	    }
-	if (sp == save) {
-	    if (ptr) *ptr = str;
-	    errno = EDOM;		/* what should this be? */
-	    return ZERO;
-	}
-	
-	while (dp > buforg && dp[-1] == '0') --dp;
-	if (dp == buforg) *dp++ = '0';
-	*dp = '\0';
-	/*  Now the contents of buffer are
-	    +--+--------+-+--------+
-	    |0.|fraction|\|leftover|
-	    +--+--------+-+--------+
-			 ^dp points here
-	    where fraction begins with 0 iff it is "0", and has at most
-	    45 digits in it, and leftover is at least 16 characters.
-	*/
-	save = sp, expt = 0, esign = 1;
-	do {
-	    c = *sp++;
-	    if (c != 'e' && c != 'E') break;
-	    c = *sp++;
-	    if (c == '-') esign -= 2, c = *sp++; else
-	    if (c == '+' /* || c == ' ' */ ) c = *sp++;
-	    if ((unsigned)(c-'0') > (unsigned)('9'-'0')) break;
-	    while (c == '0') c = *sp++;
-	    for (; (unsigned)(c-'0') <= (unsigned)('9'-'0'); c = *sp++)
-		expt = expt*10 + c-'0';	    
-	    if (esign < 0) expt = -expt;
-	    save = sp-1;
-	} while (0);
-	if (ptr) *ptr = save;
-	expt += scale;
-	/*  Now the number is sign*0.fraction*10**expt  */
-	errno = ERANGE;
-	if (expt > MDMAXEXPT) {
-	    return HUGE*sign;
-	} else
-	if (expt == MDMAXEXPT) {
-	    if (strcmp(buforg, MDMAXFRAC) > 0) return HUGE*sign;
-	} else
-	if (expt < MDMINEXPT) {
-	    return ZERO*sign;
-	} else
-	if (expt == MDMINEXPT) {
-	    if (strcmp(buforg, MDMINFRAC) < 0) return ZERO*sign;
-	}
-	/*  We have now established that the number can be  */
-	/*  represented without overflow or underflow  */
-	(void) sprintf(dp, "E%d", expt);
-	errno = 0;
-	return atof(buffer)*sign;
+    int sign, scale, dotseen;
+    int esign, expt;
+    char *save;
+    register char *sp, *dp;
+    register int c;
+    char *buforg, *buflim;
+    char buffer[64];                    /* 45-digit significant + */
+                    /* 13-digit exponent */
+    sp = str;
+    while (*sp == ' ') sp++;
+    sign = 1;
+    if (*sp == '-') sign -= 2, sp++;
+    dotseen = 0, scale = 0;
+    dp = buffer;
+    *dp++ = '0'; *dp++ = '.';
+    buforg = dp, buflim = buffer+48;
+    for (save = sp; c = *sp; sp++)
+        if (c == '.') {
+        if (dotseen) break;
+        dotseen++;
+        } else
+        if ((unsigned)(c-'0') > (unsigned)('9'-'0')) {
+        break;
+        } else
+        if (c == '0') {
+        if (dp != buforg) {
+            /* This is not the first digit, so we want to keep it */
+            if (dp < buflim) *dp++ = c;
+            if (!dotseen) scale++;
+        } else {
+            /* No non-zero digits seen yet */
+            /* If a . has been seen, scale must be adjusted */
+            if (dotseen) scale--;
+        }
+        } else {
+        /* This is a nonzero digit, so we want to keep it */
+        if (dp < buflim) *dp++ = c;
+        /* If it precedes a ., scale must be adjusted */
+        if (!dotseen) scale++;
+        }
+    if (sp == save) {
+        if (ptr) *ptr = str;
+        errno = EDOM;                   /* what should this be? */
+        return ZERO;
+    }
+
+    while (dp > buforg && dp[-1] == '0') --dp;
+    if (dp == buforg) *dp++ = '0';
+    *dp = '\0';
+    /*  Now the contents of buffer are
+        +--+--------+-+--------+
+        |0.|fraction|\|leftover|
+        +--+--------+-+--------+
+                     ^dp points here
+        where fraction begins with 0 iff it is "0", and has at most
+        45 digits in it, and leftover is at least 16 characters.
+    */
+    save = sp, expt = 0, esign = 1;
+    do {
+        c = *sp++;
+        if (c != 'e' && c != 'E') break;
+        c = *sp++;
+        if (c == '-') esign -= 2, c = *sp++; else
+        if (c == '+' /* || c == ' ' */ ) c = *sp++;
+        if ((unsigned)(c-'0') > (unsigned)('9'-'0')) break;
+        while (c == '0') c = *sp++;
+        for (; (unsigned)(c-'0') <= (unsigned)('9'-'0'); c = *sp++)
+        expt = expt*10 + c-'0';
+        if (esign < 0) expt = -expt;
+        save = sp-1;
+    } while (0);
+    if (ptr) *ptr = save;
+    expt += scale;
+    /*  Now the number is sign*0.fraction*10**expt  */
+    errno = ERANGE;
+    if (expt > MDMAXEXPT) {
+        return HUGE*sign;
+    } else
+    if (expt == MDMAXEXPT) {
+        if (strcmp(buforg, MDMAXFRAC) > 0) return HUGE*sign;
+    } else
+    if (expt < MDMINEXPT) {
+        return ZERO*sign;
+    } else
+    if (expt == MDMINEXPT) {
+        if (strcmp(buforg, MDMINFRAC) < 0) return ZERO*sign;
+    }
+    /*  We have now established that the number can be  */
+    /*  represented without overflow or underflow  */
+    (void) sprintf(dp, "E%d", expt);
+    errno = 0;
+    return atof(buffer)*sign;
 }