diff --git a/Doc/lib/asttable.tex b/Doc/lib/asttable.tex
index 7f6ba9f..8a93abf 100644
--- a/Doc/lib/asttable.tex
+++ b/Doc/lib/asttable.tex
@@ -73,6 +73,9 @@
 \lineiii{Continue}{}{}
 \hline 
 
+\lineiii{Decorators}{\member{nodes}}{List of function decorator expressions}
+\hline 
+
 \lineiii{Dict}{\member{items}}{}
 \hline 
 
@@ -101,7 +104,8 @@
 \lineiii{}{\member{names}}{}
 \hline 
 
-\lineiii{Function}{\member{name}}{name used in def, a string}
+\lineiii{Function}{\member{decorators}}{\class{Decorators} or \code{None}}
+\lineiii{}{\member{name}}{name used in def, a string}
 \lineiii{}{\member{argnames}}{list of argument names, as strings}
 \lineiii{}{\member{defaults}}{list of default values}
 \lineiii{}{\member{flags}}{xxx}
diff --git a/Doc/lib/libfuncs.tex b/Doc/lib/libfuncs.tex
index ff922d4..b3d3d30 100644
--- a/Doc/lib/libfuncs.tex
+++ b/Doc/lib/libfuncs.tex
@@ -109,10 +109,14 @@
 
 \begin{verbatim}
 class C:
+    @classmethod
     def f(cls, arg1, arg2, ...): ...
-    f = classmethod(f)
 \end{verbatim}
 
+  The \code{@classmethod} form is a function decorator -- see the description
+  of function definitions in chapter 7 of the
+  \citetitle[../ref/ref.html]{Python Reference Manual} for details.
+
   It can be called either on the class (such as \code{C.f()}) or on an
   instance (such as \code{C().f()}).  The instance is ignored except for
   its class.
@@ -122,6 +126,7 @@
   Class methods are different than \Cpp{} or Java static methods.
   If you want those, see \function{staticmethod()} in this section.
   \versionadded{2.2}
+  Function decorator syntax added in version 2.4.
 \end{funcdesc}
 
 \begin{funcdesc}{cmp}{x, y}
@@ -936,10 +941,14 @@
 
 \begin{verbatim}
 class C:
+    @staticmethod
     def f(arg1, arg2, ...): ...
-    f = staticmethod(f)
 \end{verbatim}
 
+  The \code{@staticmethod} form is a function decorator -- see the description
+  of function definitions in chapter 7 of the
+  \citetitle[../ref/ref.html]{Python Reference Manual} for details.
+
   It can be called either on the class (such as \code{C.f()}) or on an
   instance (such as \code{C().f()}).  The instance is ignored except
   for its class.
diff --git a/Doc/ref/ref7.tex b/Doc/ref/ref7.tex
index 80ddc33..1d7b860 100644
--- a/Doc/ref/ref7.tex
+++ b/Doc/ref/ref7.tex
@@ -315,8 +315,12 @@
 
 \begin{productionlist}
   \production{funcdef}
-             {"def" \token{funcname} "(" [\token{parameter_list}] ")"
+             {[\token{decorators}] "def" \token{funcname} "(" [\token{parameter_list}] ")"
               ":" \token{suite}}
+  \production{decorators}
+             {\token{decorator} ([NEWLINE] \token{decorator})* NEWLINE}
+  \production{decorator}
+             {"@" \token{dotted_name} ["(" [\token{argument_list} [","]] ")"]}
   \production{parameter_list}
              {(\token{defparameter} ",")*}
   \productioncont{("*" \token{identifier} [, "**" \token{identifier}]}
@@ -343,6 +347,27 @@
 The function definition does not execute the function body; this gets
 executed only when the function is called.
 
+A function definition may be wrapped by one or more decorator expressions.
+Decorator expressions are evaluated when the function is defined, in the scope
+that contains the function definition.  The result must be a callable,
+which is invoked with the function object as the only argument.
+The returned value is bound to the function name instead of the function
+object.  If there are multiple decorators, they are applied in reverse
+order.  For example, the following code:
+
+\begin{verbatim}
+@f1
+@f2
+def func(): pass
+\end{verbatim}
+
+is equivalent to:
+
+\begin{verbatim}
+def func(): pass
+func = f2(f1(func))
+\end{verbatim}
+
 When one or more top-level parameters have the form \var{parameter}
 \code{=} \var{expression}, the function is said to have ``default
 parameter values.''  For a parameter with a
diff --git a/Grammar/Grammar b/Grammar/Grammar
index ce75ba8..111ebe0 100644
--- a/Grammar/Grammar
+++ b/Grammar/Grammar
@@ -28,7 +28,9 @@
 file_input: (NEWLINE | stmt)* ENDMARKER
 eval_input: testlist NEWLINE* ENDMARKER
 
-funcdef: 'def' NAME parameters ':' suite
+decorator: '@' dotted_name [ '(' [arglist] ')' ]
+decorators: decorator ([NEWLINE] decorator)* NEWLINE
+funcdef: [decorators] 'def' NAME parameters ':' suite
 parameters: '(' [varargslist] ')'
 varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] | '**' NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
 fpdef: NAME | '(' fplist ')'
diff --git a/Include/graminit.h b/Include/graminit.h
index 7d4a97a..ac351be 100644
--- a/Include/graminit.h
+++ b/Include/graminit.h
@@ -1,72 +1,74 @@
 #define single_input 256
 #define file_input 257
 #define eval_input 258
-#define funcdef 259
-#define parameters 260
-#define varargslist 261
-#define fpdef 262
-#define fplist 263
-#define stmt 264
-#define simple_stmt 265
-#define small_stmt 266
-#define expr_stmt 267
-#define augassign 268
-#define print_stmt 269
-#define del_stmt 270
-#define pass_stmt 271
-#define flow_stmt 272
-#define break_stmt 273
-#define continue_stmt 274
-#define return_stmt 275
-#define yield_stmt 276
-#define raise_stmt 277
-#define import_stmt 278
-#define import_as_name 279
-#define dotted_as_name 280
-#define dotted_name 281
-#define global_stmt 282
-#define exec_stmt 283
-#define assert_stmt 284
-#define compound_stmt 285
-#define if_stmt 286
-#define while_stmt 287
-#define for_stmt 288
-#define try_stmt 289
-#define except_clause 290
-#define suite 291
-#define test 292
-#define and_test 293
-#define not_test 294
-#define comparison 295
-#define comp_op 296
-#define expr 297
-#define xor_expr 298
-#define and_expr 299
-#define shift_expr 300
-#define arith_expr 301
-#define term 302
-#define factor 303
-#define power 304
-#define atom 305
-#define listmaker 306
-#define testlist_gexp 307
-#define lambdef 308
-#define trailer 309
-#define subscriptlist 310
-#define subscript 311
-#define sliceop 312
-#define exprlist 313
-#define testlist 314
-#define testlist_safe 315
-#define dictmaker 316
-#define classdef 317
-#define arglist 318
-#define argument 319
-#define list_iter 320
-#define list_for 321
-#define list_if 322
-#define gen_iter 323
-#define gen_for 324
-#define gen_if 325
-#define testlist1 326
-#define encoding_decl 327
+#define decorator 259
+#define decorators 260
+#define funcdef 261
+#define parameters 262
+#define varargslist 263
+#define fpdef 264
+#define fplist 265
+#define stmt 266
+#define simple_stmt 267
+#define small_stmt 268
+#define expr_stmt 269
+#define augassign 270
+#define print_stmt 271
+#define del_stmt 272
+#define pass_stmt 273
+#define flow_stmt 274
+#define break_stmt 275
+#define continue_stmt 276
+#define return_stmt 277
+#define yield_stmt 278
+#define raise_stmt 279
+#define import_stmt 280
+#define import_as_name 281
+#define dotted_as_name 282
+#define dotted_name 283
+#define global_stmt 284
+#define exec_stmt 285
+#define assert_stmt 286
+#define compound_stmt 287
+#define if_stmt 288
+#define while_stmt 289
+#define for_stmt 290
+#define try_stmt 291
+#define except_clause 292
+#define suite 293
+#define test 294
+#define and_test 295
+#define not_test 296
+#define comparison 297
+#define comp_op 298
+#define expr 299
+#define xor_expr 300
+#define and_expr 301
+#define shift_expr 302
+#define arith_expr 303
+#define term 304
+#define factor 305
+#define power 306
+#define atom 307
+#define listmaker 308
+#define testlist_gexp 309
+#define lambdef 310
+#define trailer 311
+#define subscriptlist 312
+#define subscript 313
+#define sliceop 314
+#define exprlist 315
+#define testlist 316
+#define testlist_safe 317
+#define dictmaker 318
+#define classdef 319
+#define arglist 320
+#define argument 321
+#define list_iter 322
+#define list_for 323
+#define list_if 324
+#define gen_iter 325
+#define gen_for 326
+#define gen_if 327
+#define testlist1 328
+#define encoding_decl 329
diff --git a/Include/node.h b/Include/node.h
index 8f5ef23..4c64708 100644
--- a/Include/node.h
+++ b/Include/node.h
@@ -22,7 +22,9 @@
 
 /* Node access functions */
 #define NCH(n)		((n)->n_nchildren)
+	
 #define CHILD(n, i)	(&(n)->n_child[i])
+#define RCHILD(n, i)	(CHILD(n, NCH(n) + i))
 #define TYPE(n)		((n)->n_type)
 #define STR(n)		((n)->n_str)
 
diff --git a/Include/token.h b/Include/token.h
index 4e2ec06..4250000 100644
--- a/Include/token.h
+++ b/Include/token.h
@@ -57,10 +57,11 @@
 #define DOUBLESTAREQUAL	47
 #define DOUBLESLASH	48
 #define DOUBLESLASHEQUAL 49
+#define AT              50	
 /* Don't forget to update the table _PyParser_TokenNames in tokenizer.c! */
-#define OP		50
-#define ERRORTOKEN	51
-#define N_TOKENS	52
+#define OP		51
+#define ERRORTOKEN	52
+#define N_TOKENS	53
 
 /* Special definitions for cooperation with parser */
 
diff --git a/Lib/compiler/ast.py b/Lib/compiler/ast.py
index 064df50..a81937f 100644
--- a/Lib/compiler/ast.py
+++ b/Lib/compiler/ast.py
@@ -48,31 +48,333 @@
 class EmptyNode(Node):
     pass
 
-class Slice(Node):
-    nodes["slice"] = "Slice"
-    def __init__(self, expr, flags, lower, upper):
+class Expression(Node):
+    # Expression is an artificial node class to support "eval"
+    nodes["expression"] = "Expression"
+    def __init__(self, node):
+        self.node = node
+
+    def getChildren(self):
+        return self.node,
+
+    def getChildNodes(self):
+        return self.node,
+
+    def __repr__(self):
+        return "Expression(%s)" % (repr(self.node))
+
+class Add(Node):
+    nodes["add"] = "Add"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "Add((%s, %s))" % (repr(self.left), repr(self.right))
+
+class And(Node):
+    nodes["and"] = "And"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "And(%s)" % (repr(self.nodes),)
+
+class AssAttr(Node):
+    nodes["assattr"] = "AssAttr"
+    def __init__(self, expr, attrname, flags):
         self.expr = expr
+        self.attrname = attrname
         self.flags = flags
-        self.lower = lower
-        self.upper = upper
+
+    def getChildren(self):
+        return self.expr, self.attrname, self.flags
+
+    def getChildNodes(self):
+        return self.expr,
+
+    def __repr__(self):
+        return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
+
+class AssList(Node):
+    nodes["asslist"] = "AssList"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "AssList(%s)" % (repr(self.nodes),)
+
+class AssName(Node):
+    nodes["assname"] = "AssName"
+    def __init__(self, name, flags):
+        self.name = name
+        self.flags = flags
+
+    def getChildren(self):
+        return self.name, self.flags
+
+    def getChildNodes(self):
+        return ()
+
+    def __repr__(self):
+        return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
+
+class AssTuple(Node):
+    nodes["asstuple"] = "AssTuple"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "AssTuple(%s)" % (repr(self.nodes),)
+
+class Assert(Node):
+    nodes["assert"] = "Assert"
+    def __init__(self, test, fail):
+        self.test = test
+        self.fail = fail
+
+    def getChildren(self):
+        children = []
+        children.append(self.test)
+        children.append(self.fail)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.test)
+        if self.fail is not None:            nodelist.append(self.fail)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
+
+class Assign(Node):
+    nodes["assign"] = "Assign"
+    def __init__(self, nodes, expr):
+        self.nodes = nodes
+        self.expr = expr
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        children.append(self.expr)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        nodelist.append(self.expr)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
+
+class AugAssign(Node):
+    nodes["augassign"] = "AugAssign"
+    def __init__(self, node, op, expr):
+        self.node = node
+        self.op = op
+        self.expr = expr
+
+    def getChildren(self):
+        return self.node, self.op, self.expr
+
+    def getChildNodes(self):
+        return self.node, self.expr
+
+    def __repr__(self):
+        return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
+
+class Backquote(Node):
+    nodes["backquote"] = "Backquote"
+    def __init__(self, expr):
+        self.expr = expr
+
+    def getChildren(self):
+        return self.expr,
+
+    def getChildNodes(self):
+        return self.expr,
+
+    def __repr__(self):
+        return "Backquote(%s)" % (repr(self.expr),)
+
+class Bitand(Node):
+    nodes["bitand"] = "Bitand"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Bitand(%s)" % (repr(self.nodes),)
+
+class Bitor(Node):
+    nodes["bitor"] = "Bitor"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Bitor(%s)" % (repr(self.nodes),)
+
+class Bitxor(Node):
+    nodes["bitxor"] = "Bitxor"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Bitxor(%s)" % (repr(self.nodes),)
+
+class Break(Node):
+    nodes["break"] = "Break"
+    def __init__(self, ):
+        pass
+
+    def getChildren(self):
+        return ()
+
+    def getChildNodes(self):
+        return ()
+
+    def __repr__(self):
+        return "Break()"
+
+class CallFunc(Node):
+    nodes["callfunc"] = "CallFunc"
+    def __init__(self, node, args, star_args = None, dstar_args = None):
+        self.node = node
+        self.args = args
+        self.star_args = star_args
+        self.dstar_args = dstar_args
+
+    def getChildren(self):
+        children = []
+        children.append(self.node)
+        children.extend(flatten(self.args))
+        children.append(self.star_args)
+        children.append(self.dstar_args)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.node)
+        nodelist.extend(flatten_nodes(self.args))
+        if self.star_args is not None:            nodelist.append(self.star_args)
+        if self.dstar_args is not None:            nodelist.append(self.dstar_args)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
+
+class Class(Node):
+    nodes["class"] = "Class"
+    def __init__(self, name, bases, doc, code):
+        self.name = name
+        self.bases = bases
+        self.doc = doc
+        self.code = code
+
+    def getChildren(self):
+        children = []
+        children.append(self.name)
+        children.extend(flatten(self.bases))
+        children.append(self.doc)
+        children.append(self.code)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.bases))
+        nodelist.append(self.code)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
+
+class Compare(Node):
+    nodes["compare"] = "Compare"
+    def __init__(self, expr, ops):
+        self.expr = expr
+        self.ops = ops
 
     def getChildren(self):
         children = []
         children.append(self.expr)
-        children.append(self.flags)
-        children.append(self.lower)
-        children.append(self.upper)
+        children.extend(flatten(self.ops))
         return tuple(children)
 
     def getChildNodes(self):
         nodelist = []
         nodelist.append(self.expr)
-        if self.lower is not None:            nodelist.append(self.lower)
-        if self.upper is not None:            nodelist.append(self.upper)
+        nodelist.extend(flatten_nodes(self.ops))
         return tuple(nodelist)
 
     def __repr__(self):
-        return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
+        return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
 
 class Const(Node):
     nodes["const"] = "Const"
@@ -88,29 +390,133 @@
     def __repr__(self):
         return "Const(%s)" % (repr(self.value),)
 
-class Raise(Node):
-    nodes["raise"] = "Raise"
-    def __init__(self, expr1, expr2, expr3):
-        self.expr1 = expr1
-        self.expr2 = expr2
-        self.expr3 = expr3
+class Continue(Node):
+    nodes["continue"] = "Continue"
+    def __init__(self, ):
+        pass
+
+    def getChildren(self):
+        return ()
+
+    def getChildNodes(self):
+        return ()
+
+    def __repr__(self):
+        return "Continue()"
+
+class Decorators(Node):
+    nodes["decorators"] = "Decorators"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        return tuple(flatten(self.nodes))
+
+    def getChildNodes(self):
+        return flatten_nodes(self.nodes)
+
+    def __repr__(self):
+        return "Decorators(%s)" % (repr(self.nodes),)
+
+class Dict(Node):
+    nodes["dict"] = "Dict"
+    def __init__(self, items):
+        self.items = items
 
     def getChildren(self):
         children = []
-        children.append(self.expr1)
-        children.append(self.expr2)
-        children.append(self.expr3)
+        children.extend(flatten(self.items))
         return tuple(children)
 
     def getChildNodes(self):
         nodelist = []
-        if self.expr1 is not None:            nodelist.append(self.expr1)
-        if self.expr2 is not None:            nodelist.append(self.expr2)
-        if self.expr3 is not None:            nodelist.append(self.expr3)
+        nodelist.extend(flatten_nodes(self.items))
         return tuple(nodelist)
 
     def __repr__(self):
-        return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
+        return "Dict(%s)" % (repr(self.items),)
+
+class Discard(Node):
+    nodes["discard"] = "Discard"
+    def __init__(self, expr):
+        self.expr = expr
+
+    def getChildren(self):
+        return self.expr,
+
+    def getChildNodes(self):
+        return self.expr,
+
+    def __repr__(self):
+        return "Discard(%s)" % (repr(self.expr),)
+
+class Div(Node):
+    nodes["div"] = "Div"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "Div((%s, %s))" % (repr(self.left), repr(self.right))
+
+class Ellipsis(Node):
+    nodes["ellipsis"] = "Ellipsis"
+    def __init__(self, ):
+        pass
+
+    def getChildren(self):
+        return ()
+
+    def getChildNodes(self):
+        return ()
+
+    def __repr__(self):
+        return "Ellipsis()"
+
+class Exec(Node):
+    nodes["exec"] = "Exec"
+    def __init__(self, expr, locals, globals):
+        self.expr = expr
+        self.locals = locals
+        self.globals = globals
+
+    def getChildren(self):
+        children = []
+        children.append(self.expr)
+        children.append(self.locals)
+        children.append(self.globals)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.expr)
+        if self.locals is not None:            nodelist.append(self.locals)
+        if self.globals is not None:            nodelist.append(self.globals)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
+
+class FloorDiv(Node):
+    nodes["floordiv"] = "FloorDiv"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
 
 class For(Node):
     nodes["for"] = "For"
@@ -139,86 +545,6 @@
     def __repr__(self):
         return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
 
-class AssTuple(Node):
-    nodes["asstuple"] = "AssTuple"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "AssTuple(%s)" % (repr(self.nodes),)
-
-class Mul(Node):
-    nodes["mul"] = "Mul"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
-
-class Invert(Node):
-    nodes["invert"] = "Invert"
-    def __init__(self, expr):
-        self.expr = expr
-
-    def getChildren(self):
-        return self.expr,
-
-    def getChildNodes(self):
-        return self.expr,
-
-    def __repr__(self):
-        return "Invert(%s)" % (repr(self.expr),)
-
-class RightShift(Node):
-    nodes["rightshift"] = "RightShift"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
-
-class AssList(Node):
-    nodes["asslist"] = "AssList"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "AssList(%s)" % (repr(self.nodes),)
-
 class From(Node):
     nodes["from"] = "From"
     def __init__(self, modname, names):
@@ -234,6 +560,126 @@
     def __repr__(self):
         return "From(%s, %s)" % (repr(self.modname), repr(self.names))
 
