diff --git a/Python/ceval.c b/Python/ceval.c
index 64f2429..45d0a6a 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -81,6 +81,7 @@
 static object *cmp_outcome PROTO((int, object *, object *));
 static int import_from PROTO((object *, object *, object *));
 static object *build_class PROTO((object *, object *));
+static void locals_2_fast PROTO((frameobject *, int));
 
 
 /* Pointer to current frame, used to link new frames to */
@@ -994,19 +995,51 @@
 			break;
 
 		case RESERVE_FAST:
-			if (oparg > 0) {
-				XDECREF(fastlocals);
-				x = newlistobject(oparg);
-				fastlocals = (listobject *) x;
+			x = GETCONST(oparg);
+			if (x == None)
+				break;
+			if (x == NULL || !is_dictobject(x)) {
+				fatal("bad RESERVE_FAST");
+				err_setstr(SystemError, "bad RESERVE_FAST");
+				x = NULL;
+				break;
 			}
+			XDECREF(f->f_fastlocals);
+			XDECREF(f->f_localmap);
+			INCREF(x);
+			f->f_localmap = x;
+			f->f_fastlocals = x = newlistobject(
+			    x->ob_type->tp_as_mapping->mp_length(x));
+			fastlocals = (listobject *) x;
 			break;
 
 		case LOAD_FAST:
-			/* NYI */
+			x = GETLISTITEM(fastlocals, oparg);
+			if (x == NULL) {
+				err_setstr(NameError,
+					   "undefined local variable");
+				break;
+			}
+			INCREF(x);
+			PUSH(x);
 			break;
 
 		case STORE_FAST:
-			/* NYI */
+			w = GETLISTITEM(fastlocals, oparg);
+			XDECREF(w);
+			w = POP();
+			GETLISTITEM(fastlocals, oparg) = w;
+			break;
+
+		case DELETE_FAST:
+			x = GETLISTITEM(fastlocals, oparg);
+			if (x == NULL) {
+				err_setstr(NameError,
+					   "undefined local variable");
+				break;
+			}
+			DECREF(x);
+			GETLISTITEM(fastlocals, oparg) = NULL;
 			break;
 		
 		case BUILD_TUPLE:
@@ -1068,6 +1101,7 @@
 			w = GETNAMEV(oparg);
 			v = TOP();
 			err = import_from(f->f_locals, v, w);
+			locals_2_fast(f, 0);
 			break;
 		
 		case JUMP_FORWARD:
@@ -1299,8 +1333,6 @@
 	
 	current_frame = f->f_back;
 	DECREF(f);
-
-	XDECREF(fastlocals);
 	
 	return retval;
 }
@@ -1418,10 +1450,92 @@
 object *
 getlocals()
 {
-	if (current_frame == NULL)
+	/* Merge f->f_fastlocals into f->f_locals, then return the latter */
+	frameobject *f;
+	object *locals, *fast, *map;
+	int i;
+	f = current_frame;
+	if (f == NULL)
 		return NULL;
-	else
-		return current_frame->f_locals;
+	locals = f->f_locals;
+	fast = f->f_fastlocals;
+	map = f->f_localmap;
+	if (locals == NULL || fast == NULL || map == NULL)
+		return locals;
+	if (!is_dictobject(locals) || !is_listobject(fast) ||
+	    !is_dictobject(map))
+		return locals;
+	i = getdictsize(map);
+	while (--i >= 0) {
+		object *key;
+		object *value;
+		int j;
+		key = getdict2key(map, i);
+		if (key == NULL)
+			continue;
+		value = dict2lookup(map, key);
+		if (value == NULL || !is_intobject(value))
+			continue;
+		j = getintvalue(value);
+		value = getlistitem(fast, j);
+		if (value == NULL) {
+			err_clear();
+			if (dict2remove(locals, key) != 0)
+				err_clear();
+		}
+		else {
+			if (dict2insert(locals, key, value) != 0)
+				err_clear();
+		}
+	}
+	return locals;
+}
+
+static void
+locals_2_fast(f, clear)
+	frameobject *f;
+	int clear;
+{
+	/* Merge f->f_locals into f->f_fastlocals */
+	object *locals, *fast, *map;
+	int i;
+	if (f == NULL)
+		return;
+	locals = f->f_locals;
+	fast = f->f_fastlocals;
+	map = f->f_localmap;
+	if (locals == NULL || fast == NULL || map == NULL)
+		return;
+	if (!is_dictobject(locals) || !is_listobject(fast) ||
+	    !is_dictobject(map))
+		return;
+	i = getdictsize(map);
+	while (--i >= 0) {
+		object *key;
+		object *value;
+		int j;
+		key = getdict2key(map, i);
+		if (key == NULL)
+			continue;
+		value = dict2lookup(map, key);
+		if (value == NULL || !is_intobject(value))
+			continue;
+		j = getintvalue(value);
+		value = dict2lookup(locals, key);
+		if (value == NULL)
+			err_clear();
+		else
+			INCREF(value);
+		if (value != NULL || clear)
+			if (setlistitem(fast, j, value) != 0)
+				err_clear();
+	}
+}
+
+void
+mergelocals()
+{
+	locals_2_fast(current_frame, 1);
 }
 
 object *
diff --git a/Python/compile.c b/Python/compile.c
index 116b6bb..dd79937 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -27,7 +27,6 @@
 /* XXX TO DO:
    XXX Compute maximum needed stack sizes while compiling
    XXX Generate simple jump for break/return outside 'try...finally'
-   XXX Include function name in code (and module names?)
 */
 
 #include "allobjects.h"
@@ -2032,7 +2031,7 @@
 	node *ch;
 	REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */
 	c->c_name = STR(CHILD(n, 1));
-	com_addoparg(c, RESERVE_FAST, 0); /* Patched up later */
+	com_addoparg(c, RESERVE_FAST, com_addconst(c, None)); /* Patched! */
 	ch = CHILD(n, 2); /* parameters: '(' [varargslist] ')' */
 	ch = CHILD(ch, 1); /* ')' | varargslist */
 	if (TYPE(ch) == RPAR)
@@ -2100,79 +2099,95 @@
 	}
 }
 
-/* Optimization for local and global variables.
+/* Optimization for local variables in functions (and *only* functions).
 
-   XXX Need to update this text for LOAD_FAST stuff...
-
-   Attempt to replace all LOAD_NAME instructions that refer to a local
-   variable with LOAD_LOCAL instructions, and all that refer to a global
-   variable with LOAD_GLOBAL instructions.
+   This replaces all LOAD_NAME, STORE_NAME and DELETE_NAME
+   instructions that refer to local variables with LOAD_FAST etc.
+   The latter instructions are much faster because they don't need to
+   look up the variable name in a dictionary.
    
    To find all local variables, we check all STORE_NAME and IMPORT_FROM
    instructions.  This yields all local variables, including arguments,
    function definitions, class definitions and import statements.
+   (We don't check DELETE_NAME instructions, since if there's no
+   STORE_NAME the DELETE_NAME will surely fail.)
    
-   There is one leak: 'from foo import *' introduces local variables
-   that we can't know while compiling.  If this is the case, LOAD_GLOBAL
-   instructions are not generated -- LOAD_NAME is left in place for
-   globals, since it first checks for globals (LOAD_LOCAL is still used
-   for recognized locals, since it doesn't hurt).
-   
-   This optimization means that using the same name as a global and
-   as a local variable within the same scope is now illegal, which
-   is a change to the language!  Also using eval() to introduce new
-   local variables won't work.  But both were bad practice at best.
-   
-   The optimization doesn't save much: basically, it saves one
-   unsuccessful dictionary lookup per global (or built-in) variable
-   reference.  On the (slow!) Mac Plus, with 4 local variables,
-   this saving was measured to be about 0.18 ms.  We might save more
-   by using a different data structure to hold local variables, like
-   an array indexed by variable number.
+   There is one problem: 'from foo import *' introduces local variables
+   that we can't know while compiling.  If this is the case, wo don't
+   optimize at all (this rarely happens, since import is mostly used
+   at the module level).
+
+   Note that, because of this optimization, code like the following
+   won't work:
+	eval('x = 1')
+	print x
    
    NB: this modifies the string object co->co_code!
 */
 
 static void