+class Function(Node):
+    nodes["function"] = "Function"
+    def __init__(self, decorators, name, argnames, defaults, flags, doc, code):
+        self.decorators = decorators
+        self.name = name
+        self.argnames = argnames
+        self.defaults = defaults
+        self.flags = flags
+        self.doc = doc
+        self.code = code
+        self.varargs = self.kwargs = None
+        if flags & CO_VARARGS:
+            self.varargs = 1
+        if flags & CO_VARKEYWORDS:
+            self.kwargs = 1
+
+
+
+    def getChildren(self):
+        children = []
+        if self.decorators:
+            children.append(flatten(self.decorators.nodes))
+        children.append(self.name)
+        children.append(self.argnames)
+        children.extend(flatten(self.defaults))
+        children.append(self.flags)
+        children.append(self.doc)
+        children.append(self.code)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        if self.decorators:
+            nodelist.extend(flatten_nodes(self.decorators.nodes))
+        nodelist.extend(flatten_nodes(self.defaults))
+        nodelist.append(self.code)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
+
+class GenExpr(Node):
+    nodes["genexpr"] = "GenExpr"
+    def __init__(self, code):
+        self.code = code
+        self.argnames = ['[outmost-iterable]']
+        self.varargs = self.kwargs = None
+    
+
+
+    def getChildren(self):
+        return self.code,
+
+    def getChildNodes(self):
+        return self.code,
+
+    def __repr__(self):
+        return "GenExpr(%s)" % (repr(self.code),)
+
+class GenExprFor(Node):
+    nodes["genexprfor"] = "GenExprFor"
+    def __init__(self, assign, iter, ifs):
+        self.assign = assign
+        self.iter = iter
+        self.ifs = ifs
+        self.is_outmost = False
+
+
+    def getChildren(self):
+        children = []
+        children.append(self.assign)
+        children.append(self.iter)
+        children.extend(flatten(self.ifs))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.assign)
+        nodelist.append(self.iter)
+        nodelist.extend(flatten_nodes(self.ifs))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
+
+class GenExprIf(Node):
+    nodes["genexprif"] = "GenExprIf"
+    def __init__(self, test):
+        self.test = test
+
+    def getChildren(self):
+        return self.test,
+
+    def getChildNodes(self):
+        return self.test,
+
+    def __repr__(self):
+        return "GenExprIf(%s)" % (repr(self.test),)
+
+class GenExprInner(Node):
+    nodes["genexprinner"] = "GenExprInner"
+    def __init__(self, expr, quals):
+        self.expr = expr
+        self.quals = quals
+
+    def getChildren(self):
+        children = []
+        children.append(self.expr)
+        children.extend(flatten(self.quals))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.expr)
+        nodelist.extend(flatten_nodes(self.quals))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
+
 class Getattr(Node):
     nodes["getattr"] = "Getattr"
     def __init__(self, expr, attrname):
@@ -249,23 +695,222 @@
     def __repr__(self):
         return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
 
-class Dict(Node):
-    nodes["dict"] = "Dict"
-    def __init__(self, items):
-        self.items = items
+class Global(Node):
+    nodes["global"] = "Global"
+    def __init__(self, names):
+        self.names = names
+
+    def getChildren(self):
+        return self.names,
+
+    def getChildNodes(self):
+        return ()
+
+    def __repr__(self):
+        return "Global(%s)" % (repr(self.names),)
+
+class If(Node):
+    nodes["if"] = "If"
+    def __init__(self, tests, else_):
+        self.tests = tests
+        self.else_ = else_
 
     def getChildren(self):
         children = []
-        children.extend(flatten(self.items))
+        children.extend(flatten(self.tests))
+        children.append(self.else_)
         return tuple(children)
 
     def getChildNodes(self):
         nodelist = []
-        nodelist.extend(flatten_nodes(self.items))
+        nodelist.extend(flatten_nodes(self.tests))
+        if self.else_ is not None:            nodelist.append(self.else_)
         return tuple(nodelist)
 
     def __repr__(self):
-        return "Dict(%s)" % (repr(self.items),)
+        return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
+
+class Import(Node):
+    nodes["import"] = "Import"
+    def __init__(self, names):
+        self.names = names
+
+    def getChildren(self):
+        return self.names,
+
+    def getChildNodes(self):
+        return ()
+
+    def __repr__(self):
+        return "Import(%s)" % (repr(self.names),)
+
+class Invert(Node):
+    nodes["invert"] = "Invert"
+    def __init__(self, expr):
+        self.expr = expr
+
+    def getChildren(self):
+        return self.expr,
+
+    def getChildNodes(self):
+        return self.expr,
+
+    def __repr__(self):
+        return "Invert(%s)" % (repr(self.expr),)
+
+class Keyword(Node):
+    nodes["keyword"] = "Keyword"
+    def __init__(self, name, expr):
+        self.name = name
+        self.expr = expr
+
+    def getChildren(self):
+        return self.name, self.expr
+
+    def getChildNodes(self):
+        return self.expr,
+
+    def __repr__(self):
+        return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
+
+class Lambda(Node):
+    nodes["lambda"] = "Lambda"
+    def __init__(self, argnames, defaults, flags, code):
+        self.argnames = argnames
+        self.defaults = defaults
+        self.flags = flags
+        self.code = code
+        self.varargs = self.kwargs = None
+        if flags & CO_VARARGS:
+            self.varargs = 1
+        if flags & CO_VARKEYWORDS:
+            self.kwargs = 1
+    
+
+
+    def getChildren(self):
+        children = []
+        children.append(self.argnames)
+        children.extend(flatten(self.defaults))
+        children.append(self.flags)
+        children.append(self.code)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.defaults))
+        nodelist.append(self.code)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
+
+class LeftShift(Node):
+    nodes["leftshift"] = "LeftShift"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
+
+class List(Node):
+    nodes["list"] = "List"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "List(%s)" % (repr(self.nodes),)
+
+class ListComp(Node):
+    nodes["listcomp"] = "ListComp"
+    def __init__(self, expr, quals):
+        self.expr = expr
+        self.quals = quals
+
+    def getChildren(self):
+        children = []
+        children.append(self.expr)
+        children.extend(flatten(self.quals))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.expr)
+        nodelist.extend(flatten_nodes(self.quals))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
+
+class ListCompFor(Node):
+    nodes["listcompfor"] = "ListCompFor"
+    def __init__(self, assign, list, ifs):
+        self.assign = assign
+        self.list = list
+        self.ifs = ifs
+
+    def getChildren(self):
+        children = []
+        children.append(self.assign)
+        children.append(self.list)
+        children.extend(flatten(self.ifs))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.assign)
+        nodelist.append(self.list)
+        nodelist.extend(flatten_nodes(self.ifs))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
+
+class ListCompIf(Node):
+    nodes["listcompif"] = "ListCompIf"
+    def __init__(self, test):
+        self.test = test
+
+    def getChildren(self):
+        return self.test,
+
+    def getChildNodes(self):
+        return self.test,
+
+    def __repr__(self):
+        return "ListCompIf(%s)" % (repr(self.test),)
+
+class Mod(Node):
+    nodes["mod"] = "Mod"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
 
 class Module(Node):
     nodes["module"] = "Module"
@@ -282,23 +927,37 @@
     def __repr__(self):
         return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
 
-class Expression(Node):
-    # Expression is an artificial node class to support "eval"
-    nodes["expression"] = "Expression"
-    def __init__(self, node):
-        self.node = node
+class Mul(Node):
+    nodes["mul"] = "Mul"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
 
     def getChildren(self):
-        return self.node,
+        return self.left, self.right
 
     def getChildNodes(self):
-        return self.node,
+        return self.left, self.right
 
     def __repr__(self):
-        return "Expression(%s)" % (repr(self.node))
+        return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
 
-class UnaryAdd(Node):
-    nodes["unaryadd"] = "UnaryAdd"
+class Name(Node):
+    nodes["name"] = "Name"
+    def __init__(self, name):
+        self.name = name
+
+    def getChildren(self):
+        return self.name,
+
+    def getChildNodes(self):
+        return ()
+
+    def __repr__(self):
+        return "Name(%s)" % (repr(self.name),)
+
+class Not(Node):
+    nodes["not"] = "Not"
     def __init__(self, expr):
         self.expr = expr
 
@@ -309,10 +968,28 @@
         return self.expr,
 
     def __repr__(self):
-        return "UnaryAdd(%s)" % (repr(self.expr),)
+        return "Not(%s)" % (repr(self.expr),)
 
-class Ellipsis(Node):
-    nodes["ellipsis"] = "Ellipsis"
+class Or(Node):
+    nodes["or"] = "Or"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Or(%s)" % (repr(self.nodes),)
+
+class Pass(Node):
+    nodes["pass"] = "Pass"
     def __init__(self, ):
         pass
 
@@ -323,7 +1000,22 @@
         return ()
 
     def __repr__(self):
-        return "Ellipsis()"
+        return "Pass()"
+
+class Power(Node):
+    nodes["power"] = "Power"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "Power((%s, %s))" % (repr(self.left), repr(self.right))
 
 class Print(Node):
     nodes["print"] = "Print"
@@ -346,19 +1038,156 @@
     def __repr__(self):
         return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
 
-class Import(Node):
-    nodes["import"] = "Import"
-    def __init__(self, names):
-        self.names = names
+class Printnl(Node):
+    nodes["printnl"] = "Printnl"
+    def __init__(self, nodes, dest):
+        self.nodes = nodes
+        self.dest = dest
 
     def getChildren(self):
-        return self.names,
+        children = []
+        children.extend(flatten(self.nodes))
+        children.append(self.dest)
+        return tuple(children)
 
     def getChildNodes(self):
-        return ()
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        if self.dest is not None:            nodelist.append(self.dest)
+        return tuple(nodelist)
 
     def __repr__(self):
-        return "Import(%s)" % (repr(self.names),)
+        return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
+
+class Raise(Node):
+    nodes["raise"] = "Raise"
+    def __init__(self, expr1, expr2, expr3):
+        self.expr1 = expr1
+        self.expr2 = expr2
+        self.expr3 = expr3
+
+    def getChildren(self):
+        children = []
+        children.append(self.expr1)
+        children.append(self.expr2)
+        children.append(self.expr3)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        if self.expr1 is not None:            nodelist.append(self.expr1)
+        if self.expr2 is not None:            nodelist.append(self.expr2)
+        if self.expr3 is not None:            nodelist.append(self.expr3)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
+
+class Return(Node):
+    nodes["return"] = "Return"
+    def __init__(self, value):
+        self.value = value
+
+    def getChildren(self):
+        return self.value,
+
+    def getChildNodes(self):
+        return self.value,
+
+    def __repr__(self):
+        return "Return(%s)" % (repr(self.value),)
+
+class RightShift(Node):
+    nodes["rightshift"] = "RightShift"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
+
+class Slice(Node):
+    nodes["slice"] = "Slice"
+    def __init__(self, expr, flags, lower, upper):
+        self.expr = expr
+        self.flags = flags
+        self.lower = lower
+        self.upper = upper
+
+    def getChildren(self):
+        children = []
+        children.append(self.expr)
+        children.append(self.flags)
+        children.append(self.lower)
+        children.append(self.upper)
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.append(self.expr)
+        if self.lower is not None:            nodelist.append(self.lower)
+        if self.upper is not None:            nodelist.append(self.upper)
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
+
+class Sliceobj(Node):
+    nodes["sliceobj"] = "Sliceobj"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Sliceobj(%s)" % (repr(self.nodes),)
+
+class Stmt(Node):
+    nodes["stmt"] = "Stmt"
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def getChildren(self):
+        children = []
+        children.extend(flatten(self.nodes))
+        return tuple(children)
+
+    def getChildNodes(self):
+        nodelist = []
+        nodelist.extend(flatten_nodes(self.nodes))
+        return tuple(nodelist)
+
+    def __repr__(self):
+        return "Stmt(%s)" % (repr(self.nodes),)
+
+class Sub(Node):
+    nodes["sub"] = "Sub"
+    def __init__(self, (left, right)):
+        self.left = left
+        self.right = right
+
+    def getChildren(self):
+        return self.left, self.right
+
+    def getChildNodes(self):
+        return self.left, self.right
+
+    def __repr__(self):
+        return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
 
 class Subscript(Node):
     nodes["subscript"] = "Subscript"
@@ -407,231 +1236,6 @@
     def __repr__(self):
         return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
 
-class Or(Node):
-    nodes["or"] = "Or"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Or(%s)" % (repr(self.nodes),)
-
-class Name(Node):
-    nodes["name"] = "Name"
-    def __init__(self, name):
-        self.name = name
-
-    def getChildren(self):
-        return self.name,
-
-    def getChildNodes(self):
-        return ()
-
-    def __repr__(self):
-        return "Name(%s)" % (repr(self.name),)
-
-class Function(Node):
-    nodes["function"] = "Function"
-    def __init__(self, name, argnames, defaults, flags, doc, code):
-        self.name = name
-        self.argnames = argnames
-        self.defaults = defaults
-        self.flags = flags
-        self.doc = doc
-        self.code = code
-        self.varargs = self.kwargs = None
-        if flags & CO_VARARGS:
-            self.varargs = 1
-        if flags & CO_VARKEYWORDS:
-            self.kwargs = 1
-
-
-
-    def getChildren(self):
-        children = []
-        children.append(self.name)
-        children.append(self.argnames)
-        children.extend(flatten(self.defaults))
-        children.append(self.flags)
-        children.append(self.doc)
-        children.append(self.code)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.defaults))
-        nodelist.append(self.code)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Function(%s, %s, %s, %s, %s, %s)" % (repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
-
-class Assert(Node):
-    nodes["assert"] = "Assert"
-    def __init__(self, test, fail):
-        self.test = test
-        self.fail = fail
-
-    def getChildren(self):
-        children = []
-        children.append(self.test)
-        children.append(self.fail)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.test)
-        if self.fail is not None:            nodelist.append(self.fail)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
-
-class Return(Node):
-    nodes["return"] = "Return"
-    def __init__(self, value):
-        self.value = value
-
-    def getChildren(self):
-        return self.value,
-
-    def getChildNodes(self):
-        return self.value,
-
-    def __repr__(self):
-        return "Return(%s)" % (repr(self.value),)
-
-class Power(Node):
-    nodes["power"] = "Power"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "Power((%s, %s))" % (repr(self.left), repr(self.right))
-
-class Exec(Node):
-    nodes["exec"] = "Exec"
-    def __init__(self, expr, locals, globals):
-        self.expr = expr
-        self.locals = locals
-        self.globals = globals
-
-    def getChildren(self):
-        children = []
-        children.append(self.expr)
-        children.append(self.locals)
-        children.append(self.globals)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.expr)
-        if self.locals is not None:            nodelist.append(self.locals)
-        if self.globals is not None:            nodelist.append(self.globals)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
-
-class Stmt(Node):
-    nodes["stmt"] = "Stmt"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Stmt(%s)" % (repr(self.nodes),)
-
-class Sliceobj(Node):
-    nodes["sliceobj"] = "Sliceobj"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Sliceobj(%s)" % (repr(self.nodes),)
-
-class Break(Node):
-    nodes["break"] = "Break"
-    def __init__(self, ):
-        pass
-
-    def getChildren(self):
-        return ()
-
-    def getChildNodes(self):
-        return ()
-
-    def __repr__(self):
-        return "Break()"
-
-class Bitand(Node):
-    nodes["bitand"] = "Bitand"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Bitand(%s)" % (repr(self.nodes),)
-
-class FloorDiv(Node):
-    nodes["floordiv"] = "FloorDiv"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
-
 class TryFinally(Node):
     nodes["tryfinally"] = "TryFinally"
     def __init__(self, body, final):
@@ -647,81 +1251,6 @@
     def __repr__(self):
         return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
 
-class Not(Node):
-    nodes["not"] = "Not"
-    def __init__(self, expr):
-        self.expr = expr
-
-    def getChildren(self):
-        return self.expr,
-
-    def getChildNodes(self):
-        return self.expr,
-
-    def __repr__(self):
-        return "Not(%s)" % (repr(self.expr),)
-
-class Class(Node):
-    nodes["class"] = "Class"
-    def __init__(self, name, bases, doc, code):
-        self.name = name
-        self.bases = bases
-        self.doc = doc
-        self.code = code
-
-    def getChildren(self):
-        children = []
-        children.append(self.name)
-        children.extend(flatten(self.bases))
-        children.append(self.doc)
-        children.append(self.code)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.bases))
-        nodelist.append(self.code)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
-
-class Mod(Node):
-    nodes["mod"] = "Mod"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
-
-class Printnl(Node):
-    nodes["printnl"] = "Printnl"
-    def __init__(self, nodes, dest):
-        self.nodes = nodes
-        self.dest = dest
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        children.append(self.dest)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        if self.dest is not None:            nodelist.append(self.dest)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
-
 class Tuple(Node):
     nodes["tuple"] = "Tuple"
     def __init__(self, nodes):
@@ -740,114 +1269,33 @@
     def __repr__(self):
         return "Tuple(%s)" % (repr(self.nodes),)
 
-class AssAttr(Node):
-    nodes["assattr"] = "AssAttr"
-    def __init__(self, expr, attrname, flags):
+class UnaryAdd(Node):
+    nodes["unaryadd"] = "UnaryAdd"
+    def __init__(self, expr):
         self.expr = expr
-        self.attrname = attrname
-        self.flags = flags
 
     def getChildren(self):
-        return self.expr, self.attrname, self.flags
+        return self.expr,
 
     def getChildNodes(self):
         return self.expr,
 
     def __repr__(self):
-        return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
+        return "UnaryAdd(%s)" % (repr(self.expr),)
 
-class Keyword(Node):
-    nodes["keyword"] = "Keyword"
-    def __init__(self, name, expr):
-        self.name = name
+class UnarySub(Node):
+    nodes["unarysub"] = "UnarySub"
+    def __init__(self, expr):
         self.expr = expr
 
     def getChildren(self):
-        return self.name, self.expr
+        return self.expr,
 
     def getChildNodes(self):
         return self.expr,
 
     def __repr__(self):
-        return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
-
-class AugAssign(Node):
-    nodes["augassign"] = "AugAssign"
-    def __init__(self, node, op, expr):
-        self.node = node
-        self.op = op
-        self.expr = expr
-
-    def getChildren(self):
-        return self.node, self.op, self.expr
-
-    def getChildNodes(self):
-        return self.node, self.expr
-
-    def __repr__(self):
-        return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
-
-class List(Node):
-    nodes["list"] = "List"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "List(%s)" % (repr(self.nodes),)
-
-class Yield(Node):
-    nodes["yield"] = "Yield"
-    def __init__(self, value):
-        self.value = value
-
-    def getChildren(self):
-        return self.value,
-
-    def getChildNodes(self):
-        return self.value,
-
-    def __repr__(self):
-        return "Yield(%s)" % (repr(self.value),)
-
-class LeftShift(Node):
-    nodes["leftshift"] = "LeftShift"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
-
-class AssName(Node):
-    nodes["assname"] = "AssName"
-    def __init__(self, name, flags):
-        self.name = name
-        self.flags = flags
-
-    def getChildren(self):
-        return self.name, self.flags
-
-    def getChildNodes(self):
-        return ()
-
-    def __repr__(self):
-        return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
+        return "UnarySub(%s)" % (repr(self.expr),)
 
 class While(Node):
     nodes["while"] = "While"
@@ -873,444 +1321,19 @@
     def __repr__(self):
         return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
 
-class Continue(Node):
-    nodes["continue"] = "Continue"
-    def __init__(self, ):
-        pass
+class Yield(Node):
+    nodes["yield"] = "Yield"
+    def __init__(self, value):
+        self.value = value
 
     def getChildren(self):
-        return ()
+        return self.value,
 
     def getChildNodes(self):
-        return ()
+        return self.value,
 
     def __repr__(self):