-optimizer(co)
-	codeobject *co;
+optimize(c)
+	struct compiling *c;
 {
 	unsigned char *next_instr, *cur_instr;
 	object *locals;
+	int nlocals;
 	int opcode;
 	int oparg;
 	object *name;
-	int star_used;
-
+	int fast_reserved;
+	object *error_type, *error_value;
+	
 #define NEXTOP()	(*next_instr++)
 #define NEXTARG()	(next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
 #define GETITEM(v, i)	(getlistitem((v), (i)))
-#define GETNAMEOBJ(i)	(GETITEM(co->co_names, (i)))
-
+#define GETNAMEOBJ(i)	(GETITEM(c->c_names, (i)))
+	
 	locals = newdictobject();
 	if (locals == NULL) {
-		err_clear();
-		return; /* For now, this is OK */
+		c->c_errors++;
+		return;
 	}
+	nlocals = 0;
+
+	err_get(&error_type, &error_value);
 	
-	next_instr = (unsigned char *) GETSTRINGVALUE(co->co_code); 
+	next_instr = (unsigned char *) getstringvalue(c->c_code);
 	for (;;) {
 		opcode = NEXTOP();
 		if (opcode == STOP_CODE)
 			break;
 		if (HAS_ARG(opcode))
 			oparg = NEXTARG();
-		if (opcode == STORE_NAME || opcode == IMPORT_FROM) {
+		if (opcode == STORE_NAME || opcode == DELETE_NAME ||
+		    opcode == IMPORT_FROM) {
+			object *v;
 			name = GETNAMEOBJ(oparg);
-			if (dict2insert(locals, name, None) != 0) {
-				DECREF(locals);
-				return; /* Sorry */
+			if (dict2lookup(locals, name) != NULL)
+				continue;
+			err_clear();
+			v = newintobject(nlocals);
+			if (v == NULL) {
+				c->c_errors++;
+				goto err;
 			}
+			nlocals++;
+			if (dict2insert(locals, name, v) != 0) {
+				DECREF(v);
+				c->c_errors++;
+				goto err;
+			}
+			DECREF(v);
 		}
 	}
 	
-	star_used = (dictlookup(locals, "*") != NULL);
-	next_instr = (unsigned char *) GETSTRINGVALUE(co->co_code); 
+	if (nlocals == 0 || dictlookup(locals, "*") != NULL) {
+		/* Don't optimize anything */
+		goto end;
+	}
+	
+	next_instr = (unsigned char *) getstringvalue(c->c_code);
+	fast_reserved = 0;
 	for (;;) {
 		cur_instr = next_instr;
 		opcode = NEXTOP();
@@ -2180,18 +2195,40 @@
 			break;
 		if (HAS_ARG(opcode))
 			oparg = NEXTARG();
-		if (opcode == LOAD_NAME) {
+		if (opcode == RESERVE_FAST) {
+			int i = com_addconst(c, locals);
+			cur_instr[1] = i & 0xff;
+			cur_instr[2] = (i>>8) & 0xff;
+			fast_reserved = 1;
+			continue;
+		}
+		if (!fast_reserved)
+			continue;
+		if (opcode == LOAD_NAME ||
+		    opcode == STORE_NAME ||
+		    opcode == DELETE_NAME) {
+			object *v;
+			int i;
 			name = GETNAMEOBJ(oparg);
-			if (dict2lookup(locals, name) != NULL)
-				*cur_instr = LOAD_LOCAL;
-			else {
+			v = dict2lookup(locals, name);
+			if (v == NULL) {
 				err_clear();
-				if (!star_used)
-					*cur_instr = LOAD_GLOBAL;
+				continue;
 			}
+			i = getintvalue(v);
+			switch (opcode) {
+			case LOAD_NAME: cur_instr[0] = LOAD_FAST; break;
+			case STORE_NAME: cur_instr[0] = STORE_FAST; break;
+			case DELETE_NAME: cur_instr[0] = DELETE_FAST; break;
+			}
+			cur_instr[1] = i & 0xff;
+			cur_instr[2] = (i>>8) & 0xff;
 		}
 	}
-	
+
+ end:
+	err_setval(error_type, error_value);
+ err:
 	DECREF(locals);
 }
 
@@ -2206,6 +2243,8 @@
 		return NULL;
 	compile_node(&sc, n);
 	com_done(&sc);
+	if (TYPE(n) == funcdef && sc.c_errors == 0)
+		optimize(&sc);
 	co = NULL;
 	if (sc.c_errors == 0) {
 		object *v, *w;
@@ -2218,7 +2257,5 @@
 		XDECREF(w);
 	}
 	com_free(&sc);
-	if (co != NULL && filename[0] != '<')
-		optimizer(co);
 	return co;
 }
diff --git a/Python/import.c b/Python/import.c
index 4b7ee13..2171f4b 100644
--- a/Python/import.c
+++ b/Python/import.c
@@ -54,7 +54,7 @@
 
 /* Magic word to reject pre-0.9.9 .pyc files */
 
-#define MAGIC 0x99BE2AL
+#define MAGIC 0x99BE3AL
 
 static object *modules;
 
diff --git a/Python/pythonrun.c b/Python/pythonrun.c
index e59458e..c387c62 100644
--- a/Python/pythonrun.c
+++ b/Python/pythonrun.c
@@ -304,16 +304,23 @@
 	char *filename;
 	/*dict*/object *globals, *locals;
 {
+	object *res;
+	int needmerge = 0;
 	if (globals == NULL) {
 		globals = getglobals();
-		if (locals == NULL)
+		if (locals == NULL) {
 			locals = getlocals();
+			needmerge = 1;
+		}
 	}
 	else {
 		if (locals == NULL)
 			locals = globals;
 	}
-	return eval_node(n, filename, globals, locals);
+	res = eval_node(n, filename, globals, locals);
+	if (needmerge)
+		mergelocals();
+	return res;
 }
 
 object *