-        return "Continue()"
-
-class Backquote(Node):
-    nodes["backquote"] = "Backquote"
-    def __init__(self, expr):
-        self.expr = expr
-
-    def getChildren(self):
-        return self.expr,
-
-    def getChildNodes(self):
-        return self.expr,
-
-    def __repr__(self):
-        return "Backquote(%s)" % (repr(self.expr),)
-
-class Discard(Node):
-    nodes["discard"] = "Discard"
-    def __init__(self, expr):
-        self.expr = expr
-
-    def getChildren(self):
-        return self.expr,
-
-    def getChildNodes(self):
-        return self.expr,
-
-    def __repr__(self):
-        return "Discard(%s)" % (repr(self.expr),)
-
-class Div(Node):
-    nodes["div"] = "Div"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "Div((%s, %s))" % (repr(self.left), repr(self.right))
-
-class Assign(Node):
-    nodes["assign"] = "Assign"
-    def __init__(self, nodes, expr):
-        self.nodes = nodes
-        self.expr = expr
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        children.append(self.expr)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        nodelist.append(self.expr)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
-
-class Lambda(Node):
-    nodes["lambda"] = "Lambda"
-    def __init__(self, argnames, defaults, flags, code):
-        self.argnames = argnames
-        self.defaults = defaults
-        self.flags = flags
-        self.code = code
-        self.varargs = self.kwargs = None
-        if flags & CO_VARARGS:
-            self.varargs = 1
-        if flags & CO_VARKEYWORDS:
-            self.kwargs = 1
-
-
-    def getChildren(self):
-        children = []
-        children.append(self.argnames)
-        children.extend(flatten(self.defaults))
-        children.append(self.flags)
-        children.append(self.code)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.defaults))
-        nodelist.append(self.code)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
-
-class And(Node):
-    nodes["and"] = "And"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "And(%s)" % (repr(self.nodes),)
-
-class Compare(Node):
-    nodes["compare"] = "Compare"
-    def __init__(self, expr, ops):
-        self.expr = expr
-        self.ops = ops
-
-    def getChildren(self):
-        children = []
-        children.append(self.expr)
-        children.extend(flatten(self.ops))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.expr)
-        nodelist.extend(flatten_nodes(self.ops))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
-
-class Bitor(Node):
-    nodes["bitor"] = "Bitor"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Bitor(%s)" % (repr(self.nodes),)
-
-class Bitxor(Node):
-    nodes["bitxor"] = "Bitxor"
-    def __init__(self, nodes):
-        self.nodes = nodes
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.nodes))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.nodes))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "Bitxor(%s)" % (repr(self.nodes),)
-
-class CallFunc(Node):
-    nodes["callfunc"] = "CallFunc"
-    def __init__(self, node, args, star_args = None, dstar_args = None):
-        self.node = node
-        self.args = args
-        self.star_args = star_args
-        self.dstar_args = dstar_args
-
-    def getChildren(self):
-        children = []
-        children.append(self.node)
-        children.extend(flatten(self.args))
-        children.append(self.star_args)
-        children.append(self.dstar_args)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.node)
-        nodelist.extend(flatten_nodes(self.args))
-        if self.star_args is not None:            nodelist.append(self.star_args)
-        if self.dstar_args is not None:            nodelist.append(self.dstar_args)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
-
-class Global(Node):
-    nodes["global"] = "Global"
-    def __init__(self, names):
-        self.names = names
-
-    def getChildren(self):
-        return self.names,
-
-    def getChildNodes(self):
-        return ()
-
-    def __repr__(self):
-        return "Global(%s)" % (repr(self.names),)
-
-class Add(Node):
-    nodes["add"] = "Add"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "Add((%s, %s))" % (repr(self.left), repr(self.right))
-
-class ListCompIf(Node):
-    nodes["listcompif"] = "ListCompIf"
-    def __init__(self, test):
-        self.test = test
-
-    def getChildren(self):
-        return self.test,
-
-    def getChildNodes(self):
-        return self.test,
-
-    def __repr__(self):
-        return "ListCompIf(%s)" % (repr(self.test),)
-
-class Sub(Node):
-    nodes["sub"] = "Sub"
-    def __init__(self, (left, right)):
-        self.left = left
-        self.right = right
-
-    def getChildren(self):
-        return self.left, self.right
-
-    def getChildNodes(self):
-        return self.left, self.right
-
-    def __repr__(self):
-        return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
-
-class Pass(Node):
-    nodes["pass"] = "Pass"
-    def __init__(self, ):
-        pass
-
-    def getChildren(self):
-        return ()
-
-    def getChildNodes(self):
-        return ()
-
-    def __repr__(self):
-        return "Pass()"
-
-class UnarySub(Node):
-    nodes["unarysub"] = "UnarySub"
-    def __init__(self, expr):
-        self.expr = expr
-
-    def getChildren(self):
-        return self.expr,
-
-    def getChildNodes(self):
-        return self.expr,
-
-    def __repr__(self):
-        return "UnarySub(%s)" % (repr(self.expr),)
-
-class If(Node):
-    nodes["if"] = "If"
-    def __init__(self, tests, else_):
-        self.tests = tests
-        self.else_ = else_
-
-    def getChildren(self):
-        children = []
-        children.extend(flatten(self.tests))
-        children.append(self.else_)
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.extend(flatten_nodes(self.tests))
-        if self.else_ is not None:            nodelist.append(self.else_)
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
-
-class ListComp(Node):
-    nodes["listcomp"] = "ListComp"
-    def __init__(self, expr, quals):
-        self.expr = expr
-        self.quals = quals
-
-    def getChildren(self):
-        children = []
-        children.append(self.expr)
-        children.extend(flatten(self.quals))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.expr)
-        nodelist.extend(flatten_nodes(self.quals))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
-
-class ListCompFor(Node):
-    nodes["listcompfor"] = "ListCompFor"
-    def __init__(self, assign, list, ifs):
-        self.assign = assign
-        self.list = list
-        self.ifs = ifs
-
-    def getChildren(self):
-        children = []
-        children.append(self.assign)
-        children.append(self.list)
-        children.extend(flatten(self.ifs))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.assign)
-        nodelist.append(self.list)
-        nodelist.extend(flatten_nodes(self.ifs))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
-
-class GenExpr(Node):
-    nodes["genexpr"] = "GenExpr"
-    def __init__(self, code):
-        self.code = code
-        self.argnames = ['[outmost-iterable]']
-        self.varargs = self.kwargs = None
-
-    def getChildren(self):
-        return self.code,
-
-    def getChildNodes(self):
-        return self.code,
-
-    def __repr__(self):
-        return "GenExpr(%s)" % (repr(self.code),)
-
-class GenExprInner(Node):
-    nodes["genexprinner"] = "GenExprInner"
-    def __init__(self, expr, quals):
-        self.expr = expr
-        self.quals = quals
-
-    def getChildren(self):
-        children = []
-        children.append(self.expr)
-        children.extend(flatten(self.quals))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.expr)
-        nodelist.extend(flatten_nodes(self.quals))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
-
-class GenExprFor(Node):
-    nodes["genexprfor"] = "GenExprFor"
-    def __init__(self, assign, iter, ifs):
-        self.assign = assign
-        self.iter = iter
-        self.ifs = ifs
-        self.is_outmost = False
-
-    def getChildren(self):
-        children = []
-        children.append(self.assign)
-        children.append(self.iter)
-        children.extend(flatten(self.ifs))
-        return tuple(children)
-
-    def getChildNodes(self):
-        nodelist = []
-        nodelist.append(self.assign)
-        nodelist.append(self.iter)
-        nodelist.extend(flatten_nodes(self.ifs))
-        return tuple(nodelist)
-
-    def __repr__(self):
-        return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
-
-class GenExprIf(Node):
-    nodes["genexprif"] = "GenExprIf"
-    def __init__(self, test):
-        self.test = test
-
-    def getChildren(self):
-        return self.test,
-
-    def getChildNodes(self):
-        return self.test,
-
-    def __repr__(self):
-        return "GenExprIf(%s)" % (repr(self.test),)
+        return "Yield(%s)" % (repr(self.value),)
 
 klasses = globals()
 for k in nodes.keys():
diff --git a/Lib/compiler/pycodegen.py b/Lib/compiler/pycodegen.py
index 4d5f728..e859ac5 100644
--- a/Lib/compiler/pycodegen.py
+++ b/Lib/compiler/pycodegen.py
@@ -366,6 +366,13 @@
         self._visitFuncOrLambda(node, isLambda=1)
 
     def _visitFuncOrLambda(self, node, isLambda=0):
+        if not isLambda and node.decorators:
+            for decorator in reversed(node.decorators.nodes):
+                self.visit(decorator)
+            ndecorators = len(node.decorators.nodes)
+        else:
+            ndecorators = 0
+            
         gen = self.FunctionGen(node, self.scopes, isLambda,
                                self.class_name, self.get_module())
         walk(node.code, gen)
@@ -382,6 +389,9 @@
         else:
             self.emit('LOAD_CONST', gen)
             self.emit('MAKE_FUNCTION', len(node.defaults))
+            
+        for i in range(ndecorators):
+            self.emit('CALL_FUNCTION', 1)
 
     def visitClass(self, node):
         gen = self.ClassGen(node, self.scopes,
diff --git a/Lib/compiler/symbols.py b/Lib/compiler/symbols.py
index e1581a4..9d4605a 100644
--- a/Lib/compiler/symbols.py
+++ b/Lib/compiler/symbols.py
@@ -224,6 +224,8 @@
     visitExpression = visitModule
 
     def visitFunction(self, node, parent):
+        if node.decorators:
+            self.visit(node.decorators, parent)
         parent.add_def(node.name)
         for n in node.defaults:
             self.visit(n, parent)
diff --git a/Lib/compiler/transformer.py b/Lib/compiler/transformer.py
index aa5a28b..229657b 100644
--- a/Lib/compiler/transformer.py
+++ b/Lib/compiler/transformer.py
@@ -185,29 +185,81 @@
         ### is this sufficient?
         return Expression(self.com_node(nodelist[0]))
 
+    def decorator_name(self, nodelist):
+        listlen = len(nodelist)
+        assert listlen >= 1 and listlen % 2 == 1
+
+        item = self.atom_name(nodelist)
+        i = 1
+        while i < listlen:
+            assert nodelist[i][0] == token.DOT
+            assert nodelist[i + 1][0] == token.NAME
+            item = Getattr(item, nodelist[i + 1][1])
+            i += 2
+
+        return item
+        
+    def decorator(self, nodelist):
+        # '@' dotted_name [ '(' [arglist] ')' ]
+        assert len(nodelist) in (2, 4, 5)
+        assert nodelist[0][0] == token.AT
+
+        assert nodelist[1][0] == symbol.dotted_name
+        funcname = self.decorator_name(nodelist[1][1:])
+
+        if len(nodelist) > 2:
+            assert nodelist[2][0] == token.LPAR
+            expr = self.com_call_function(funcname, nodelist[3])
+        else:
+            expr = funcname
+            
+        return expr
+    
+    def decorators(self, nodelist):
+        # decorators: decorator ([NEWLINE] decorator)* NEWLINE
+        listlen = len(nodelist)
+        i = 0
+        items = []
+        while i < listlen:
+            assert nodelist[i][0] == symbol.decorator
+            items.append(self.decorator(nodelist[i][1:]))
+            i += 1
+
+            if i < listlen and nodelist[i][0] == token.NEWLINE:
+                i += 1
+        return Decorators(items)
+    
     def funcdef(self, nodelist):
-        # funcdef: 'def' NAME parameters ':' suite
+        #                    -6   -5    -4         -3  -2    -1
+        # funcdef: [decorators] 'def' NAME parameters ':' suite
         # parameters: '(' [varargslist] ')'
 
-        lineno = nodelist[1][2]
-        name = nodelist[1][1]
-        args = nodelist[2][2]
+        if len(nodelist) == 6:
+            assert nodelist[0][0] == symbol.decorators
+            decorators = self.decorators(nodelist[0][1:])
+        else:
+            assert len(nodelist) == 5
+            decorators = None
+            
+        lineno = nodelist[-4][2]
+        name = nodelist[-4][1]
+        args = nodelist[-3][2]
 
         if args[0] == symbol.varargslist:
             names, defaults, flags = self.com_arglist(args[1:])
         else:
             names = defaults = ()
             flags = 0
-        doc = self.get_docstring(nodelist[4])
+        doc = self.get_docstring(nodelist[-1])
 
         # code for function
-        code = self.com_node(nodelist[4])
+        code = self.com_node(nodelist[-1])
 
         if doc is not None:
             assert isinstance(code, Stmt)
             assert isinstance(code.nodes[0], Discard)
             del code.nodes[0]
-        n = Function(name, names, defaults, flags, doc, code)
+        n = Function(decorators, name, names, defaults, flags, doc, code)
         n.lineno = lineno
         return n
 
diff --git a/Lib/pyclbr.py b/Lib/pyclbr.py
index 9e6bcb0..0812e22 100644
--- a/Lib/pyclbr.py
+++ b/Lib/pyclbr.py
@@ -222,7 +222,7 @@
                         else:
                             super.append(token)
                     inherit = names
-                cur_class = Class(module, class_name, inherit, file, lineno)
+                cur_class = Class(fullmodule, class_name, inherit, file, lineno)
                 if not stack:
                     dict[class_name] = cur_class
                 stack.append((cur_class, thisindent))
diff --git a/Lib/symbol.py b/Lib/symbol.py
index c839e4a..cb57208 100755
--- a/Lib/symbol.py
+++ b/Lib/symbol.py
@@ -13,75 +13,77 @@
 single_input = 256
 file_input = 257
 eval_input = 258
-funcdef = 259
-parameters = 260
-varargslist = 261
-fpdef = 262
-fplist = 263
-stmt = 264
-simple_stmt = 265
-small_stmt = 266
-expr_stmt = 267
-augassign = 268
-print_stmt = 269
-del_stmt = 270
-pass_stmt = 271
-flow_stmt = 272
-break_stmt = 273
-continue_stmt = 274
-return_stmt = 275
-yield_stmt = 276
-raise_stmt = 277
-import_stmt = 278
-import_as_name = 279
-dotted_as_name = 280
-dotted_name = 281
-global_stmt = 282
-exec_stmt = 283
-assert_stmt = 284
-compound_stmt = 285
-if_stmt = 286
-while_stmt = 287
-for_stmt = 288
-try_stmt = 289
-except_clause = 290
-suite = 291
-test = 292
-and_test = 293
-not_test = 294
-comparison = 295
-comp_op = 296
-expr = 297
-xor_expr = 298
-and_expr = 299
-shift_expr = 300
-arith_expr = 301
-term = 302
-factor = 303
-power = 304
-atom = 305
-listmaker = 306
-testlist_gexp = 307
-lambdef = 308
-trailer = 309
-subscriptlist = 310
-subscript = 311
-sliceop = 312
-exprlist = 313
-testlist = 314
-testlist_safe = 315
-dictmaker = 316
-classdef = 317
-arglist = 318
-argument = 319
-list_iter = 320
-list_for = 321
-list_if = 322
-gen_iter = 323
-gen_for = 324
-gen_if = 325
-testlist1 = 326
-encoding_decl = 327
+decorator = 259
+decorators = 260
+funcdef = 261
+parameters = 262
+varargslist = 263
+fpdef = 264
+fplist = 265
+stmt = 266
+simple_stmt = 267
+small_stmt = 268
+expr_stmt = 269
+augassign = 270
+print_stmt = 271
+del_stmt = 272
+pass_stmt = 273
+flow_stmt = 274
+break_stmt = 275
+continue_stmt = 276
+return_stmt = 277
+yield_stmt = 278
+raise_stmt = 279
+import_stmt = 280
+import_as_name = 281
+dotted_as_name = 282
+dotted_name = 283
+global_stmt = 284
+exec_stmt = 285
+assert_stmt = 286
+compound_stmt = 287
+if_stmt = 288
+while_stmt = 289
+for_stmt = 290
+try_stmt = 291
+except_clause = 292
+suite = 293
+test = 294
+and_test = 295
+not_test = 296
+comparison = 297
+comp_op = 298
+expr = 299
+xor_expr = 300
+and_expr = 301
+shift_expr = 302
+arith_expr = 303
+term = 304
+factor = 305
+power = 306
+atom = 307
+listmaker = 308
+testlist_gexp = 309
+lambdef = 310
+trailer = 311
+subscriptlist = 312
+subscript = 313
+sliceop = 314
+exprlist = 315
+testlist = 316
+testlist_safe = 317
+dictmaker = 318
+classdef = 319
+arglist = 320
+argument = 321
+list_iter = 322
+list_for = 323
+list_if = 324
+gen_iter = 325
+gen_for = 326
+gen_if = 327
+testlist1 = 328
+encoding_decl = 329
 #--end constants--
 
 sym_name = {}
diff --git a/Lib/test/output/test_tokenize b/Lib/test/output/test_tokenize
index ea55181..b78a223 100644
--- a/Lib/test/output/test_tokenize
+++ b/Lib/test/output/test_tokenize
@@ -645,4 +645,15 @@
 174,29-174,30:	OP	')'
 174,30-174,31:	NEWLINE	'\n'
 175,0-175,1:	NL	'\n'
-176,0-176,0:	ENDMARKER	''
+176,0-176,1:	OP	'@'
+176,1-176,13:	NAME	'staticmethod'
+176,13-176,14:	NEWLINE	'\n'
+177,0-177,3:	NAME	'def'
+177,4-177,7:	NAME	'foo'
+177,7-177,8:	OP	'('
+177,8-177,9:	OP	')'
+177,9-177,10:	OP	':'
+177,11-177,15:	NAME	'pass'
+177,15-177,16:	NEWLINE	'\n'
+178,0-178,1:	NL	'\n'
+179,0-179,0:	ENDMARKER	''
diff --git a/Lib/test/pyclbr_input.py b/Lib/test/pyclbr_input.py
new file mode 100644
index 0000000..b410fcc
--- /dev/null
+++ b/Lib/test/pyclbr_input.py
@@ -0,0 +1,33 @@
+"""Test cases for test_pyclbr.py"""
+
+def f(): pass
+
+class Other(object):
+    @classmethod
+    def foo(c): pass
+
+    def om(self): pass
+
+class B (object):
+    def bm(self): pass
+    
+class C (B):
+    foo = Other().foo
+    om = Other.om
+    
+    d = 10
+
+    # XXX: This causes test_pyclbr.py to fail, but only because the
+    #      introspection-based is_method() code in the test can't
+    #      distinguish between this and a geniune method function like m().
+    #      The pyclbr.py module gets this right as it parses the text.
+    #
+    #f = f
+    
+    def m(self): pass
+    
+    @staticmethod
+    def sm(self): pass
+
+    @classmethod
+    def cm(self): pass
diff --git a/Lib/test/test_decorators.py b/Lib/test/test_decorators.py
new file mode 100644
index 0000000..98d5d3e
--- /dev/null
+++ b/Lib/test/test_decorators.py
@@ -0,0 +1,194 @@
+import unittest
+from test import test_support
+
+def funcattrs(**kwds):
+    def decorate(func):
+        func.__dict__.update(kwds)
+        return func
+    return decorate
+
+class MiscDecorators (object):
+    @staticmethod
+    def author(name):
+        def decorate(func):
+            func.__dict__['author'] = name
+            return func
+        return decorate
+
+# -----------------------------------------------
+
+class DbcheckError (Exception):
+    def __init__(self, exprstr, func, args, kwds):
+        # A real version of this would set attributes here
+        Exception.__init__(self, "dbcheck %r failed (func=%s args=%s kwds=%s)" %
+                           (exprstr, func, args, kwds))
+    
+    
+def dbcheck(exprstr, globals=None, locals=None):
+    "Decorator to implement debugging assertions"
+    def decorate(func):
+        expr = compile(exprstr, "dbcheck-%s" % func.func_name, "eval")
+        def check(*args, **kwds):
+            if not eval(expr, globals, locals):
+                raise DbcheckError(exprstr, func, args, kwds)
+            return func(*args, **kwds)
+        return check
+    return decorate
+
+# -----------------------------------------------
+
+def countcalls(counts):
+    "Decorator to count calls to a function"
+    def decorate(func):
+        name = func.func_name
+        counts[name] = 0
+        def call(*args, **kwds):
+            counts[name] += 1
+            return func(*args, **kwds)
+        # XXX: Would like to say: call.func_name = func.func_name here
+        #      to make nested decorators work in any order, but func_name
+        #      is a readonly attribute
+        return call
+    return decorate
+
+# -----------------------------------------------
+
+def memoize(func):
+    saved = {}
+    def call(*args):
+        try:
+            return saved[args]
+        except KeyError:
+            res = func(*args)
+            saved[args] = res
+            return res
+        except TypeError:
+            # Unhashable argument
+            return func(*args)
+    return call
+            
+# -----------------------------------------------
+
+class TestDecorators(unittest.TestCase):
+
+    def test_single(self):
+        class C(object):
+            @staticmethod
+            def foo(): return 42
+        self.assertEqual(C.foo(), 42)
+        self.assertEqual(C().foo(), 42)
+
+    def test_dotted(self):
+        decorators = MiscDecorators()
+        @decorators.author('Cleese')
+        def foo(): return 42
+        self.assertEqual(foo(), 42)
+        self.assertEqual(foo.author, 'Cleese')
+
+    def test_argforms(self):
+        # A few tests of argument passing, as we use restricted form
+        # of expressions for decorators.
+        
+        def noteargs(*args, **kwds):
+            def decorate(func):
+                setattr(func, 'dbval', (args, kwds))
+                return func
+            return decorate
+
+        args = ( 'Now', 'is', 'the', 'time' )
+        kwds = dict(one=1, two=2)
+        @noteargs(*args, **kwds)
+        def f1(): return 42
+        self.assertEqual(f1(), 42)
+        self.assertEqual(f1.dbval, (args, kwds))
+
+        @noteargs('terry', 'gilliam', eric='idle', john='cleese')
+        def f2(): return 84
+        self.assertEqual(f2(), 84)
+        self.assertEqual(f2.dbval, (('terry', 'gilliam'),
+                                     dict(eric='idle', john='cleese')))
+
+        @noteargs(1, 2,)
+        def f3(): pass
+        self.assertEqual(f3.dbval, ((1, 2), {}))
+
+    def test_dbcheck(self):
+        @dbcheck('args[1] is not None')
+        def f(a, b):
+            return a + b
+        self.assertEqual(f(1, 2), 3)
+        self.assertRaises(DbcheckError, f, 1, None)
+
+    def test_memoize(self):
+        # XXX: This doesn't work unless memoize is the last decorator -
+        #      see the comment in countcalls.
+        counts = {}
+        @countcalls(counts) @memoize 
+        def double(x):
+            return x * 2
+
+        self.assertEqual(counts, dict(double=0))
+
+        # Only the first call with a given argument bumps the call count:
+        #
+        self.assertEqual(double(2), 4)
+        self.assertEqual(counts['double'], 1)
+        self.assertEqual(double(2), 4)
+        self.assertEqual(counts['double'], 1)
+        self.assertEqual(double(3), 6)
+        self.assertEqual(counts['double'], 2)
+
+        # Unhashable arguments do not get memoized:
+        #
+        self.assertEqual(double([10]), [10, 10])
+        self.assertEqual(counts['double'], 3)
+        self.assertEqual(double([10]), [10, 10])
+        self.assertEqual(counts['double'], 4)
+
+    def test_errors(self):
+        # Test syntax restrictions - these are all compile-time errors:
+        #
+        for expr in [ "1+2", "x[3]", "(1, 2)" ]:
+            # Sanity check: is expr is a valid expression by itself?
+            compile(expr, "testexpr", "exec")
+            
+            codestr = "@%s\ndef f(): pass" % expr
+            self.assertRaises(SyntaxError, compile, codestr, "test", "exec")
+
+        # Test runtime errors
+
+        def unimp(func):
+            raise NotImplementedError
+        context = dict(nullval=None, unimp=unimp)
+        
+        for expr, exc in [ ("undef", NameError),
+                           ("nullval", TypeError),
+                           ("nullval.attr", AttributeError),
+                           ("unimp", NotImplementedError)]:
+            codestr = "@%s\ndef f(): pass\nassert f() is None" % expr
+            code = compile(codestr, "test", "exec")
+            self.assertRaises(exc, eval, code, context)
+
+    def test_double(self):
+        class C(object):
+            @funcattrs(abc=1, xyz="haha")
+            @funcattrs(booh=42)
+            def foo(self): return 42
+        self.assertEqual(C().foo(), 42)
+        self.assertEqual(C.foo.abc, 1)
+        self.assertEqual(C.foo.xyz, "haha")
+        self.assertEqual(C.foo.booh, 42)
+
+    def test_order(self):
+        class C(object):
+            @funcattrs(abc=1) @staticmethod
+            def foo(): return 42
+        # This wouldn't work if staticmethod was called first
+        self.assertEqual(C.foo(), 42)
+        self.assertEqual(C().foo(), 42)
+
+def test_main():
+    test_support.run_unittest(TestDecorators)
+
+if __name__=="__main__":
+    test_main()
diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py
index 9652f6b..978ce57 100644
--- a/Lib/test/test_parser.py
+++ b/Lib/test/test_parser.py
@@ -15,8 +15,8 @@
         t = st1.totuple()
         try:
             st2 = parser.sequence2st(t)
-        except parser.ParserError:
-            self.fail("could not roundtrip %r" % s)
+        except parser.ParserError, why:
+            self.fail("could not roundtrip %r: %s" % (s, why))
 
         self.assertEquals(t, st2.totuple(),
                           "could not re-generate syntax tree")
@@ -119,6 +119,14 @@
         self.check_suite("def f(a, b, foo=bar, *args, **kw): pass")
         self.check_suite("def f(a, b, foo=bar, **kw): pass")
 
+        self.check_suite("@staticmethod\n"
+                         "def f(): pass")
+        self.check_suite("@staticmethod\n"
+                         "@funcattrs(x, y)\n"
+                         "def f(): pass")
+        self.check_suite("@funcattrs()\n"
+                         "def f(): pass")
+
     def test_import_from_statement(self):
         self.check_suite("from sys.path import *")
         self.check_suite("from sys.path import dirname")
diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py
index 48e8bf7..eddd593 100644
--- a/Lib/test/test_pyclbr.py
+++ b/Lib/test/test_pyclbr.py
@@ -8,6 +8,9 @@
 import pyclbr
 from unittest import TestCase
 
+StaticMethodType = type(staticmethod(lambda: None))
+ClassMethodType = type(classmethod(lambda c: None))
+
 # This next line triggers an error on old versions of pyclbr.
 
 from commands import getstatus
@@ -43,11 +46,10 @@
             print >>sys.stderr, "***",key
         self.failUnless(obj.has_key(key))
 
-    def assertEquals(self, a, b, ignore=None):
+    def assertEqualsOrIgnored(self, a, b, ignore):
         ''' succeed iff a == b or a in ignore or b in ignore '''
-        if (ignore == None) or (a in ignore) or (b in ignore): return
-
-        unittest.TestCase.assertEquals(self, a, b)
+        if a not in ignore and b not in ignore:
+            self.assertEquals(a, b)
 
     def checkModule(self, moduleName, module=None, ignore=()):
         ''' succeed iff pyclbr.readmodule_ex(modulename) corresponds
@@ -62,11 +64,22 @@
 
         dict = pyclbr.readmodule_ex(moduleName)
 
-        def ismethod(obj, name):
-            if not  isinstance(obj, MethodType):
-                return False
-            if obj.im_self is not None:
-                return False
+        def ismethod(oclass, obj, name):
+            classdict = oclass.__dict__
+            if isinstance(obj, FunctionType):
+                if not isinstance(classdict[name], StaticMethodType):
+                    return False
+            else:
+                if not  isinstance(obj, MethodType):
+                    return False
+                if obj.im_self is not None:
+                    if (not isinstance(classdict[name], ClassMethodType) or
+                        obj.im_self is not oclass):
+                        return False
+                else:
+                    if not isinstance(classdict[name], FunctionType):
+                        return False
+
             objname = obj.__name__
             if objname.startswith("__") and not objname.endswith("__"):
                 objname = "_%s%s" % (obj.im_class.__name__, objname)
@@ -81,7 +94,7 @@
             if isinstance(value, pyclbr.Function):
                 self.assertEquals(type(py_item), FunctionType)
             else:
-                self.assertEquals(type(py_item), ClassType)
+                self.failUnless(isinstance(py_item, (ClassType, type)))
                 real_bases = [base.__name__ for base in py_item.__bases__]
                 pyclbr_bases = [ getattr(base, 'name', base)
                                  for base in value.super ]
@@ -94,7 +107,7 @@
 
                 actualMethods = []
                 for m in py_item.__dict__.keys():
-                    if ismethod(getattr(py_item, m), m):
+                    if ismethod(py_item, getattr(py_item, m), m):
                         actualMethods.append(m)
                 foundMethods = []
                 for m in value.methods.keys():
@@ -107,7 +120,8 @@
                     self.assertListEq(foundMethods, actualMethods, ignore)
                     self.assertEquals(py_item.__module__, value.module)
 
-                    self.assertEquals(py_item.__name__, value.name, ignore)
+                    self.assertEqualsOrIgnored(py_item.__name__, value.name,
+                                               ignore)
                     # can't check file or lineno
                 except:
                     print >>sys.stderr, "class=%s" % py_item
@@ -132,6 +146,12 @@
         self.checkModule('rfc822')
         self.checkModule('difflib')
 
+    def test_decorators(self):
+        # XXX: See comment in pyclbr_input.py for a test that would fail
+        #      if it were not commented out.
+        #
+        self.checkModule('test.pyclbr_input')
+        
     def test_others(self):
         cm = self.checkModule
 
diff --git a/Lib/test/tokenize_tests.txt b/Lib/test/tokenize_tests.txt
index e990a36..4ef3bf1 100644
--- a/Lib/test/tokenize_tests.txt
+++ b/Lib/test/tokenize_tests.txt
@@ -173,3 +173,6 @@
 import sys, time
 x = sys.modules['time'].time()
 
+@staticmethod
+def foo(): pass
+
diff --git a/Lib/token.py b/Lib/token.py
index f75412c..c4db6c5 100755
--- a/Lib/token.py
+++ b/Lib/token.py
@@ -60,9 +60,10 @@
 DOUBLESTAREQUAL = 47
 DOUBLESLASH = 48
 DOUBLESLASHEQUAL = 49
-OP = 50
-ERRORTOKEN = 51
-N_TOKENS = 52
+AT = 50
+OP = 51
+ERRORTOKEN = 52
+N_TOKENS = 53
 NT_OFFSET = 256
 #--end constants--
 
diff --git a/Lib/tokenize.py b/Lib/tokenize.py
index 7e6fa12..9087e84 100644
--- a/Lib/tokenize.py
+++ b/Lib/tokenize.py
@@ -83,7 +83,7 @@
                  r"~")
 
 Bracket = '[][(){}]'
-Special = group(r'\r?\n', r'[:;.,`]')
+Special = group(r'\r?\n', r'[:;.,`@]')
 Funny = group(Operator, Bracket, Special)
 
 PlainToken = group(Number, Funny, String, Name)
diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c
index 35c5dee..81d96e1 100644
--- a/Modules/parsermodule.c
+++ b/Modules/parsermodule.c
@@ -824,6 +824,7 @@
 #define validate_vbar(ch)       validate_terminal(ch,       VBAR, "|")
 #define validate_doublestar(ch) validate_terminal(ch, DOUBLESTAR, "**")
 #define validate_dot(ch)        validate_terminal(ch,        DOT, ".")
+#define validate_at(ch)         validate_terminal(ch,         AT, "@")
 #define validate_name(ch, str)  validate_terminal(ch,       NAME, str)
 
 #define VALIDATER(n)    static int validate_##n(node *tree)
@@ -2362,20 +2363,72 @@
     return ok;
 }
 
+/*  decorator:
+ *    '@' dotted_name [ '(' [arglist] ')' ]
+ */
+static int
+validate_decorator(node *tree)
+{
+    int ok;
+    int nch = NCH(tree);
+    ok = (validate_ntype(tree, decorator) &&
+	  (nch == 2 || nch == 4 || nch == 5) &&
+	  validate_at(CHILD(tree, 0)) &&
+	  validate_dotted_name(CHILD(tree, 1)));
+
+    if (ok && nch != 2) {
+	    ok = (validate_lparen(CHILD(tree, 2)) &&
+		  validate_rparen(RCHILD(tree, -1)));
+
+	    if (ok && nch == 5)
+		ok = validate_arglist(CHILD(tree, 3));
+    }
+
+    return ok;
+}
+    
+/*  decorators:
+ *    decorator ([NEWLINE] decorator)* NEWLINE
+ */
+static int
+validate_decorators(node *tree)
+{
+    int i, nch, ok; 
+    nch = NCH(tree);
+    ok = validate_ntype(tree, decorators) && nch >= 2;
+
+    i = 0;
+    while (ok && i < nch - 1) {
+	ok = validate_decorator(CHILD(tree, i));
+	if (TYPE(CHILD(tree, i + 1)) == NEWLINE)
+	    ++i;
+	++i;
+    }
+
+    return ok;
+}			       
+
 /*  funcdef:
- *      'def' NAME parameters ':' suite
- *
+ *      
+ *            -6   -5    -4         -3  -2 -1
+ *  [decorators] 'def' NAME parameters ':' suite
  */
 static int
 validate_funcdef(node *tree)
 {
-    return (validate_ntype(tree, funcdef)
-            && validate_numnodes(tree, 5, "funcdef")
-            && validate_name(CHILD(tree, 0), "def")
-            && validate_ntype(CHILD(tree, 1), NAME)
-            && validate_colon(CHILD(tree, 3))
-            && validate_parameters(CHILD(tree, 2))
-            && validate_suite(CHILD(tree, 4)));
+    int nch = NCH(tree);
+    int ok = (validate_ntype(tree, funcdef)
+	       && ((nch == 5) || (nch == 6))
+	       && validate_name(RCHILD(tree, -5), "def")
+	       && validate_ntype(RCHILD(tree, -4), NAME)
+	       && validate_colon(RCHILD(tree, -2))
+	       && validate_parameters(RCHILD(tree, -3))
+	       && validate_suite(RCHILD(tree, -1)));
+
+    if (ok && (nch == 6))
+	ok = validate_decorators(CHILD(tree, 0));
+
+    return ok;
 }
 
 
diff --git a/Parser/tokenizer.c b/Parser/tokenizer.c
index 0821bda..4fdc2e6 100644
--- a/Parser/tokenizer.c
+++ b/Parser/tokenizer.c
@@ -92,6 +92,7 @@
 	"DOUBLESTAREQUAL",
 	"DOUBLESLASH",
 	"DOUBLESLASHEQUAL",
+	"AT",
 	/* This table must match the #defines in token.h! */
 	"OP",
 	"<ERRORTOKEN>",
@@ -847,6 +848,7 @@
 	case '}':	return RBRACE;
 	case '^':	return CIRCUMFLEX;
 	case '~':	return TILDE;
+	case '@':       return AT;
 	default:	return OP;
 	}
 }
diff --git a/Python/compile.c b/Python/compile.c
index 771bc2f..337cc2e 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -1876,6 +1876,7 @@
 	else com_list(c, n, 0);
 }
 
+
 static void
 com_dictmaker(struct compiling *c, node *n)
 {
@@ -3963,8 +3964,9 @@
 		n = CHILD(n, 1);
 	}
 	else {
-		REQ(n, funcdef); /* funcdef: 'def' NAME parameters ... */
-		n = CHILD(n, 2);
+		REQ(n, funcdef);
+		/* funcdef: [decorators] 'def' NAME parameters ':' suite */
+		n = RCHILD(n, -3);
 		REQ(n, parameters); /* parameters: '(' [varargslist] ')' */
 		n = CHILD(n, 1);
 	}
@@ -4009,15 +4011,89 @@
 }
 
 static void
+com_decorator_name(struct compiling *c, node *n)
+{
+	/* dotted_name: NAME ('.' NAME)* */
+	
+	int i, nch;
+	node *varname;
+
+	REQ(n, dotted_name);
+	nch = NCH(n);
+	assert(nch >= 1 && nch % 2 == 1);
+
+	varname = CHILD(n, 0);
+	REQ(varname, NAME);
+	com_addop_varname(c, VAR_LOAD, STR(varname));
+		
+	for (i = 1; i < nch; i += 2) {
+		node *attrname;
+		
+		REQ(CHILD(n, i), DOT);
+
+		attrname = CHILD(n, i + 1);
+		REQ(attrname, NAME);
+		com_addop_name(c, LOAD_ATTR, STR(attrname));
+	}
+}
+
+static void
+com_decorator(struct compiling *c, node *n)
+{
+	/* decorator: '@' dotted_name [ '(' [arglist] ')' ] */
+	int nch = NCH(n);
+	assert(nch >= 2);
+	REQ(CHILD(n, 0), AT);
+	com_decorator_name(c, CHILD(n, 1));
+
+	if (nch > 2) {
+		assert(nch == 4 || nch == 5);
+		REQ(CHILD(n, 2), LPAR);
+		REQ(CHILD(n, nch - 1), RPAR);
+		com_call_function(c, CHILD(n, 3));
+	}
+}
+
+static int
+com_decorators(struct compiling *c, node *n)
+{
+	int i, nch, ndecorators;
+	
+	/* decorator ([NEWLINE] decorator)* NEWLINE */
+	nch = NCH(n);
+	assert(nch >= 2);
+	REQ(CHILD(n, nch - 1), NEWLINE);
+
+	ndecorators = 0;
+	for (i = NCH(n) - 1; i >= 0; --i) {
+		node *ch = CHILD(n, i);
+		if (TYPE(ch) != NEWLINE) {
+			com_decorator(c, ch);
+			++ndecorators;
+		}
+	}
+
+	return ndecorators;
+}
+
+static void
 com_funcdef(struct compiling *c, node *n)
 {
 	PyObject *co;
-	int ndefs;
-	REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */
+	int ndefs, ndecorators;
+	REQ(n, funcdef);
+	/*          -6            -5   -4   -3         -2  -1
+	   funcdef: [decorators] 'def' NAME parameters ':' suite */
+
+	if (NCH(n) == 6)
+		ndecorators = com_decorators(c, CHILD(n, 0));
+	else
+		ndecorators = 0;
+	
 	ndefs = com_argdefs(c, n);
 	if (ndefs < 0)
 		return;
-	symtable_enter_scope(c->c_symtable, STR(CHILD(n, 1)), TYPE(n),
+	symtable_enter_scope(c->c_symtable, STR(RCHILD(n, -4)), TYPE(n),
 			     n->n_lineno);
 	co = (PyObject *)icompile(n, c);
 	symtable_exit_scope(c->c_symtable);
@@ -4033,7 +4109,12 @@
 		else
 			com_addoparg(c, MAKE_FUNCTION, ndefs);
 		com_pop(c, ndefs);
-		com_addop_varname(c, VAR_STORE, STR(CHILD(n, 1)));
+		while (ndecorators > 0) {
+			com_addoparg(c, CALL_FUNCTION, 1);
+			com_pop(c, 1);
+			ndecorators--;
+		}
+		com_addop_varname(c, VAR_STORE, STR(RCHILD(n, -4)));
 		com_pop(c, 1);
 		Py_DECREF(co);
 	}
@@ -4112,7 +4193,7 @@
 	switch (TYPE(n)) {
 	
 	/* Definition nodes */
-	
+
 	case funcdef:
 		com_funcdef(c, n);
 		break;
@@ -4377,21 +4458,23 @@
 {
 	PyObject *doc;
 	node *ch;
-	REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */
-	c->c_name = STR(CHILD(n, 1));
-	doc = get_docstring(c, CHILD(n, 4));
+	REQ(n, funcdef);
+	/*          -6            -5   -4   -3         -2  -1
+	   funcdef: [decorators] 'def' NAME parameters ':' suite */
+	c->c_name = STR(RCHILD(n, -4));
+	doc = get_docstring(c, RCHILD(n, -1));
 	if (doc != NULL) {
 		(void) com_addconst(c, doc);
 		Py_DECREF(doc);
 	}
 	else
 		(void) com_addconst(c, Py_None); /* No docstring */
-	ch = CHILD(n, 2); /* parameters: '(' [varargslist] ')' */
+	ch = RCHILD(n, -3); /* parameters: '(' [varargslist] ')' */
 	ch = CHILD(ch, 1); /* ')' | varargslist */
 	if (TYPE(ch) == varargslist)
 		com_arglist(c, ch);
 	c->c_infunction = 1;
-	com_node(c, CHILD(n, 4));
+	com_node(c, RCHILD(n, -1));
 	c->c_infunction = 0;
 	com_strip_lnotab(c);
 	com_addoparg(c, LOAD_CONST, com_addconst(c, Py_None));
@@ -5587,9 +5670,12 @@
  loop:
 	switch (TYPE(n)) {
 	case funcdef: {
-		char *func_name = STR(CHILD(n, 1));
+		char *func_name;
+		if (NCH(n) == 6)
+			symtable_node(st, CHILD(n, 0));
+		func_name = STR(RCHILD(n, -4));
 		symtable_add_def(st, func_name, DEF_LOCAL);
-		symtable_default_args(st, CHILD(n, 2));
+		symtable_default_args(st, RCHILD(n, -3));
 		symtable_enter_scope(st, func_name, TYPE(n), n->n_lineno);
 		symtable_funcdef(st, n);
 		symtable_exit_scope(st);
@@ -5734,6 +5820,17 @@
 	   to be coded with great care, even though they look like
 	   rather innocuous.  Each case must double-check TYPE(n).
 	*/
+	case decorator:
+		if (TYPE(n) == decorator) {
+			/* decorator: '@' dotted_name [ '(' [arglist] ')' ] */
+			node *name, *varname;
+			name = CHILD(n, 1);
+			REQ(name, dotted_name);
+			varname = CHILD(name, 0);
+			REQ(varname, NAME);
+			symtable_add_use(st, STR(varname));
+		}
+		/* fall through */
 	case argument:
 		if (TYPE(n) == argument && NCH(n) == 3) {
 			n = CHILD(n, 2);
@@ -5787,7 +5884,7 @@
 		if (NCH(n) == 4)
 			symtable_params(st, CHILD(n, 1));
 	} else
-		symtable_params(st, CHILD(n, 2));
+		symtable_params(st, RCHILD(n, -3));
 	body = CHILD(n, NCH(n) - 1);
 	symtable_node(st, body);
 }
diff --git a/Python/graminit.c b/Python/graminit.c
index cd8240b..1718096 100644
--- a/Python/graminit.c
+++ b/Python/graminit.c
@@ -49,11 +49,13 @@
 static arc arcs_3_1[1] = {
 	{12, 2},
 };
-static arc arcs_3_2[1] = {
+static arc arcs_3_2[2] = {
 	{13, 3},
+	{0, 2},
 };
-static arc arcs_3_3[1] = {
+static arc arcs_3_3[2] = {
 	{14, 4},
+	{15, 5},
 };
 static arc arcs_3_4[1] = {
 	{15, 5},
@@ -64,200 +66,242 @@
 static state states_3[6] = {
 	{1, arcs_3_0},
 	{1, arcs_3_1},
-	{1, arcs_3_2},
-	{1, arcs_3_3},
+	{2, arcs_3_2},
+	{2, arcs_3_3},
 	{1, arcs_3_4},
 	{1, arcs_3_5},
 };
 static arc arcs_4_0[1] = {
-	{16, 1},
+	{10, 1},
 };
 static arc arcs_4_1[2] = {
-	{17, 2},
-	{18, 3},
+	{2, 2},
+	{10, 1},
 };
-static arc arcs_4_2[1] = {
-	{18, 3},
+static arc arcs_4_2[2] = {
+	{10, 1},
+	{0, 2},
 };
-static arc arcs_4_3[1] = {
-	{0, 3},
-};
-static state states_4[4] = {
+static state states_4[3] = {
 	{1, arcs_4_0},
 	{2, arcs_4_1},
-	{1, arcs_4_2},
-	{1, arcs_4_3},
+	{2, arcs_4_2},
 };
-static arc arcs_5_0[3] = {
-	{19, 1},
-	{23, 2},
-	{24, 3},
+static arc arcs_5_0[2] = {
+	{16, 1},
+	{18, 2},
 };
-static arc arcs_5_1[3] = {
-	{20, 4},
-	{22, 5},
-	{0, 1},
+static arc arcs_5_1[1] = {
+	{18, 2},
 };
 static arc arcs_5_2[1] = {
-	{12, 6},
+	{19, 3},
 };
 static arc arcs_5_3[1] = {
-	{12, 7},
+	{20, 4},
 };
 static arc arcs_5_4[1] = {
-	{21, 8},
+	{21, 5},
 };
-static arc arcs_5_5[4] = {
-	{19, 1},
-	{23, 2},
-	{24, 3},
-	{0, 5},
+static arc arcs_5_5[1] = {
+	{22, 6},
 };
-static arc arcs_5_6[2] = {
-	{22, 9},
+static arc arcs_5_6[1] = {
 	{0, 6},
 };
-static arc arcs_5_7[1] = {
-	{0, 7},
-};
-static arc arcs_5_8[2] = {
-	{22, 5},
-	{0, 8},
-};
-static arc arcs_5_9[1] = {
-	{24, 3},
-};
-static state states_5[10] = {
-	{3, arcs_5_0},
-	{3, arcs_5_1},
+static state states_5[7] = {
+	{2, arcs_5_0},
+	{1, arcs_5_1},
 	{1, arcs_5_2},
 	{1, arcs_5_3},
 	{1, arcs_5_4},
-	{4, arcs_5_5},
-	{2, arcs_5_6},
-	{1, arcs_5_7},
-	{2, arcs_5_8},
-	{1, arcs_5_9},
+	{1, arcs_5_5},
+	{1, arcs_5_6},
 };
-static arc arcs_6_0[2] = {
-	{12, 1},
-	{16, 2},
+static arc arcs_6_0[1] = {
+	{13, 1},
 };
-static arc arcs_6_1[1] = {
-	{0, 1},
+static arc arcs_6_1[2] = {
+	{23, 2},
+	{15, 3},
 };
 static arc arcs_6_2[1] = {
-	{25, 3},
+	{15, 3},
 };
 static arc arcs_6_3[1] = {
-	{18, 1},
+	{0, 3},
 };
 static state states_6[4] = {
-	{2, arcs_6_0},
-	{1, arcs_6_1},
+	{1, arcs_6_0},
+	{2, arcs_6_1},
 	{1, arcs_6_2},
 	{1, arcs_6_3},
 };
-static arc arcs_7_0[1] = {
-	{19, 1},
+static arc arcs_7_0[3] = {
+	{24, 1},
+	{28, 2},
+	{29, 3},
 };
-static arc arcs_7_1[2] = {
-	{22, 2},
+static arc arcs_7_1[3] = {
+	{25, 4},
+	{27, 5},
 	{0, 1},
 };
-static arc arcs_7_2[2] = {
-	{19, 1},
-	{0, 2},
+static arc arcs_7_2[1] = {
+	{19, 6},
 };
-static state states_7[3] = {
-	{1, arcs_7_0},
-	{2, arcs_7_1},
-	{2, arcs_7_2},
+static arc arcs_7_3[1] = {
+	{19, 7},
+};
+static arc arcs_7_4[1] = {
+	{26, 8},
+};
+static arc arcs_7_5[4] = {
+	{24, 1},
+	{28, 2},
+	{29, 3},
+	{0, 5},
+};
+static arc arcs_7_6[2] = {
+	{27, 9},
+	{0, 6},
+};
+static arc arcs_7_7[1] = {
+	{0, 7},
+};
+static arc arcs_7_8[2] = {
+	{27, 5},
+	{0, 8},
+};
+static arc arcs_7_9[1] = {
+	{29, 3},
+};
+static state states_7[10] = {
+	{3, arcs_7_0},
+	{3, arcs_7_1},
+	{1, arcs_7_2},
+	{1, arcs_7_3},
+	{1, arcs_7_4},
+	{4, arcs_7_5},
+	{2, arcs_7_6},
+	{1, arcs_7_7},
+	{2, arcs_7_8},
+	{1, arcs_7_9},
 };
 static arc arcs_8_0[2] = {
-	{3, 1},
-	{4, 1},
+	{19, 1},
+	{13, 2},
 };
 static arc arcs_8_1[1] = {
 	{0, 1},
 };
-static state states_8[2] = {
+static arc arcs_8_2[1] = {
+	{30, 3},
+};
+static arc arcs_8_3[1] = {
+	{15, 1},
+};
+static state states_8[4] = {
 	{2, arcs_8_0},
 	{1, arcs_8_1},
+	{1, arcs_8_2},
+	{1, arcs_8_3},
 };
 static arc arcs_9_0[1] = {
-	{26, 1},
+	{24, 1},
 };
 static arc arcs_9_1[2] = {
 	{27, 2},
-	{2, 3},
+	{0, 1},
 };
 static arc arcs_9_2[2] = {
-	{26, 1},
-	{2, 3},
+	{24, 1},
+	{0, 2},
 };
-static arc arcs_9_3[1] = {
-	{0, 3},
-};
-static state states_9[4] = {
+static state states_9[3] = {
 	{1, arcs_9_0},
 	{2, arcs_9_1},
 	{2, arcs_9_2},
-	{1, arcs_9_3},
 };
-static arc arcs_10_0[9] = {
-	{28, 1},
-	{29, 1},
-	{30, 1},
-	{31, 1},
-	{32, 1},
-	{33, 1},
-	{34, 1},
-	{35, 1},
-	{36, 1},
+static arc arcs_10_0[2] = {
+	{3, 1},
+	{4, 1},
 };
 static arc arcs_10_1[1] = {
 	{0, 1},
 };
 static state states_10[2] = {
-	{9, arcs_10_0},
+	{2, arcs_10_0},
 	{1, arcs_10_1},
 };
 static arc arcs_11_0[1] = {
-	{9, 1},
+	{31, 1},
 };
-static arc arcs_11_1[3] = {
-	{37, 2},
-	{20, 3},
-	{0, 1},
+static arc arcs_11_1[2] = {
+	{32, 2},
+	{2, 3},
 };
-static arc arcs_11_2[1] = {
-	{9, 4},
+static arc arcs_11_2[2] = {
+	{31, 1},
+	{2, 3},
 };
 static arc arcs_11_3[1] = {
-	{9, 5},
+	{0, 3},
 };
-static arc arcs_11_4[1] = {
-	{0, 4},
-};
-static arc arcs_11_5[2] = {
-	{20, 3},
-	{0, 5},
-};
-static state states_11[6] = {
+static state states_11[4] = {
 	{1, arcs_11_0},
-	{3, arcs_11_1},
-	{1, arcs_11_2},
+	{2, arcs_11_1},
+	{2, arcs_11_2},
 	{1, arcs_11_3},
-	{1, arcs_11_4},
-	{2, arcs_11_5},
 };
-static arc arcs_12_0[12] = {
+static arc arcs_12_0[9] = {
+	{33, 1},
+	{34, 1},
+	{35, 1},
+	{36, 1},
+	{37, 1},
 	{38, 1},
 	{39, 1},
 	{40, 1},
 	{41, 1},
-	{42, 1},
+};
+static arc arcs_12_1[1] = {
+	{0, 1},
+};
+static state states_12[2] = {
+	{9, arcs_12_0},
+	{1, arcs_12_1},
+};
+static arc arcs_13_0[1] = {
+	{9, 1},
+};
+static arc arcs_13_1[3] = {
+	{42, 2},
+	{25, 3},
+	{0, 1},
+};
+static arc arcs_13_2[1] = {
+	{9, 4},
+};
+static arc arcs_13_3[1] = {
+	{9, 5},
+};
+static arc arcs_13_4[1] = {
+	{0, 4},
+};
+static arc arcs_13_5[2] = {
+	{25, 3},
+	{0, 5},
+};
+static state states_13[6] = {
+	{1, arcs_13_0},
+	{3, arcs_13_1},
+	{1, arcs_13_2},
+	{1, arcs_13_3},
+	{1, arcs_13_4},
+	{2, arcs_13_5},
+};
+static arc arcs_14_0[12] = {
 	{43, 1},
 	{44, 1},
 	{45, 1},
@@ -265,99 +309,80 @@
 	{47, 1},
 	{48, 1},
 	{49, 1},
-};
-static arc arcs_12_1[1] = {
-	{0, 1},
-};
-static state states_12[2] = {
-	{12, arcs_12_0},
-	{1, arcs_12_1},
-};
-static arc arcs_13_0[1] = {
 	{50, 1},
-};
-static arc arcs_13_1[3] = {
-	{21, 2},
-	{51, 3},
-	{0, 1},
-};
-static arc arcs_13_2[2] = {
-	{22, 4},
-	{0, 2},
-};
-static arc arcs_13_3[1] = {
-	{21, 5},
-};
-static arc arcs_13_4[2] = {
-	{21, 2},
-	{0, 4},
-};
-static arc arcs_13_5[2] = {
-	{22, 6},
-	{0, 5},
-};
-static arc arcs_13_6[1] = {
-	{21, 7},
-};
-static arc arcs_13_7[2] = {
-	{22, 8},
-	{0, 7},
-};
-static arc arcs_13_8[2] = {
-	{21, 7},
-	{0, 8},
-};
-static state states_13[9] = {
-	{1, arcs_13_0},
-	{3, arcs_13_1},
-	{2, arcs_13_2},
-	{1, arcs_13_3},
-	{2, arcs_13_4},
-	{2, arcs_13_5},
-	{1, arcs_13_6},
-	{2, arcs_13_7},
-	{2, arcs_13_8},
-};
-static arc arcs_14_0[1] = {
+	{51, 1},
 	{52, 1},
-};
-static arc arcs_14_1[1] = {
-	{53, 2},
-};
-static arc arcs_14_2[1] = {
-	{0, 2},
-};
-static state states_14[3] = {
-	{1, arcs_14_0},
-	{1, arcs_14_1},
-	{1, arcs_14_2},
-};
-static arc arcs_15_0[1] = {
+	{53, 1},
 	{54, 1},
 };
-static arc arcs_15_1[1] = {
+static arc arcs_14_1[1] = {
 	{0, 1},
 };
-static state states_15[2] = {
-	{1, arcs_15_0},
-	{1, arcs_15_1},
+static state states_14[2] = {
+	{12, arcs_14_0},
+	{1, arcs_14_1},
 };
-static arc arcs_16_0[5] = {
+static arc arcs_15_0[1] = {
 	{55, 1},
-	{56, 1},
+};
+static arc arcs_15_1[3] = {
+	{26, 2},
+	{56, 3},
+	{0, 1},
+};
+static arc arcs_15_2[2] = {
+	{27, 4},
+	{0, 2},
+};
+static arc arcs_15_3[1] = {
+	{26, 5},
+};
+static arc arcs_15_4[2] = {
+	{26, 2},
+	{0, 4},
+};
+static arc arcs_15_5[2] = {
+	{27, 6},
+	{0, 5},
+};
+static arc arcs_15_6[1] = {
+	{26, 7},
+};
+static arc arcs_15_7[2] = {
+	{27, 8},
+	{0, 7},
+};
+static arc arcs_15_8[2] = {
+	{26, 7},
+	{0, 8},
+};
+static state states_15[9] = {
+	{1, arcs_15_0},
+	{3, arcs_15_1},
+	{2, arcs_15_2},
+	{1, arcs_15_3},
+	{2, arcs_15_4},
+	{2, arcs_15_5},
+	{1, arcs_15_6},
+	{2, arcs_15_7},
+	{2, arcs_15_8},
+};
+static arc arcs_16_0[1] = {
 	{57, 1},
-	{58, 1},
-	{59, 1},
 };
 static arc arcs_16_1[1] = {
-	{0, 1},
+	{58, 2},
 };
-static state states_16[2] = {
-	{5, arcs_16_0},
+static arc arcs_16_2[1] = {
+	{0, 2},
+};
+static state states_16[3] = {
+	{1, arcs_16_0},
 	{1, arcs_16_1},
+	{1, arcs_16_2},
 };
 static arc arcs_17_0[1] = {
-	{60, 1},
+	{59, 1},
 };
 static arc arcs_17_1[1] = {
 	{0, 1},
@@ -366,567 +391,569 @@
 	{1, arcs_17_0},
 	{1, arcs_17_1},
 };
-static arc arcs_18_0[1] = {
+static arc arcs_18_0[5] = {
+	{60, 1},
 	{61, 1},
+	{62, 1},
+	{63, 1},
+	{64, 1},
 };
 static arc arcs_18_1[1] = {
 	{0, 1},
 };
 static state states_18[2] = {
-	{1, arcs_18_0},
+	{5, arcs_18_0},
 	{1, arcs_18_1},
 };
 static arc arcs_19_0[1] = {
-	{62, 1},
+	{65, 1},
 };
-static arc arcs_19_1[2] = {
-	{9, 2},
+static arc arcs_19_1[1] = {
 	{0, 1},
 };
-static arc arcs_19_2[1] = {
-	{0, 2},
-};
-static state states_19[3] = {
+static state states_19[2] = {
 	{1, arcs_19_0},
-	{2, arcs_19_1},
-	{1, arcs_19_2},
+	{1, arcs_19_1},
 };
 static arc arcs_20_0[1] = {
-	{63, 1},
+	{66, 1},
 };
 static arc arcs_20_1[1] = {
-	{9, 2},
+	{0, 1},
 };
-static arc arcs_20_2[1] = {
-	{0, 2},
-};
-static state states_20[3] = {
+static state states_20[2] = {
 	{1, arcs_20_0},
 	{1, arcs_20_1},
-	{1, arcs_20_2},
 };
 static arc arcs_21_0[1] = {
-	{64, 1},
+	{67, 1},
 };
 static arc arcs_21_1[2] = {
-	{21, 2},
+	{9, 2},
 	{0, 1},
 };
-static arc arcs_21_2[2] = {
-	{22, 3},
+static arc arcs_21_2[1] = {
 	{0, 2},
 };
-static arc arcs_21_3[1] = {
-	{21, 4},
-};
-static arc arcs_21_4[2] = {
-	{22, 5},
-	{0, 4},
-};
-static arc arcs_21_5[1] = {
-	{21, 6},
-};
-static arc arcs_21_6[1] = {
-	{0, 6},
-};
-static state states_21[7] = {
+static state states_21[3] = {
 	{1, arcs_21_0},
 	{2, arcs_21_1},
-	{2, arcs_21_2},
-	{1, arcs_21_3},
-	{2, arcs_21_4},
-	{1, arcs_21_5},
-	{1, arcs_21_6},
+	{1, arcs_21_2},
 };
-static arc arcs_22_0[2] = {
-	{65, 1},
-	{67, 2},
-};
-static arc arcs_22_1[1] = {
-	{66, 3},
-};
-static arc arcs_22_2[1] = {
-	{68, 4},
-};
-static arc arcs_22_3[2] = {
-	{22, 1},
-	{0, 3},
-};
-static arc arcs_22_4[1] = {
-	{65, 5},
-};
-static arc arcs_22_5[2] = {
-	{23, 6},
-	{69, 7},
-};
-static arc arcs_22_6[1] = {
-	{0, 6},
-};
-static arc arcs_22_7[2] = {
-	{22, 8},
-	{0, 7},
-};
-static arc arcs_22_8[1] = {
-	{69, 7},
-};
-static state states_22[9] = {
-	{2, arcs_22_0},
-	{1, arcs_22_1},
-	{1, arcs_22_2},
-	{2, arcs_22_3},
-	{1, arcs_22_4},
-	{2, arcs_22_5},
-	{1, arcs_22_6},
-	{2, arcs_22_7},
-	{1, arcs_22_8},
-};
-static arc arcs_23_0[1] = {
-	{12, 1},
-};
-static arc arcs_23_1[2] = {
-	{12, 2},
-	{0, 1},
-};
-static arc arcs_23_2[1] = {
-	{12, 3},
-};
-static arc arcs_23_3[1] = {
-	{0, 3},
-};
-static state states_23[4] = {
-	{1, arcs_23_0},
-	{2, arcs_23_1},
-	{1, arcs_23_2},
-	{1, arcs_23_3},
-};
-static arc arcs_24_0[1] = {
+static arc arcs_22_0[1] = {
 	{68, 1},
 };
-static arc arcs_24_1[2] = {
-	{12, 2},
-	{0, 1},
+static arc arcs_22_1[1] = {
+	{9, 2},
 };
-static arc arcs_24_2[1] = {
-	{12, 3},
-};
-static arc arcs_24_3[1] = {
-	{0, 3},
-};
-static state states_24[4] = {
-	{1, arcs_24_0},
-	{2, arcs_24_1},
-	{1, arcs_24_2},
-	{1, arcs_24_3},
-};
-static arc arcs_25_0[1] = {
-	{12, 1},
-};
-static arc arcs_25_1[2] = {
-	{70, 0},
-	{0, 1},
-};
-static state states_25[2] = {
-	{1, arcs_25_0},
-	{2, arcs_25_1},
-};
-static arc arcs_26_0[1] = {
-	{71, 1},
-};
-static arc arcs_26_1[1] = {
-	{12, 2},
-};
-static arc arcs_26_2[2] = {
-	{22, 1},
+static arc arcs_22_2[1] = {
 	{0, 2},
 };
-static state states_26[3] = {
-	{1, arcs_26_0},
-	{1, arcs_26_1},
-	{2, arcs_26_2},
+static state states_22[3] = {
+	{1, arcs_22_0},
+	{1, arcs_22_1},
+	{1, arcs_22_2},
 };
-static arc arcs_27_0[1] = {
-	{72, 1},
+static arc arcs_23_0[1] = {
+	{69, 1},
 };
-static arc arcs_27_1[1] = {
-	{73, 2},
+static arc arcs_23_1[2] = {
+	{26, 2},
+	{0, 1},
 };
-static arc arcs_27_2[2] = {
-	{74, 3},
+static arc arcs_23_2[2] = {
+	{27, 3},
 	{0, 2},
 };
-static arc arcs_27_3[1] = {
-	{21, 4},
+static arc arcs_23_3[1] = {
+	{26, 4},
 };
-static arc arcs_27_4[2] = {
-	{22, 5},
+static arc arcs_23_4[2] = {
+	{27, 5},
 	{0, 4},
 };
-static arc arcs_27_5[1] = {
-	{21, 6},
+static arc arcs_23_5[1] = {
+	{26, 6},
 };
-static arc arcs_27_6[1] = {
+static arc arcs_23_6[1] = {
 	{0, 6},
 };
-static state states_27[7] = {
+static state states_23[7] = {
+	{1, arcs_23_0},
+	{2, arcs_23_1},
+	{2, arcs_23_2},
+	{1, arcs_23_3},
+	{2, arcs_23_4},
+	{1, arcs_23_5},
+	{1, arcs_23_6},
+};
+static arc arcs_24_0[2] = {
+	{70, 1},
+	{72, 2},
+};
+static arc arcs_24_1[1] = {
+	{71, 3},
+};
+static arc arcs_24_2[1] = {
+	{12, 4},
+};
+static arc arcs_24_3[2] = {
+	{27, 1},
+	{0, 3},
+};
+static arc arcs_24_4[1] = {
+	{70, 5},
+};
+static arc arcs_24_5[2] = {
+	{28, 6},
+	{73, 7},
+};
+static arc arcs_24_6[1] = {
+	{0, 6},
+};
+static arc arcs_24_7[2] = {
+	{27, 8},
+	{0, 7},
+};
+static arc arcs_24_8[1] = {
+	{73, 7},
+};
+static state states_24[9] = {
+	{2, arcs_24_0},
+	{1, arcs_24_1},
+	{1, arcs_24_2},
+	{2, arcs_24_3},
+	{1, arcs_24_4},
+	{2, arcs_24_5},
+	{1, arcs_24_6},
+	{2, arcs_24_7},
+	{1, arcs_24_8},
+};
+static arc arcs_25_0[1] = {
+	{19, 1},
+};
+static arc arcs_25_1[2] = {
+	{19, 2},
+	{0, 1},
+};
+static arc arcs_25_2[1] = {
+	{19, 3},
+};
+static arc arcs_25_3[1] = {
+	{0, 3},
+};
+static state states_25[4] = {
+	{1, arcs_25_0},
+	{2, arcs_25_1},
+	{1, arcs_25_2},
+	{1, arcs_25_3},
+};
+static arc arcs_26_0[1] = {
+	{12, 1},
+};
+static arc arcs_26_1[2] = {
+	{19, 2},
+	{0, 1},
+};
+static arc arcs_26_2[1] = {
+	{19, 3},
+};
+static arc arcs_26_3[1] = {
+	{0, 3},
+};
+static state states_26[4] = {
+	{1, arcs_26_0},
+	{2, arcs_26_1},
+	{1, arcs_26_2},
+	{1, arcs_26_3},
+};
+static arc arcs_27_0[1] = {
+	{19, 1},
+};
+static arc arcs_27_1[2] = {
+	{74, 0},
+	{0, 1},
+};
+static state states_27[2] = {
 	{1, arcs_27_0},
-	{1, arcs_27_1},
-	{2, arcs_27_2},
-	{1, arcs_27_3},
-	{2, arcs_27_4},
-	{1, arcs_27_5},
-	{1, arcs_27_6},
+	{2, arcs_27_1},
 };
 static arc arcs_28_0[1] = {
 	{75, 1},
 };
 static arc arcs_28_1[1] = {
-	{21, 2},
+	{19, 2},
 };
 static arc arcs_28_2[2] = {
-	{22, 3},
+	{27, 1},
 	{0, 2},
 };
-static arc arcs_28_3[1] = {
-	{21, 4},
-};
-static arc arcs_28_4[1] = {
-	{0, 4},
-};
-static state states_28[5] = {
+static state states_28[3] = {
 	{1, arcs_28_0},
 	{1, arcs_28_1},
 	{2, arcs_28_2},
-	{1, arcs_28_3},
-	{1, arcs_28_4},
 };
-static arc arcs_29_0[6] = {
+static arc arcs_29_0[1] = {
 	{76, 1},
-	{77, 1},
-	{78, 1},
-	{79, 1},
-	{10, 1},
-	{80, 1},
 };
 static arc arcs_29_1[1] = {
-	{0, 1},
+	{77, 2},
 };
-static state states_29[2] = {
-	{6, arcs_29_0},
-	{1, arcs_29_1},
+static arc arcs_29_2[2] = {
+	{78, 3},
+	{0, 2},
 };
-static arc arcs_30_0[1] = {
-	{81, 1},
+static arc arcs_29_3[1] = {
+	{26, 4},
 };
-static arc arcs_30_1[1] = {
-	{21, 2},
-};
-static arc arcs_30_2[1] = {
-	{14, 3},
-};
-static arc arcs_30_3[1] = {
-	{15, 4},
-};
-static arc arcs_30_4[3] = {
-	{82, 1},
-	{83, 5},
+static arc arcs_29_4[2] = {
+	{27, 5},
 	{0, 4},
 };
-static arc arcs_30_5[1] = {
-	{14, 6},
+static arc arcs_29_5[1] = {
+	{26, 6},
 };
-static arc arcs_30_6[1] = {
-	{15, 7},
+static arc arcs_29_6[1] = {
+	{0, 6},
 };
-static arc arcs_30_7[1] = {
-	{0, 7},
+static state states_29[7] = {
+	{1, arcs_29_0},
+	{1, arcs_29_1},
+	{2, arcs_29_2},
+	{1, arcs_29_3},
+	{2, arcs_29_4},
+	{1, arcs_29_5},
+	{1, arcs_29_6},
 };
-static state states_30[8] = {
+static arc arcs_30_0[1] = {
+	{79, 1},
+};
+static arc arcs_30_1[1] = {
+	{26, 2},
+};
+static arc arcs_30_2[2] = {
+	{27, 3},
+	{0, 2},
+};
+static arc arcs_30_3[1] = {
+	{26, 4},
+};
+static arc arcs_30_4[1] = {
+	{0, 4},
+};
+static state states_30[5] = {
 	{1, arcs_30_0},
 	{1, arcs_30_1},
-	{1, arcs_30_2},
+	{2, arcs_30_2},
 	{1, arcs_30_3},
-	{3, arcs_30_4},
-	{1, arcs_30_5},
-	{1, arcs_30_6},
-	{1, arcs_30_7},
+	{1, arcs_30_4},
 };
-static arc arcs_31_0[1] = {
+static arc arcs_31_0[6] = {
+	{80, 1},
+	{81, 1},
+	{82, 1},
+	{83, 1},
+	{17, 1},
 	{84, 1},
 };
 static arc arcs_31_1[1] = {
-	{21, 2},
+	{0, 1},
 };
-static arc arcs_31_2[1] = {
-	{14, 3},
-};
-static arc arcs_31_3[1] = {
-	{15, 4},
-};
-static arc arcs_31_4[2] = {
-	{83, 5},
-	{0, 4},
-};
-static arc arcs_31_5[1] = {
-	{14, 6},
-};
-static arc arcs_31_6[1] = {
-	{15, 7},
-};
-static arc arcs_31_7[1] = {
-	{0, 7},
-};
-static state states_31[8] = {
-	{1, arcs_31_0},
+static state states_31[2] = {
+	{6, arcs_31_0},
 	{1, arcs_31_1},
-	{1, arcs_31_2},
-	{1, arcs_31_3},
-	{2, arcs_31_4},
-	{1, arcs_31_5},
-	{1, arcs_31_6},
-	{1, arcs_31_7},
 };
 static arc arcs_32_0[1] = {
 	{85, 1},
 };
 static arc arcs_32_1[1] = {
-	{53, 2},
+	{26, 2},
 };
 static arc arcs_32_2[1] = {
-	{74, 3},
+	{21, 3},
 };
 static arc arcs_32_3[1] = {
-	{9, 4},
+	{22, 4},
 };
-static arc arcs_32_4[1] = {
-	{14, 5},
+static arc arcs_32_4[3] = {
+	{86, 1},
+	{87, 5},
+	{0, 4},
 };
 static arc arcs_32_5[1] = {
-	{15, 6},
+	{21, 6},
 };
-static arc arcs_32_6[2] = {
-	{83, 7},
-	{0, 6},
+static arc arcs_32_6[1] = {
+	{22, 7},
 };
 static arc arcs_32_7[1] = {
-	{14, 8},
+	{0, 7},
 };
-static arc arcs_32_8[1] = {
-	{15, 9},
-};
-static arc arcs_32_9[1] = {
-	{0, 9},
-};
-static state states_32[10] = {
+static state states_32[8] = {
 	{1, arcs_32_0},
 	{1, arcs_32_1},
 	{1, arcs_32_2},
 	{1, arcs_32_3},
-	{1, arcs_32_4},
+	{3, arcs_32_4},
 	{1, arcs_32_5},
-	{2, arcs_32_6},
+	{1, arcs_32_6},
 	{1, arcs_32_7},
-	{1, arcs_32_8},
-	{1, arcs_32_9},
 };
 static arc arcs_33_0[1] = {
-	{86, 1},
+	{88, 1},
 };
 static arc arcs_33_1[1] = {
-	{14, 2},
+	{26, 2},
 };
 static arc arcs_33_2[1] = {
-	{15, 3},
+	{21, 3},
 };
-static arc arcs_33_3[2] = {
-	{87, 4},
-	{88, 5},
+static arc arcs_33_3[1] = {
+	{22, 4},
 };
-static arc arcs_33_4[1] = {
-	{14, 6},
+static arc arcs_33_4[2] = {
+	{87, 5},
+	{0, 4},
 };
 static arc arcs_33_5[1] = {
-	{14, 7},
+	{21, 6},
 };
 static arc arcs_33_6[1] = {
-	{15, 8},
+	{22, 7},
 };
 static arc arcs_33_7[1] = {
-	{15, 9},
+	{0, 7},
 };
-static arc arcs_33_8[3] = {
-	{87, 4},
-	{83, 5},
-	{0, 8},
-};
-static arc arcs_33_9[1] = {
-	{0, 9},
-};
-static state states_33[10] = {
+static state states_33[8] = {
 	{1, arcs_33_0},
 	{1, arcs_33_1},
 	{1, arcs_33_2},
-	{2, arcs_33_3},
-	{1, arcs_33_4},
+	{1, arcs_33_3},
+	{2, arcs_33_4},
 	{1, arcs_33_5},
 	{1, arcs_33_6},
 	{1, arcs_33_7},
-	{3, arcs_33_8},
-	{1, arcs_33_9},
 };
 static arc arcs_34_0[1] = {
 	{89, 1},
 };
-static arc arcs_34_1[2] = {
-	{21, 2},
-	{0, 1},
+static arc arcs_34_1[1] = {
+	{58, 2},
 };
-static arc arcs_34_2[2] = {
-	{22, 3},
-	{0, 2},
+static arc arcs_34_2[1] = {
+	{78, 3},
 };
 static arc arcs_34_3[1] = {
-	{21, 4},
+	{9, 4},
 };
 static arc arcs_34_4[1] = {
-	{0, 4},
+	{21, 5},
 };
-static state states_34[5] = {
+static arc arcs_34_5[1] = {
+	{22, 6},
+};
+static arc arcs_34_6[2] = {
+	{87, 7},
+	{0, 6},
+};
+static arc arcs_34_7[1] = {
+	{21, 8},
+};
+static arc arcs_34_8[1] = {
+	{22, 9},
+};
+static arc arcs_34_9[1] = {
+	{0, 9},
+};
+static state states_34[10] = {
 	{1, arcs_34_0},
-	{2, arcs_34_1},
-	{2, arcs_34_2},
+	{1, arcs_34_1},
+	{1, arcs_34_2},
 	{1, arcs_34_3},
 	{1, arcs_34_4},
+	{1, arcs_34_5},
+	{2, arcs_34_6},
+	{1, arcs_34_7},
+	{1, arcs_34_8},
+	{1, arcs_34_9},
 };
-static arc arcs_35_0[2] = {
-	{3, 1},
-	{2, 2},
+static arc arcs_35_0[1] = {
+	{90, 1},
 };
 static arc arcs_35_1[1] = {
-	{0, 1},
+	{21, 2},
 };
 static arc arcs_35_2[1] = {
-	{90, 3},
+	{22, 3},
 };
-static arc arcs_35_3[1] = {
-	{6, 4},
+static arc arcs_35_3[2] = {
+	{91, 4},
+	{92, 5},
 };
-static arc arcs_35_4[2] = {
-	{6, 4},
-	{91, 1},
+static arc arcs_35_4[1] = {
+	{21, 6},
 };
-static state states_35[5] = {
-	{2, arcs_35_0},
+static arc arcs_35_5[1] = {
+	{21, 7},
+};
+static arc arcs_35_6[1] = {
+	{22, 8},
+};
+static arc arcs_35_7[1] = {
+	{22, 9},
+};
+static arc arcs_35_8[3] = {
+	{91, 4},
+	{87, 5},
+	{0, 8},
+};
+static arc arcs_35_9[1] = {
+	{0, 9},
+};
+static state states_35[10] = {
+	{1, arcs_35_0},
 	{1, arcs_35_1},
 	{1, arcs_35_2},
-	{1, arcs_35_3},
-	{2, arcs_35_4},
+	{2, arcs_35_3},
+	{1, arcs_35_4},
+	{1, arcs_35_5},
+	{1, arcs_35_6},
+	{1, arcs_35_7},
+	{3, arcs_35_8},
+	{1, arcs_35_9},
 };
-static arc arcs_36_0[2] = {
-	{92, 1},
-	{94, 2},
+static arc arcs_36_0[1] = {
+	{93, 1},
 };
 static arc arcs_36_1[2] = {
-	{93, 3},
+	{26, 2},
 	{0, 1},
 };
-static arc arcs_36_2[1] = {
+static arc arcs_36_2[2] = {
+	{27, 3},
 	{0, 2},
 };
 static arc arcs_36_3[1] = {
-	{92, 1},
+	{26, 4},
 };
-static state states_36[4] = {
-	{2, arcs_36_0},
+static arc arcs_36_4[1] = {
+	{0, 4},
+};
+static state states_36[5] = {
+	{1, arcs_36_0},
 	{2, arcs_36_1},
-	{1, arcs_36_2},
+	{2, arcs_36_2},
 	{1, arcs_36_3},
+	{1, arcs_36_4},
 };
-static arc arcs_37_0[1] = {
-	{95, 1},
+static arc arcs_37_0[2] = {
+	{3, 1},
+	{2, 2},
 };
-static arc arcs_37_1[2] = {
-	{96, 0},
+static arc arcs_37_1[1] = {
 	{0, 1},
 };
-static state states_37[2] = {
-	{1, arcs_37_0},
-	{2, arcs_37_1},
+static arc arcs_37_2[1] = {
+	{94, 3},
+};
+static arc arcs_37_3[1] = {
+	{6, 4},
+};
+static arc arcs_37_4[2] = {
+	{6, 4},
+	{95, 1},
+};
+static state states_37[5] = {
+	{2, arcs_37_0},
+	{1, arcs_37_1},
+	{1, arcs_37_2},
+	{1, arcs_37_3},
+	{2, arcs_37_4},
 };
 static arc arcs_38_0[2] = {
-	{97, 1},
+	{96, 1},
 	{98, 2},
 };
-static arc arcs_38_1[1] = {
-	{95, 2},
+static arc arcs_38_1[2] = {
+	{97, 3},
+	{0, 1},
 };
 static arc arcs_38_2[1] = {
 	{0, 2},
 };
-static state states_38[3] = {
+static arc arcs_38_3[1] = {
+	{96, 1},
+};
+static state states_38[4] = {
 	{2, arcs_38_0},
-	{1, arcs_38_1},
+	{2, arcs_38_1},
 	{1, arcs_38_2},
+	{1, arcs_38_3},
 };
 static arc arcs_39_0[1] = {
-	{73, 1},
+	{99, 1},
 };
 static arc arcs_39_1[2] = {
-	{99, 0},
+	{100, 0},
 	{0, 1},
 };
 static state states_39[2] = {
 	{1, arcs_39_0},
 	{2, arcs_39_1},
 };
-static arc arcs_40_0[10] = {
-	{100, 1},
+static arc arcs_40_0[2] = {
 	{101, 1},
-	{102, 1},
-	{103, 1},
-	{104, 1},
-	{105, 1},
-	{106, 1},
-	{74, 1},
-	{97, 2},
-	{107, 3},
+	{102, 2},
 };
 static arc arcs_40_1[1] = {
-	{0, 1},
+	{99, 2},
 };
 static arc arcs_40_2[1] = {
-	{74, 1},
+	{0, 2},
 };
-static arc arcs_40_3[2] = {
-	{97, 1},
-	{0, 3},
-};
-static state states_40[4] = {
-	{10, arcs_40_0},
+static state states_40[3] = {
+	{2, arcs_40_0},
 	{1, arcs_40_1},
 	{1, arcs_40_2},
-	{2, arcs_40_3},
 };
 static arc arcs_41_0[1] = {
-	{108, 1},
+	{77, 1},
 };
 static arc arcs_41_1[2] = {
-	{109, 0},
+	{103, 0},
 	{0, 1},
 };
 static state states_41[2] = {
 	{1, arcs_41_0},
 	{2, arcs_41_1},
 };
-static arc arcs_42_0[1] = {
+static arc arcs_42_0[10] = {
+	{104, 1},
+	{105, 1},
+	{106, 1},
+	{107, 1},
+	{108, 1},
+	{109, 1},
 	{110, 1},
+	{78, 1},
+	{101, 2},
+	{111, 3},
 };
-static arc arcs_42_1[2] = {
-	{111, 0},
+static arc arcs_42_1[1] = {
 	{0, 1},
 };
-static state states_42[2] = {
-	{1, arcs_42_0},
-	{2, arcs_42_1},
+static arc arcs_42_2[1] = {
+	{78, 1},
+};
+static arc arcs_42_3[2] = {
+	{101, 1},
+	{0, 3},
+};
+static state states_42[4] = {
+	{10, arcs_42_0},
+	{1, arcs_42_1},
+	{1, arcs_42_2},
+	{2, arcs_42_3},
 };
 static arc arcs_43_0[1] = {
 	{112, 1},
@@ -942,811 +969,842 @@
 static arc arcs_44_0[1] = {
 	{114, 1},
 };
-static arc arcs_44_1[3] = {
+static arc arcs_44_1[2] = {
 	{115, 0},
-	{51, 0},
 	{0, 1},
 };
 static state states_44[2] = {
 	{1, arcs_44_0},
-	{3, arcs_44_1},
+	{2, arcs_44_1},
 };
 static arc arcs_45_0[1] = {
 	{116, 1},
 };
-static arc arcs_45_1[3] = {
+static arc arcs_45_1[2] = {
 	{117, 0},
-	{118, 0},
 	{0, 1},
 };
 static state states_45[2] = {
 	{1, arcs_45_0},
-	{3, arcs_45_1},
+	{2, arcs_45_1},
 };
 static arc arcs_46_0[1] = {
-	{119, 1},
+	{118, 1},
 };
-static arc arcs_46_1[5] = {
-	{23, 0},
-	{120, 0},
-	{121, 0},
-	{122, 0},
+static arc arcs_46_1[3] = {
+	{119, 0},
+	{56, 0},
 	{0, 1},
 };
 static state states_46[2] = {
 	{1, arcs_46_0},
-	{5, arcs_46_1},
+	{3, arcs_46_1},
 };
-static arc arcs_47_0[4] = {
-	{117, 1},
-	{118, 1},
-	{123, 1},
-	{124, 2},
+static arc arcs_47_0[1] = {
+	{120, 1},
 };
-static arc arcs_47_1[1] = {
-	{119, 2},
-};
-static arc arcs_47_2[1] = {
-	{0, 2},
-};
-static state states_47[3] = {
-	{4, arcs_47_0},
-	{1, arcs_47_1},
-	{1, arcs_47_2},
-};
-static arc arcs_48_0[1] = {
-	{125, 1},
-};
-static arc arcs_48_1[3] = {
-	{126, 1},
-	{24, 2},
+static arc arcs_47_1[3] = {
+	{121, 0},
+	{122, 0},
 	{0, 1},
 };
-static arc arcs_48_2[1] = {
-	{119, 3},
+static state states_47[2] = {
+	{1, arcs_47_0},
+	{3, arcs_47_1},
 };
-static arc arcs_48_3[1] = {
-	{0, 3},
+static arc arcs_48_0[1] = {
+	{123, 1},
 };
-static state states_48[4] = {
+static arc arcs_48_1[5] = {
+	{28, 0},
+	{124, 0},
+	{125, 0},
+	{126, 0},
+	{0, 1},
+};
+static state states_48[2] = {
 	{1, arcs_48_0},
-	{3, arcs_48_1},
-	{1, arcs_48_2},
-	{1, arcs_48_3},
+	{5, arcs_48_1},
 };
-static arc arcs_49_0[7] = {
-	{16, 1},
+static arc arcs_49_0[4] = {
+	{121, 1},
+	{122, 1},
+	{127, 1},
 	{128, 2},
-	{131, 3},
-	{134, 4},
-	{12, 5},
-	{136, 5},
-	{137, 6},
 };
-static arc arcs_49_1[2] = {
-	{127, 7},
-	{18, 5},
+static arc arcs_49_1[1] = {
+	{123, 2},
 };
-static arc arcs_49_2[2] = {
-	{129, 8},
-	{130, 5},
+static arc arcs_49_2[1] = {
+	{0, 2},
 };
-static arc arcs_49_3[2] = {
-	{132, 9},
-	{133, 5},
-};
-static arc arcs_49_4[1] = {
-	{135, 10},
-};
-static arc arcs_49_5[1] = {
-	{0, 5},
-};
-static arc arcs_49_6[2] = {
-	{137, 6},
-	{0, 6},
-};
-static arc arcs_49_7[1] = {
-	{18, 5},
-};
-static arc arcs_49_8[1] = {
-	{130, 5},
-};
-static arc arcs_49_9[1] = {
-	{133, 5},
-};
-static arc arcs_49_10[1] = {
-	{134, 5},
-};
-static state states_49[11] = {
-	{7, arcs_49_0},
-	{2, arcs_49_1},
-	{2, arcs_49_2},
-	{2, arcs_49_3},
-	{1, arcs_49_4},
-	{1, arcs_49_5},
-	{2, arcs_49_6},
-	{1, arcs_49_7},
-	{1, arcs_49_8},
-	{1, arcs_49_9},
-	{1, arcs_49_10},
+static state states_49[3] = {
+	{4, arcs_49_0},
+	{1, arcs_49_1},
+	{1, arcs_49_2},
 };
 static arc arcs_50_0[1] = {
-	{21, 1},
+	{129, 1},
 };
 static arc arcs_50_1[3] = {
-	{138, 2},
-	{22, 3},
+	{130, 1},
+	{29, 2},
 	{0, 1},
 };
 static arc arcs_50_2[1] = {
-	{0, 2},
+	{123, 3},
 };
-static arc arcs_50_3[2] = {
-	{21, 4},
+static arc arcs_50_3[1] = {
 	{0, 3},
 };
-static arc arcs_50_4[2] = {
-	{22, 3},
-	{0, 4},
-};
-static state states_50[5] = {
+static state states_50[4] = {
 	{1, arcs_50_0},
 	{3, arcs_50_1},
 	{1, arcs_50_2},
-	{2, arcs_50_3},
-	{2, arcs_50_4},
+	{1, arcs_50_3},
 };
-static arc arcs_51_0[1] = {
-	{21, 1},
+static arc arcs_51_0[7] = {
+	{13, 1},
+	{132, 2},
+	{135, 3},
+	{138, 4},
+	{19, 5},
+	{140, 5},
+	{141, 6},
 };
-static arc arcs_51_1[3] = {
-	{139, 2},
-	{22, 3},
-	{0, 1},
+static arc arcs_51_1[2] = {
+	{131, 7},
+	{15, 5},
 };
-static arc arcs_51_2[1] = {
-	{0, 2},
+static arc arcs_51_2[2] = {
+	{133, 8},
+	{134, 5},
 };
 static arc arcs_51_3[2] = {
-	{21, 4},
-	{0, 3},
+	{136, 9},
+	{137, 5},
 };
-static arc arcs_51_4[2] = {
-	{22, 3},
-	{0, 4},
+static arc arcs_51_4[1] = {
+	{139, 10},
 };
-static state states_51[5] = {
-	{1, arcs_51_0},
-	{3, arcs_51_1},
-	{1, arcs_51_2},
+static arc arcs_51_5[1] = {
+	{0, 5},
+};
+static arc arcs_51_6[2] = {
+	{141, 6},
+	{0, 6},
+};
+static arc arcs_51_7[1] = {
+	{15, 5},
+};
+static arc arcs_51_8[1] = {
+	{134, 5},
+};
+static arc arcs_51_9[1] = {
+	{137, 5},
+};
+static arc arcs_51_10[1] = {
+	{138, 5},
+};
+static state states_51[11] = {
+	{7, arcs_51_0},
+	{2, arcs_51_1},
+	{2, arcs_51_2},
 	{2, arcs_51_3},
-	{2, arcs_51_4},
+	{1, arcs_51_4},
+	{1, arcs_51_5},
+	{2, arcs_51_6},
+	{1, arcs_51_7},
+	{1, arcs_51_8},
+	{1, arcs_51_9},
+	{1, arcs_51_10},
 };
 static arc arcs_52_0[1] = {
-	{140, 1},
+	{26, 1},
 };
-static arc arcs_52_1[2] = {
-	{17, 2},
-	{14, 3},
+static arc arcs_52_1[3] = {
+	{142, 2},
+	{27, 3},
+	{0, 1},
 };
 static arc arcs_52_2[1] = {
-	{14, 3},
+	{0, 2},
 };
-static arc arcs_52_3[1] = {
-	{21, 4},
+static arc arcs_52_3[2] = {
+	{26, 4},
+	{0, 3},
 };
-static arc arcs_52_4[1] = {
+static arc arcs_52_4[2] = {
+	{27, 3},
 	{0, 4},
 };
 static state states_52[5] = {
 	{1, arcs_52_0},
-	{2, arcs_52_1},
+	{3, arcs_52_1},
 	{1, arcs_52_2},
-	{1, arcs_52_3},
-	{1, arcs_52_4},
+	{2, arcs_52_3},
+	{2, arcs_52_4},
 };
-static arc arcs_53_0[3] = {
-	{16, 1},
-	{128, 2},
-	{70, 3},
+static arc arcs_53_0[1] = {
+	{26, 1},
 };
-static arc arcs_53_1[2] = {
-	{141, 4},
-	{18, 5},
-};
-static arc arcs_53_2[1] = {
-	{142, 6},
-};
-static arc arcs_53_3[1] = {
-	{12, 5},
-};
-static arc arcs_53_4[1] = {
-	{18, 5},
-};
-static arc arcs_53_5[1] = {
-	{0, 5},
-};
-static arc arcs_53_6[1] = {
-	{130, 5},
-};
-static state states_53[7] = {
-	{3, arcs_53_0},
-	{2, arcs_53_1},
-	{1, arcs_53_2},
-	{1, arcs_53_3},
-	{1, arcs_53_4},
-	{1, arcs_53_5},
-	{1, arcs_53_6},
-};
-static arc arcs_54_0[1] = {
-	{143, 1},
-};
-static arc arcs_54_1[2] = {
-	{22, 2},
+static arc arcs_53_1[3] = {
+	{143, 2},
+	{27, 3},
 	{0, 1},
 };
-static arc arcs_54_2[2] = {
-	{143, 1},
+static arc arcs_53_2[1] = {
 	{0, 2},
 };
-static state states_54[3] = {
-	{1, arcs_54_0},
-	{2, arcs_54_1},
-	{2, arcs_54_2},
-};
-static arc arcs_55_0[3] = {
-	{70, 1},
-	{21, 2},
-	{14, 3},
-};
-static arc arcs_55_1[1] = {
-	{70, 4},
-};
-static arc arcs_55_2[2] = {
-	{14, 3},
-	{0, 2},
-};
-static arc arcs_55_3[3] = {
-	{21, 5},
-	{144, 6},
+static arc arcs_53_3[2] = {
+	{26, 4},
 	{0, 3},
 };
-static arc arcs_55_4[1] = {
-	{70, 6},
+static arc arcs_53_4[2] = {
+	{27, 3},
+	{0, 4},
 };
-static arc arcs_55_5[2] = {
-	{144, 6},
+static state states_53[5] = {
+	{1, arcs_53_0},
+	{3, arcs_53_1},
+	{1, arcs_53_2},
+	{2, arcs_53_3},
+	{2, arcs_53_4},
+};
+static arc arcs_54_0[1] = {
+	{144, 1},
+};
+static arc arcs_54_1[2] = {
+	{23, 2},
+	{21, 3},
+};
+static arc arcs_54_2[1] = {
+	{21, 3},
+};
+static arc arcs_54_3[1] = {
+	{26, 4},
+};
+static arc arcs_54_4[1] = {
+	{0, 4},
+};
+static state states_54[5] = {
+	{1, arcs_54_0},
+	{2, arcs_54_1},
+	{1, arcs_54_2},
+	{1, arcs_54_3},
+	{1, arcs_54_4},
+};
+static arc arcs_55_0[3] = {
+	{13, 1},
+	{132, 2},
+	{74, 3},
+};
+static arc arcs_55_1[2] = {
+	{14, 4},
+	{15, 5},
+};
+static arc arcs_55_2[1] = {
+	{145, 6},
+};
+static arc arcs_55_3[1] = {
+	{19, 5},
+};
+static arc arcs_55_4[1] = {
+	{15, 5},
+};
+static arc arcs_55_5[1] = {
 	{0, 5},
 };
 static arc arcs_55_6[1] = {
-	{0, 6},
+	{134, 5},
 };
 static state states_55[7] = {
 	{3, arcs_55_0},
-	{1, arcs_55_1},
-	{2, arcs_55_2},
-	{3, arcs_55_3},
+	{2, arcs_55_1},
+	{1, arcs_55_2},
+	{1, arcs_55_3},
 	{1, arcs_55_4},
-	{2, arcs_55_5},
+	{1, arcs_55_5},
 	{1, arcs_55_6},
 };
 static arc arcs_56_0[1] = {
-	{14, 1},
+	{146, 1},
 };
 static arc arcs_56_1[2] = {
-	{21, 2},
+	{27, 2},
 	{0, 1},
 };
-static arc arcs_56_2[1] = {
+static arc arcs_56_2[2] = {
+	{146, 1},
 	{0, 2},
 };
 static state states_56[3] = {
 	{1, arcs_56_0},
 	{2, arcs_56_1},
-	{1, arcs_56_2},
+	{2, arcs_56_2},
 };
-static arc arcs_57_0[1] = {
-	{73, 1},
+static arc arcs_57_0[3] = {
+	{74, 1},
+	{26, 2},
+	{21, 3},
 };
-static arc arcs_57_1[2] = {
-	{22, 2},
-	{0, 1},
+static arc arcs_57_1[1] = {
+	{74, 4},
 };
 static arc arcs_57_2[2] = {
-	{73, 1},
+	{21, 3},
 	{0, 2},
 };
-static state states_57[3] = {
-	{1, arcs_57_0},
-	{2, arcs_57_1},
+static arc arcs_57_3[3] = {
+	{26, 5},
+	{147, 6},
+	{0, 3},
+};
+static arc arcs_57_4[1] = {
+	{74, 6},
+};
+static arc arcs_57_5[2] = {
+	{147, 6},
+	{0, 5},
+};
+static arc arcs_57_6[1] = {
+	{0, 6},
+};
+static state states_57[7] = {
+	{3, arcs_57_0},
+	{1, arcs_57_1},
 	{2, arcs_57_2},
+	{3, arcs_57_3},
+	{1, arcs_57_4},
+	{2, arcs_57_5},
+	{1, arcs_57_6},
 };
 static arc arcs_58_0[1] = {
 	{21, 1},
 };
 static arc arcs_58_1[2] = {
-	{22, 2},
+	{26, 2},
 	{0, 1},
 };
-static arc arcs_58_2[2] = {
-	{21, 1},
+static arc arcs_58_2[1] = {
 	{0, 2},
 };
 static state states_58[3] = {
 	{1, arcs_58_0},
 	{2, arcs_58_1},
-	{2, arcs_58_2},
+	{1, arcs_58_2},
 };
 static arc arcs_59_0[1] = {
-	{21, 1},
+	{77, 1},
 };
 static arc arcs_59_1[2] = {
-	{22, 2},
+	{27, 2},
 	{0, 1},
 };
-static arc arcs_59_2[1] = {
-	{21, 3},
+static arc arcs_59_2[2] = {
+	{77, 1},
+	{0, 2},
 };
-static arc arcs_59_3[2] = {
-	{22, 4},
-	{0, 3},
-};
-static arc arcs_59_4[2] = {
-	{21, 3},
-	{0, 4},
-};
-static state states_59[5] = {
+static state states_59[3] = {
 	{1, arcs_59_0},
 	{2, arcs_59_1},
-	{1, arcs_59_2},
-	{2, arcs_59_3},
-	{2, arcs_59_4},
+	{2, arcs_59_2},
 };
 static arc arcs_60_0[1] = {
-	{21, 1},
+	{26, 1},
 };
-static arc arcs_60_1[1] = {
-	{14, 2},
+static arc arcs_60_1[2] = {
+	{27, 2},
+	{0, 1},
 };
-static arc arcs_60_2[1] = {
-	{21, 3},
+static arc arcs_60_2[2] = {
+	{26, 1},
+	{0, 2},
 };
-static arc arcs_60_3[2] = {
-	{22, 4},
-	{0, 3},
-};
-static arc arcs_60_4[2] = {
-	{21, 1},
-	{0, 4},
-};
-static state states_60[5] = {
+static state states_60[3] = {
 	{1, arcs_60_0},
-	{1, arcs_60_1},
-	{1, arcs_60_2},
-	{2, arcs_60_3},
-	{2, arcs_60_4},
+	{2, arcs_60_1},
+	{2, arcs_60_2},
 };
 static arc arcs_61_0[1] = {
-	{146, 1},
+	{26, 1},
 };
-static arc arcs_61_1[1] = {
-	{12, 2},
-};
-static arc arcs_61_2[2] = {
-	{16, 3},
-	{14, 4},
-};
-static arc arcs_61_3[1] = {
-	{9, 5},
-};
-static arc arcs_61_4[1] = {
-	{15, 6},
-};
-static arc arcs_61_5[1] = {
-	{18, 7},
-};
-static arc arcs_61_6[1] = {
-	{0, 6},
-};
-static arc arcs_61_7[1] = {
-	{14, 4},
-};
-static state states_61[8] = {
-	{1, arcs_61_0},
-	{1, arcs_61_1},
-	{2, arcs_61_2},
-	{1, arcs_61_3},
-	{1, arcs_61_4},
-	{1, arcs_61_5},
-	{1, arcs_61_6},
-	{1, arcs_61_7},
-};
-static arc arcs_62_0[3] = {
-	{147, 1},
-	{23, 2},
-	{24, 3},
-};
-static arc arcs_62_1[2] = {
-	{22, 4},
+static arc arcs_61_1[2] = {
+	{27, 2},
 	{0, 1},
 };
-static arc arcs_62_2[1] = {
-	{21, 5},
+static arc arcs_61_2[1] = {
+	{26, 3},
 };
-static arc arcs_62_3[1] = {
-	{21, 6},
+static arc arcs_61_3[2] = {
+	{27, 4},
+	{0, 3},
 };
-static arc arcs_62_4[4] = {
-	{147, 1},
-	{23, 2},
-	{24, 3},
+static arc arcs_61_4[2] = {
+	{26, 3},
 	{0, 4},
 };
-static arc arcs_62_5[2] = {
-	{22, 7},
-	{0, 5},
+static state states_61[5] = {
+	{1, arcs_61_0},
+	{2, arcs_61_1},
+	{1, arcs_61_2},
+	{2, arcs_61_3},
+	{2, arcs_61_4},
 };
-static arc arcs_62_6[1] = {
-	{0, 6},
+static arc arcs_62_0[1] = {
+	{26, 1},
 };
-static arc arcs_62_7[1] = {
-	{24, 3},
+static arc arcs_62_1[1] = {
+	{21, 2},
 };
-static state states_62[8] = {
-	{3, arcs_62_0},
-	{2, arcs_62_1},
+static arc arcs_62_2[1] = {
+	{26, 3},
+};
+static arc arcs_62_3[2] = {
+	{27, 4},
+	{0, 3},
+};
+static arc arcs_62_4[2] = {
+	{26, 1},
+	{0, 4},
+};
+static state states_62[5] = {
+	{1, arcs_62_0},
+	{1, arcs_62_1},
 	{1, arcs_62_2},
-	{1, arcs_62_3},
-	{4, arcs_62_4},
-	{2, arcs_62_5},
-	{1, arcs_62_6},
-	{1, arcs_62_7},
+	{2, arcs_62_3},
+	{2, arcs_62_4},
 };
 static arc arcs_63_0[1] = {
-	{21, 1},
+	{149, 1},
 };
-static arc arcs_63_1[3] = {
-	{20, 2},
-	{139, 3},
-	{0, 1},
+static arc arcs_63_1[1] = {
+	{19, 2},
 };
-static arc arcs_63_2[1] = {
+static arc arcs_63_2[2] = {
+	{13, 3},
 	{21, 4},
 };
 static arc arcs_63_3[1] = {
-	{0, 3},
+	{9, 5},
 };
-static arc arcs_63_4[2] = {
-	{139, 3},
-	{0, 4},
+static arc arcs_63_4[1] = {
+	{22, 6},
 };
-static state states_63[5] = {
+static arc arcs_63_5[1] = {
+	{15, 7},
+};
+static arc arcs_63_6[1] = {
+	{0, 6},
+};
+static arc arcs_63_7[1] = {
+	{21, 4},
+};
+static state states_63[8] = {
 	{1, arcs_63_0},
-	{3, arcs_63_1},
-	{1, arcs_63_2},
+	{1, arcs_63_1},
+	{2, arcs_63_2},
 	{1, arcs_63_3},
-	{2, arcs_63_4},
+	{1, arcs_63_4},
+	{1, arcs_63_5},
+	{1, arcs_63_6},
+	{1, arcs_63_7},
 };
-static arc arcs_64_0[2] = {
-	{138, 1},
-	{149, 1},
+static arc arcs_64_0[3] = {
+	{150, 1},
+	{28, 2},
+	{29, 3},
 };
-static arc arcs_64_1[1] = {
+static arc arcs_64_1[2] = {
+	{27, 4},
 	{0, 1},
 };
-static state states_64[2] = {
-	{2, arcs_64_0},
-	{1, arcs_64_1},
+static arc arcs_64_2[1] = {
+	{26, 5},
 };
-static arc arcs_65_0[1] = {
-	{85, 1},
+static arc arcs_64_3[1] = {
+	{26, 6},
 };
-static arc arcs_65_1[1] = {
-	{53, 2},
-};
-static arc arcs_65_2[1] = {
-	{74, 3},
-};
-static arc arcs_65_3[1] = {
-	{145, 4},
-};
-static arc arcs_65_4[2] = {
-	{148, 5},
+static arc arcs_64_4[4] = {
+	{150, 1},
+	{28, 2},
+	{29, 3},
 	{0, 4},
 };
-static arc arcs_65_5[1] = {
+static arc arcs_64_5[2] = {
+	{27, 7},
 	{0, 5},
 };
-static state states_65[6] = {
+static arc arcs_64_6[1] = {
+	{0, 6},
+};
+static arc arcs_64_7[1] = {
+	{29, 3},
+};
+static state states_64[8] = {
+	{3, arcs_64_0},
+	{2, arcs_64_1},
+	{1, arcs_64_2},
+	{1, arcs_64_3},
+	{4, arcs_64_4},
+	{2, arcs_64_5},
+	{1, arcs_64_6},
+	{1, arcs_64_7},
+};
+static arc arcs_65_0[1] = {
+	{26, 1},
+};
+static arc arcs_65_1[3] = {
+	{25, 2},
+	{143, 3},
+	{0, 1},
+};
+static arc arcs_65_2[1] = {
+	{26, 4},
+};
+static arc arcs_65_3[1] = {
+	{0, 3},
+};
+static arc arcs_65_4[2] = {
+	{143, 3},
+	{0, 4},
+};
+static state states_65[5] = {
 	{1, arcs_65_0},
-	{1, arcs_65_1},
+	{3, arcs_65_1},
 	{1, arcs_65_2},
 	{1, arcs_65_3},
 	{2, arcs_65_4},
-	{1, arcs_65_5},
 };
-static arc arcs_66_0[1] = {
-	{81, 1},
+static arc arcs_66_0[2] = {
+	{142, 1},
+	{152, 1},
 };
 static arc arcs_66_1[1] = {
-	{21, 2},
-};
-static arc arcs_66_2[2] = {
-	{148, 3},
-	{0, 2},
-};
-static arc arcs_66_3[1] = {
-	{0, 3},
-};
-static state states_66[4] = {
-	{1, arcs_66_0},
-	{1, arcs_66_1},
-	{2, arcs_66_2},
-	{1, arcs_66_3},
-};
-static arc arcs_67_0[2] = {
-	{139, 1},
-	{151, 1},
-};
-static arc arcs_67_1[1] = {
 	{0, 1},
 };
-static state states_67[2] = {
-	{2, arcs_67_0},
+static state states_66[2] = {
+	{2, arcs_66_0},
+	{1, arcs_66_1},
+};
+static arc arcs_67_0[1] = {
+	{89, 1},
+};
+static arc arcs_67_1[1] = {
+	{58, 2},
+};
+static arc arcs_67_2[1] = {
+	{78, 3},
+};
+static arc arcs_67_3[1] = {
+	{148, 4},
+};
+static arc arcs_67_4[2] = {
+	{151, 5},
+	{0, 4},
+};
+static arc arcs_67_5[1] = {
+	{0, 5},
+};
+static state states_67[6] = {
+	{1, arcs_67_0},
 	{1, arcs_67_1},
+	{1, arcs_67_2},
+	{1, arcs_67_3},
+	{2, arcs_67_4},
+	{1, arcs_67_5},
 };
 static arc arcs_68_0[1] = {
 	{85, 1},
 };
 static arc arcs_68_1[1] = {
-	{53, 2},
+	{26, 2},
 };
-static arc arcs_68_2[1] = {
-	{74, 3},
-};
-static arc arcs_68_3[1] = {
-	{21, 4},
-};
-static arc arcs_68_4[2] = {
-	{150, 5},
-	{0, 4},
-};
-static arc arcs_68_5[1] = {
-	{0, 5},
-};
-static state states_68[6] = {
-	{1, arcs_68_0},
-	{1, arcs_68_1},
-	{1, arcs_68_2},
-	{1, arcs_68_3},
-	{2, arcs_68_4},
-	{1, arcs_68_5},
-};
-static arc arcs_69_0[1] = {
-	{81, 1},
-};
-static arc arcs_69_1[1] = {
-	{21, 2},
-};
-static arc arcs_69_2[2] = {
-	{150, 3},
+static arc arcs_68_2[2] = {
+	{151, 3},
 	{0, 2},
 };
-static arc arcs_69_3[1] = {
+static arc arcs_68_3[1] = {
 	{0, 3},
 };
-static state states_69[4] = {
-	{1, arcs_69_0},
+static state states_68[4] = {
+	{1, arcs_68_0},
+	{1, arcs_68_1},
+	{2, arcs_68_2},
+	{1, arcs_68_3},
+};
+static arc arcs_69_0[2] = {
+	{143, 1},
+	{154, 1},
+};
+static arc arcs_69_1[1] = {
+	{0, 1},
+};
+static state states_69[2] = {
+	{2, arcs_69_0},
 	{1, arcs_69_1},
-	{2, arcs_69_2},
-	{1, arcs_69_3},
 };
 static arc arcs_70_0[1] = {
-	{21, 1},
+	{89, 1},
 };
-static arc arcs_70_1[2] = {
-	{22, 0},
-	{0, 1},
+static arc arcs_70_1[1] = {
+	{58, 2},
 };
-static state states_70[2] = {
+static arc arcs_70_2[1] = {
+	{78, 3},
+};
+static arc arcs_70_3[1] = {
+	{26, 4},
+};
+static arc arcs_70_4[2] = {
+	{153, 5},
+	{0, 4},
+};
+static arc arcs_70_5[1] = {
+	{0, 5},
+};
+static state states_70[6] = {
 	{1, arcs_70_0},
-	{2, arcs_70_1},
+	{1, arcs_70_1},
+	{1, arcs_70_2},
+	{1, arcs_70_3},
+	{2, arcs_70_4},
+	{1, arcs_70_5},
 };
 static arc arcs_71_0[1] = {
-	{12, 1},
+	{85, 1},
 };
 static arc arcs_71_1[1] = {
-	{0, 1},
+	{26, 2},
 };
-static state states_71[2] = {
+static arc arcs_71_2[2] = {
+	{153, 3},
+	{0, 2},
+};
+static arc arcs_71_3[1] = {
+	{0, 3},
+};
+static state states_71[4] = {
 	{1, arcs_71_0},
 	{1, arcs_71_1},
+	{2, arcs_71_2},
+	{1, arcs_71_3},
 };
-static dfa dfas[72] = {
+static arc arcs_72_0[1] = {
+	{26, 1},
+};
+static arc arcs_72_1[2] = {
+	{27, 0},
+	{0, 1},
+};
+static state states_72[2] = {
+	{1, arcs_72_0},
+	{2, arcs_72_1},
+};
+static arc arcs_73_0[1] = {
+	{19, 1},
+};
+static arc arcs_73_1[1] = {
+	{0, 1},
+};
+static state states_73[2] = {
+	{1, arcs_73_0},
+	{1, arcs_73_1},
+};
+static dfa dfas[74] = {
 	{256, "single_input", 0, 3, states_0,
-	 "\004\030\001\000\000\000\124\360\213\011\162\000\002\000\140\010\111\023\004\000"},
+	 "\004\050\014\000\000\000\200\012\176\231\040\007\040\000\000\206\220\064\041\000"},
 	{257, "file_input", 0, 2, states_1,
-	 "\204\030\001\000\000\000\124\360\213\011\162\000\002\000\140\010\111\023\004\000"},
+	 "\204\050\014\000\000\000\200\012\176\231\040\007\040\000\000\206\220\064\041\000"},
 	{258, "eval_input", 0, 3, states_2,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{259, "funcdef", 0, 6, states_3,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{259, "decorator", 0, 6, states_3,
 	 "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{260, "parameters", 0, 4, states_4,
-	 "\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{261, "varargslist", 0, 10, states_5,
-	 "\000\020\201\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{262, "fpdef", 0, 4, states_6,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{263, "fplist", 0, 3, states_7,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{264, "stmt", 0, 2, states_8,
-	 "\000\030\001\000\000\000\124\360\213\011\162\000\002\000\140\010\111\023\004\000"},
-	{265, "simple_stmt", 0, 4, states_9,
-	 "\000\020\001\000\000\000\124\360\213\011\000\000\002\000\140\010\111\023\000\000"},
-	{266, "small_stmt", 0, 2, states_10,
-	 "\000\020\001\000\000\000\124\360\213\011\000\000\002\000\140\010\111\023\000\000"},
-	{267, "expr_stmt", 0, 6, states_11,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{268, "augassign", 0, 2, states_12,
-	 "\000\000\000\000\300\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{269, "print_stmt", 0, 9, states_13,
-	 "\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{270, "del_stmt", 0, 3, states_14,
-	 "\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{271, "pass_stmt", 0, 2, states_15,
-	 "\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{272, "flow_stmt", 0, 2, states_16,
-	 "\000\000\000\000\000\000\000\360\001\000\000\000\000\000\000\000\000\000\000\000"},
-	{273, "break_stmt", 0, 2, states_17,
-	 "\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{274, "continue_stmt", 0, 2, states_18,
-	 "\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{275, "return_stmt", 0, 3, states_19,
-	 "\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{276, "yield_stmt", 0, 3, states_20,
-	 "\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{277, "raise_stmt", 0, 7, states_21,
-	 "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000"},
-	{278, "import_stmt", 0, 9, states_22,
-	 "\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000"},
-	{279, "import_as_name", 0, 4, states_23,
-	 "\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{280, "dotted_as_name", 0, 4, states_24,
-	 "\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{281, "dotted_name", 0, 2, states_25,
-	 "\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{282, "global_stmt", 0, 3, states_26,
-	 "\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000"},
-	{283, "exec_stmt", 0, 7, states_27,
-	 "\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000"},
-	{284, "assert_stmt", 0, 5, states_28,
+	{260, "decorators", 0, 3, states_4,
+	 "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{261, "funcdef", 0, 7, states_5,
+	 "\000\010\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{262, "parameters", 0, 4, states_6,
+	 "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{263, "varargslist", 0, 10, states_7,
+	 "\000\040\010\060\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{264, "fpdef", 0, 4, states_8,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{265, "fplist", 0, 3, states_9,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{266, "stmt", 0, 2, states_10,
+	 "\000\050\014\000\000\000\200\012\176\231\040\007\040\000\000\206\220\064\041\000"},
+	{267, "simple_stmt", 0, 4, states_11,
+	 "\000\040\010\000\000\000\200\012\176\231\000\000\040\000\000\206\220\064\001\000"},
+	{268, "small_stmt", 0, 2, states_12,
+	 "\000\040\010\000\000\000\200\012\176\231\000\000\040\000\000\206\220\064\001\000"},
+	{269, "expr_stmt", 0, 6, states_13,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{270, "augassign", 0, 2, states_14,
+	 "\000\000\000\000\000\370\177\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{271, "print_stmt", 0, 9, states_15,
+	 "\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{272, "del_stmt", 0, 3, states_16,
+	 "\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{273, "pass_stmt", 0, 2, states_17,
+	 "\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{274, "flow_stmt", 0, 2, states_18,
+	 "\000\000\000\000\000\000\000\000\076\000\000\000\000\000\000\000\000\000\000\000"},
+	{275, "break_stmt", 0, 2, states_19,
+	 "\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000"},
+	{276, "continue_stmt", 0, 2, states_20,
+	 "\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000"},
+	{277, "return_stmt", 0, 3, states_21,
+	 "\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000"},
+	{278, "yield_stmt", 0, 3, states_22,
+	 "\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000"},
+	{279, "raise_stmt", 0, 7, states_23,
+	 "\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000"},
+	{280, "import_stmt", 0, 9, states_24,
+	 "\000\000\000\000\000\000\000\000\100\001\000\000\000\000\000\000\000\000\000\000"},
+	{281, "import_as_name", 0, 4, states_25,
+	 "\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{282, "dotted_as_name", 0, 4, states_26,
+	 "\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{283, "dotted_name", 0, 2, states_27,
+	 "\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{284, "global_stmt", 0, 3, states_28,
 	 "\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000"},
-	{285, "compound_stmt", 0, 2, states_29,
-	 "\000\010\000\000\000\000\000\000\000\000\162\000\000\000\000\000\000\000\004\000"},
-	{286, "if_stmt", 0, 8, states_30,
-	 "\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000"},
-	{287, "while_stmt", 0, 8, states_31,
-	 "\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000"},
-	{288, "for_stmt", 0, 10, states_32,
+	{285, "exec_stmt", 0, 7, states_29,
+	 "\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000"},
+	{286, "assert_stmt", 0, 5, states_30,
+	 "\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000"},
+	{287, "compound_stmt", 0, 2, states_31,
+	 "\000\010\004\000\000\000\000\000\000\000\040\007\000\000\000\000\000\000\040\000"},
+	{288, "if_stmt", 0, 8, states_32,
 	 "\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000"},
-	{289, "try_stmt", 0, 10, states_33,
-	 "\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000"},
-	{290, "except_clause", 0, 5, states_34,
+	{289, "while_stmt", 0, 8, states_33,
+	 "\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000"},
+	{290, "for_stmt", 0, 10, states_34,
 	 "\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000"},
-	{291, "suite", 0, 5, states_35,
-	 "\004\020\001\000\000\000\124\360\213\011\000\000\002\000\140\010\111\023\000\000"},
-	{292, "test", 0, 4, states_36,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{293, "and_test", 0, 2, states_37,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\003\000\000"},
-	{294, "not_test", 0, 3, states_38,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\003\000\000"},
-	{295, "comparison", 0, 2, states_39,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{296, "comp_op", 0, 4, states_40,
-	 "\000\000\000\000\000\000\000\000\000\004\000\000\362\017\000\000\000\000\000\000"},
-	{297, "expr", 0, 2, states_41,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{298, "xor_expr", 0, 2, states_42,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{299, "and_expr", 0, 2, states_43,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{300, "shift_expr", 0, 2, states_44,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{301, "arith_expr", 0, 2, states_45,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{302, "term", 0, 2, states_46,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{303, "factor", 0, 3, states_47,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{304, "power", 0, 4, states_48,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\000\000\111\003\000\000"},
-	{305, "atom", 0, 11, states_49,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\000\000\111\003\000\000"},
-	{306, "listmaker", 0, 5, states_50,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{307, "testlist_gexp", 0, 5, states_51,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{308, "lambdef", 0, 5, states_52,
-	 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\000"},
-	{309, "trailer", 0, 7, states_53,
-	 "\000\000\001\000\000\000\000\000\100\000\000\000\000\000\000\000\001\000\000\000"},
-	{310, "subscriptlist", 0, 3, states_54,
-	 "\000\120\001\000\000\000\000\000\100\000\000\000\002\000\140\010\111\023\000\000"},
-	{311, "subscript", 0, 7, states_55,
-	 "\000\120\001\000\000\000\000\000\100\000\000\000\002\000\140\010\111\023\000\000"},
-	{312, "sliceop", 0, 3, states_56,
-	 "\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
-	{313, "exprlist", 0, 3, states_57,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\000\000\140\010\111\003\000\000"},
-	{314, "testlist", 0, 3, states_58,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{315, "testlist_safe", 0, 5, states_59,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{316, "dictmaker", 0, 5, states_60,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{317, "classdef", 0, 8, states_61,
-	 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000"},
-	{318, "arglist", 0, 8, states_62,
-	 "\000\020\201\001\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{319, "argument", 0, 5, states_63,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{320, "list_iter", 0, 2, states_64,
-	 "\000\000\000\000\000\000\000\000\000\000\042\000\000\000\000\000\000\000\000\000"},
-	{321, "list_for", 0, 6, states_65,
+	{291, "try_stmt", 0, 10, states_35,
+	 "\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000"},
+	{292, "except_clause", 0, 5, states_36,
+	 "\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000"},
+	{293, "suite", 0, 5, states_37,
+	 "\004\040\010\000\000\000\200\012\176\231\000\000\040\000\000\206\220\064\001\000"},
+	{294, "test", 0, 4, states_38,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{295, "and_test", 0, 2, states_39,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\000\000"},
+	{296, "not_test", 0, 3, states_40,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\000\000"},
+	{297, "comparison", 0, 2, states_41,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{298, "comp_op", 0, 4, states_42,
+	 "\000\000\000\000\000\000\000\000\000\100\000\000\040\377\000\000\000\000\000\000"},
+	{299, "expr", 0, 2, states_43,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{300, "xor_expr", 0, 2, states_44,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{301, "and_expr", 0, 2, states_45,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{302, "shift_expr", 0, 2, states_46,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{303, "arith_expr", 0, 2, states_47,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{304, "term", 0, 2, states_48,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{305, "factor", 0, 3, states_49,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{306, "power", 0, 4, states_50,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\000\220\064\000\000"},
+	{307, "atom", 0, 11, states_51,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\000\220\064\000\000"},
+	{308, "listmaker", 0, 5, states_52,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{309, "testlist_gexp", 0, 5, states_53,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{310, "lambdef", 0, 5, states_54,
+	 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000"},
+	{311, "trailer", 0, 7, states_55,
+	 "\000\040\000\000\000\000\000\000\000\004\000\000\000\000\000\000\020\000\000\000"},
+	{312, "subscriptlist", 0, 3, states_56,
+	 "\000\040\050\000\000\000\000\000\000\004\000\000\040\000\000\206\220\064\001\000"},
+	{313, "subscript", 0, 7, states_57,
+	 "\000\040\050\000\000\000\000\000\000\004\000\000\040\000\000\206\220\064\001\000"},
+	{314, "sliceop", 0, 3, states_58,
+	 "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{315, "exprlist", 0, 3, states_59,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\000\000\000\206\220\064\000\000"},
+	{316, "testlist", 0, 3, states_60,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{317, "testlist_safe", 0, 5, states_61,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{318, "dictmaker", 0, 5, states_62,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{319, "classdef", 0, 8, states_63,
+	 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\040\000"},
+	{320, "arglist", 0, 8, states_64,
+	 "\000\040\010\060\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{321, "argument", 0, 5, states_65,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{322, "list_iter", 0, 2, states_66,
+	 "\000\000\000\000\000\000\000\000\000\000\040\002\000\000\000\000\000\000\000\000"},
+	{323, "list_for", 0, 6, states_67,
+	 "\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000"},
+	{324, "list_if", 0, 4, states_68,
 	 "\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000"},
-	{322, "list_if", 0, 4, states_66,
-	 "\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000"},
-	{323, "gen_iter", 0, 2, states_67,
-	 "\000\000\000\000\000\000\000\000\000\000\042\000\000\000\000\000\000\000\000\000"},
-	{324, "gen_for", 0, 6, states_68,
+	{325, "gen_iter", 0, 2, states_69,
+	 "\000\000\000\000\000\000\000\000\000\000\040\002\000\000\000\000\000\000\000\000"},
+	{326, "gen_for", 0, 6, states_70,
+	 "\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000"},
+	{327, "gen_if", 0, 4, states_71,
 	 "\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000"},
-	{325, "gen_if", 0, 4, states_69,
-	 "\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000"},
-	{326, "testlist1", 0, 2, states_70,
-	 "\000\020\001\000\000\000\000\000\000\000\000\000\002\000\140\010\111\023\000\000"},
-	{327, "encoding_decl", 0, 2, states_71,
-	 "\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
+	{328, "testlist1", 0, 2, states_72,
+	 "\000\040\010\000\000\000\000\000\000\000\000\000\040\000\000\206\220\064\001\000"},
+	{329, "encoding_decl", 0, 2, states_73,
+	 "\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"},
 };
-static label labels[153] = {
+static label labels[156] = {
 	{0, "EMPTY"},
 	{256, 0},
 	{4, 0},
-	{265, 0},
-	{285, 0},
+	{267, 0},
+	{287, 0},
 	{257, 0},
-	{264, 0},
+	{266, 0},
 	{0, 0},
 	{258, 0},
-	{314, 0},
+	{316, 0},
 	{259, 0},
+	{50, 0},
+	{283, 0},
+	{7, 0},
+	{320, 0},
+	{8, 0},
+	{260, 0},
+	{261, 0},
 	{1, "def"},
 	{1, 0},
-	{260, 0},
-	{11, 0},
-	{291, 0},
-	{7, 0},
-	{261, 0},
-	{8, 0},
 	{262, 0},
+	{11, 0},
+	{293, 0},
+	{263, 0},
+	{264, 0},
 	{22, 0},
-	{292, 0},
+	{294, 0},
 	{12, 0},
 	{16, 0},
 	{36, 0},
-	{263, 0},
-	{266, 0},
+	{265, 0},
+	{268, 0},
 	{13, 0},
-	{267, 0},
 	{269, 0},
-	{270, 0},
 	{271, 0},
 	{272, 0},
-	{278, 0},
-	{282, 0},
-	{283, 0},
+	{273, 0},
+	{274, 0},
+	{280, 0},
 	{284, 0},
-	{268, 0},
+	{285, 0},
+	{286, 0},
+	{270, 0},
 	{37, 0},
 	{38, 0},
 	{39, 0},
@@ -1762,53 +1820,52 @@
 	{1, "print"},
 	{35, 0},
 	{1, "del"},
-	{313, 0},
+	{315, 0},
 	{1, "pass"},
-	{273, 0},
-	{274, 0},
 	{275, 0},
-	{277, 0},
 	{276, 0},
+	{277, 0},
+	{279, 0},
+	{278, 0},
 	{1, "break"},
 	{1, "continue"},
 	{1, "return"},
 	{1, "yield"},
 	{1, "raise"},
 	{1, "import"},
-	{280, 0},
+	{282, 0},
 	{1, "from"},
 	{281, 0},
-	{279, 0},
 	{23, 0},
 	{1, "global"},
 	{1, "exec"},
-	{297, 0},
+	{299, 0},
 	{1, "in"},
 	{1, "assert"},
-	{286, 0},
-	{287, 0},
 	{288, 0},
 	{289, 0},
-	{317, 0},
+	{290, 0},
+	{291, 0},
+	{319, 0},
 	{1, "if"},
 	{1, "elif"},
 	{1, "else"},
 	{1, "while"},
 	{1, "for"},
 	{1, "try"},
-	{290, 0},
+	{292, 0},
 	{1, "finally"},
 	{1, "except"},
 	{5, 0},
 	{6, 0},
-	{293, 0},
+	{295, 0},
 	{1, "or"},
-	{308, 0},
-	{294, 0},
+	{310, 0},
+	{296, 0},
 	{1, "and"},
 	{1, "not"},
-	{295, 0},
-	{296, 0},
+	{297, 0},
+	{298, 0},
 	{20, 0},
 	{21, 0},
 	{28, 0},
@@ -1817,55 +1874,54 @@
 	{29, 0},
 	{29, 0},
 	{1, "is"},
-	{298, 0},
-	{18, 0},
-	{299, 0},
-	{33, 0},
 	{300, 0},
-	{19, 0},
+	{18, 0},
 	{301, 0},
-	{34, 0},
+	{33, 0},
 	{302, 0},
+	{19, 0},
+	{303, 0},
+	{34, 0},
+	{304, 0},
 	{14, 0},
 	{15, 0},
-	{303, 0},
+	{305, 0},
 	{17, 0},
 	{24, 0},
 	{48, 0},
 	{32, 0},
-	{304, 0},
-	{305, 0},
-	{309, 0},
-	{307, 0},
-	{9, 0},
 	{306, 0},
+	{307, 0},
+	{311, 0},
+	{309, 0},
+	{9, 0},
+	{308, 0},
 	{10, 0},
 	{26, 0},
-	{316, 0},
+	{318, 0},
 	{27, 0},
 	{25, 0},
-	{326, 0},
+	{328, 0},
 	{2, 0},
 	{3, 0},
-	{321, 0},
-	{324, 0},
-	{1, "lambda"},
-	{318, 0},
-	{310, 0},
-	{311, 0},
-	{312, 0},
-	{315, 0},
-	{1, "class"},
-	{319, 0},
-	{320, 0},
-	{322, 0},
 	{323, 0},
+	{326, 0},
+	{1, "lambda"},
+	{312, 0},
+	{313, 0},
+	{314, 0},
+	{317, 0},
+	{1, "class"},
+	{321, 0},
+	{322, 0},
+	{324, 0},
 	{325, 0},
 	{327, 0},
+	{329, 0},
 };
 grammar _PyParser_Grammar = {
-	72,
+	74,
 	dfas,
-	{153, labels},
+	{156, labels},
 	256
 };
diff --git a/Tools/compiler/ast.txt b/Tools/compiler/ast.txt
index 6a990d4..a235b99 100644
--- a/Tools/compiler/ast.txt
+++ b/Tools/compiler/ast.txt
@@ -8,7 +8,8 @@
 #  = ... a default value for the node constructor (optional args)
 Module: doc*, node
 Stmt: nodes!
-Function: name*, argnames*, defaults!, flags*, doc*, code
+Decorators: nodes!
+Function: decorators&, name*, argnames*, defaults!, flags*, doc*, code
 Lambda: argnames*, defaults!, flags*, code
 Class: name*, bases!, doc*, code
 Pass: 
diff --git a/Tools/compiler/astgen.py b/Tools/compiler/astgen.py
index 08d501b..4fe4bbe 100644
--- a/Tools/compiler/astgen.py
+++ b/Tools/compiler/astgen.py
@@ -154,19 +154,19 @@
                 else:
                     print >> buf, "        return %s" % COMMA.join(clist)
             else:
-                print >> buf, "        nodes = []"
-                template = "        nodes.%s(%sself.%s%s)"
+                print >> buf, "        nodelist = []"
+                template = "        nodelist.%s(%sself.%s%s)"
                 for name in self.argnames:
                     if self.argprops[name] == P_NONE:
                         tmp = ("        if self.%s is not None:"
-                               "            nodes.append(self.%s)")
+                               "            nodelist.append(self.%s)")
                         print >> buf, tmp % (name, name)
                     elif self.argprops[name] == P_NESTED:
                         print >> buf, template % ("extend", "flatten_nodes(",
                                                   name, ")")
                     elif self.argprops[name] == P_NODE:
                         print >> buf, template % ("append", "", name, "")
-                print >> buf, "        return tuple(nodes)"
+                print >> buf, "        return tuple(nodelist)"
 
     def _gen_repr(self, buf):
         print >> buf, "    def __repr__(self):"
@@ -208,7 +208,7 @@
             # some extra code for a Node's __init__ method
             name = mo.group(1)
             cur = classes[name]
-    return classes.values()
+    return sorted(classes.values(), key=lambda n: n.name)
 
 def main():
     prologue, epilogue = load_boilerplate(sys.argv[-1])
@@ -245,9 +245,9 @@
 def flatten_nodes(list):
     return [n for n in flatten(list) if isinstance(n, Node)]
 
-def asList(nodes):
+def asList(nodearg):
     l = []
-    for item in nodes:
+    for item in nodearg:
         if hasattr(item, "asList"):
             l.append(item.asList())
         else:
@@ -274,6 +274,21 @@
 class EmptyNode(Node):
     pass
 
+class Expression(Node):
+    # Expression is an artificial node class to support "eval"
+    nodes["expression"] = "Expression"
+    def __init__(self, node):
+        self.node = node
+
+    def getChildren(self):
+        return self.node,
+
+    def getChildNodes(self):
+        return self.node,
+
+    def __repr__(self):
+        return "Expression(%s)" % (repr(self.node))
+
 ### EPILOGUE
 klasses = globals()
 for k in nodes.keys():
diff --git a/Tools/compiler/regrtest.py b/Tools/compiler/regrtest.py
index def07c2..50d06e7 100644
--- a/Tools/compiler/regrtest.py
+++ b/Tools/compiler/regrtest.py
@@ -47,6 +47,8 @@
                 continue
             # make sure the .pyc file is not over-written
             os.chmod(source + "c", 444)
+        elif file == 'CVS':
+            pass
         else:
             path = os.path.join(dir, file)
             if os.path.isdir(path):