X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fparser.tab.c;h=964770c4d0fb2e19594aea572f07928004de9bdb;hb=c63b2bf21dc1df9a736f0b4c08f6cba828cdab92;hp=59cda49dac493e81d184c251be1e08c4002a3a4a;hpb=15d3df10f09bd780efa101d0c253db96716eb145;p=swftools.git

diff --git a/lib/as3/parser.tab.c b/lib/as3/parser.tab.c
index 59cda49..964770c 100644
--- a/lib/as3/parser.tab.c
+++ b/lib/as3/parser.tab.c
@@ -1,5 +1,5 @@
 
-/* A Bison parser, made by GNU Bison 2.4.  */
+/* A Bison parser, made by GNU Bison 2.4.1.  */
 
 /* Skeleton implementation for Bison's Yacc-like parsers in C
    
@@ -46,7 +46,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.4"
+#define YYBISON_VERSION "2.4.1"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "./skeleton.m4"
@@ -84,18 +84,21 @@
 #include "abc.h"
 #include "pool.h"
 #include "files.h"
+#include "common.h"
 #include "tokenizer.h"
 #include "registry.h"
 #include "code.h"
 #include "opcodes.h"
 #include "compiler.h"
+#include "expr.h"
+#include "initcode.h"
 
 extern int a3_lex();
 
 
 
 /* Line 198 of skeleton.m4  */
-#line 99 "parser.tab.c"
+#line 102 "parser.tab.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -123,65 +126,65 @@ extern int a3_lex();
       know about them.  */
    enum yytokentype {
      T_IDENTIFIER = 258,
-     T_NAMESPACE = 259,
-     T_STRING = 260,
-     T_REGEXP = 261,
-     T_EMPTY = 262,
-     T_INT = 263,
-     T_UINT = 264,
-     T_BYTE = 265,
-     T_SHORT = 266,
-     T_FLOAT = 267,
-     T_FOR = 268,
-     T_WHILE = 269,
-     T_DO = 270,
-     T_SWITCH = 271,
-     KW_IMPLEMENTS = 272,
-     KW_NAMESPACE = 273,
-     KW_PACKAGE = 274,
-     KW_PROTECTED = 275,
-     KW_PUBLIC = 276,
-     KW_PRIVATE = 277,
-     KW_USE = 278,
-     KW_INTERNAL = 279,
-     KW_NEW = 280,
-     KW_NATIVE = 281,
-     KW_FUNCTION = 282,
-     KW_FINALLY = 283,
-     KW_UNDEFINED = 284,
-     KW_CONTINUE = 285,
-     KW_CLASS = 286,
-     KW_CONST = 287,
-     KW_CATCH = 288,
-     KW_CASE = 289,
-     KW_SET = 290,
-     KW_VOID = 291,
-     KW_THROW = 292,
-     KW_STATIC = 293,
-     KW_WITH = 294,
-     KW_INSTANCEOF = 295,
-     KW_IMPORT = 296,
-     KW_RETURN = 297,
-     KW_TYPEOF = 298,
-     KW_INTERFACE = 299,
-     KW_NULL = 300,
-     KW_VAR = 301,
-     KW_DYNAMIC = 302,
-     KW_OVERRIDE = 303,
-     KW_FINAL = 304,
-     KW_EACH = 305,
-     KW_GET = 306,
-     KW_TRY = 307,
-     KW_SUPER = 308,
-     KW_EXTENDS = 309,
-     KW_FALSE = 310,
-     KW_TRUE = 311,
-     KW_BOOLEAN = 312,
-     KW_UINT = 313,
-     KW_INT = 314,
-     KW_NUMBER = 315,
-     KW_STRING = 316,
-     KW_DEFAULT = 317,
+     T_STRING = 259,
+     T_REGEXP = 260,
+     T_EMPTY = 261,
+     T_INT = 262,
+     T_UINT = 263,
+     T_FLOAT = 264,
+     T_FOR = 265,
+     T_WHILE = 266,
+     T_DO = 267,
+     T_SWITCH = 268,
+     KW_IMPLEMENTS = 269,
+     KW_NAMESPACE = 270,
+     KW_PACKAGE = 271,
+     KW_PROTECTED = 272,
+     KW_ARGUMENTS = 273,
+     KW_PUBLIC = 274,
+     KW_PRIVATE = 275,
+     KW_USE = 276,
+     KW_INTERNAL = 277,
+     KW_NEW = 278,
+     KW_NATIVE = 279,
+     KW_FUNCTION = 280,
+     KW_FINALLY = 281,
+     KW_UNDEFINED = 282,
+     KW_NAN = 283,
+     KW_CONTINUE = 284,
+     KW_CLASS = 285,
+     KW_CONST = 286,
+     KW_CATCH = 287,
+     KW_CASE = 288,
+     KW_SET = 289,
+     KW_VOID = 290,
+     KW_THROW = 291,
+     KW_STATIC = 292,
+     KW_WITH = 293,
+     KW_INSTANCEOF = 294,
+     KW_IMPORT = 295,
+     KW_RETURN = 296,
+     KW_TYPEOF = 297,
+     KW_INTERFACE = 298,
+     KW_NULL = 299,
+     KW_VAR = 300,
+     KW_DYNAMIC = 301,
+     KW_OVERRIDE = 302,
+     KW_FINAL = 303,
+     KW_EACH = 304,
+     KW_GET = 305,
+     KW_TRY = 306,
+     KW_SUPER = 307,
+     KW_EXTENDS = 308,
+     KW_FALSE = 309,
+     KW_TRUE = 310,
+     KW_BOOLEAN = 311,
+     KW_UINT = 312,
+     KW_INT = 313,
+     KW_NUMBER = 314,
+     KW_STRING = 315,
+     KW_DEFAULT = 316,
+     KW_DEFAULT_XML = 317,
      KW_DELETE = 318,
      KW_IF = 319,
      KW_ELSE = 320,
@@ -200,33 +203,35 @@ extern int a3_lex();
      T_DIVBY = 333,
      T_MODBY = 334,
      T_MULBY = 335,
-     T_PLUSBY = 336,
-     T_MINUSBY = 337,
-     T_XORBY = 338,
-     T_SHRBY = 339,
-     T_SHLBY = 340,
-     T_USHRBY = 341,
-     T_OROR = 342,
-     T_ANDAND = 343,
-     T_COLONCOLON = 344,
-     T_MINUSMINUS = 345,
-     T_PLUSPLUS = 346,
-     T_DOTDOT = 347,
-     T_DOTDOTDOT = 348,
-     T_SHL = 349,
-     T_USHR = 350,
-     T_SHR = 351,
-     prec_none = 352,
-     below_semicolon = 353,
-     below_assignment = 354,
-     below_minus = 356,
-     minusminus_prefix = 357,
-     plusplus_prefix = 358,
-     below_curly = 359,
-     new2 = 360,
-     above_identifier = 361,
-     below_else = 362,
-     above_function = 363
+     T_ANDBY = 336,
+     T_PLUSBY = 337,
+     T_MINUSBY = 338,
+     T_XORBY = 339,
+     T_SHRBY = 340,
+     T_SHLBY = 341,
+     T_USHRBY = 342,
+     T_OROR = 343,
+     T_ANDAND = 344,
+     T_COLONCOLON = 345,
+     T_MINUSMINUS = 346,
+     T_PLUSPLUS = 347,
+     T_DOTDOT = 348,
+     T_DOTDOTDOT = 349,
+     T_SHL = 350,
+     T_USHR = 351,
+     T_SHR = 352,
+     prec_none = 353,
+     below_semicolon = 354,
+     below_assignment = 355,
+     below_lt = 356,
+     below_minus = 357,
+     minusminus_prefix = 358,
+     plusplus_prefix = 359,
+     below_curly = 360,
+     new2 = 361,
+     above_identifier = 362,
+     below_else = 363,
+     above_function = 364
    };
 #endif
 
@@ -235,12 +240,12 @@ extern int a3_lex();
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union 
 /* Line 223 of skeleton.m4  */
-#line 44 "parser.y"
+#line 47 "parser.y"
 tokenunion
 {
 
 /* Line 223 of skeleton.m4  */
-#line 44 "parser.y"
+#line 47 "parser.y"
 
     enum yytokentype token;
 
@@ -266,6 +271,7 @@ tokenunion
     regexp_t regexp;
     modifiers_t flags;
     namespace_decl_t* namespace_decl;
+    node_t*node;
     struct {
         abc_exception_list_t *l;
         code_t*finally;
@@ -274,7 +280,7 @@ tokenunion
 
 
 /* Line 223 of skeleton.m4  */
-#line 278 "parser.tab.c"
+#line 284 "parser.tab.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -285,7 +291,7 @@ tokenunion
 /* Copy the second part of user declarations.  */
 
 /* Line 273 of skeleton.m4  */
-#line 265 "parser.y"
+#line 274 "parser.y"
 
 
 static int a3_error(char*s)
@@ -294,6 +300,13 @@ static int a3_error(char*s)
    return 0; //make gcc happy
 }
 
+static void parsererror(const char*file, int line, const char*f)
+{
+    syntaxerror("internal error in %s, %s:%d", f, file, line);
+}
+
+#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
+
 
 static char* concat2(const char* t1, const char* t2)
 {
@@ -321,7 +334,6 @@ static char* concat3(const char* t1, const char* t2, const char* t3)
 typedef struct _import {
     char*package;
 } import_t;
-
 DECLARE_LIST(import);
 
 DECLARE(methodstate);
@@ -331,11 +343,12 @@ typedef struct _classstate {
     /* class data */
     classinfo_t*info;
     abc_class_t*abc;
-   
+
     methodstate_t*init;
     methodstate_t*static_init;
     //code_t*init;
     //code_t*static_init;
+    parsedclass_t*dependencies;
 
     char has_constructor;
 } classstate_t;
@@ -348,14 +361,20 @@ struct _methodstate {
     char is_constructor;
     char has_super;
     char is_global;
+    char is_static;
     int variable_count;
 
     dict_t*unresolved_variables;
+    dict_t*allvars; // all variables (in all sublevels, but not for inner functions)
 
     char inner;
     char uses_parent_function;
+    char no_variable_scoping;
     int uses_slots;
     dict_t*slots;
+    int activation_var;
+
+    int need_arguments;
 
     abc_method_t*abc;
     int var_index; // for inner methods
@@ -370,6 +389,23 @@ struct _methodstate {
     methodstate_list_t*innerfunctions;
 };
 
+methodstate_t*methodstate_new()
+{
+    NEW(methodstate_t,m);
+    m->allvars = dict_new();
+    return m;
+}
+void methodstate_destroy(methodstate_t*m) 
+{
+    dict_destroy(m->unresolved_variables); m->unresolved_variables = 0;
+    list_free(m->innerfunctions);m->innerfunctions=0;
+
+    if(m->allvars) {
+        DICT_ITERATE_DATA(m->allvars, void*, data) {free(data);}
+        m->allvars = 0;
+    }
+}
+
 typedef struct _state {
     struct _state*old;
     int level;
@@ -378,22 +414,32 @@ typedef struct _state {
     import_list_t*wildcard_imports;
     dict_t*import_toplevel_packages;
     dict_t*imports;
-    namespace_list_t*active_namespaces;
-    namespace_decl_list_t*new_namespaces;
+
+    dict_t*namespaces;
+    namespace_list_t*active_namespace_urls;
+    
     char has_own_imports;
     char new_vars; // e.g. transition between two functions
+    char xmlfilter; // are we inside a xmlobj..() filter?
   
     classstate_t*cls;   
     methodstate_t*method;
 
     char*exception_name;
+
+    int switch_var;
     
     dict_t*vars;
 } state_t;
 
 typedef struct _global {
     abc_file_t*file;
-    abc_script_t*init;
+
+    parsedclass_list_t*classes;
+    abc_script_t*classinit;
+
+    abc_script_t*init; //package-level code
+
     dict_t*token2info;
     dict_t*file2token2info;
 } global_t;
@@ -403,18 +449,19 @@ static state_t* state = 0;
 
 DECLARE_LIST(state);
 
-#define MULTINAME(m,x) \
-    multiname_t m;\
-    namespace_t m##_ns;\
-    (x)->package; \
-    registry_fill_multiname(&m, &m##_ns, (slotinfo_t*)(x));
-                    
+/* protected handling here is a big hack: we just assume the protectedns
+   is package:class. the correct approach would be to add the proper
+   namespace to all protected members in the registry, even though that
+   would slow down searching */
 #define MEMBER_MULTINAME(m,f,n) \
     multiname_t m;\
     namespace_t m##_ns;\
     if(f) { \
-        if((m##_ns.access = ((slotinfo_t*)(f))->access)==ACCESS_NAMESPACE) \
+        m##_ns.access = ((slotinfo_t*)(f))->access; \
+        if(m##_ns.access == ACCESS_NAMESPACE) \
             m##_ns.name = ((slotinfo_t*)(f))->package; \
+        else if(m##_ns.access == ACCESS_PROTECTED && (f)->parent) \
+            m##_ns.name = concat3((f)->parent->package,":",(f)->parent->name); \
         else \
             m##_ns.name = ""; \
         m.type = QNAME; \
@@ -441,13 +488,22 @@ DECLARE_LIST(state);
 static namespace_t ns1 = {ACCESS_PRIVATE, ""};
 static namespace_t ns2 = {ACCESS_PROTECTED, ""};
 static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};
-static namespace_t ns4 = {ACCESS_PACKAGE, ""};
-static namespace_list_t nl4 = {&ns4,0};
+static namespace_t stdns = {ACCESS_PACKAGE, ""};
+static namespace_list_t nl4 = {&stdns,0};
 static namespace_list_t nl3 = {&ns3,&nl4};
 static namespace_list_t nl2 = {&ns2,&nl3};
 static namespace_list_t nl1 = {&ns1,&nl2};
 static namespace_set_t nopackage_namespace_set = {&nl1};
 
+static dict_t*definitions=0;
+void as3_set_define(const char*c)
+{
+    if(!definitions) 
+        definitions = dict_new();
+    if(!dict_contains(definitions,c))
+        dict_put(definitions,c,0);
+}
+
 static void new_state()
 {
     NEW(state_t, s);
@@ -463,28 +519,14 @@ static void new_state()
     state = s;
     state->level++;
     state->has_own_imports = 0;    
-    state->new_namespaces = 0;
     state->vars = dict_new(); 
     state->old = oldstate;
     state->new_vars = 0;
-}
-static void state_has_imports()
-{
-    state->wildcard_imports = list_clone(state->wildcard_imports);
-    state->imports = dict_clone(state->imports);
-    state->has_own_imports = 1;
-}
-static void import_toplevel(const char*package)
-{
-    char* s = strdup(package);
-    while(1) {
-        dict_put(state->import_toplevel_packages, s, 0);
-        char*x = strrchr(s, '.');
-        if(!x)
-            break;
-        *x = 0;
-    }
-    free(s);
+
+    state->namespaces = dict_new();
+   
+    if(oldstate)
+        state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);
 }
 
 static void state_destroy(state_t*state)
@@ -497,17 +539,12 @@ static void state_destroy(state_t*state)
         dict_destroy(state->imports);state->imports=0;
     }
     if(state->vars) {
-        int t;
-        for(t=0;t<state->vars->hashsize;t++) {
-            dictentry_t*e =state->vars->slots[t];
-            while(e) {
-                free(e->data);e->data=0;
-                e = e->next;
-            }
-        }
         dict_destroy(state->vars);state->vars=0;
     }
     
+    list_free(state->active_namespace_urls)
+    state->active_namespace_urls = 0;
+    
     free(state);
 }
 
@@ -519,27 +556,20 @@ static void old_state()
     
     state = state->old;
 
-    namespace_decl_list_t*nl=leaving->new_namespaces;
-    while(nl) {
-        tokenizer_unregister_namespace(nl->namespace_decl->name);
-        nl = nl->next;
-    }
-    
     if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
-        free(leaving->method);
-        leaving->method=0;
+        methodstate_destroy(leaving->method);leaving->method=0;
     }
     if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
         free(leaving->cls);
         leaving->cls=0;
     }
-    
+
     state_destroy(leaving);
 }
 
 static code_t* method_header(methodstate_t*m);
 static code_t* wrap_function(code_t*c,code_t*header, code_t*body);
-static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0);
+static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0);
 
 
 static char* internal_filename_package = 0;
@@ -548,6 +578,7 @@ void initialize_file(char*filename)
     if(state) {
         syntaxerror("invalid call to initialize_file during parsing of another file");
     }
+    
     new_state();
     state->package = internal_filename_package = strdup(filename);
     
@@ -563,10 +594,14 @@ void initialize_file(char*filename)
         state->method = rfx_calloc(sizeof(methodstate_t));
         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
         state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
+	state->method->allvars = dict_new();
     } else {
         state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
-        function_initvars(state->method, 0, 0, 1);
-        global->init = abc_initscript(global->file);
+        state->method->variable_count = 0;
+        if(!state->method)
+            syntaxerror("internal error: skewed tokencount");
+        function_initvars(state->method, 0, 0, 0, 1);
+        global->init = 0;
     }
 }
 
@@ -575,12 +610,16 @@ void finish_file()
     if(!state || state->level!=1) {
         syntaxerror("unexpected end of file in pass %d", as3_pass);
     }
-
+    
     if(as3_pass==2) {
+        dict_del(global->file2token2info, current_filename);
         code_t*header = method_header(state->method);
-        code_t*c = wrap_function(header, 0, global->init->method->body->code);
-        global->init->method->body->code = c;
-        free(state->method);state->method=0;
+        //if(global->init->method->body->code || global->init->traits) {
+        if(global->init) {
+            code_t*c = wrap_function(header, 0, global->init->method->body->code);
+            global->init->method->body->code = abc_returnvoid(c);
+            free(state->method);state->method=0;
+        }
     }
 
     //free(state->package);state->package=0; // used in registry
@@ -594,69 +633,48 @@ void initialize_parser()
     global->file->flags &= ~ABCFILE_LAZY;
     global->file2token2info = dict_new();
     global->token2info = 0;
+    global->classinit = abc_initscript(global->file);
 }
 
 void* finish_parser()
 {
     dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
-
     global->token2info=0;
-
-    return global->file;
-}
-
-
-static void xx_scopetest() 
-{
-    /* findpropstrict doesn't just return a scope object- it
-       also makes it "active" somehow. Push local_0 on the
-       scope stack and read it back with findpropstrict, it'll
-       contain properties like "trace". Trying to find the same
-       property on a "vanilla" local_0 yields only a "undefined" */
-    //c = abc_findpropstrict(c, "[package]::trace");
     
-    /*c = abc_getlocal_0(c);
-    c = abc_findpropstrict(c, "[package]::trace");
-    c = abc_coerce_a(c);
-    c = abc_setlocal_1(c);
+    initcode_add_classlist(global->classinit, global->classes);
 
-    c = abc_pushbyte(c, 0);
-    c = abc_setlocal_2(c);
-   
-    code_t*xx = c = abc_label(c);
-    c = abc_findpropstrict(c, "[package]::trace");
-    c = abc_pushstring(c, "prop:");
-    c = abc_hasnext2(c, 1, 2);
-    c = abc_dup(c);
-    c = abc_setlocal_3(c);
-    c = abc_callpropvoid(c, "[package]::trace", 2);
-    c = abc_getlocal_3(c);
-    c = abc_kill(c, 3);
-    c = abc_iftrue(c,xx);*/
+    return global->file;
 }
 
 typedef struct _variable {
     int index;
     classinfo_t*type;
     char init;
+    char kill;
+    char is_parameter;
     methodstate_t*is_inner_method;
 } variable_t;
 
-static variable_t* find_variable(state_t*s, char*name)
+static variable_t* find_variable(state_t*s, const char*name)
 {
-    while(s) {
-        variable_t*v = 0;
-        v = dict_lookup(s->vars, name);
-        if(v) return v;
-        if(s->new_vars) break;
-        s = s->old;
+    if(s->method->no_variable_scoping) {
+        return dict_lookup(s->method->allvars, name);
+    } else {
+        state_t*top = s;
+        while(s) {
+            variable_t*v = 0;
+            v = dict_lookup(s->vars, name);
+            if(v) return v;
+            if(s->new_vars) break;
+            s = s->old;
+        }
+        return 0;
     }
-    return 0;
 }
-static variable_t* find_slot(state_t*s, const char*name)
+static variable_t* find_slot(methodstate_t*m, const char*name)
 {
-    if(s->method && s->method->slots)
-        return dict_lookup(s->method->slots, name);
+    if(m && m->slots)
+        return dict_lookup(m->slots, name);
     return 0;
 }
 
@@ -667,61 +685,110 @@ static variable_t* find_variable_safe(state_t*s, char*name)
         syntaxerror("undefined variable: %s", name);
     return v;
 }
+
 static char variable_exists(char*name) 
 {
     return dict_contains(state->vars, name);
 }
-code_t*defaultvalue(code_t*c, classinfo_t*type);
 
-static variable_t* new_variable2(const char*name, classinfo_t*type, char init, char maybeslot)
+static code_t*defaultvalue(code_t*c, classinfo_t*type)
+{
+    parserassert(!type || type->kind!=INFOTYPE_UNRESOLVED);
+    if(TYPE_IS_INT(type)) {
+       c = abc_pushbyte(c, 0);
+    } else if(TYPE_IS_UINT(type)) {
+       c = abc_pushuint(c, 0);
+    } else if(TYPE_IS_FLOAT(type)) {
+       c = abc_pushnan(c);
+    } else if(TYPE_IS_BOOLEAN(type)) {
+       c = abc_pushfalse(c);
+    } else if(TYPE_IS_STRING(type)) {
+       c = abc_pushnull(c);
+       c = abc_coerce_s(c);
+    } else if(!type) {
+       //c = abc_pushundefined(c);
+        syntaxerror("internal error: can't generate default value for * type");
+    } else {
+       c = abc_pushnull(c);
+       MULTINAME(m, type);
+       c = abc_coerce2(c, &m);
+    }
+    return c;
+}
+
+static int alloc_local()
+{
+    return state->method->variable_count++;
+}
+
+static variable_t* new_variable2(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
 {
     if(maybeslot) {
-        variable_t*v = find_slot(state, name);
-        if(v)
+        variable_t*v = find_slot(method, name);
+        if(v) {
+            alloc_local(); 
             return v;
+        }
     }
 
     NEW(variable_t, v);
-    v->index = state->method->variable_count++;
+    v->index = alloc_local();
     v->type = type;
-    v->init = init;
+    v->init = v->kill = init;
  
-    if(name) 
-        dict_put(state->vars, name, v);
+    if(name) {
+        if(!method->no_variable_scoping) 
+        {
+            if(dict_contains(state->vars, name)) {
+                syntaxerror("variable %s already defined", name);
+            }
+            dict_put(state->vars, name, v);
+        }
+        if(method->no_variable_scoping && 
+           as3_pass==2 && 
+           dict_contains(state->method->allvars, name)) 
+        {
+            variable_t*v = dict_lookup(state->method->allvars, name);
+            if(v->type != type && (!v->type || v->type->kind!=INFOTYPE_UNRESOLVED)) {
+                syntaxerror("variable %s already defined.", name);
+	    }
+            return v;
+        }
+        dict_put(state->method->allvars, name, v);
+    }
 
     return v;
 }
-static int new_variable(const char*name, classinfo_t*type, char init, char maybeslot)
+static int new_variable(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
 {
-    return new_variable2(name, type, init, maybeslot)->index;
+    return new_variable2(method, name, type, init, maybeslot)->index;
 }
 
 #define TEMPVARNAME "__as3_temp__"
-static int gettempvar()
+int gettempvar()
 {
     variable_t*v = find_variable(state, TEMPVARNAME);
+    int i;
     if(v) 
-        return v->index;
-    return new_variable(TEMPVARNAME, 0, 0, 0);
+        i = v->index;
+    else
+        i = new_variable(state->method, TEMPVARNAME, 0, 0, 0);
+    parserassert(i);
+    return i;
 }
 
-code_t* var_block(code_t*body) 
+static code_t* var_block(code_t*body, dict_t*vars) 
 {
     code_t*c = 0;
     code_t*k = 0;
     int t;
-    int num=0;
-    for(t=0;t<state->vars->hashsize;t++) {
-        dictentry_t*e = state->vars->slots[t];
-        while(e) {
-            variable_t*v = (variable_t*)e->data;
-            if(v->type && v->init) {
-                c = defaultvalue(c, v->type);
-                c = abc_setlocal(c, v->index);
-                k = abc_kill(k, v->index); 
-                num++;
-            }
-            e = e->next;
+    DICT_ITERATE_DATA(vars, variable_t*, v) {
+        if(v->type && v->init) {
+            c = defaultvalue(c, v->type);
+            c = abc_setlocal(c, v->index);
+        }
+        if(v->type && v->kill) {
+            k = abc_kill(k, v->index); 
         }
     }
 
@@ -749,7 +816,7 @@ code_t* var_block(code_t*body)
     return c;
 }
 
-void unknown_variable(char*name) 
+static void unknown_variable(char*name) 
 {
     if(!state->method->unresolved_variables)
         state->method->unresolved_variables = dict_new();
@@ -757,25 +824,27 @@ void unknown_variable(char*name)
         dict_put(state->method->unresolved_variables, name, 0);
 }
 
-#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
-
-static void parsererror(const char*file, int line, const char*f)
-{
-    syntaxerror("internal error in %s, %s:%d", f, file, line);
-}
-
-   
-static code_t* add_scope_code(code_t*c, methodstate_t*m)
+static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
 {
-    if(m->uses_slots || (m->late_binding && !m->inner)) {
+    if(m->uses_slots || m->innerfunctions || (m->late_binding && !m->inner)) {
         c = abc_getlocal_0(c);
         c = abc_pushscope(c);
     }
     if(m->uses_slots) {
-        /* FIXME: does this need to be the same activation object as
-                  in the function header? */
-        c = abc_newactivation(c);
-        c = abc_pushscope(c);
+        /* FIXME: this alloc_local() causes variable indexes to be
+           different in pass2 than in pass1 */
+        if(!m->activation_var) {
+            m->activation_var = alloc_local();
+        }
+        if(init) {
+            c = abc_newactivation(c);
+            c = abc_dup(c);
+            c = abc_pushscope(c);
+            c = abc_setlocal(c, m->activation_var);
+        } else {
+            c = abc_getlocal(c, m->activation_var);
+            c = abc_pushscope(c);
+        }
     }
     return c;
 }
@@ -784,7 +853,7 @@ static code_t* method_header(methodstate_t*m)
 {
     code_t*c = 0;
 
-    c = add_scope_code(c, m);
+    c = add_scope_code(c, m, 1);
 
     methodstate_list_t*l = m->innerfunctions;
     while(l) {
@@ -811,6 +880,19 @@ static code_t* method_header(methodstate_t*m)
         c = abc_getlocal_0(c);
         c = abc_constructsuper(c, 0);
     }
+
+    if(m->slots) {
+        /* all parameters that are used by inner functions
+           need to be copied from local to slot */
+        parserassert(m->activation_var);
+        DICT_ITERATE_ITEMS(m->slots,char*,name,variable_t*,v) {
+            if(v->is_parameter) {
+                c = abc_getlocal(c, m->activation_var); 
+                c = abc_getlocal(c, v->index); 
+                c = abc_setslot(c, v->index); 
+            }
+        }
+    }
     list_free(m->innerfunctions);
     m->innerfunctions = 0;
     return c;
@@ -820,7 +902,7 @@ static code_t* method_header(methodstate_t*m)
 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
 {
     c = code_append(c, header);
-    c = code_append(c, var_block(body));
+    c = code_append(c, var_block(body, state->method->no_variable_scoping?state->method->allvars:state->vars));
     /* append return if necessary */
     if(!c || (c->opcode != OPCODE_RETURNVOID && 
               c->opcode != OPCODE_RETURNVALUE)) {
@@ -829,20 +911,15 @@ static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
     return c;
 }
 
-
 static void startpackage(char*name)
 {
     new_state();
-    /*printf("entering package \"%s\"\n", name);*/
     state->package = strdup(name);
 }
 static void endpackage()
 {
-    /*printf("leaving package \"%s\"\n", state->package);*/
-
     //used e.g. in classinfo_register:
     //free(state->package);state->package=0;
-
     old_state();
 }
 
@@ -852,6 +929,29 @@ static void endpackage()
 #define FLAG_PACKAGEINTERNAL 2048
 #define FLAG_NAMESPACE 4096
 
+static slotinfo_t* find_class(const char*name);
+
+const char* lookup_namespace(const char*name)
+{
+    state_t*s = state;
+    while(s) {
+	const char*url = dict_lookup(s->namespaces, name);
+	if(url) 
+	    return url;
+	s = s->old;
+    }
+    varinfo_t*a;
+    registry_find(state->package, name);
+    if(( a = (varinfo_t*)find_class(name) )) {
+	if(a->kind == INFOTYPE_VAR) {
+	    if(!a->value || !NS_TYPE(a->value->type)) 
+		syntaxerror("%s.%s is not a namespace", a->package, a->name);
+	    return a->value->ns->name;
+	}
+    }
+    return 0;
+}
+
 static namespace_t modifiers2access(modifiers_t*mod)
 {
     namespace_t ns;
@@ -861,7 +961,15 @@ static namespace_t modifiers2access(modifiers_t*mod)
         if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
             syntaxerror("invalid combination of access levels and namespaces");
         ns.access = ACCESS_NAMESPACE;
-        ns.name = mod->ns;
+	const char*url = lookup_namespace(mod->ns);
+	if(!url) {
+	    if(as3_pass>1) {
+		syntaxerror("unknown namespace: %s (pass %d)", mod->ns, as3_pass);
+	    } else {
+		url = mod->ns;
+	    }
+	}
+        ns.name = url;
     } else if(mod->flags&FLAG_PUBLIC)  {
         if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
             syntaxerror("invalid combination of access levels");
@@ -879,64 +987,86 @@ static namespace_t modifiers2access(modifiers_t*mod)
     }
     return ns;
 }
-static slotinfo_t* find_class(const char*name);
 
-static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0)
+static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse, char is_static)
+{
+    return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse, is_static);
+}
+
+static void innerfunctions2vars(methodstate_t*m)
+{
+    methodstate_list_t*l = m->innerfunctions;
+    while(l) {
+        methodstate_t*m = l->methodstate;
+        
+        variable_t* v = new_variable2(state->method, m->info->name, TYPE_FUNCTION(m->info), 0, 0);
+        m->var_index = v->index;
+        if(m->is_a_slot)
+            m->slot_index = m->is_a_slot;
+        v->is_inner_method = m;
+        l = l->next;
+    }
+}
+
+static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0)
 {
     if(var0) {
         int index = -1;
         if(m->inner)
-            index = new_variable("this", 0, 0, 0);
+            index = new_variable(m, "this", 0, 0, 0);
         else if(!m->is_global)
-            index = new_variable((flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
+            index = new_variable(m, (flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);
         else
-            index = new_variable("globalscope", 0, 0, 0);
-        if(index)
-            *(int*)0=0;
+            index = new_variable(m, "globalscope", 0, 0, 0);
+        if(index) {
+            DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
+                printf("%s %d\n", name, v->index);
+            }
+        }
         parserassert(!index);
     }
 
-    if(m->uses_slots) {
-        /* as variables and slots share the same number, make sure
-           that those variable indices are reserved. It's up to the
-           optimizer to later shuffle the variables down to lower
-           indices */
-        m->variable_count = m->uses_slots;
-    }
-
-    if(params) {
+    if(has_params) {
         param_list_t*p=0;
         for(p=params->list;p;p=p->next) {
-            new_variable(p->param->name, p->param->type, 0, 1);
+            variable_t*v = new_variable2(m, p->param->name, p->param->type, 0, 1);
+            v->is_parameter = 1;
+        }
+        if(as3_pass==2 && m->need_arguments) {
+            /* arguments can never be used by an innerfunction (the inner functions
+               have their own arguments var), so it's ok to  not initialize this until
+               pass 2. (We don't know whether we need it before, anyway) */
+            variable_t*v = new_variable2(m, "arguments", TYPE_ARRAY, 0, 0);
+            m->need_arguments = v->index;
         }
     }
-
-    if(as3_pass==2) {
-        m->scope_code = add_scope_code(m->scope_code, m);
-    }
-
     
-    methodstate_list_t*l = m->innerfunctions;
-    while(l) {
-        methodstate_t*m = l->methodstate;
-        
-        variable_t* v = new_variable2(m->info->name, TYPE_FUNCTION(m->info), 0, 1);
-        m->var_index = v->index;
-        m->slot_index = v->index;
-        v->is_inner_method = m;
-
-        l = l->next;
-    }
+    innerfunctions2vars(m);
     
-    if(as3_pass==2 && m->slots) {
-        /* exchange unresolved identifiers with the actual objects */
-        DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {
-            if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {
-                v->type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
-                if(!v->type || v->type->kind != INFOTYPE_CLASS) {
-                    syntaxerror("Couldn't find class %s", v->type->name);
+    if(as3_pass==2) {
+        m->scope_code = add_scope_code(m->scope_code, m, 0);
+        if(m->slots) {
+            /* exchange unresolved identifiers with the actual objects */
+            DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v1) {
+                if(v1->type && v1->type->kind == INFOTYPE_UNRESOLVED) {
+                    classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v1->type);
+                    if(!type || type->kind != INFOTYPE_CLASS) {
+                        syntaxerror("Couldn't find class %s::%s (%s)", v1->type->package, v1->type->name, name);
+                    }
+                    v1->type = type;
                 }
             }
+	}
+	if(m->allvars) {
+            DICT_ITERATE_ITEMS(m->allvars, char*, name2, variable_t*, v2) {
+                if(v2->type && v2->type->kind == INFOTYPE_UNRESOLVED) {
+                    classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v2->type);
+                    if(!type || type->kind != INFOTYPE_CLASS) {
+                        syntaxerror("Couldn't find class %s::%s (%s)", v2->type->package, v2->type->name, name2);
+                    }
+                    v2->type = type;
+                }
+	    }
         }
     }
 }
@@ -959,6 +1089,9 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
     if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
         syntaxerror("public and internal not supported at the same time.");
     
+    if((mod->flags&(FLAG_PROTECTED|FLAG_STATIC)) == (FLAG_PROTECTED|FLAG_STATIC))
+        syntaxerror("protected and static not supported at the same time.");
+    
     //if(!(mod->flags&FLAG_INTERFACE) && !extends) {
     if(!(mod->flags&FLAG_INTERFACE) && !extends) {
         // all classes extend object
@@ -981,10 +1114,11 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
 
     if(as3_pass==1) {
         state->cls = rfx_calloc(sizeof(classstate_t));
-        state->cls->init = rfx_calloc(sizeof(methodstate_t));
-        state->cls->static_init = rfx_calloc(sizeof(methodstate_t));
+        state->cls->init = methodstate_new();
+        state->cls->static_init = methodstate_new();
+        state->cls->static_init->is_static=FLAG_STATIC;
         /* notice: we make no effort to initialize the top variable (local0) here,
-           even though it has special meaning. We just rely on the facat
+           even though it has special meaning. We just rely on the fact
            that pass 1 won't do anything with variables */
         
         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
@@ -1000,6 +1134,7 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
         int num_interfaces = (list_length(implements));
         state->cls->info = classinfo_register(access, package, classname, num_interfaces);
         state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);
+        state->cls->info->superclass = extends;
         
         int pos = 0;
         classinfo_list_t*l = implements;
@@ -1010,12 +1145,14 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
     
     if(as3_pass == 2) {
         state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
-        
-        state->method = state->cls->init;
+    
         parserassert(state->cls && state->cls->info);
        
-        function_initvars(state->cls->init, 0, 0, 1);
-        function_initvars(state->cls->static_init, 0, 0, 0);
+        state->method = state->cls->static_init;
+
+        function_initvars(state->cls->init, 0, 0, 0, 1);
+        state->cls->static_init->variable_count=1;
+        function_initvars(state->cls->static_init, 0, 0, 0, 0);
 
         if(extends && (extends->flags & FLAG_FINAL))
             syntaxerror("Can't extend final class '%s'", extends->name);
@@ -1028,79 +1165,31 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
             pos++;
         }
 
-        /* fill out interfaces and extends (we couldn't resolve those during the first pass) */
-        state->cls->info->superclass = extends;
-
         /* generate the abc code for this class */
         MULTINAME(classname2,state->cls->info);
         multiname_t*extends2 = sig2mname(extends);
 
-        state->cls->abc = abc_class_new(global->file, &classname2, extends2);
+        /* don't add the class to the class index just yet- that will be done later
+           by initscript */
+        state->cls->abc = abc_class_new(0, &classname2, extends2);
+        state->cls->abc->file = global->file;
+
+        multiname_destroy(extends2);
         if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);
         if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
         if(state->cls->info->flags&FLAG_INTERFACE) {
             abc_class_interface(state->cls->abc);
         }
 
-        abc_class_protectedNS(state->cls->abc, classname);
-
         for(mlist=implements;mlist;mlist=mlist->next) {
             MULTINAME(m, mlist->classinfo);
             abc_class_add_interface(state->cls->abc, &m);
         }
 
-        /* write the construction code for this class to the global init
-           function */
-        int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
-
-        abc_method_body_t*m = global->init->method->body;
-        __ getglobalscope(m);
-        classinfo_t*s = extends;
-
-        int count=0;
-        
-        while(s) {
-            //TODO: take a look at the current scope stack, maybe 
-            //      we can re-use something
-            s = s->superclass;
-            if(!s) 
-            break;
-           
-            multiname_t*s2 = sig2mname(s);
-            __ getlex2(m, s2);
-            multiname_destroy(s2);
-
-            __ pushscope(m); count++;
-            m->code = m->code->prev->prev; // invert
-        }
-        /* continue appending after last op end */
-        while(m->code && m->code->next) m->code = m->code->next; 
-
-        /* TODO: if this is one of *our* classes, we can also 
-                 do a getglobalscope/getslot <nr> (which references
-                 the init function's slots) */
-        if(extends2) {
-            __ getlex2(m, extends2);
-            __ dup(m);
-            /* notice: we get a Verify Error #1107 if the top elemnt on the scope
-               stack is not the superclass */
-            __ pushscope(m);count++;
-        } else {
-            __ pushnull(m);
-            /* notice: we get a verify error #1107 if the top element on the scope 
-               stack is not the global object */
-            __ getlocal_0(m);
-            __ pushscope(m);count++;
-        }
-        __ newclass(m,state->cls->abc);
-        while(count--) {
-            __ popscope(m);
-        }
-        __ setslot(m, slotindex);
-        multiname_destroy(extends2);
+        state->cls->dependencies = parsedclass_new(state->cls->info, state->cls->abc);
+        list_append(global->classes, state->cls->dependencies);
 
         /* flash.display.MovieClip handling */
-
         if(!as3_globalclass && (mod->flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {
             if(state->package && state->package[0]) {
                 as3_globalclass = concat3(state->package, ".", classname);
@@ -1111,23 +1200,6 @@ static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, cl
     }
 }
 
-static int slotstate_varconst = 0;
-static modifiers_t*slotstate_flags = 0;
-static void setslotstate(modifiers_t* flags, int varconst)
-{
-    slotstate_varconst = varconst;
-    slotstate_flags = flags;
-    if(state->cls) {
-        if(flags && flags->flags&FLAG_STATIC) {
-            state->method = state->cls->static_init;
-        } else {
-            state->method = state->cls->init;
-        }
-    } else {
-        parserassert(state->method);
-    }
-}
-
 static void endclass()
 {
     if(as3_pass == 2) {
@@ -1153,6 +1225,21 @@ static void endclass()
             code_t*c = method_header(state->cls->static_init);
             m->body->code = wrap_function(c, 0, m->body->code);
         }
+      
+        trait_list_t*trait = state->cls->abc->traits;
+        /* switch all protected members to the protected ns of this class */
+        while(trait) {
+            trait_t*t = trait->trait;
+            if(t->name->ns->access == ACCESS_PROTECTED) {
+                if(!state->cls->abc->protectedNS) {
+                    char*n = concat3(state->cls->info->package, ":", state->cls->info->name);
+                    state->cls->abc->protectedNS = namespace_new_protected(n);
+                    state->cls->abc->flags |= CLASS_PROTECTED_NS;
+                }
+                t->name->ns->name = strdup(state->cls->abc->protectedNS->name);
+            }
+            trait = trait->next;
+        }
     }
 
     old_state();
@@ -1169,6 +1256,12 @@ void check_code_for_break(code_t*c)
             char*name = string_cstr(c->data[0]);
             syntaxerror("Unresolved \"continue %s\"", name);
         }
+        if(c->opcode == OPCODE___RETHROW__) {
+            syntaxerror("Unresolved \"rethrow\"");
+        }
+        if(c->opcode == OPCODE___FALLTHROUGH__) {
+            syntaxerror("Unresolved \"fallthrough\"");
+        }
         if(c->opcode == OPCODE___PUSHPACKAGE__) {
             char*name = string_cstr(c->data[0]);
             syntaxerror("Can't reference a package (%s) as such", name);
@@ -1177,10 +1270,8 @@ void check_code_for_break(code_t*c)
     }
 }
 
-
 static void check_constant_against_type(classinfo_t*t, constant_t*c)
 {
-    return;
 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
    if(TYPE_IS_NUMBER(t)) {
         xassert(c->type == CONSTANT_FLOAT
@@ -1201,7 +1292,7 @@ static void check_override(memberinfo_t*m, int flags)
 {
     if(!m)
         return;
-    if(m->parent == state->cls->info)
+    if(m->parent == state->cls->info && !((flags^m->flags)&FLAG_STATIC))
         syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);
     if(!m->parent)
         syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);
@@ -1234,18 +1325,15 @@ static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, c
     if(!state->cls) {
         //package method
         minfo = methodinfo_register_global(ns.access, state->package, name);
-        minfo->return_type = 0; // save this for pass 2
+        minfo->return_type = return_type;
     } else if(getset != KW_GET && getset != KW_SET) {
         //class method
-        memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);
+        memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0, mod->flags&FLAG_STATIC);
         if(m) {
-            printf("%s.%s | %s.%s\n", 
-                m->package, m->name,
-                ns.name, name);
             syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
         }
-        minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
-        minfo->return_type = 0; // save this for pass 2 
+        minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);
+        minfo->return_type = return_type;
         // getslot on a member slot only returns "undefined", so no need
         // to actually store these
         //state->minfo->slot = state->method->abc->method->trait->slot_id;
@@ -1260,9 +1348,9 @@ static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, c
         } else
             syntaxerror("setter function needs to take exactly one argument");
         // not sure wether to look into superclasses here, too
-        minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1);
+        minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1, mod->flags&FLAG_STATIC);
         if(minfo) {
-            if(minfo->kind!=INFOTYPE_SLOT)
+            if(minfo->kind!=INFOTYPE_VAR)
                 syntaxerror("class already contains a method called '%s'", name);
             if(!(minfo->subtype & (SUBTYPE_GETSET)))
                 syntaxerror("class already contains a field called '%s'", name);
@@ -1282,11 +1370,12 @@ static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, c
                     type?type->name:"*");
             }*/
         } else {
-            minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
-            minfo->kind = INFOTYPE_SLOT; //hack
+            minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name, mod->flags&FLAG_STATIC);
+            minfo->kind = INFOTYPE_VAR; //hack
             minfo->subtype = gs;
-            minfo->return_type = 0;
+            minfo->return_type = type;
         }
+
         /* can't assign a slot as getter and setter might have different slots */
         //minfo->slot = slot;
     }
@@ -1302,19 +1391,27 @@ static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
     //parserassert(state->method && state->method->info);
 
     methodstate_t*parent_method = state->method;
+    variable_t*v = 0;
 
     if(as3_pass==1) {
         return_type = 0; // not valid in pass 1
+        if(name) {
+            v = new_variable2(parent_method, name, 0, 0, 0);
+        }
     }
 
     new_state();
     state->new_vars = 1;
    
     if(as3_pass == 1) {
-        state->method = rfx_calloc(sizeof(methodstate_t));
+        state->method = methodstate_new();
         state->method->inner = 1;
+        state->method->is_static = parent_method->is_static;
         state->method->variable_count = 0;
         state->method->abc = rfx_calloc(sizeof(abc_method_t));
+        if(v) {
+            v->is_inner_method = state->method;
+        }
 
         NEW(methodinfo_t,minfo);
         minfo->kind = INFOTYPE_METHOD;
@@ -1327,7 +1424,7 @@ static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
 
         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
     
-        function_initvars(state->method, params, 0, 1);
+        function_initvars(state->method, 1, params, 0, 1);
     }
 
     if(as3_pass == 2) {
@@ -1336,7 +1433,7 @@ static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
         parserassert(state->method);
 
         state->method->info->return_type = return_type;
-        function_initvars(state->method, params, 0, 1);
+        function_initvars(state->method, 1, params, 0, 1);
     }
 }
 
@@ -1348,10 +1445,11 @@ static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
     }
     new_state();
     state->new_vars = 1;
-    
+
     if(as3_pass == 1) {
-        state->method = rfx_calloc(sizeof(methodstate_t));
+        state->method = methodstate_new();
         state->method->has_super = 0;
+        state->method->is_static = mod->flags&FLAG_STATIC;
 
         if(state->cls) {
             state->method->is_constructor = !strcmp(state->cls->info->name,name);
@@ -1364,7 +1462,7 @@ static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
 
         state->method->info = registerfunction(getset, mod, name, params, return_type, 0);
        
-        function_initvars(state->method, params, mod->flags, 1);
+        function_initvars(state->method, 1, params, mod->flags, 1);
         
         dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
     }
@@ -1375,7 +1473,7 @@ static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
         parserassert(state->method);
                 
         if(state->cls) {
-            memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2);
+            memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2, mod->flags&FLAG_STATIC);
             check_override(m, mod->flags);
         }
             
@@ -1383,68 +1481,75 @@ static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
             state->cls->has_constructor |= state->method->is_constructor;
         }
         
-        state->method->info->return_type = return_type;
-        function_initvars(state->method, params, mod->flags, 1);
+        function_initvars(state->method, 1, params, mod->flags, 1);
     } 
 }
 
+static void insert_unresolved(methodstate_t*m, dict_t*xvars, dict_t*allvars)
+{
+    parserassert(m->inner);
+    if(m->unresolved_variables) {
+        dict_t*d = m->unresolved_variables;
+        int t;
+        DICT_ITERATE_KEY(d, char*, id) {
+            /* check parent method's variables */
+            variable_t*v;
+            if(dict_contains(allvars, id)) {
+                m->uses_parent_function = 1;
+                state->method->uses_slots = 1;
+                dict_put(xvars, id, 0);
+            }
+        }
+    }
+    methodstate_list_t*ml = m->innerfunctions;
+    while(ml) {
+        insert_unresolved(ml->methodstate, xvars, allvars);
+        ml = ml->next;
+    }
+}
+
 static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
                           params_t*params, classinfo_t*return_type, code_t*body)
 {
-    int flags = mod?mod->flags:0;
-
     if(as3_pass==1) {
-        // store inner methods in variables
-        function_initvars(state->method, 0, 0, 0);
-
-        methodstate_list_t*ml = state->method->innerfunctions;
-        
         dict_t*xvars = dict_new();
-
-        while(ml) {
-            methodstate_t*m = ml->methodstate;
-            parserassert(m->inner);
-            if(m->unresolved_variables) {
-                dict_t*d = m->unresolved_variables;
-                int t;
-                for(t=0;t<d->hashsize;t++) {
-                    dictentry_t*l = d->slots[t]; 
-                    while(l) {
-                        /* check parent method's variables */
-                        variable_t*v;
-                        if((v=find_variable(state, l->key))) {
-                            m->uses_parent_function = 1;
-                            state->method->uses_slots = 1;
-                            dict_put(xvars, l->key, 0);
-                        }
-                        l = l->next;
+        
+        if(state->method->unresolved_variables) {
+            DICT_ITERATE_KEY(state->method->unresolved_variables, char*, vname) {
+                if(!state->method->no_variable_scoping && dict_contains(state->method->allvars, vname)) {
+                    variable_t*v = dict_lookup(state->method->allvars, vname);
+                    if(!v->is_inner_method) {
+                        state->method->no_variable_scoping = 1;
+                        as3_warning("function %s uses forward or outer block variable references (%s): switching into compatibility mode", name, vname);
                     }
-                    if(l) break;
                 }
-
-                dict_destroy(m->unresolved_variables);
-                m->unresolved_variables = 0;
             }
+        }
+
+        methodstate_list_t*ml = state->method->innerfunctions;
+        while(ml) {
+            insert_unresolved(ml->methodstate, xvars, state->method->allvars);
             ml = ml->next;
         }
         
         if(state->method->uses_slots) {
             state->method->slots = dict_new();
             int i = 1;
-            DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
+            DICT_ITERATE_ITEMS(state->method->allvars, char*, name, variable_t*, v) {
                 if(!name) syntaxerror("internal error");
                 if(v->index && dict_contains(xvars, name)) {
-                    v->init = 0;
-                    v->index = i++;
+                    v->init = v->kill = 0;
+                    v->index = i;
                     if(v->is_inner_method) {
-                        v->is_inner_method->is_a_slot = 1;
+                        v->is_inner_method->is_a_slot = i;
                     }
-                    //v->type = 0;
+                    i++;
                     dict_put(state->method->slots, name, v);
                 }
             }
             state->method->uses_slots = i;
             dict_destroy(state->vars);state->vars = 0;
+            parserassert(state->new_vars);
         }
         old_state();
         return 0;
@@ -1465,10 +1570,9 @@ static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*
         } else if(state->method->is_constructor) {
             f = abc_class_getconstructor(state->cls->abc, type2);
         } else if(!state->method->is_global) {
-            namespace_t mname_ns = {state->method->info->access, ""};
-            multiname_t mname = {QNAME, &mname_ns, 0, name};
-
-            if(flags&FLAG_STATIC)
+            namespace_t ns = modifiers2access(mod);
+            multiname_t mname = {QNAME, &ns, 0, name};
+            if(mod->flags&FLAG_STATIC)
                 f = abc_class_staticmethod(state->cls->abc, type2, &mname);
             else
                 f = abc_class_method(state->cls->abc, type2, &mname);
@@ -1478,16 +1582,18 @@ static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*
             multiname_t mname = {QNAME, &mname_ns, 0, name};
 
             f = abc_method_new(global->file, type2, 1);
+            if(!global->init) global->init = abc_initscript(global->file);
             trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);
             //abc_code_t*c = global->init->method->body->code;
         }
         //flash doesn't seem to allow us to access function slots
         //state->method->info->slot = slot;
 
-        if(flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
+        if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;
         if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;
         if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;
         if(params->varargs) f->flags |= METHOD_NEED_REST;
+        if(state->method->need_arguments) f->flags |= METHOD_NEED_ARGUMENTS;
 
         char opt=0;
         param_list_t*p=0;
@@ -1501,7 +1607,7 @@ static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*
                 check_constant_against_type(p->param->type, p->param->value);
                 opt=1;list_append(f->optional_parameters, p->param->value);
             } else if(opt) {
-                syntaxerror("non-optional parameter not allowed after optional parameters");
+                syntaxerror("function %s: non-optional parameter not allowed after optional parameters", name);
             }
         }
         if(state->method->slots) {
@@ -1537,11 +1643,6 @@ static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*
     return 0;
 }
 
-char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
-{
-    return 1; // FIXME
-}
-
 void breakjumpsto(code_t*c, char*name, code_t*jump) 
 {
     while(c) {
@@ -1569,29 +1670,6 @@ void continuejumpsto(code_t*c, char*name, code_t*jump)
     }
 }
 
-#define IS_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)))
-#define IS_NUMBER_OR_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)) || TYPE_IS_NUMBER((a)))
-#define BOTH_INT(a,b) (IS_INT(a) && IS_INT(b))
-
-classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, char op)
-{
-    if(!type1 || !type2) 
-        return registry_getanytype();
-    if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
-        return registry_getanytype();
-
-    if(op=='+') {
-        if(IS_NUMBER_OR_INT(type1) && IS_NUMBER_OR_INT(type2)) {
-            return TYPE_NUMBER;
-        } else {
-            return TYPE_ANY;
-        }
-    }
-
-    if(type1 == type2)
-        return type1;
-    return registry_getanytype();
-}
 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
 {
     if(from==to)
@@ -1609,15 +1687,35 @@ code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
     if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&
        (TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {
         // allow conversion between number types
+        if(TYPE_IS_UINT(to))
+            return abc_convert_u(c);
+        else if(TYPE_IS_INT(to))
+            return abc_convert_i(c);
+        else if(TYPE_IS_NUMBER(to))
+            return abc_convert_d(c);
         return abc_coerce2(c, &m);
     }
-    //printf("%s.%s\n", from.package, from.name);
-    //printf("%s.%s\n", to.package, to.name);
 
-    classinfo_t*supertype = from;
-    while(supertype) {
+    if(TYPE_IS_XMLLIST(to) && TYPE_IS_XML(from))
+        return c;
+
+    if(TYPE_IS_BOOLEAN(to))
+        return abc_convert_b(c);
+    if(TYPE_IS_STRING(to))
+        return abc_convert_s(c);
+    if(TYPE_IS_OBJECT(to))
+        return abc_coerce2(c, &m);
+    if(TYPE_IS_OBJECT(from) && TYPE_IS_XMLLIST(to))
+        return abc_coerce2(c, &m);
+    if(TYPE_IS_OBJECT(from) && TYPE_IS_ARRAY(to))
+        return abc_coerce2(c, &m);
+
+    classinfo_t*supertype = from;
+    while(supertype) {
         if(supertype == to) {
-             // target type is one of from's superclasses
+             /* target type is one of from's superclasses.
+                (not sure we need this coerce - as far as the verifier
+                 is concerned, object==object (i think) */
              return abc_coerce2(c, &m);
         }
         int t=0;
@@ -1637,30 +1735,23 @@ code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
     if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))
         return c;
 
+
     as3_error("can't convert type %s%s%s to %s%s%s", 
-        from->package, from->package?".":"", from->name, 
-        to->package, to->package?".":"", to->name);
+        from->package, from->package[0]?".":"", from->name, 
+        to->package, to->package[0]?".":"", to->name);
+
     return c;
 }
-
-code_t*defaultvalue(code_t*c, classinfo_t*type)
+code_t* coerce_to_type(code_t*c, classinfo_t*t)
 {
-    if(TYPE_IS_INT(type)) {
-       c = abc_pushbyte(c, 0);
-    } else if(TYPE_IS_UINT(type)) {
-       c = abc_pushuint(c, 0);
-    } else if(TYPE_IS_FLOAT(type)) {
-       c = abc_pushnan(c);
-    } else if(TYPE_IS_BOOLEAN(type)) {
-       c = abc_pushfalse(c);
-    } else if(!type) {
-       //c = abc_pushundefined(c);
+    if(!t) {
+        return abc_coerce_a(c);
+    } else if(TYPE_IS_STRING(t)) {
+        return abc_coerce_s(c);
     } else {
-       c = abc_pushnull(c);
-       MULTINAME(m, type);
-       c = abc_coerce2(c, &m);
+        MULTINAME(m, t);
+        return abc_coerce2(c, &m);
     }
-    return c;
 }
 
 char is_pushundefined(code_t*c)
@@ -1748,6 +1839,7 @@ typedcode_t push_class(slotinfo_t*a)
             infotypename(a), a->name, a->package, state->package);
     }
 
+
     if(a->kind != INFOTYPE_CLASS) {
         MULTINAME(m, a);
         x.c = abc_findpropstrict2(x.c, &m);
@@ -1759,9 +1851,16 @@ typedcode_t push_class(slotinfo_t*a)
             varinfo_t*v = (varinfo_t*)a;
             x.t = v->type;
         }
+        return x;
     } else {
+        if(state->cls && state->method == state->cls->static_init) {
+            /* we're in the static initializer. 
+               record the fact that we're using this class here */
+            parsedclass_add_dependency(state->cls->dependencies, (classinfo_t*)a);
+        }
         classinfo_t*c = (classinfo_t*)a;
-        if(c->slot) {
+        //if(c->slot) {
+        if(0) { //Error #1026: Slot 1 exceeds slotCount=0 of global
             x.c = abc_getglobalscope(x.c);
             x.c = abc_getslot(x.c, c->slot);
         } else {
@@ -1773,175 +1872,6 @@ typedcode_t push_class(slotinfo_t*a)
     return x;
 }
 
-static char is_getlocal(code_t*c)
-{
-    if(!c || c->prev || c->next)
-        return 0;
-    return(c->opcode == OPCODE_GETLOCAL
-        || c->opcode == OPCODE_GETLOCAL_0
-        || c->opcode == OPCODE_GETLOCAL_1
-        || c->opcode == OPCODE_GETLOCAL_2
-        || c->opcode == OPCODE_GETLOCAL_3);
-}
-static int getlocalnr(code_t*c)
-{
-    if(c->opcode == OPCODE_GETLOCAL) {return (ptroff_t)c->data[0];}
-    else if(c->opcode == OPCODE_GETLOCAL_0) {return 0;}
-    else if(c->opcode == OPCODE_GETLOCAL_1) {return 1;}
-    else if(c->opcode == OPCODE_GETLOCAL_2) {return 2;}
-    else if(c->opcode == OPCODE_GETLOCAL_3) {return 3;}
-    else syntaxerror("Internal error: opcode %02x is not a getlocal call", c->opcode);
-    return 0;
-}
-
-static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore)
-{
-    /* converts this:
-
-       [prefix code] [read instruction]
-
-       to this:
-
-       [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
-    */
-    if(in && in->opcode == OPCODE_COERCE_A) {
-        in = code_cutlast(in);
-    }
-    if(in->next)
-        syntaxerror("internal error");
-
-    /* chop off read instruction */
-    code_t*prefix = in;
-    code_t*r = in;
-    if(r->prev) {
-        prefix = r->prev;r->prev = 0;
-        prefix->next=0;
-    } else {
-        prefix = 0;
-    }
-        
-    char use_temp_var = readbefore;
-
-    /* generate the write instruction, and maybe append a dup to the prefix code */
-    code_t* write = abc_nop(0);
-    if(r->opcode == OPCODE_GETPROPERTY) {
-        write->opcode = OPCODE_SETPROPERTY;
-        multiname_t*m = (multiname_t*)r->data[0];
-        write->data[0] = multiname_clone(m);
-        if(m->type == QNAME || m->type == MULTINAME) {
-            if(!justassign) {
-                prefix = abc_dup(prefix); // we need the object, too
-            }
-            use_temp_var = 1;
-        } else if(m->type == MULTINAMEL) {
-            if(!justassign) {
-                /* dupping two values on the stack requires 5 operations and one register- 
-                   couldn't adobe just have given us a dup2? */
-                int temp = gettempvar();
-                prefix = abc_setlocal(prefix, temp);
-                prefix = abc_dup(prefix);
-                prefix = abc_getlocal(prefix, temp);
-                prefix = abc_swap(prefix);
-                prefix = abc_getlocal(prefix, temp);
-                if(!use_temp_var);
-                    prefix = abc_kill(prefix, temp);
-            }
-            use_temp_var = 1;
-        } else {
-            syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname/multiname)");
-        }
-    } else if(r->opcode == OPCODE_GETSLOT) {
-        write->opcode = OPCODE_SETSLOT;
-        write->data[0] = r->data[0];
-        if(!justassign) {
-            prefix = abc_dup(prefix); // we need the object, too
-        }
-        use_temp_var = 1;
-    } else if(r->opcode == OPCODE_GETLOCAL) { 
-        write->opcode = OPCODE_SETLOCAL;
-        write->data[0] = r->data[0];
-    } else if(r->opcode == OPCODE_GETLOCAL_0) { 
-        write->opcode = OPCODE_SETLOCAL_0;
-    } else if(r->opcode == OPCODE_GETLOCAL_1) { 
-        write->opcode = OPCODE_SETLOCAL_1;
-    } else if(r->opcode == OPCODE_GETLOCAL_2) { 
-        write->opcode = OPCODE_SETLOCAL_2;
-    } else if(r->opcode == OPCODE_GETLOCAL_3) { 
-        write->opcode = OPCODE_SETLOCAL_3;
-    } else if(r->opcode == OPCODE_GETSUPER) { 
-        write->opcode = OPCODE_SETSUPER;
-        multiname_t*m = (multiname_t*)r->data[0];
-        write->data[0] = multiname_clone(m);
-    } else {
-        code_dump(r);
-        syntaxerror("illegal lvalue: can't assign a value to this expression");
-    }
-    code_t* c = 0;
-    
-    int temp = -1;
-    if(!justassign) {
-        if(use_temp_var) {
-            /* with getproperty/getslot, we have to be extra careful not
-               to execute the read code twice, as it might have side-effects
-               (e.g. if the property is in fact a setter/getter combination)
-
-               So read the value, modify it, and write it again,
-               using prefix only once and making sure (by using a temporary
-               register) that the return value is what we just wrote */
-            temp = gettempvar();
-            c = code_append(c, prefix);
-            c = code_append(c, r);
-            if(readbefore) {
-                c = abc_dup(c);
-                c = abc_setlocal(c, temp);
-            }
-            c = code_append(c, middlepart);
-            if(!readbefore) {
-                c = abc_dup(c);
-                c = abc_setlocal(c, temp);
-            }
-            c = code_append(c, write);
-            c = abc_getlocal(c, temp);
-            c = abc_kill(c, temp);
-        } else {
-            /* if we're allowed to execute the read code twice *and*
-               the middlepart doesn't modify the code, things are easier.
-            */
-            code_t* r2 = code_dup(r);
-            //c = code_append(c, prefix);
-            parserassert(!prefix);
-            c = code_append(c, r);
-            c = code_append(c, middlepart);
-            c = code_append(c, write);
-            c = code_append(c, r2);
-        }
-    } else {
-        /* even smaller version: overwrite the value without reading
-           it out first */
-        if(!use_temp_var) {
-            if(prefix) {
-                c = code_append(c, prefix);
-                c = abc_dup(c);
-            }
-            c = code_append(c, middlepart);
-            c = code_append(c, write);
-            c = code_append(c, r);
-        } else {
-            code_free(r);r=0;
-            temp = gettempvar();
-            if(prefix) {
-                c = code_append(c, prefix);
-            }
-            c = code_append(c, middlepart);
-            c = abc_dup(c);
-            c = abc_setlocal(c, temp);
-            c = code_append(c, write);
-            c = abc_getlocal(c, temp);
-            c = abc_kill(c, temp);
-        }
-    }
-    return c;
-}
 
 char is_break_or_jump(code_t*c)
 {
@@ -1958,7 +1888,6 @@ char is_break_or_jump(code_t*c)
     return 0;
 }
 
-
 #define IS_FINALLY_TARGET(op) \
         ((op) == OPCODE___CONTINUE__ || \
          (op) == OPCODE___BREAK__ || \
@@ -2077,13 +2006,312 @@ code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
 #define PASS1 }} if(as3_pass == 1) {{
 #define PASS1END }} if(as3_pass == 2) {{
 #define PASS2 }} if(as3_pass == 2) {{
-#define PASS12 }} {{
+#define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{
 #define PASS12END }} if(as3_pass == 2) {{
+#define PASS_ALWAYS }} {{
 
 
 
 /* Line 273 of skeleton.m4  */
-#line 2087 "parser.tab.c"
+#line 2017 "parser.tab.c"
+/* Unqualified %code blocks.  */
+
+/* Line 274 of skeleton.m4  */
+#line 2107 "parser.y"
+
+    char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
+    {
+        return 1; // FIXME
+    }
+    char do_init_variable(char*name)
+    {
+        if(!state->method->no_variable_scoping)
+            return 0;
+        if(!state->new_vars)
+            return 1;
+        return 1;
+    }
+
+
+/* Line 274 of skeleton.m4  */
+#line 2557 "parser.y"
+
+    static void state_has_imports()
+    {
+        state->wildcard_imports = list_clone(state->wildcard_imports);
+        state->imports = dict_clone(state->imports);
+        state->has_own_imports = 1;
+    }
+    static void import_toplevel(const char*package)
+    {
+        char* s = strdup(package);
+        while(1) {
+            dict_put(state->import_toplevel_packages, s, 0);
+            char*x = strrchr(s, '.');
+            if(!x)
+                break;
+            *x = 0;
+        }
+        free(s);
+    }
+
+
+/* Line 274 of skeleton.m4  */
+#line 2700 "parser.y"
+
+    static int slotstate_varconst = 0;
+    static modifiers_t*slotstate_flags = 0;
+    static void setslotstate(modifiers_t* flags, int varconst)
+    {
+        slotstate_varconst = varconst;
+        slotstate_flags = flags;
+        if(state->cls) {
+            if(flags) {
+                if(flags->flags&FLAG_STATIC) {
+                    state->method = state->cls->static_init;
+                } else {
+                    state->method = state->cls->init;
+                }
+            } else {
+                // reset to "default" state (all in class code is static by default) */
+                state->method = state->cls->static_init;
+            }
+        } else {
+            parserassert(state->method);
+        }
+    }
+    static trait_t* add_abc_slot(modifiers_t* modifiers, const char*name, multiname_t*m, code_t***c)
+    {
+        int flags = modifiers->flags;
+        namespace_t ns = modifiers2access(modifiers);
+
+        /* slot name */
+        multiname_t mname = {QNAME, &ns, 0, name};
+      
+        trait_list_t**traits;
+        code_t**code=0;
+        if(!state->cls) {
+            // global variable
+            if(!global->init) global->init = abc_initscript(global->file);
+            ns.name = state->package;
+            traits = &global->init->traits;
+            code = &global->init->method->body->code;
+        } else if(flags&FLAG_STATIC) {
+            // static variable
+            traits = &state->cls->abc->static_traits;
+            code = &state->cls->static_init->header;
+        } else {
+            // instance variable
+            traits = &state->cls->abc->traits;
+            code = &state->cls->init->header;
+            
+            if(ns.access == ACCESS_PROTECTED) {
+                ns.name = concat3(state->cls->info->package,":",state->cls->info->name);
+            }
+        }
+        if(c)
+            *c = code;
+        if(m) 
+            *m = *multiname_clone(&mname);
+            
+        return trait_new_member(traits, 0, multiname_clone(&mname), 0);
+    }
+
+
+/* Line 274 of skeleton.m4  */
+#line 2874 "parser.y"
+
+    static int xml_level = 0;
+
+
+/* Line 274 of skeleton.m4  */
+#line 3541 "parser.y"
+
+    node_t* resolve_identifier(const char*name);
+    node_t* get_descendants(node_t*e,const char*ns,const char*subnode,char multi, char attr)
+    {
+	typedcode_t v = node_read(e);
+	typedcode_t w;
+
+	multiname_t m = {0,0,0,subnode};
+	namespace_t zero = {ZERONAMESPACE,"*"};
+	if(!strcmp(ns,"*")) {
+	    m.ns = &zero;
+	    m.type = attr?QNAMEA:QNAME;
+	} else {
+	    typedcode_t w = node_read(resolve_identifier(ns));
+	    if(!TYPE_IS_NAMESPACE(w.t)) {
+		as3_softwarning("%s might not be a namespace", ns);
+	    }
+	    v.c = code_append(v.c, w.c);
+	    v.c = converttype(v.c, w.t, TYPE_NAMESPACE);
+	    m.type = attr?RTQNAMEA:RTQNAME;
+	}
+
+	if(!multi) {
+	    v.c = abc_getproperty2(v.c, &m);
+	} else {
+	    v.c = abc_getdescendants2(v.c, &m);
+	}
+
+	if(TYPE_IS_XML(v.t)) {
+	    v.t = TYPE_XMLLIST;
+	} else {
+	    v.c = abc_coerce_a(v.c);
+	    v.t = TYPE_ANY;
+	}
+	return mkcodenode(v);
+    }
+
+
+/* Line 274 of skeleton.m4  */
+#line 3712 "parser.y"
+
+    node_t* var_read(variable_t*v)
+    {
+        typedcode_t o;
+	o.c = abc_getlocal(0, v->index);
+	o.t = v->type;
+	return mkcodenode(o);
+    }
+
+    node_t* resolve_identifier(const char*name)
+    {
+        typedcode_t o;
+        o.t = 0;
+        o.c = 0;
+
+        slotinfo_t*a = 0;
+        memberinfo_t*f = 0;
+
+        variable_t*v;
+        /* look at variables */
+        if((v = find_variable(state, name))) {
+            // name is a local variable
+	    return var_read(v);
+        }
+        if((v = find_slot(state->method, name))) {
+            o.c = abc_getscopeobject(o.c, 1);
+            o.c = abc_getslot(o.c, v->index);
+            o.t = v->type;
+            return mkcodenode(o);
+        }
+
+        int i_am_static = state->method->is_static;
+
+        if(!state->method->inner && !state->xmlfilter && state->cls)
+	{
+	    /* look at current class' members */
+	    if((f = findmember_nsset(state->cls->info, name, 1, i_am_static)))
+	    {
+		// name is a member or attribute in this class
+		int var_is_static = (f->flags&FLAG_STATIC);
+
+		if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
+		    /* if the variable is a constant (and we know what is evaluates to), we
+		       can just use the value itself */
+		    varinfo_t*v = (varinfo_t*)f;
+		    if(v->value) {
+			return mkconstnode(v->value);
+		    }
+		}
+	       
+		if(var_is_static >= i_am_static) {
+		    if(f->kind == INFOTYPE_METHOD) {
+			o.t = TYPE_FUNCTION(f);
+		    } else {
+			o.t = f->type;
+		    }
+
+		    if(var_is_static && !i_am_static) {
+		    /* access to a static member from a non-static location.
+		       do this via findpropstrict:
+		       there doesn't seem to be any non-lookup way to access
+		       static properties of a class */
+			state->method->late_binding = 1;
+			o.t = f->type;
+			namespace_t ns = {f->access, f->package};
+			multiname_t m = {QNAME, &ns, 0, name};
+			o.c = abc_findpropstrict2(o.c, &m);
+			o.c = abc_getproperty2(o.c, &m);
+			return mkcodenode(o);
+		    } else if(f->slot>0) {
+			o.c = abc_getlocal_0(o.c);
+			o.c = abc_getslot(o.c, f->slot);
+			return mkcodenode(o);
+		    } else {
+			MEMBER_MULTINAME(m, f, name);
+			o.c = abc_getlocal_0(o.c);
+			o.c = abc_getproperty2(o.c, &m);
+			return mkcodenode(o);
+		    }
+		}
+	    } 
+	    /* special case: it's allowed to access non-static constants
+	       from a static context */
+	    if(i_am_static && (f=findmember_nsset(state->cls->info, name, 1, 0))) {
+		if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {
+		    varinfo_t*v = (varinfo_t*)f;
+		    if(v->value) {
+			return mkconstnode(v->value);
+		    }
+		}
+	    }
+	}
+        
+        /* look at actual classes, in the current package and imported */
+        if(!state->xmlfilter && (a = find_class(name))) {
+	    registry_use(a);
+            if(state->cls && state->cls->info == (classinfo_t*)a && i_am_static) {
+                o.c = abc_getlocal_0(0);
+                o.t = TYPE_CLASS((classinfo_t*)a);
+            } else {
+                o = push_class(a);
+            }
+            return mkcodenode(o);
+        }
+
+        /* look through package prefixes */
+        if(!state->xmlfilter && 
+           (dict_contains(state->import_toplevel_packages, name) || 
+            registry_ispackage(name))) {
+            o.c = abc___pushpackage__(o.c, (char*)name);
+            o.t = 0;
+            return mkcodenode(o); //?
+        }
+
+        /* unknown object, let the avm2 resolve it */
+        if(1) {
+            if(!state->method->inner && !state->xmlfilter) {
+                /* we really should make inner functions aware of the class context */
+                as3_warning("Couldn't resolve '%s', doing late binding", name);
+            }
+            state->method->late_binding = 1;
+                    
+            multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, name};
+
+            o.t = 0;
+            o.c = abc_findpropstrict2(o.c, &m);
+            o.c = abc_getproperty2(o.c, &m);
+            return mkcodenode(o);
+        }
+    }
+
+
+/* Line 274 of skeleton.m4  */
+#line 3869 "parser.y"
+
+    void add_active_url(const char*url)
+    {
+        NEW(namespace_t,n);
+        n->name = url;
+        list_append(state->active_namespace_urls, n);
+    }
+
+
+
+/* Line 274 of skeleton.m4  */
+#line 2315 "parser.tab.c"
 
 #ifdef short
 # undef short
@@ -2296,22 +2524,22 @@ union yyalloc
 #endif
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  146
+#define YYFINAL  162
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   3061
+#define YYLAST   3382
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  134
+#define YYNTOKENS  135
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  114
+#define YYNNTS  135
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  308
+#define YYNRULES  356
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  520
+#define YYNSTATES  612
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   363
+#define YYMAXUTOK   364
 
 #define YYTRANSLATE(YYX)						\
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -2322,16 +2550,16 @@ static const yytype_uint8 yytranslate[] =
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   118,     2,     2,     2,   116,   108,     2,
-     122,   133,   115,   113,   100,   112,   127,   114,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,   105,    99,
-     109,   102,   110,   104,   128,     2,     2,     2,     2,     2,
+       2,     2,     2,   119,     2,     2,     2,   117,   108,     2,
+     123,   134,   116,   114,   101,   113,   128,   115,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,   105,   100,
+     110,   103,   111,   104,   129,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   124,     2,   125,   107,     2,     2,     2,     2,     2,
+       2,   125,     2,   126,   107,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   126,   106,   132,   117,     2,     2,     2,
+       2,     2,     2,   127,   106,   133,   118,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -2354,8 +2582,8 @@ static const yytype_uint8 yytranslate[] =
       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
-      95,    96,    97,    98,   101,   103,   111,   119,   120,   121,
-     123,   129,   130,   131
+      95,    96,    97,    98,    99,   102,   109,   112,   120,   121,
+     122,   124,   130,   131,   132
 };
 
 #if YYDEBUG
@@ -2365,168 +2593,196 @@ static const yytype_uint16 yyprhs[] =
 {
        0,     0,     3,     5,     6,     8,    10,    13,    15,    17,
       19,    21,    23,    25,    30,    32,    33,    35,    37,    40,
-      42,    44,    46,    48,    50,    55,    57,    59,    60,    63,
-      65,    67,    69,    71,    73,    75,    77,    79,    81,    83,
-      85,    87,    89,    93,    96,    98,   100,   102,   104,   106,
-     108,   110,   115,   118,   120,   122,   126,   129,   130,   133,
-     136,   138,   142,   146,   147,   150,   151,   159,   160,   162,
-     164,   168,   170,   173,   177,   186,   193,   194,   201,   202,
-     210,   212,   215,   217,   220,   221,   223,   225,   228,   230,
-     233,   238,   242,   243,   252,   253,   263,   264,   270,   272,
-     275,   277,   280,   282,   283,   290,   293,   295,   300,   303,
-     305,   307,   311,   313,   314,   321,   322,   328,   331,   336,
-     337,   339,   341,   344,   346,   348,   350,   352,   354,   356,
-     358,   360,   362,   364,   365,   368,   369,   372,   373,   376,
-     377,   387,   388,   397,   398,   400,   402,   405,   407,   412,
-     414,   416,   418,   419,   421,   423,   426,   428,   431,   440,
-     442,   444,   445,   450,   452,   456,   460,   461,   464,   466,
-     468,   470,   472,   474,   476,   478,   480,   482,   483,   485,
-     488,   493,   497,   499,   504,   507,   509,   511,   512,   513,
-     526,   528,   529,   530,   541,   543,   547,   549,   551,   553,
-     557,   559,   561,   563,   566,   567,   568,   572,   573,   575,
-     577,   579,   582,   585,   586,   591,   596,   601,   604,   606,
-     609,   611,   613,   617,   619,   621,   623,   625,   627,   629,
-     631,   633,   635,   637,   639,   641,   643,   645,   647,   649,
-     651,   653,   657,   661,   665,   669,   673,   677,   681,   685,
-     689,   693,   696,   699,   703,   707,   711,   715,   719,   723,
-     727,   731,   735,   739,   743,   747,   751,   755,   759,   764,
-     767,   769,   773,   776,   781,   785,   786,   788,   792,   798,
-     802,   806,   810,   814,   818,   822,   826,   830,   834,   838,
-     842,   846,   852,   855,   858,   861,   864,   868,   871,   876,
-     882,   886,   892,   896,   898,   901,   906,   911,   914
+      42,    44,    46,    48,    50,    55,    60,    62,    64,    65,
+      68,    70,    72,    74,    76,    78,    80,    82,    84,    86,
+      88,    90,    92,    94,    96,   100,   103,   105,   107,   109,
+     111,   113,   115,   117,   122,   125,   127,   129,   130,   134,
+     137,   138,   141,   144,   146,   150,   154,   155,   158,   159,
+     162,   169,   170,   172,   174,   178,   180,   183,   187,   196,
+     203,   209,   216,   218,   221,   223,   226,   227,   229,   231,
+     234,   236,   239,   244,   248,   249,   258,   259,   269,   270,
+     276,   278,   281,   283,   286,   288,   289,   296,   299,   301,
+     306,   309,   311,   313,   315,   317,   321,   323,   324,   331,
+     332,   338,   341,   344,   349,   350,   352,   354,   357,   359,
+     361,   363,   365,   367,   369,   371,   373,   375,   377,   378,
+     381,   382,   385,   386,   389,   390,   400,   401,   410,   411,
+     413,   415,   418,   420,   425,   427,   429,   434,   436,   437,
+     439,   441,   444,   446,   449,   458,   460,   462,   463,   468,
+     470,   474,   478,   479,   482,   484,   486,   488,   490,   492,
+     494,   496,   498,   500,   502,   504,   506,   507,   508,   513,
+     514,   519,   520,   523,   526,   529,   532,   536,   538,   540,
+     541,   543,   550,   561,   573,   575,   578,   580,   584,   588,
+     592,   596,   597,   599,   602,   607,   611,   613,   618,   621,
+     623,   625,   626,   627,   640,   642,   643,   644,   655,   657,
+     661,   663,   665,   667,   671,   673,   675,   677,   680,   681,
+     682,   686,   687,   689,   691,   693,   696,   699,   700,   705,
+     710,   715,   718,   720,   723,   725,   727,   729,   733,   735,
+     739,   740,   742,   744,   746,   748,   750,   752,   756,   762,
+     764,   766,   768,   770,   772,   774,   776,   778,   780,   782,
+     786,   790,   794,   798,   802,   806,   810,   814,   818,   822,
+     826,   830,   833,   836,   840,   844,   848,   852,   856,   860,
+     864,   868,   872,   876,   880,   884,   888,   892,   896,   899,
+     902,   904,   908,   911,   916,   920,   924,   928,   932,   936,
+     940,   944,   948,   952,   956,   960,   964,   970,   973,   976,
+     979,   982,   986,   989,   990,   997,   999,  1001,  1003,  1005,
+    1011,  1015,  1021,  1027,  1032,  1039,  1044,  1051,  1058,  1065,
+    1069,  1071,  1074,  1079,  1084,  1087,  1092
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int16 yyrhs[] =
 {
-     135,     0,    -1,   136,    -1,    -1,   137,    -1,   138,    -1,
-     137,   138,    -1,   186,    -1,   198,    -1,   196,    -1,   217,
-      -1,   207,    -1,   147,    -1,   148,   126,   136,   132,    -1,
-      99,    -1,    -1,   140,    -1,   141,    -1,   140,   141,    -1,
-     198,    -1,   196,    -1,   217,    -1,   207,    -1,   147,    -1,
-     148,   126,   139,   132,    -1,    99,    -1,   143,    -1,    -1,
-     143,   145,    -1,   145,    -1,   189,    -1,   159,    -1,   160,
-      -1,   161,    -1,   163,    -1,   171,    -1,   154,    -1,   183,
-      -1,   179,    -1,   239,    -1,   247,    -1,   246,    -1,   126,
-     143,   132,    -1,   126,   132,    -1,    99,    -1,   144,    -1,
-     150,    -1,   165,    -1,   166,    -1,   236,    -1,   181,    -1,
-     148,   126,   143,   132,    -1,   145,    99,    -1,   145,    -1,
-     144,    -1,     3,    89,     3,    -1,   102,   237,    -1,    -1,
-      46,   151,    -1,    32,   151,    -1,   152,    -1,   151,   100,
-     152,    -1,     3,   227,   149,    -1,    -1,    65,   146,    -1,
-      -1,    64,   122,   155,   238,   133,   146,   153,    -1,    -1,
-     150,    -1,   239,    -1,    46,     3,   227,    -1,     3,    -1,
-      13,   122,    -1,    13,    50,   122,    -1,   158,   156,    99,
-     238,    99,   239,   133,   146,    -1,   158,   157,    68,   238,
-     133,   146,    -1,    -1,    14,   122,   162,   238,   133,   146,
-      -1,    -1,    15,   164,   146,    14,   122,   238,   133,    -1,
-      66,    -1,    66,     3,    -1,    30,    -1,    30,     3,    -1,
-      -1,   168,    -1,   170,    -1,   168,   170,    -1,   169,    -1,
-     168,   169,    -1,    34,   240,   105,   142,    -1,    62,   105,
-     142,    -1,    -1,    16,   122,   172,   240,   133,   126,   167,
-     132,    -1,    -1,    33,   122,     3,   227,   133,   174,   126,
-     142,   132,    -1,    -1,    28,   126,   176,   142,   132,    -1,
-     173,    -1,   177,   173,    -1,   177,    -1,   177,   175,    -1,
-     175,    -1,    -1,    52,   126,   180,   142,   132,   178,    -1,
-      37,   238,    -1,    37,    -1,    39,   122,   238,   133,    -1,
-     182,   146,    -1,     3,    -1,    19,    -1,   185,   127,   184,
-      -1,   184,    -1,    -1,    19,   185,   126,   187,   139,   132,
-      -1,    -1,    19,   126,   188,   139,   132,    -1,    41,   223,
-      -1,    41,   185,   127,   115,    -1,    -1,   191,    -1,   192,
-      -1,   191,   192,    -1,    21,    -1,    22,    -1,    20,    -1,
-      38,    -1,    47,    -1,    49,    -1,    48,    -1,    26,    -1,
-      24,    -1,     4,    -1,    -1,    54,   224,    -1,    -1,    54,
-     225,    -1,    -1,    17,   225,    -1,    -1,   190,    31,     3,
-     193,   195,   126,   197,   200,   132,    -1,    -1,   190,    44,
-       3,   194,   126,   199,   203,   132,    -1,    -1,   201,    -1,
-     202,    -1,   201,   202,    -1,    99,    -1,   148,   126,   200,
-     132,    -1,   207,    -1,   217,    -1,   144,    -1,    -1,   204,
-      -1,   205,    -1,   204,   205,    -1,    99,    -1,    46,     3,
-      -1,   190,    27,   216,     3,   122,   213,   133,   227,    -1,
-      46,    -1,    32,    -1,    -1,   190,   206,   208,   209,    -1,
-     210,    -1,   209,   100,   210,    -1,     3,   227,   149,    -1,
-      -1,   102,   212,    -1,    10,    -1,     8,    -1,     9,    -1,
-      12,    -1,     5,    -1,    56,    -1,    55,    -1,    45,    -1,
-       3,    -1,    -1,   214,    -1,    93,   215,    -1,   214,   100,
-      93,   215,    -1,   214,   100,   215,    -1,   215,    -1,     3,
-     105,   226,   211,    -1,     3,   211,    -1,    51,    -1,    35,
-      -1,    -1,    -1,   190,    27,   216,     3,   122,   213,   133,
-     227,   126,   218,   142,   132,    -1,     3,    -1,    -1,    -1,
-      27,   219,   122,   213,   133,   227,   126,   221,   142,   132,
-      -1,     3,    -1,   185,   127,     3,    -1,   223,    -1,   222,
-      -1,   224,    -1,   225,   100,   224,    -1,   224,    -1,   115,
-      -1,    36,    -1,   105,   226,    -1,    -1,    -1,   122,   229,
-     133,    -1,    -1,   230,    -1,   231,    -1,   237,    -1,   230,
-     100,    -1,   231,   237,    -1,    -1,    25,   240,   232,   228,
-      -1,   240,   122,   229,   133,    -1,    53,   122,   229,   133,
-      -1,    63,   240,    -1,    42,    -1,    42,   238,    -1,   240,
-      -1,   240,    -1,   238,   100,   240,    -1,   238,    -1,   220,
-      -1,   241,    -1,   244,    -1,   233,    -1,   235,    -1,   234,
-      -1,     6,    -1,    10,    -1,    11,    -1,     8,    -1,     9,
-      -1,    12,    -1,     5,    -1,    29,    -1,    56,    -1,    55,
-      -1,    45,    -1,   240,   109,   240,    -1,   240,   110,   240,
-      -1,   240,    75,   240,    -1,   240,    76,   240,    -1,   240,
-      71,   240,    -1,   240,    72,   240,    -1,   240,    74,   240,
-      -1,   240,    73,   240,    -1,   240,    87,   240,    -1,   240,
-      88,   240,    -1,   118,   240,    -1,   117,   240,    -1,   240,
-     108,   240,    -1,   240,   107,   240,    -1,   240,   106,   240,
-      -1,   240,    96,   240,    -1,   240,    95,   240,    -1,   240,
-      94,   240,    -1,   240,   114,   240,    -1,   240,   116,   240,
-      -1,   240,   113,   240,    -1,   240,   112,   240,    -1,   240,
-     115,   240,    -1,   240,    68,   240,    -1,   240,    69,   240,
-      -1,   240,    40,   240,    -1,   240,    67,   240,    -1,    43,
-     122,   240,   133,    -1,    36,   240,    -1,    36,    -1,   122,
-     238,   133,    -1,   112,   240,    -1,   240,   124,   240,   125,
-      -1,   124,   229,   125,    -1,    -1,   243,    -1,   237,   105,
-     237,    -1,   243,   100,   237,   105,   237,    -1,    70,   242,
-     132,    -1,   240,    80,   240,    -1,   240,    79,   240,    -1,
-     240,    85,   240,    -1,   240,    84,   240,    -1,   240,    86,
-     240,    -1,   240,    78,   240,    -1,   240,    77,   240,    -1,
-     240,    83,   240,    -1,   240,    81,   240,    -1,   240,    82,
-     240,    -1,   240,   102,   240,    -1,   240,   104,   240,   105,
-     240,    -1,   240,    91,    -1,   240,    90,    -1,    91,   240,
-      -1,    90,   240,    -1,    53,   127,     3,    -1,   128,     3,
-      -1,   240,   127,   128,     3,    -1,   240,   127,     3,    89,
-       3,    -1,   240,    92,     3,    -1,   240,   127,   122,   240,
-     133,    -1,   240,   127,     3,    -1,     3,    -1,    18,     3,
-      -1,    18,     3,   102,     3,    -1,    18,     3,   102,     5,
-      -1,   190,   245,    -1,    23,    18,   224,    -1
+     136,     0,    -1,   137,    -1,    -1,   138,    -1,   139,    -1,
+     138,   139,    -1,   187,    -1,   199,    -1,   197,    -1,   233,
+      -1,   208,    -1,   148,    -1,   150,   127,   137,   133,    -1,
+     100,    -1,    -1,   141,    -1,   142,    -1,   141,   142,    -1,
+     199,    -1,   197,    -1,   233,    -1,   208,    -1,   148,    -1,
+     150,   127,   140,   133,    -1,   125,   149,   260,   126,    -1,
+     100,    -1,   144,    -1,    -1,   144,   146,    -1,   146,    -1,
+     268,    -1,   190,    -1,   162,    -1,   163,    -1,   164,    -1,
+     165,    -1,   172,    -1,   158,    -1,   184,    -1,   180,    -1,
+     256,    -1,   269,    -1,   267,    -1,   127,   144,   133,    -1,
+     127,   133,    -1,   100,    -1,   145,    -1,   152,    -1,   166,
+      -1,   167,    -1,   252,    -1,   182,    -1,   150,   127,   144,
+     133,    -1,   146,   100,    -1,   146,    -1,   145,    -1,    -1,
+       3,    90,     3,    -1,   103,   260,    -1,    -1,    45,   153,
+      -1,    31,   153,    -1,   154,    -1,   153,   101,   154,    -1,
+       3,   243,   151,    -1,    -1,   156,   147,    -1,    -1,    65,
+     155,    -1,    64,   123,   254,   134,   155,   157,    -1,    -1,
+     152,    -1,   256,    -1,    45,     3,   243,    -1,     3,    -1,
+      10,   123,    -1,    10,    49,   123,    -1,   161,   159,   100,
+     254,   100,   256,   134,   155,    -1,   161,   160,    68,   254,
+     134,   155,    -1,    11,   123,   254,   134,   155,    -1,    12,
+     155,    11,   123,   254,   134,    -1,    66,    -1,    66,     3,
+      -1,    29,    -1,    29,     3,    -1,    -1,   169,    -1,   171,
+      -1,   169,   171,    -1,   170,    -1,   169,   170,    -1,    33,
+     260,   105,   143,    -1,    61,   105,   143,    -1,    -1,    13,
+     123,   173,   260,   134,   127,   168,   133,    -1,    -1,    32,
+     123,     3,   243,   134,   175,   127,   143,   133,    -1,    -1,
+      26,   127,   177,   143,   133,    -1,   174,    -1,   178,   174,
+      -1,   178,    -1,   178,   176,    -1,   176,    -1,    -1,    51,
+     127,   181,   143,   133,   179,    -1,    36,   254,    -1,    36,
+      -1,    38,   123,   254,   134,    -1,   183,   147,    -1,     3,
+      -1,    16,    -1,    15,    -1,    28,    -1,   186,   128,   185,
+      -1,   185,    -1,    -1,    16,   186,   127,   188,   140,   133,
+      -1,    -1,    16,   127,   189,   140,   133,    -1,    40,     3,
+      -1,    40,   239,    -1,    40,   186,   128,   116,    -1,    -1,
+     192,    -1,   193,    -1,   192,   193,    -1,    19,    -1,    20,
+      -1,    17,    -1,    37,    -1,    46,    -1,    48,    -1,    47,
+      -1,    24,    -1,    22,    -1,     3,    -1,    -1,    53,   240,
+      -1,    -1,    53,   241,    -1,    -1,    14,   241,    -1,    -1,
+     191,    30,     3,   194,   196,   127,   198,   201,   133,    -1,
+      -1,   191,    43,     3,   195,   127,   200,   204,   133,    -1,
+      -1,   202,    -1,   203,    -1,   202,   203,    -1,   100,    -1,
+     150,   127,   201,   133,    -1,   208,    -1,   233,    -1,   125,
+     149,   260,   126,    -1,   145,    -1,    -1,   205,    -1,   206,
+      -1,   205,   206,    -1,   100,    -1,    45,     3,    -1,   191,
+      25,   232,     3,   123,   229,   134,   243,    -1,    45,    -1,
+      31,    -1,    -1,   191,   207,   209,   210,    -1,   211,    -1,
+     210,   101,   211,    -1,     3,   243,   151,    -1,    -1,   103,
+     260,    -1,     7,    -1,     8,    -1,     9,    -1,     4,    -1,
+      55,    -1,    54,    -1,    44,    -1,    27,    -1,    28,    -1,
+     226,    -1,   110,    -1,   111,    -1,    -1,    -1,   127,   260,
+     219,   133,    -1,    -1,   127,   260,   221,   133,    -1,    -1,
+     222,   218,    -1,   222,     4,    -1,   222,   111,    -1,   226,
+     222,    -1,   223,   226,   222,    -1,     3,    -1,   220,    -1,
+      -1,   227,    -1,   215,   224,   225,   115,   217,   111,    -1,
+     215,   224,   225,   216,   222,   110,   115,   224,   217,   111,
+      -1,   215,   224,   225,   216,   222,   223,   110,   115,   224,
+     217,   111,    -1,   228,    -1,   227,   228,    -1,   220,    -1,
+     220,   103,     4,    -1,   220,   103,   220,    -1,     3,   103,
+     220,    -1,     3,   103,     4,    -1,    -1,   230,    -1,    94,
+     231,    -1,   230,   101,    94,   231,    -1,   230,   101,   231,
+      -1,   231,    -1,     3,   105,   242,   212,    -1,     3,   212,
+      -1,    50,    -1,    34,    -1,    -1,    -1,   191,    25,   232,
+       3,   123,   229,   134,   243,   127,   234,   143,   133,    -1,
+       3,    -1,    -1,    -1,    25,   235,   123,   229,   134,   243,
+     127,   237,   143,   133,    -1,   185,    -1,   186,   128,   185,
+      -1,   239,    -1,   238,    -1,   240,    -1,   241,   101,   240,
+      -1,   240,    -1,   116,    -1,    35,    -1,   105,   242,    -1,
+      -1,    -1,   123,   245,   134,    -1,    -1,   246,    -1,   247,
+      -1,   253,    -1,   246,   101,    -1,   247,   253,    -1,    -1,
+      23,   260,   248,   244,    -1,   260,   123,   245,   134,    -1,
+      52,   123,   245,   134,    -1,    63,   260,    -1,    41,    -1,
+      41,   254,    -1,   260,    -1,   255,    -1,   260,    -1,   255,
+     101,   260,    -1,   260,    -1,   256,   101,   260,    -1,    -1,
+     259,    -1,     3,    -1,     4,    -1,     7,    -1,     8,    -1,
+       9,    -1,   258,   105,   253,    -1,   259,   101,   258,   105,
+     253,    -1,   236,    -1,   264,    -1,   249,    -1,   251,    -1,
+     250,    -1,   265,    -1,   213,    -1,   214,    -1,     5,    -1,
+      18,    -1,   125,   245,   126,    -1,    70,   257,   133,    -1,
+     260,   110,   260,    -1,   260,   111,   260,    -1,   260,    75,
+     260,    -1,   260,    76,   260,    -1,   260,    71,   260,    -1,
+     260,    72,   260,    -1,   260,    74,   260,    -1,   260,    73,
+     260,    -1,   260,    88,   260,    -1,   260,    89,   260,    -1,
+     119,   260,    -1,   118,   260,    -1,   260,   108,   260,    -1,
+     260,   107,   260,    -1,   260,   106,   260,    -1,   260,    97,
+     260,    -1,   260,    96,   260,    -1,   260,    95,   260,    -1,
+     260,   115,   260,    -1,   260,   117,   260,    -1,   260,   114,
+     260,    -1,   260,   113,   260,    -1,   260,   116,   260,    -1,
+     260,    68,   260,    -1,   260,    69,   260,    -1,   260,    39,
+     260,    -1,   260,    67,   260,    -1,    42,   260,    -1,    35,
+     260,    -1,    35,    -1,   123,   255,   134,    -1,   113,   260,
+      -1,   260,   125,   260,   126,    -1,   260,    80,   260,    -1,
+     260,    79,   260,    -1,   260,    86,   260,    -1,   260,    85,
+     260,    -1,   260,    87,   260,    -1,   260,    78,   260,    -1,
+     260,    77,   260,    -1,   260,    84,   260,    -1,   260,    81,
+     260,    -1,   260,    82,   260,    -1,   260,    83,   260,    -1,
+     260,   103,   260,    -1,   260,   104,   260,   105,   260,    -1,
+     260,    92,    -1,   260,    91,    -1,    92,   260,    -1,    91,
+     260,    -1,    52,   128,     3,    -1,   129,     3,    -1,    -1,
+     260,   128,   123,   261,   260,   134,    -1,     3,    -1,   116,
+      -1,   185,    -1,   116,    -1,   260,   128,   262,    90,   263,
+      -1,   260,    93,   263,    -1,   260,    93,   262,    90,   263,
+      -1,   260,   128,   125,   260,   126,    -1,   260,   128,   129,
+     263,    -1,   260,   128,   129,   262,    90,   263,    -1,   260,
+      93,   129,   263,    -1,   260,    93,   129,   262,    90,   263,
+      -1,   260,   128,   129,   125,   260,   126,    -1,   260,    93,
+     129,   125,   260,   126,    -1,   260,   128,   263,    -1,     3,
+      -1,    15,     3,    -1,    15,     3,   103,     3,    -1,    15,
+       3,   103,     4,    -1,   191,   266,    -1,    62,    15,   103,
+     260,    -1,    21,    15,   240,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,  2065,  2065,  2067,  2067,  2068,  2069,  2071,  2072,  2073,
-    2074,  2075,  2076,  2077,  2078,  2080,  2080,  2081,  2082,  2084,
-    2085,  2086,  2087,  2088,  2089,  2090,  2092,  2093,  2095,  2096,
-    2099,  2100,  2101,  2102,  2103,  2104,  2105,  2106,  2107,  2108,
-    2109,  2110,  2111,  2112,  2115,  2116,  2117,  2118,  2119,  2120,
-    2121,  2122,  2126,  2127,  2131,  2138,  2142,  2143,  2147,  2148,
-    2150,  2151,  2153,  2214,  2215,  2218,  2218,  2237,  2238,  2239,
-    2244,  2248,  2253,  2254,  2256,  2276,  2324,  2324,  2343,  2343,
-    2358,  2361,  2364,  2367,  2371,  2372,  2373,  2374,  2375,  2376,
-    2378,  2389,  2392,  2392,  2421,  2421,  2446,  2446,  2462,  2463,
-    2464,  2465,  2473,  2482,  2482,  2531,  2535,  2546,  2558,  2575,
-    2576,  2578,  2579,  2581,  2581,  2583,  2583,  2586,  2602,  2619,
-    2620,  2621,  2622,  2630,  2631,  2632,  2633,  2634,  2635,  2636,
-    2637,  2638,  2639,  2643,  2644,  2646,  2647,  2649,  2650,  2654,
-    2652,  2660,  2658,  2667,  2668,  2669,  2670,  2671,  2672,  2673,
-    2674,  2676,  2682,  2683,  2684,  2685,  2686,  2687,  2690,  2703,
-    2703,  2705,  2705,  2707,  2708,  2710,  2785,  2786,  2788,  2789,
-    2790,  2791,  2792,  2794,  2795,  2796,  2797,  2809,  2813,  2819,
-    2825,  2833,  2838,  2844,  2852,  2860,  2861,  2862,  2865,  2864,
-    2881,  2882,  2884,  2883,  2907,  2926,  2940,  2941,  2943,  2944,
-    2946,  2947,  2948,  2957,  2958,  2962,  2963,  2965,  2966,  2967,
-    2969,  2973,  2974,  2979,  2980,  3016,  3062,  3083,  3104,  3107,
-    3114,  3115,  3116,  3122,  3128,  3130,  3132,  3134,  3136,  3138,
-    3140,  3157,  3162,  3165,  3168,  3171,  3174,  3177,  3180,  3183,
-    3186,  3190,  3193,  3196,  3199,  3202,  3205,  3208,  3211,  3215,
-    3226,  3244,  3249,  3254,  3259,  3264,  3269,  3273,  3277,  3282,
-    3286,  3290,  3299,  3308,  3318,  3323,  3335,  3341,  3346,  3352,
-    3358,  3362,  3364,  3375,  3384,  3391,  3392,  3394,  3400,  3409,
-    3416,  3428,  3434,  3440,  3446,  3452,  3458,  3464,  3470,  3483,
-    3494,  3501,  3514,  3541,  3555,  3569,  3583,  3598,  3605,  3612,
-    3619,  3626,  3637,  3687,  3792,  3799,  3806,  3813,  3820
+       0,  1998,  1998,  2000,  2000,  2001,  2002,  2004,  2005,  2006,
+    2007,  2008,  2009,  2010,  2011,  2013,  2013,  2014,  2015,  2017,
+    2018,  2019,  2020,  2021,  2022,  2023,  2024,  2026,  2027,  2029,
+    2032,  2035,  2036,  2037,  2038,  2039,  2040,  2041,  2042,  2043,
+    2044,  2045,  2046,  2047,  2048,  2049,  2052,  2053,  2054,  2055,
+    2056,  2057,  2058,  2059,  2071,  2072,  2076,  2087,  2095,  2122,
+    2123,  2125,  2126,  2128,  2129,  2131,  2192,  2192,  2196,  2197,
+    2200,  2216,  2217,  2218,  2223,  2227,  2232,  2233,  2235,  2255,
+    2299,  2315,  2327,  2330,  2333,  2336,  2340,  2341,  2342,  2343,
+    2344,  2345,  2347,  2358,  2361,  2361,  2392,  2392,  2417,  2417,
+    2433,  2434,  2435,  2436,  2444,  2453,  2453,  2502,  2506,  2517,
+    2527,  2544,  2545,  2546,  2547,  2549,  2550,  2552,  2552,  2554,
+    2554,  2578,  2586,  2600,  2616,  2617,  2618,  2619,  2626,  2627,
+    2628,  2629,  2630,  2631,  2632,  2633,  2634,  2635,  2639,  2640,
+    2642,  2643,  2645,  2646,  2650,  2648,  2656,  2654,  2663,  2664,
+    2665,  2666,  2667,  2668,  2669,  2670,  2671,  2673,  2679,  2680,
+    2681,  2682,  2683,  2684,  2687,  2760,  2760,  2762,  2762,  2764,
+    2765,  2767,  2851,  2852,  2860,  2861,  2864,  2865,  2866,  2867,
+    2868,  2869,  2870,  2878,  2889,  2890,  2891,  2893,  2893,  2896,
+    2896,  2899,  2900,  2903,  2908,  2911,  2914,  2917,  2920,  2924,
+    2927,  2931,  2935,  2940,  2946,  2949,  2952,  2955,  2960,  2963,
+    2966,  2976,  2980,  2986,  2992,  3000,  3005,  3011,  3019,  3027,
+    3028,  3029,  3032,  3031,  3048,  3049,  3051,  3050,  3074,  3094,
+    3109,  3110,  3112,  3113,  3115,  3116,  3117,  3126,  3127,  3131,
+    3132,  3134,  3135,  3136,  3138,  3142,  3143,  3148,  3149,  3196,
+    3246,  3267,  3289,  3292,  3299,  3302,  3305,  3308,  3311,  3314,
+    3319,  3320,  3322,  3323,  3324,  3325,  3326,  3328,  3334,  3343,
+    3344,  3345,  3346,  3347,  3348,  3350,  3354,  3359,  3377,  3388,
+    3398,  3407,  3408,  3409,  3410,  3411,  3412,  3413,  3414,  3415,
+    3416,  3417,  3418,  3419,  3420,  3421,  3422,  3423,  3424,  3425,
+    3426,  3427,  3428,  3429,  3430,  3431,  3432,  3433,  3434,  3435,
+    3436,  3437,  3438,  3439,  3440,  3441,  3442,  3443,  3444,  3445,
+    3446,  3447,  3448,  3449,  3450,  3451,  3452,  3454,  3455,  3456,
+    3457,  3459,  3474,  3482,  3482,  3536,  3537,  3538,  3539,  3579,
+    3582,  3589,  3592,  3603,  3611,  3615,  3622,  3626,  3636,  3647,
+    3844,  3878,  3885,  3892,  3899,  3921,  3928
 };
 #endif
 
@@ -2535,54 +2791,58 @@ static const yytype_uint16 yyrline[] =
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
 {
-  "$end", "error", "$undefined", "T_IDENTIFIER", "T_NAMESPACE",
-  "T_STRING", "T_REGEXP", "T_EMPTY", "T_INT", "T_UINT", "T_BYTE",
-  "T_SHORT", "T_FLOAT", "\"for\"", "\"while\"", "\"do\"", "\"switch\"",
-  "\"implements\"", "\"namespace\"", "\"package\"", "\"protected\"",
-  "\"public\"", "\"private\"", "\"use\"", "\"internal\"", "\"new\"",
-  "\"native\"", "\"function\"", "\"finally\"", "\"undefined\"",
-  "\"continue\"", "\"class\"", "\"const\"", "\"catch\"", "\"case\"",
-  "\"set\"", "\"void\"", "\"throw\"", "\"static\"", "\"with\"",
-  "\"instanceof\"", "\"import\"", "\"return\"", "\"typeof\"",
-  "\"interface\"", "\"null\"", "\"var\"", "\"dynamic\"", "\"override\"",
-  "\"final\"", "\"each\"", "\"get\"", "\"try\"", "\"super\"",
-  "\"extends\"", "\"false\"", "\"true\"", "\"Boolean\"", "\"uint\"",
-  "\"int\"", "\"Number\"", "\"String\"", "\"default\"", "\"delete\"",
-  "\"if\"", "\"else\"", "\"break\"", "\"is\"", "\"in\"", "\"as\"",
-  "\"{ (dictionary)\"", "\"==\"", "\"===\"", "\"!=\"", "\"!==\"", "\"<=\"",
-  "\">=\"", "\"|=\"", "\"/=\"", "\"%=\"", "\"*=\"", "\"+=\"", "\"-=\"",
-  "\"^=\"", "\">>=\"", "\"<<=\"", "\">>>=\"", "\"||\"", "\"&&\"", "\"::\"",
-  "\"--\"", "\"++\"", "\"..\"", "\"...\"", "\"<<\"", "\">>>\"", "\">>\"",
-  "prec_none", "below_semicolon", "';'", "','", "below_assignment", "'='",
-  "\"&=\"", "'?'", "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "below_minus",
-  "'-'", "'+'", "'/'", "'*'", "'%'", "'~'", "'!'", "minusminus_prefix",
-  "plusplus_prefix", "below_curly", "'('", "new2", "'['", "']'", "'{'",
-  "'.'", "'@'", "above_identifier", "below_else", "above_function", "'}'",
-  "')'", "$accept", "PROGRAM", "MAYBE_PROGRAM_CODE_LIST",
-  "PROGRAM_CODE_LIST", "PROGRAM_CODE", "MAYBE_INPACKAGE_CODE_LIST",
-  "INPACKAGE_CODE_LIST", "INPACKAGE_CODE", "MAYBECODE", "CODE",
-  "CODE_STATEMENT", "CODEPIECE", "CODEBLOCK", "PACKAGE_INITCODE",
+  "$end", "error", "$undefined", "T_IDENTIFIER", "T_STRING", "T_REGEXP",
+  "T_EMPTY", "T_INT", "T_UINT", "T_FLOAT", "\"for\"", "\"while\"",
+  "\"do\"", "\"switch\"", "\"implements\"", "\"namespace\"", "\"package\"",
+  "\"protected\"", "\"arguments\"", "\"public\"", "\"private\"", "\"use\"",
+  "\"internal\"", "\"new\"", "\"native\"", "\"function\"", "\"finally\"",
+  "\"undefined\"", "\"NaN\"", "\"continue\"", "\"class\"", "\"const\"",
+  "\"catch\"", "\"case\"", "\"set\"", "\"void\"", "\"throw\"",
+  "\"static\"", "\"with\"", "\"instanceof\"", "\"import\"", "\"return\"",
+  "\"typeof\"", "\"interface\"", "\"null\"", "\"var\"", "\"dynamic\"",
+  "\"override\"", "\"final\"", "\"each\"", "\"get\"", "\"try\"",
+  "\"super\"", "\"extends\"", "\"false\"", "\"true\"", "\"Boolean\"",
+  "\"uint\"", "\"int\"", "\"Number\"", "\"String\"", "\"default\"",
+  "\"default xml\"", "\"delete\"", "\"if\"", "\"else\"", "\"break\"",
+  "\"is\"", "\"in\"", "\"as\"", "\"{ (dictionary)\"", "\"==\"", "\"===\"",
+  "\"!=\"", "\"!==\"", "\"<=\"", "\">=\"", "\"|=\"", "\"/=\"", "\"%=\"",
+  "\"*=\"", "\"&=\"", "\"+=\"", "\"-=\"", "\"^=\"", "\">>=\"", "\"<<=\"",
+  "\">>>=\"", "\"||\"", "\"&&\"", "\"::\"", "\"--\"", "\"++\"", "\"..\"",
+  "\"...\"", "\"<<\"", "\">>>\"", "\">>\"", "prec_none", "below_semicolon",
+  "';'", "','", "below_assignment", "'='", "'?'", "':'", "'|'", "'^'",
+  "'&'", "below_lt", "'<'", "'>'", "below_minus", "'-'", "'+'", "'/'",
+  "'*'", "'%'", "'~'", "'!'", "minusminus_prefix", "plusplus_prefix",
+  "below_curly", "'('", "new2", "'['", "']'", "'{'", "'.'", "'@'",
+  "above_identifier", "below_else", "above_function", "'}'", "')'",
+  "$accept", "PROGRAM", "MAYBE_PROGRAM_CODE_LIST", "PROGRAM_CODE_LIST",
+  "PROGRAM_CODE", "MAYBE_INPACKAGE_CODE_LIST", "INPACKAGE_CODE_LIST",
+  "INPACKAGE_CODE", "MAYBECODE", "CODE", "CODE_STATEMENT", "CODEPIECE",
+  "CODEBLOCK", "PACKAGE_INITCODE", "EMBED_START",
   "CONDITIONAL_COMPILATION", "MAYBEEXPRESSION", "VARIABLE_DECLARATION",
-  "VARIABLE_LIST", "ONE_VARIABLE", "MAYBEELSE", "IF", "$@1", "FOR_INIT",
-  "FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN", "WHILE", "$@2", "DO_WHILE",
-  "$@3", "BREAK", "CONTINUE", "MAYBE_CASE_LIST", "CASE_LIST", "CASE",
-  "DEFAULT", "SWITCH", "$@4", "CATCH", "$@5", "FINALLY", "$@6",
-  "CATCH_LIST", "CATCH_FINALLY_LIST", "TRY", "$@7", "THROW", "WITH_HEAD",
-  "WITH", "X_IDENTIFIER", "PACKAGE", "PACKAGE_DECLARATION", "$@8", "$@9",
+  "VARIABLE_LIST", "ONE_VARIABLE", "IF_CODEBLOCK", "$@1", "MAYBEELSE",
+  "IF", "FOR_INIT", "FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN", "WHILE",
+  "DO_WHILE", "BREAK", "CONTINUE", "MAYBE_CASE_LIST", "CASE_LIST", "CASE",
+  "DEFAULT", "SWITCH", "$@2", "CATCH", "$@3", "FINALLY", "$@4",
+  "CATCH_LIST", "CATCH_FINALLY_LIST", "TRY", "$@5", "THROW", "WITH_HEAD",
+  "WITH", "X_IDENTIFIER", "PACKAGE", "PACKAGE_DECLARATION", "$@6", "$@7",
   "IMPORT", "MAYBE_MODIFIERS", "MODIFIER_LIST", "MODIFIER", "EXTENDS",
-  "EXTENDS_LIST", "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@10",
-  "INTERFACE_DECLARATION", "$@11", "MAYBE_CLASS_BODY", "CLASS_BODY",
+  "EXTENDS_LIST", "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@8",
+  "INTERFACE_DECLARATION", "$@9", "MAYBE_CLASS_BODY", "CLASS_BODY",
   "CLASS_BODY_ITEM", "MAYBE_INTERFACE_BODY", "INTERFACE_BODY",
-  "IDECLARATION", "VARCONST", "SLOT_DECLARATION", "$@12", "SLOT_LIST",
-  "ONE_SLOT", "MAYBESTATICCONSTANT", "STATICCONSTANT", "MAYBE_PARAM_LIST",
-  "PARAM_LIST", "PARAM", "GETSET", "FUNCTION_DECLARATION", "$@13",
-  "MAYBE_IDENTIFIER", "INNERFUNCTION", "$@14", "CLASS", "PACKAGEANDCLASS",
-  "CLASS_SPEC", "CLASS_SPEC_LIST", "TYPE", "MAYBETYPE",
-  "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST", "EXPRESSION_LIST",
-  "EXPRESSION_LIST_AND_COMMA", "XX", "NEW", "FUNCTIONCALL", "DELETE",
-  "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION", "VOIDEXPRESSION", "E",
-  "CONSTANT", "MAYBE_EXPRPAIR_LIST", "EXPRPAIR_LIST", "VAR_READ",
-  "NAMESPACE_ID", "NAMESPACE_DECLARATION", "USE_NAMESPACE", 0
+  "IDECLARATION", "VARCONST", "SLOT_DECLARATION", "$@10", "SLOT_LIST",
+  "ONE_SLOT", "MAYBECONSTANT", "CONSTANT", "XML", "OPEN", "CLOSE",
+  "CLOSE2", "XMLEXPR1", "$@11", "XMLEXPR2", "$@12", "XMLTEXT", "XML2",
+  "XML_ID_OR_EXPR", "MAYBE_XMLATTRIBUTES", "XMLNODE", "XMLATTRIBUTES",
+  "XMLATTRIBUTE", "MAYBE_PARAM_LIST", "PARAM_LIST", "PARAM", "GETSET",
+  "FUNCTION_DECLARATION", "$@13", "MAYBE_IDENTIFIER", "INNERFUNCTION",
+  "$@14", "CLASS", "PACKAGEANDCLASS", "CLASS_SPEC", "CLASS_SPEC_LIST",
+  "TYPE", "MAYBETYPE", "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST",
+  "EXPRESSION_LIST", "EXPRESSION_LIST_AND_COMMA", "XX", "NEW",
+  "FUNCTIONCALL", "DELETE", "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION",
+  "COMMA_EXPRESSION", "VOIDEXPRESSION", "MAYBE_DICT_EXPRPAIR_LIST",
+  "DICTLH", "DICT_EXPRPAIR_LIST", "E", "$@15", "ID_OR_NS", "SUBNODE",
+  "MEMBER", "VAR_READ", "NAMESPACE_ID", "NAMESPACE_DECLARATION",
+  "DEFAULT_NAMESPACE", "USE_NAMESPACE", 0
 };
 #endif
 
@@ -2600,48 +2860,53 @@ static const yytype_uint16 yytoknum[] =
      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
-     345,   346,   347,   348,   349,   350,   351,   352,   353,    59,
-      44,   354,    61,   355,    63,    58,   124,    94,    38,    60,
-      62,   356,    45,    43,    47,    42,    37,   126,    33,   357,
-     358,   359,    40,   360,    91,    93,   123,    46,    64,   361,
-     362,   363,   125,    41
+     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
+      59,    44,   355,    61,    63,    58,   124,    94,    38,   356,
+      60,    62,   357,    45,    43,    47,    42,    37,   126,    33,
+     358,   359,   360,    40,   361,    91,    93,   123,    46,    64,
+     362,   363,   364,   125,    41
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const yytype_uint8 yyr1[] =
+static const yytype_uint16 yyr1[] =
 {
-       0,   134,   135,   136,   136,   137,   137,   138,   138,   138,
-     138,   138,   138,   138,   138,   139,   139,   140,   140,   141,
-     141,   141,   141,   141,   141,   141,   142,   142,   143,   143,
-     144,   144,   144,   144,   144,   144,   144,   144,   144,   144,
-     144,   144,   144,   144,   145,   145,   145,   145,   145,   145,
-     145,   145,   146,   146,   147,   148,   149,   149,   150,   150,
-     151,   151,   152,   153,   153,   155,   154,   156,   156,   156,
-     157,   157,   158,   158,   159,   160,   162,   161,   164,   163,
-     165,   165,   166,   166,   167,   167,   167,   167,   168,   168,
-     169,   170,   172,   171,   174,   173,   176,   175,   177,   177,
-     178,   178,   178,   180,   179,   181,   181,   182,   183,   184,
-     184,   185,   185,   187,   186,   188,   186,   189,   189,   190,
-     190,   191,   191,   192,   192,   192,   192,   192,   192,   192,
-     192,   192,   192,   193,   193,   194,   194,   195,   195,   197,
-     196,   199,   198,   200,   200,   201,   201,   202,   202,   202,
-     202,   202,   203,   203,   204,   204,   205,   205,   205,   206,
-     206,   208,   207,   209,   209,   210,   211,   211,   212,   212,
-     212,   212,   212,   212,   212,   212,   212,   213,   213,   213,
-     213,   214,   214,   215,   215,   216,   216,   216,   218,   217,
-     219,   219,   221,   220,   222,   223,   224,   224,   225,   225,
-     226,   226,   226,   227,   227,   228,   228,   229,   229,   229,
-     230,   231,   230,   232,   233,   234,   234,   235,   236,   236,
-     237,   238,   238,   239,   240,   240,   240,   240,   240,   240,
-     240,   241,   241,   241,   241,   241,   241,   241,   241,   241,
-     241,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   240,   240,   240,   240,   242,   242,   243,   243,   240,
-     240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   240,   240,   244,   245,   245,   245,   246,   247
+       0,   135,   136,   137,   137,   138,   138,   139,   139,   139,
+     139,   139,   139,   139,   139,   140,   140,   141,   141,   142,
+     142,   142,   142,   142,   142,   142,   142,   143,   143,   144,
+     144,   145,   145,   145,   145,   145,   145,   145,   145,   145,
+     145,   145,   145,   145,   145,   145,   146,   146,   146,   146,
+     146,   146,   146,   146,   147,   147,   148,   149,   150,   151,
+     151,   152,   152,   153,   153,   154,   156,   155,   157,   157,
+     158,   159,   159,   159,   160,   160,   161,   161,   162,   163,
+     164,   165,   166,   166,   167,   167,   168,   168,   168,   168,
+     169,   169,   170,   171,   173,   172,   175,   174,   177,   176,
+     178,   178,   179,   179,   179,   181,   180,   182,   182,   183,
+     184,   185,   185,   185,   185,   186,   186,   188,   187,   189,
+     187,   190,   190,   190,   191,   191,   192,   192,   193,   193,
+     193,   193,   193,   193,   193,   193,   193,   193,   194,   194,
+     195,   195,   196,   196,   198,   197,   200,   199,   201,   201,
+     202,   202,   203,   203,   203,   203,   203,   203,   204,   204,
+     205,   205,   206,   206,   206,   207,   207,   209,   208,   210,
+     210,   211,   212,   212,   213,   213,   213,   213,   213,   213,
+     213,   213,   213,   214,   215,   216,   217,   219,   218,   221,
+     220,   222,   222,   222,   222,   223,   223,   224,   224,   225,
+     225,   226,   226,   226,   227,   227,   228,   228,   228,   228,
+     228,   229,   229,   229,   229,   230,   230,   231,   231,   232,
+     232,   232,   234,   233,   235,   235,   237,   236,   238,   239,
+     240,   240,   241,   241,   242,   242,   242,   243,   243,   244,
+     244,   245,   245,   245,   246,   247,   246,   248,   249,   250,
+     250,   251,   252,   252,   253,   254,   255,   255,   256,   256,
+     257,   257,   258,   258,   258,   258,   258,   259,   259,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   261,   260,   262,   262,   263,   263,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   264,
+     265,   266,   266,   266,   267,   268,   269
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -2649,35 +2914,40 @@ static const yytype_uint8 yyr2[] =
 {
        0,     2,     1,     0,     1,     1,     2,     1,     1,     1,
        1,     1,     1,     4,     1,     0,     1,     1,     2,     1,
-       1,     1,     1,     1,     4,     1,     1,     0,     2,     1,
+       1,     1,     1,     1,     4,     4,     1,     1,     0,     2,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     3,     2,     1,     1,     1,     1,     1,     1,
-       1,     4,     2,     1,     1,     3,     2,     0,     2,     2,
-       1,     3,     3,     0,     2,     0,     7,     0,     1,     1,
-       3,     1,     2,     3,     8,     6,     0,     6,     0,     7,
-       1,     2,     1,     2,     0,     1,     1,     2,     1,     2,
-       4,     3,     0,     8,     0,     9,     0,     5,     1,     2,
-       1,     2,     1,     0,     6,     2,     1,     4,     2,     1,
-       1,     3,     1,     0,     6,     0,     5,     2,     4,     0,
-       1,     1,     2,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     0,     2,     0,     2,     0,     2,     0,
-       9,     0,     8,     0,     1,     1,     2,     1,     4,     1,
-       1,     1,     0,     1,     1,     2,     1,     2,     8,     1,
-       1,     0,     4,     1,     3,     3,     0,     2,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     0,     1,     2,
-       4,     3,     1,     4,     2,     1,     1,     0,     0,    12,
-       1,     0,     0,    10,     1,     3,     1,     1,     1,     3,
-       1,     1,     1,     2,     0,     0,     3,     0,     1,     1,
-       1,     2,     2,     0,     4,     4,     4,     2,     1,     2,
-       1,     1,     3,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     2,     2,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     4,     2,
-       1,     3,     2,     4,     3,     0,     1,     3,     5,     3,
+       1,     1,     1,     1,     3,     2,     1,     1,     1,     1,
+       1,     1,     1,     4,     2,     1,     1,     0,     3,     2,
+       0,     2,     2,     1,     3,     3,     0,     2,     0,     2,
+       6,     0,     1,     1,     3,     1,     2,     3,     8,     6,
+       5,     6,     1,     2,     1,     2,     0,     1,     1,     2,
+       1,     2,     4,     3,     0,     8,     0,     9,     0,     5,
+       1,     2,     1,     2,     1,     0,     6,     2,     1,     4,
+       2,     1,     1,     1,     1,     3,     1,     0,     6,     0,
+       5,     2,     2,     4,     0,     1,     1,     2,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     0,     2,
+       0,     2,     0,     2,     0,     9,     0,     8,     0,     1,
+       1,     2,     1,     4,     1,     1,     4,     1,     0,     1,
+       1,     2,     1,     2,     8,     1,     1,     0,     4,     1,
+       3,     3,     0,     2,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     0,     0,     4,     0,
+       4,     0,     2,     2,     2,     2,     3,     1,     1,     0,
+       1,     6,    10,    11,     1,     2,     1,     3,     3,     3,
+       3,     0,     1,     2,     4,     3,     1,     4,     2,     1,
+       1,     0,     0,    12,     1,     0,     0,    10,     1,     3,
+       1,     1,     1,     3,     1,     1,     1,     2,     0,     0,
+       3,     0,     1,     1,     1,     2,     2,     0,     4,     4,
+       4,     2,     1,     2,     1,     1,     1,     3,     1,     3,
+       0,     1,     1,     1,     1,     1,     1,     3,     5,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     5,     2,     2,     2,     2,     3,     2,     4,     5,
-       3,     5,     3,     1,     2,     4,     4,     2,     3
+       3,     2,     2,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     2,     2,
+       1,     3,     2,     4,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     5,     2,     2,     2,
+       2,     3,     2,     0,     6,     1,     1,     1,     1,     5,
+       3,     5,     5,     4,     6,     4,     6,     6,     6,     3,
+       1,     2,     4,     4,     2,     4,     3
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -2685,836 +2955,934 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint16 yydefact[] =
 {
-     119,   303,   132,   236,   230,   233,   234,   231,   232,   235,
-       0,     0,    78,     0,     0,   125,   123,   124,     0,   131,
-       0,   130,   191,   237,   270,   126,     0,     0,     0,   240,
-     127,   129,   128,     0,     0,   239,   238,     0,     0,   275,
-       0,     0,    14,     0,     0,     0,     0,   207,   119,     0,
-       0,     2,   119,     5,    54,    12,     0,    36,    67,    31,
-      32,    33,    34,    35,    38,   119,    37,     7,    30,     0,
-     120,   121,     9,     8,    11,    10,   224,   227,   229,   228,
-     223,    39,   221,   225,   226,    41,    40,     0,     0,    72,
-      76,   119,    92,   109,   110,   115,   112,     0,     0,   303,
-     213,   190,     0,   269,     0,     0,   117,     0,   103,   207,
-       0,   217,    65,     0,   220,     0,   276,   295,   294,   272,
-     252,   251,     0,     0,   208,   209,   210,    82,     0,   106,
-     218,     0,    80,    44,    43,   119,    45,    29,     0,    46,
-      47,    48,    50,     0,    49,   297,     1,     6,   119,   303,
-       0,    68,     0,     0,    69,    53,   108,     0,   187,     0,
-     160,     0,   159,   161,   307,   122,     0,     0,     0,     0,
+     124,   350,   177,   277,   174,   175,   176,     0,     0,    66,
+       0,     0,   130,   278,   128,   129,     0,   136,     0,   135,
+     225,   181,   182,   310,   131,     0,     0,     0,   180,   132,
+     134,   133,     0,     0,   179,   178,     0,     0,     0,   260,
+       0,     0,    14,   184,     0,     0,     0,     0,   241,   124,
+       0,     0,     2,   124,     5,    56,    12,     0,    38,    71,
+      33,    34,    35,    36,    37,    40,   124,    39,     7,    32,
+       0,   125,   126,     9,     8,    11,   275,   276,     0,   183,
+      10,   269,   271,   273,   272,    41,   258,   270,   274,    43,
+      31,    42,     0,     0,    76,     0,     0,   124,    94,   111,
+     113,   112,   114,   119,   116,     0,     0,   350,   247,   224,
+       0,   309,     0,   121,     0,   122,   308,   105,   241,     0,
+       0,   251,     0,   262,   263,   264,   265,   266,     0,     0,
+     261,   330,   329,   312,   292,   291,     0,   256,     0,   242,
+     243,   244,   254,    84,     0,   108,   252,     0,    82,    46,
+      45,   124,    47,    30,     0,    48,    49,    50,    52,     0,
+      51,   332,     1,     6,   124,   350,     0,    72,     0,     0,
+      73,    55,   110,     0,   221,     0,   166,     0,   165,   167,
+     354,   137,   127,   197,     0,   198,   199,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   293,
-     292,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   207,     0,     0,
-      55,    73,     0,     0,     0,   119,   113,     0,   194,     0,
-     197,   196,   308,   205,   177,     0,     0,     0,    27,     0,
-     296,     0,     0,   279,     0,   271,   274,   211,   212,    83,
-     204,    59,    60,   105,   219,    58,    81,    42,    28,   119,
-       0,   204,     0,     0,    52,   304,   186,   185,     0,   133,
-     135,     0,   222,   266,   267,   264,   265,   245,   246,   248,
-     247,   243,   244,   286,   285,   281,   280,   288,   289,   287,
-     283,   282,   284,   249,   250,   300,   258,   257,   256,   290,
-       0,   255,   254,   253,   241,   242,   262,   261,   259,   263,
-     260,     0,     0,   302,     0,     0,     0,     0,     0,    25,
-       0,   119,    17,    23,     0,    20,    19,    22,    21,   119,
-     111,     0,   207,   214,   166,     0,     0,   178,   182,   107,
-     195,   118,   268,     0,    26,   216,     0,   277,     0,     0,
-      57,     0,   119,    13,    57,     0,     0,     0,     0,     0,
-     137,     0,     0,   204,   162,   163,     0,   215,   273,     0,
-       0,   298,   119,     0,     0,   116,    18,   119,     0,     0,
-       0,     0,   184,   179,   204,     0,     0,   119,     0,   202,
-     201,   200,   203,     0,    62,    61,    51,     0,   119,   305,
-     306,   177,   134,     0,     0,   198,   136,   141,    57,     0,
-     291,   299,   301,    77,     0,    84,     0,   114,   206,   176,
-     172,   169,   170,   168,   171,   175,   174,   173,   167,   166,
-       0,     0,   181,     0,     0,    98,   102,   100,   104,    63,
-     278,    56,     0,    75,     0,   138,   139,     0,   119,   165,
-     164,    79,     0,     0,     0,    85,    88,    86,    24,   183,
-     192,   180,    96,     0,    99,   101,   119,    66,   119,   204,
-     119,   199,     0,   156,     0,     0,   119,   154,     0,    27,
-      93,    89,    87,    27,    27,   204,    64,    74,     0,   147,
-     151,     0,     0,     0,   119,   145,   149,   150,   157,   187,
-     142,   155,    27,    91,     0,     0,     0,   188,   119,   140,
-     146,     0,    90,   193,    97,    94,    27,     0,     0,     0,
-       0,   148,   177,    27,   189,     0,     0,   204,    95,   158
+       0,   328,   327,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   241,
+       0,     0,    58,    77,     0,   255,     0,    67,     0,   124,
+     117,     0,   228,     0,   231,   230,   356,   239,   211,     0,
+       0,    28,     0,   331,     0,     0,   280,     0,     0,     0,
+     311,   279,   245,   246,    85,   238,    62,    63,   107,   253,
+      61,    83,    44,    29,   124,     0,   238,     0,     0,    54,
+     351,   220,   219,     0,   138,   140,     0,   189,     0,   206,
+       0,   200,   204,   259,   306,   307,   304,   305,   285,   286,
+     288,   287,   283,   284,   320,   319,   315,   314,   322,   323,
+     324,   321,   317,   316,   318,   289,   290,   111,   338,     0,
+     337,     0,   340,   298,   297,   296,   325,     0,   295,   294,
+     293,   281,   282,   302,   301,   299,   303,   300,     0,     0,
+     333,     0,     0,     0,   349,    66,     0,     0,    26,    57,
+       0,   124,    17,    23,     0,    20,    19,    22,    21,   124,
+     115,     0,   241,   248,   172,     0,     0,   212,   216,   109,
+     123,   229,     0,    27,   250,   355,    66,   267,     0,   257,
+       0,    60,     0,   124,    13,    60,     0,     0,     0,     0,
+       0,   142,     0,     0,   238,   168,   169,     0,     0,     0,
+     185,   186,   191,   205,     0,     0,   345,     0,     0,   249,
+     313,     0,     0,     0,     0,   343,     0,    80,     0,     0,
+       0,   120,    18,   124,     0,     0,     0,     0,   218,   213,
+     238,     0,     0,    68,     0,   236,   235,   234,   237,     0,
+      65,    64,    53,     0,    66,   352,   353,   211,   139,     0,
+       0,   232,   141,   146,    60,     0,   190,   210,   209,   207,
+     208,     0,     0,     0,     0,   338,   341,   326,     0,   342,
+       0,     0,   339,    81,    86,     0,     0,   118,   240,   173,
+     172,     0,     0,   215,     0,     0,   100,   104,   102,   106,
+      66,    70,   268,    59,     0,    79,     0,   143,   144,     0,
+     124,   171,   170,   201,   193,   184,   194,     0,   192,     0,
+     191,   348,   346,   334,   347,   344,     0,     0,     0,    87,
+      90,    88,    25,    24,   217,   226,   214,    98,     0,   101,
+     103,    69,    66,   238,   124,   233,     0,   162,     0,     0,
+     124,   160,     0,   187,   184,   191,   195,     0,    28,    95,
+      91,    89,    28,    28,   238,    78,     0,   152,    57,   157,
+       0,     0,     0,   124,   150,   154,   155,   163,   221,   147,
+     161,   186,     0,     0,   196,    28,    93,     0,     0,     0,
+     222,     0,   124,   145,   151,     0,     0,   188,   186,    92,
+     227,    99,    96,    28,     0,     0,     0,   202,     0,     0,
+       0,   156,   153,   211,   203,    28,   223,     0,     0,   238,
+      97,   164
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,    50,    51,    52,    53,   310,   311,   312,   333,   334,
-     136,   137,   156,   313,   138,   384,   139,   245,   242,   457,
-      57,   231,   152,   153,    58,    59,    60,    61,   212,    62,
-      91,   140,   141,   444,   445,   446,   447,    63,   214,   425,
-     509,   426,   474,   427,   428,    64,   228,   142,    65,    66,
-      96,   219,    67,   319,   215,    68,   143,    70,    71,   350,
-     352,   394,   315,   460,   316,   438,   483,   484,   485,   465,
-     466,   467,   163,   317,   261,   354,   355,   372,   418,   326,
-     327,   328,   258,   318,   506,   102,    76,   473,   220,   221,
-     381,   396,   382,   340,   323,   123,   124,   125,   223,    77,
-      78,    79,   144,   126,    80,    81,    82,    83,   115,   116,
-      84,   164,    85,    86
+      -1,    51,    52,    53,    54,   350,   351,   352,   372,   373,
+     152,   153,   172,   353,   420,   154,   440,   155,   270,   267,
+      96,    97,   491,    58,   168,   169,    59,    60,    61,    62,
+      63,   156,   157,   518,   519,   520,   521,    64,   238,   486,
+     599,   487,   553,   488,   489,    65,   251,   158,    66,    67,
+     320,   243,    68,   359,   239,    69,   159,    71,    72,   391,
+     393,   450,   355,   534,   356,   500,   562,   563,   564,   539,
+     540,   541,   179,   357,   286,   395,   396,   428,    76,    77,
+      78,   402,   461,   508,   572,   185,   397,   462,   509,   186,
+     290,    79,   291,   292,   366,   367,   368,   283,   358,   593,
+     110,    81,   552,   244,   245,   437,   452,   438,   381,   363,
+     138,   139,   140,   247,    82,    83,    84,   160,   141,   234,
+     235,    85,   128,   129,   130,    86,   411,   321,   322,    87,
+      88,   180,    89,    90,    91
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -388
+#define YYPACT_NINF -508
 static const yytype_int16 yypact[] =
 {
-    1673,   -42,  -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,
-     -29,   -72,  -388,   -47,    16,  -388,  -388,  -388,    74,  -388,
-    2093,  -388,    64,  -388,  2163,  -388,   -24,    42,    25,  -388,
-    -388,  -388,  -388,    -1,     5,  -388,  -388,  2093,    56,  2093,
-    2093,  2093,  -388,  2093,  2093,  2093,  2093,  2093,   633,   110,
-     144,  -388,   503,  -388,  -388,  -388,    50,  -388,  2023,  -388,
-    -388,  -388,  -388,  -388,  -388,  1925,  -388,  -388,  -388,    97,
-     233,  -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,
-     104,  -388,  2568,  -388,  -388,  -388,  -388,   196,    84,  -388,
-    -388,  1925,  -388,  -388,  -388,  -388,  -388,    85,    70,  -388,
-     -59,  -388,    91,   237,  2093,    87,  -388,  2093,  -388,  2093,
-     225,   237,  -388,   130,  2568,   106,   139,   237,   237,   174,
-     237,   237,   -61,   121,   147,  2093,  -388,   245,   253,  2093,
-    2093,   253,   255,  -388,  -388,   763,  -388,  -388,   135,  -388,
-    -388,  -388,  -388,   249,  -388,  -388,  -388,  -388,  1023,   195,
-     265,  -388,   170,   202,  -388,   173,  -388,   270,    72,   271,
-    -388,   272,  -388,  -388,  -388,  -388,  2093,  2093,  2093,  2093,
-    2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,
-    2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,  -388,
-    -388,   273,  2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,
-    2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,  2093,    11,
-    -388,  -388,  2093,   269,  2093,  1153,  -388,    42,   157,   158,
-    -388,  -388,  -388,   164,    13,   -57,    19,  2188,  1799,   160,
-    -388,  2093,  2093,  -388,  2093,  -388,  -388,  -388,  -388,  -388,
-     189,   197,  -388,   104,   104,   197,  -388,  -388,  -388,  1925,
-     163,   189,  2093,  2093,  -388,   198,  -388,  -388,   296,   251,
-     252,   305,  2568,   301,   495,   495,   495,  2934,  2934,  2934,
-    2934,   301,   301,  2568,  2568,  2568,  2568,  2568,  2568,  2568,
-    2568,  2568,  2568,  2629,  2690,  -388,   118,   118,   118,  2568,
-    2385,  2751,  2812,  2873,   301,   301,   174,   174,   237,   237,
-     237,   177,  2446,   226,  2093,   311,   -56,   194,  2259,  -388,
-     185,  1283,  -388,  -388,   192,  -388,  -388,  -388,  -388,  1153,
-    -388,   119,  2093,  -388,   100,   320,   191,   230,  -388,  -388,
-     157,  -388,  -388,   193,  1799,  -388,   -54,  -388,   221,    22,
-     229,   253,   893,  -388,   -28,    31,   -16,    99,   210,    70,
-     317,    70,   212,   189,   236,  -388,  2093,  -388,  -388,   339,
-    2322,  -388,  1925,  2093,   213,  -388,  -388,  1153,   214,   217,
-      54,    22,  -388,  -388,   189,    15,   112,  1925,  2093,  -388,
-    -388,  -388,  -388,  2093,  -388,  -388,  -388,  2093,  1925,  -388,
-    -388,    13,  -388,    70,   219,  -388,   247,  -388,   229,   305,
-    2568,  -388,  -388,  -388,   -15,    26,   220,  -388,  -388,  -388,
-    -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,   261,
-     227,   320,  -388,   240,   250,  -388,  -388,   112,  -388,   286,
-    -388,  -388,   222,  -388,   242,   247,  -388,    70,   203,  -388,
-    -388,  -388,  2093,   274,   246,    26,  -388,  -388,  -388,  -388,
-    -388,  -388,  -388,   377,  -388,  -388,  1925,  -388,  1925,   189,
-    1413,  -388,   378,  -388,   359,   256,   336,  -388,  2507,  1799,
-    -388,  -388,  -388,  1799,  1799,   189,  -388,  -388,   263,  -388,
-    -388,   264,    51,   262,  1543,  -388,  -388,  -388,  -388,    72,
-    -388,  -388,  1799,  -388,   266,   267,   254,  -388,  1413,  -388,
-    -388,   397,  -388,  -388,  -388,  -388,  1799,   275,   280,   278,
-     276,  -388,    13,  1799,  -388,   279,   277,   189,  -388,  -388
+    1734,  1659,  -508,  -508,  -508,  -508,  -508,    -3,   -45,  -508,
+     -10,    93,  -508,  -508,  -508,  -508,    51,  -508,  2068,  -508,
+      84,  -508,  -508,  2125,  -508,    -5,    73,  2068,  -508,  -508,
+    -508,  -508,     8,   -49,  -508,  -508,   121,  2068,    22,   381,
+    2068,  2068,  -508,  -508,  2068,  2068,  2068,  2068,  2068,   714,
+     144,   155,  -508,   587,  -508,  -508,  -508,    32,  -508,   429,
+    -508,  -508,  -508,  -508,  -508,  -508,  1988,  -508,  -508,  -508,
+     126,   469,  -508,  -508,  -508,  -508,  -508,  -508,    15,  -508,
+    -508,  -508,  -508,  -508,  -508,   131,  2882,  -508,  -508,  -508,
+    -508,  -508,   219,   111,  -508,  2068,   224,  1988,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,   -23,   279,  -508,   -55,  -508,
+     115,   -43,  2068,   116,   118,  -508,   -43,  -508,  2068,   240,
+     145,   -43,  2068,  -508,  -508,  -508,  -508,  -508,   125,   154,
+     148,   -43,   -43,   386,   -43,   -43,   -39,  2820,   135,   163,
+    2068,  -508,  2820,   264,   265,  2068,  2068,   265,   274,  -508,
+    -508,   841,  -508,  -508,   161,  -508,  -508,  -508,  -508,   275,
+    -508,  -508,  -508,  -508,  1095,   225,   297,  -508,   201,   235,
+     131,   205,  -508,   305,    90,   307,  -508,   308,  -508,  -508,
+    -508,  -508,  -508,  -508,  2068,  -508,    16,  2068,  2068,  2068,
+    2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,
+    2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,
+    2068,  -508,  -508,    44,  2068,  2068,  2068,  2068,  2068,  2068,
+    2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,  2068,
+    2068,   146,  -508,  -508,   179,   217,   198,  -508,  2068,  1222,
+    -508,   279,   194,   199,  -508,  -508,  -508,   207,    23,   197,
+     342,  1861,   202,  -508,  2068,   204,  -508,  2068,   381,  2068,
+    -508,  -508,  -508,  -508,  -508,   223,   234,  -508,  -508,  -508,
+     234,  -508,  -508,  -508,  1988,   211,   223,  2068,  2068,  -508,
+     236,  -508,  -508,   343,   296,   301,   353,  2820,   259,   260,
+      -4,    16,  -508,  2820,  1087,   579,   579,   579,  3254,  3254,
+    3254,  3254,  1087,  1087,  2820,  2820,  2820,  2820,  2820,  2820,
+    2820,  2820,  2820,  2820,  2820,  2944,  3006,   282,   285,   257,
+    -508,   286,  -508,   679,   679,   679,  2820,  2324,  3068,  3130,
+    3192,  1087,  1087,   386,   386,   -43,   -43,   -43,   230,  2386,
+    -508,  2068,   281,   289,  -508,  -508,  2068,  2184,  -508,   243,
+     238,  1349,  -508,  -508,   254,  -508,  -508,  -508,  -508,  1222,
+    -508,   279,  2068,  -508,    47,   380,   252,   293,  -508,  -508,
+    -508,   272,   269,  1861,  -508,  2820,  -508,  -508,   299,  2820,
+     271,   304,   265,   968,  -508,   -26,   309,   276,   122,   288,
+     279,   398,   279,   290,   223,   312,  -508,   283,    12,    17,
+    -508,  -508,  -508,  -508,  2068,   325,  -508,   352,  2068,  -508,
+    -508,  2068,  2448,  2068,   328,  -508,   352,  -508,   287,   292,
+    2068,  -508,  -508,  1222,   298,   310,  2068,   271,  -508,  -508,
+     223,    38,    67,   355,  2068,  -508,  -508,  -508,  -508,  2068,
+    -508,  -508,  -508,  2068,  -508,  -508,  -508,    23,  -508,   279,
+     302,  -508,   329,  -508,   304,   353,  -508,  -508,  -508,  -508,
+    -508,   315,    19,  2510,   352,  -508,  -508,  2820,  2254,  -508,
+    2572,   352,  -508,  -508,    42,  2634,   306,  -508,  -508,  2820,
+     332,   314,   380,  -508,   316,   319,  -508,  -508,    67,  -508,
+    -508,  -508,  -508,  2820,   -36,  -508,   311,   329,  -508,   279,
+     233,  -508,  -508,  -508,  -508,   331,  -508,  2068,  -508,   338,
+    -508,  -508,  -508,  -508,  -508,  -508,  2068,   344,   317,    42,
+    -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,   448,  -508,
+    -508,  -508,  -508,   223,  1476,  -508,   450,  -508,   430,   326,
+     295,  -508,    15,  2820,   346,  -508,    26,  2696,  1861,  -508,
+    -508,  -508,  1861,  1861,   223,  -508,   336,  -508,   243,  -508,
+     339,   206,   334,  1603,  -508,  -508,  -508,  -508,    90,  -508,
+    -508,  -508,   337,    15,    26,  1861,  -508,   347,   349,   335,
+    -508,  2068,  1476,  -508,  -508,   462,   364,  -508,  -508,  -508,
+    -508,  -508,  -508,  1861,  2758,   354,   362,  -508,   365,   363,
+     361,  -508,  -508,    23,  -508,  1861,  -508,   371,   374,   223,
+    -508,  -508
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -388,  -388,   257,  -388,   354,  -296,  -388,   107,  -387,   -31,
-       1,   -55,   -85,    29,     2,    21,   362,   293,    81,  -388,
-    -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,
-    -388,  -388,  -388,  -388,  -388,   -21,   -19,  -388,  -388,     6,
-    -388,     7,  -388,  -388,  -388,  -388,  -388,  -388,  -388,  -388,
-    -175,    76,  -388,  -388,  -388,  -388,     0,  -388,   357,  -388,
-    -388,  -388,    48,  -388,    49,  -388,   -68,  -388,   -53,  -388,
-    -388,   -30,  -388,     3,  -388,  -388,    33,    18,  -388,  -376,
-    -388,  -305,   -49,     4,  -388,  -388,  -388,  -388,  -388,   412,
-     -89,    52,    71,  -239,  -388,   -96,  -388,  -388,  -388,  -388,
-    -388,  -388,  -388,   -34,    -9,   -50,   -13,  -388,  -388,  -388,
-    -388,  -388,  -388,  -388
+    -508,  -508,   333,  -508,   443,  -339,  -508,   147,  -228,   -41,
+       1,   -57,   411,    37,   -48,     2,    59,   459,   375,   140,
+    -332,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+    -508,  -508,  -508,  -508,  -508,     5,     6,  -508,  -508,    35,
+    -508,    39,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -508,
+      13,    41,  -508,  -508,  -508,  -508,     0,  -508,   455,  -508,
+    -508,  -508,    61,  -508,    63,  -508,   -53,  -508,   -35,  -508,
+    -508,    -9,  -508,     3,  -508,  -508,    75,    52,  -508,  -508,
+    -508,  -508,  -507,  -508,  -508,  -169,  -508,  -459,  -508,  -471,
+    -508,  -440,  -508,   242,  -433,  -508,  -334,   -27,     4,  -508,
+    -508,  -508,  -508,  -508,   517,  -101,    95,   123,  -231,  -508,
+    -106,  -508,  -508,  -508,  -508,  -508,  -508,  -508,  -130,   -54,
+     498,   -52,  -508,   291,  -508,   -12,  -508,  -204,  -188,  -508,
+    -508,  -508,  -508,  -508,  -508
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -154
+#define YYTABLE_NINF -337
 static const yytype_int16 yytable[] =
 {
-      69,    54,    56,    74,    75,   113,   213,   100,   154,   222,
-     155,   103,   344,   229,   303,   434,   324,   135,   324,    93,
-     373,    88,   330,   368,   111,   218,   114,   117,   118,    55,
-     119,   120,   121,   191,   114,    94,   155,   122,    94,   166,
-     -70,    94,   320,   166,   166,    93,   166,    87,    72,    73,
-      90,   320,    69,    54,    56,    74,    75,   409,   379,   410,
-     442,    94,   411,   412,   413,   208,   414,   101,   209,   157,
-     422,   406,   235,   218,   383,    92,   329,   362,   158,   377,
-     248,    55,   493,   160,   166,   166,   494,   495,   443,    94,
-      97,   238,    98,    89,   227,   225,   114,   162,   104,   415,
-      72,    73,   389,   105,   390,   502,   325,   256,   421,   416,
-     417,   301,   114,   145,   398,   157,   451,   388,   441,   510,
-     243,   244,   330,   257,   158,   108,   516,   109,   159,   160,
-     387,   166,   110,   304,   331,   420,   515,   380,    94,   305,
-     423,   161,    95,   162,   146,   424,   320,   107,    69,    54,
-      56,    74,    75,   262,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   148,    55,   112,   286,
-     287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
-     297,   298,   299,   300,   114,   302,    72,    73,   337,   210,
-     338,   308,   370,   306,   166,   371,   211,     2,   189,   190,
-     191,   216,   217,   224,   226,    69,    54,   314,   342,   114,
-     478,   114,   336,    15,    16,    17,   369,    19,   230,    21,
-     202,   203,   204,   205,   206,   232,   496,     2,   233,   234,
-     207,    25,   208,   345,   346,   209,   236,   237,   239,   462,
-      30,    31,    32,    15,    16,    17,   240,    19,   246,    21,
-     392,   249,   395,   -71,   189,   190,   191,   157,   251,   252,
-     253,    25,   254,   255,   259,   260,   285,   403,   519,   248,
-      30,    31,    32,   307,  -109,   321,   322,   248,   204,   205,
-     206,   360,   429,   335,   339,   343,   207,   341,   208,   348,
-     347,   209,   463,   433,   395,   349,   351,   155,   353,   114,
-     357,    69,    54,   314,   361,   359,   363,   365,   367,    69,
-      54,   314,   155,   324,   374,   376,   378,   189,   190,   191,
-     375,   383,   391,   155,   393,  -152,   399,   432,   397,   405,
-       2,  -154,   401,   400,   430,   436,   407,   437,   461,   431,
-     408,   456,   448,   450,   404,   458,    15,    16,    17,   207,
-      19,   208,    21,   370,   209,   114,   452,    69,    54,   314,
-     114,   476,   453,   477,    25,   459,  -154,  -154,   470,   469,
-     475,   488,   462,    30,    31,    32,   489,   505,   490,   497,
-     498,   189,   190,   191,   499,   192,   193,   194,   503,   504,
-     508,   155,   512,   155,   513,   250,   147,   511,   514,   518,
-    -154,  -154,   517,   202,   203,   204,   205,   206,   366,   439,
-     151,   241,   385,   207,   471,   208,   472,   165,   209,   468,
-     507,   500,   440,   454,   455,   463,   491,   449,   464,   106,
-     501,     0,   419,     0,     0,   435,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     482,   480,   481,   486,   487,     0,   464,     0,  -153,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   482,   480,   481,   486,   487,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   482,   480,
-     481,   486,   487,    -4,     0,     0,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,    14,    15,    16,    17,    18,    19,    20,    21,
-       0,     0,    23,     0,     0,   167,     0,     0,     0,    24,
-       0,    25,    26,     0,    27,     0,    28,     0,    29,     0,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,  -154,  -154,  -154,     0,    37,    38,     0,     0,
-     175,   176,     0,    39,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   189,   190,   191,     0,   192,
-     193,   194,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,    42,     0,   200,   201,     0,   202,   203,   204,
-     205,   206,     0,     0,     0,    43,     0,   207,     0,   208,
-      44,    45,   209,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,    -4,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,    15,    16,    17,    18,    19,    20,    21,
-      22,     0,    23,   127,     0,   128,     0,     0,     0,    24,
-     129,    25,    26,     0,    27,   130,    28,     0,    29,   131,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,   132,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,   133,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,   134,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,    15,    16,    17,    18,    19,    20,    21,
-      22,     0,    23,   127,     0,   128,     0,     0,     0,    24,
-     129,    25,    26,     0,    27,   130,    28,     0,    29,   131,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,   132,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
+      70,    55,    57,    75,    80,   246,   108,   170,   151,   171,
+     263,   111,   252,   417,   496,   116,   457,   289,   183,   288,
+     424,   459,   510,   504,   104,   121,   364,   343,   131,   132,
+     504,   429,   133,   134,   135,   137,   142,    56,   213,   104,
+     171,   364,   -74,   344,   433,   385,    93,   317,   211,   212,
+     213,   546,   105,    70,    55,    57,    75,    80,   249,   100,
+     101,    73,   259,    74,   586,   187,   106,   114,   255,   545,
+     230,   571,   102,   231,   118,   516,   113,   439,    95,   119,
+     229,   598,   230,   137,   476,   231,   574,   109,   100,   101,
+      56,   268,   269,   484,   273,   260,    99,   483,   532,   485,
+     137,   102,   588,   517,   240,   241,   142,   400,   100,   101,
+     137,   401,   495,    98,    73,   405,    74,   365,   112,   242,
+      94,   102,   289,   338,   281,   445,   446,   377,   142,   505,
+     506,   406,   482,   137,   137,   117,   120,   506,   414,   184,
+     282,   173,   184,   184,   184,   122,   507,   161,   526,   317,
+     426,   174,   427,   507,   415,   162,   175,   176,   531,   164,
+     318,   100,   101,   454,    70,    55,    57,    75,    80,   177,
+     607,   178,   287,   319,   102,   293,   294,   295,   296,   297,
+     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
+     308,   309,   310,   311,   312,   313,   314,   315,   316,   481,
+     555,    56,   323,   324,   325,   326,   327,   328,   329,   330,
+     331,   332,   333,   334,   335,   336,   337,   142,   339,   466,
+     103,   173,   232,   386,   387,    73,   347,    74,   472,   458,
+     460,   174,   187,   383,   233,   236,   181,   176,   248,    70,
+      55,   354,   375,   253,  -111,   142,   250,   379,   254,   258,
+      12,   178,    14,    15,   360,    17,   425,    19,   256,   257,
+     317,   261,   318,   371,   262,   137,   137,   264,   265,   340,
+      24,   341,   100,   101,    99,   342,   512,   271,   536,    29,
+      30,    31,    99,   515,   317,   102,   100,   101,   274,   448,
+     173,   451,   418,   -75,   100,   101,   100,   101,   181,   102,
+     276,   277,   556,   278,   492,   279,   435,   102,   280,   102,
+     284,   285,    12,   345,    14,    15,   273,    17,   259,    19,
+     576,   346,  -116,   579,   577,   578,   273,   361,   380,   412,
+     362,   369,    24,   537,   137,   382,   374,   142,   376,   388,
+     536,    29,    30,    31,   384,    99,   389,   589,   451,   390,
+     142,    70,    55,   354,   392,    99,   394,   100,   101,    70,
+      55,   354,   398,   399,   409,   600,  -158,   100,   101,  -241,
+     102,   421,  -335,   318,   371,  -336,   407,   608,   611,   416,
+     102,   423,   404,   364,   123,   124,   430,   436,   125,   126,
+     127,   494,   463,   242,   431,   537,   467,   318,   535,   468,
+    -115,   470,   432,   242,   434,   242,   413,   439,   475,   443,
+     444,   447,   449,   455,   479,   464,   456,   453,   471,   474,
+     490,   473,   142,    70,    55,   354,   503,   493,  -159,   498,
+     499,   477,   165,     2,     3,   426,     4,     5,     6,   523,
+     242,   525,   528,   527,   478,   533,   542,    13,   544,   548,
+     549,   554,    18,   567,    20,   568,    21,    22,   370,   569,
+     144,   573,   242,   580,    23,   596,   582,   583,   465,   592,
+     587,    27,   181,    28,   166,   597,   604,   211,   212,   213,
+     590,    33,   591,    34,    35,   603,    12,   602,    14,    15,
+     605,    17,    37,    19,   606,   543,   163,   275,   422,    39,
+     538,   226,   227,   228,   547,   609,    24,   610,   237,   229,
+     581,   230,   242,   501,   231,    29,    30,    31,   167,   266,
+      40,    41,   441,   529,   550,   551,   182,   530,   584,   595,
+     502,   570,   524,   403,   561,   559,   560,   565,   566,    43,
+     538,   585,    44,   115,   497,   136,   142,    45,    46,   378,
+     480,     0,    47,     0,    48,     0,     0,     0,    50,     0,
+       0,     0,     0,   561,   559,   560,   565,   566,     0,   594,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,   133,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,   247,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,    15,    16,    17,    18,    19,    20,    21,
-      22,     0,    23,   127,     0,   128,     0,     0,     0,    24,
-     129,    25,    26,     0,    27,   130,    28,     0,    29,   131,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,   132,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,   133,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,   386,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,    14,    15,    16,    17,    18,    19,    20,    21,
-       0,     0,    23,     0,     0,     0,     0,     0,     0,    24,
-       0,    25,    26,     0,    27,     0,    28,     0,    29,     0,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,    42,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,    -3,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,    15,    16,    17,    18,    19,    20,    21,
-       0,     0,    23,     0,     0,     0,     0,     0,     0,    24,
-       0,    25,    26,     0,    27,     0,    28,     0,    29,     0,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
+       0,     0,   561,   559,   560,   565,   566,    -4,     0,     0,
+       1,     2,     3,     0,     4,     5,     6,     7,     8,     9,
+      10,     0,     0,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,     0,     0,    21,    22,     0,     0,   188,     0,
+       0,     0,    23,     0,    24,    25,     0,    26,     0,    27,
+       0,    28,     0,    29,    30,    31,     0,     0,    32,    33,
+       0,    34,    35,     0,     0,     0,  -337,  -337,  -337,    36,
+      37,    38,     0,     0,   196,   197,     0,    39,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,   309,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,   -15,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,    15,    16,    17,    18,    19,    20,    21,
-       0,     0,    23,     0,     0,     0,     0,     0,     0,    24,
-       0,    25,    26,     0,    27,     0,    28,     0,    29,     0,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
+     211,   212,   213,     0,   214,   215,   216,     0,    40,    41,
+       0,     0,     0,     0,     0,     0,     0,    42,     0,   222,
+     223,     0,   224,   225,   226,   227,   228,    43,     0,     0,
+      44,     0,   229,     0,   230,    45,    46,   231,     0,     0,
+      47,     0,    48,     0,    49,     0,    50,     1,     2,     3,
+      -4,     4,     5,     6,     7,     8,     9,    10,     0,     0,
+       0,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+       0,    21,    22,   143,     0,   144,     0,     0,     0,    23,
+     145,    24,    25,     0,    26,   146,    27,     0,    28,   147,
+      29,    30,    31,     0,     0,    32,    33,     0,    34,    35,
+     211,   212,   213,     0,     0,     0,    36,    37,    38,     0,
+     148,     0,     0,     0,    39,     0,     0,     0,     0,     0,
+       0,     0,   224,   225,   226,   227,   228,     0,     0,     0,
+       0,     0,   229,     0,   230,    40,    41,   231,     0,     0,
+       0,     0,     0,     0,   149,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    43,     0,     0,    44,     0,     0,
+       0,     0,    45,    46,     0,     0,     0,    47,     0,    48,
+       0,    49,     0,    50,     1,     2,     3,   150,     4,     5,
+       6,     7,     8,     9,    10,     0,     0,     0,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,     0,    21,    22,
+     143,     0,   144,     0,     0,     0,    23,   145,    24,    25,
+       0,    26,   146,    27,     0,    28,   147,    29,    30,    31,
+       0,     0,    32,    33,     0,    34,    35,     0,     0,     0,
+       0,     0,     0,    36,    37,    38,     0,   148,     0,     0,
+       0,    39,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,   309,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,   -16,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,    15,    16,    17,    18,    19,    20,    21,
-       0,     0,    23,     0,     0,     0,     0,     0,     0,    24,
-       0,    25,    26,     0,    27,     0,    28,     0,    29,     0,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
+       0,     0,    40,    41,     0,     0,     0,     0,     0,     0,
+       0,   149,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    43,     0,     0,    44,     0,     0,     0,     0,    45,
+      46,     0,     0,     0,    47,     0,    48,     0,    49,     0,
+      50,     1,     2,     3,   272,     4,     5,     6,     7,     8,
+       9,    10,     0,     0,     0,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,     0,    21,    22,   143,     0,   144,
+       0,     0,     0,    23,   145,    24,    25,     0,    26,   146,
+      27,     0,    28,   147,    29,    30,    31,     0,     0,    32,
+      33,     0,    34,    35,     0,     0,     0,     0,     0,     0,
+      36,    37,    38,     0,   148,     0,     0,     0,    39,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,   479,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,     0,     0,  -143,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,    15,    16,    17,    18,    19,    20,    21,
-       0,     0,    23,     0,     0,     0,     0,     0,     0,    24,
-       0,    25,    26,     0,    27,     0,    28,     0,    29,     0,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    40,
+      41,     0,     0,     0,     0,     0,     0,     0,   149,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    43,     0,
+       0,    44,     0,     0,     0,     0,    45,    46,     0,     0,
+       0,    47,     0,    48,     0,    49,     0,    50,     1,     2,
+       3,   442,     4,     5,     6,     7,     8,     9,    10,     0,
+       0,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+       0,     0,    21,    22,     0,     0,  -337,     0,     0,     0,
+      23,     0,    24,    25,     0,    26,     0,    27,     0,    28,
+       0,    29,    30,    31,     0,     0,    32,    33,     0,    34,
+      35,     0,     0,     0,     0,     0,     0,    36,    37,    38,
+       0,     0,  -337,  -337,     0,    39,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   211,   212,
+     213,     0,   214,   215,   216,     0,    40,    41,     0,     0,
+       0,     0,     0,     0,     0,    42,     0,  -337,  -337,     0,
+     224,   225,   226,   227,   228,    43,     0,     0,    44,     0,
+     229,     0,   230,    45,    46,   231,     0,     0,    47,     0,
+      48,     0,    49,     0,    50,     1,     2,     3,    -3,     4,
+       5,     6,     7,     8,     9,    10,     0,     0,     0,    12,
+      13,    14,    15,    16,    17,    18,    19,     0,     0,    21,
+      22,     0,     0,     0,     0,     0,     0,    23,     0,    24,
+      25,     0,    26,     0,    27,     0,    28,     0,    29,    30,
+      31,     0,     0,    32,    33,     0,    34,    35,     0,     0,
+       0,     0,     0,     0,    36,    37,    38,     0,     0,     0,
+       0,     0,    39,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,   479,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     0,    -3,     0,  -144,     1,     2,     3,     4,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,    14,    15,    16,    17,    18,    19,    20,    21,
-       0,     0,    23,     0,     0,     0,     0,     0,     0,    24,
-       0,    25,    26,     0,    27,     0,    28,     0,    29,     0,
-      30,    31,    32,     0,     0,    33,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
+       0,     0,   348,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    43,     0,     0,    44,     0,     0,     0,     0,
+      45,    46,     0,     0,     0,    47,     0,   349,     0,    49,
+       0,    50,     1,     2,     3,   -15,     4,     5,     6,     7,
+       8,     9,    10,     0,     0,     0,    12,    13,    14,    15,
+      16,    17,    18,    19,     0,     0,    21,    22,     0,     0,
+       0,     0,     0,     0,    23,     0,    24,    25,     0,    26,
+       0,    27,     0,    28,     0,    29,    30,    31,     0,     0,
+      32,    33,     0,    34,    35,     0,     0,     0,     0,     0,
+       0,    36,    37,    38,     0,     0,     0,     0,     0,    39,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,     0,     0,
-       0,     0,    42,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,     0,     0,
-      44,    45,     0,     0,     0,    46,     0,    47,     0,    48,
-       0,    49,     1,     2,     3,     4,     0,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,     0,  -119,     0,    15,
-      16,    17,    18,    19,    20,    21,    22,     0,    23,   127,
-       0,   128,     0,     0,     0,    24,   129,    25,    26,     0,
-      27,   130,    28,     0,    29,   131,    30,    31,    32,     0,
-       0,    33,    34,     0,    35,    36,     0,     0,     0,     0,
-       0,     0,    37,    38,     0,   132,     0,     0,     0,    39,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    40,
-      41,     0,     0,     0,     0,     0,     0,     0,   133,     0,
+      40,    41,     0,     0,     0,     0,     0,     0,     0,   348,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    43,
+       0,     0,    44,     0,     0,     0,     0,    45,    46,     0,
+       0,     0,    47,     0,   349,     0,    49,     0,    50,     1,
+       2,     3,   -16,     4,     5,     6,     7,     8,     9,    10,
+       0,     0,     0,    12,    13,    14,    15,    16,    17,    18,
+      19,     0,     0,    21,    22,     0,     0,     0,     0,     0,
+       0,    23,     0,    24,    25,     0,    26,     0,    27,     0,
+      28,     0,    29,    30,    31,     0,     0,    32,    33,     0,
+      34,    35,     0,     0,     0,     0,     0,     0,    36,    37,
+      38,     0,     0,     0,     0,     0,    39,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    43,     0,     0,     0,     0,    44,    45,     0,     0,
-       0,    46,     0,    47,     0,    48,     0,    49,     1,     2,
-       3,     4,     0,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,     0,     0,     0,    15,    16,    17,    18,    19,
-      20,    21,    22,     0,    23,   127,     0,   128,     0,     0,
-       0,    24,   129,    25,    26,     0,    27,   130,    28,     0,
-      29,   131,    30,    31,    32,     0,     0,    33,    34,     0,
-      35,    36,     0,     0,     0,     0,     0,     0,    37,    38,
-       0,   132,     0,     0,     0,    39,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    40,    41,     0,
+       0,     0,     0,     0,     0,     0,   557,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    43,     0,     0,    44,
+       0,     0,     0,     0,    45,    46,     0,     0,     0,    47,
+       0,   558,     0,    49,     0,    50,     1,     2,     3,  -148,
+       4,     5,     6,     7,     8,     9,    10,     0,     0,     0,
+      12,    13,    14,    15,    16,    17,    18,    19,     0,     0,
+      21,    22,     0,     0,     0,     0,     0,     0,    23,     0,
+      24,    25,     0,    26,     0,    27,     0,    28,     0,    29,
+      30,    31,     0,     0,    32,    33,     0,    34,    35,     0,
+       0,     0,  -137,     0,     0,    36,    37,    38,     0,     0,
+       0,     0,     0,    39,  -137,     0,  -137,     0,  -137,  -137,
+       0,  -137,     0,  -137,  -137,     0,     0,     0,     0,  -137,
+    -137,     0,     0,     0,    40,    41,  -137,     0,     0,     0,
+       0,     0,  -137,   557,  -137,  -137,  -137,  -137,     0,     0,
+       0,     0,     0,    43,     0,     0,    44,     0,     0,     0,
+       0,    45,    46,     0,     0,     0,    47,     0,   558,     0,
+      49,     0,    50,     0,    -3,     0,  -149,     1,     2,     3,
+       0,     4,     5,     6,     7,     8,     9,    10,     0,    92,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
+       0,    21,    22,     0,     0,     0,     0,     0,     0,    23,
+       0,    24,    25,     0,    26,     0,    27,     0,    28,     0,
+      29,    30,    31,     0,     0,    32,    33,     0,    34,    35,
+       0,     0,     0,     0,     0,     0,    36,    37,    38,     0,
+       0,     0,     0,     0,    39,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,    40,    41,     0,     0,     0,
-       0,     0,     0,     0,   133,     0,   149,     0,     3,     4,
-       0,     5,     6,     7,     8,     9,     0,    43,     0,     0,
-       0,     0,    44,    45,     0,     0,     0,    46,    20,    47,
-      22,    48,    23,    49,     0,   128,     0,     0,     0,    24,
-       0,     0,     0,     0,     0,     0,    28,     0,    29,   150,
-       0,     0,     0,     0,     0,     0,    34,     0,    35,    36,
-       0,     0,     0,     0,     0,     0,    37,     0,     0,     0,
-       0,     0,     0,    39,     0,     0,    99,     0,     3,     4,
-       0,     5,     6,     7,     8,     9,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,    20,     0,
-      22,     0,    23,     0,     0,     0,     0,     0,     0,    24,
-       0,     0,     0,     0,     0,    43,    28,     0,    29,     0,
-      44,    45,     0,     0,     0,    46,    34,    47,    35,    36,
-       0,    49,     0,     0,     0,     0,    37,     0,     0,     0,
-       0,     0,     0,    39,     0,     0,    99,     0,     3,     4,
-       0,     5,     6,     7,     8,     9,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,     0,     0,     0,    20,     0,
-      22,     0,    23,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    43,     0,     0,    29,     0,
-      44,    45,     0,     0,     0,    46,    34,    47,    35,    36,
-       0,    49,     0,     0,     0,     0,     0,     0,   167,     0,
-       0,     0,     0,    39,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    42,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    43,     0,     0,    44,     0,     0,
+       0,     0,    45,    46,     0,     0,     0,    47,     0,    48,
+       0,    49,     0,    50,     1,     2,     3,     0,     4,     5,
+       6,     7,     8,     9,    10,     0,  -124,     0,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,     0,    21,    22,
+     143,     0,   144,     0,     0,     0,    23,   145,    24,    25,
+       0,    26,   146,    27,     0,    28,   147,    29,    30,    31,
+       0,     0,    32,    33,     0,    34,    35,     0,     0,     0,
+       0,     0,     0,    36,    37,    38,     0,   148,     0,     0,
+       0,    39,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    40,    41,     0,     0,     0,     0,     0,     0,
+       0,   149,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    43,     0,     0,    44,     0,     0,     0,     0,    45,
+      46,     0,     0,     0,    47,     0,    48,     0,    49,     0,
+      50,     1,     2,     3,     0,     4,     5,     6,     7,     8,
+       9,    10,     0,     0,     0,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,     0,    21,    22,   143,     0,   144,
+       0,     0,     0,    23,   145,    24,    25,     0,    26,   146,
+      27,     0,    28,   147,    29,    30,    31,     0,     0,    32,
+      33,     0,    34,    35,     0,     0,     0,     0,     0,     0,
+      36,    37,    38,     0,   148,     0,     0,     0,    39,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,    41,   168,   169,   170,     0,   171,
-     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
-     191,     0,   192,   193,   194,    46,     0,    47,     0,     0,
-     195,    49,   196,     0,   197,   198,   199,   200,   201,   167,
-     202,   203,   204,   205,   206,     0,     0,     0,     0,     0,
-     207,     0,   208,     0,     0,   209,     0,     0,     0,     0,
-       0,   332,     0,     0,     0,     0,   168,   169,   170,     0,
-     171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
-     190,   191,     0,   192,   193,   194,     0,     0,     0,     0,
-       0,   195,   167,   196,     0,   197,   198,   199,   200,   201,
-       0,   202,   203,   204,   205,   206,     0,     0,     0,     0,
-       0,   207,     0,   208,     0,     0,   209,     0,     0,   168,
-     169,   170,   364,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-     188,     0,   189,   190,   191,     0,   192,   193,   194,     0,
-       0,     0,     0,     0,   195,   167,   196,     0,   197,   198,
-     199,   200,   201,     0,   202,   203,   204,   205,   206,     0,
-       0,     0,     0,     0,   207,     0,   208,     0,     0,   209,
-       0,     0,   168,   169,   170,   402,   171,   172,   173,   174,
-     175,   176,   177,   178,   179,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,     0,   189,   190,   191,     0,   192,
-     193,   194,     0,     0,     0,     0,   167,   195,     0,   196,
-     356,   197,   198,   199,   200,   201,     0,   202,   203,   204,
-     205,   206,     0,     0,     0,     0,     0,   207,     0,   208,
-       0,     0,   209,   168,   169,   170,     0,   171,   172,   173,
-     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
-     184,   185,   186,   187,   188,     0,   189,   190,   191,     0,
-     192,   193,   194,     0,     0,     0,     0,   167,   195,     0,
-     196,     0,   197,   198,   199,   200,   201,     0,   202,   203,
-     204,   205,   206,     0,     0,     0,     0,     0,   207,     0,
-     208,   358,     0,   209,   168,   169,   170,     0,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,     0,   189,   190,   191,
-       0,   192,   193,   194,     0,     0,     0,     0,   167,   195,
-       0,   196,   492,   197,   198,   199,   200,   201,     0,   202,
-     203,   204,   205,   206,     0,     0,     0,     0,     0,   207,
-       0,   208,     0,     0,   209,   168,   169,   170,     0,   171,
-     172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
-     182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
-     191,     0,   192,   193,   194,     0,     0,     0,     0,   167,
-     195,     0,   196,     0,   197,   198,   199,   200,   201,     0,
-     202,   203,   204,   205,   206,     0,     0,     0,     0,     0,
-     207,     0,   208,     0,     0,   209,   168,   169,   170,     0,
-     171,   172,   173,   174,   175,   176,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   188,     0,   189,
-     190,   191,     0,   192,   193,   194,     0,     0,     0,     0,
-     167,     0,     0,     0,     0,   197,   198,   199,   200,   201,
-       0,   202,   203,   204,   205,   206,     0,     0,     0,     0,
-       0,   207,     0,   208,     0,     0,   209,   168,   169,   170,
-       0,   171,   172,   173,   174,   175,   176,     0,     0,     0,
+       0,   107,     2,     3,     0,     4,     5,     6,     0,    40,
+      41,     0,     0,     0,     0,     0,    13,     0,   149,     0,
+       0,    18,     0,    20,     0,    21,    22,     0,    43,     0,
+       0,    44,     0,    23,     0,     0,    45,    46,     0,     0,
+      27,    47,    28,    48,     0,    49,     0,    50,     0,     0,
+      33,     0,    34,    35,     0,     0,     0,     0,   107,     2,
+       3,    37,     4,     5,     6,     0,     0,     0,    39,     0,
+       0,     0,     0,    13,     0,     0,     0,     0,    18,     0,
+      20,     0,    21,    22,     0,     0,     0,     0,     0,    40,
+      41,     0,     0,     0,     0,     0,     0,     0,     0,    28,
+       0,     0,     0,     0,     0,     0,     0,    33,    43,    34,
+      35,    44,     0,     0,     0,     0,    45,    46,     0,     0,
+       0,    47,     0,    48,     0,    39,     0,    50,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     189,   190,   191,     0,   192,   193,   194,     0,     0,     0,
-       0,   167,     0,     0,     0,     0,   197,   198,   199,   200,
-     201,     0,   202,   203,   204,   205,   206,     0,     0,     0,
-       0,     0,   207,     0,   208,     0,     0,   209,   168,   169,
-     170,     0,   171,   172,   173,   174,   175,   176,     0,     0,
+       0,     0,     0,     0,     0,     0,    40,    41,     0,     0,
+       0,     0,     0,   188,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   189,   190,   191,     0,   192,   193,   194,     0,     0,
-       0,     0,   167,     0,     0,     0,     0,     0,   198,   199,
-     200,   201,     0,   202,   203,   204,   205,   206,     0,     0,
-       0,     0,     0,   207,     0,   208,     0,     0,   209,   168,
-     169,   170,     0,   171,   172,   173,   174,   175,   176,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    47,     0,
+      48,   189,   190,   191,    50,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
+     215,   216,     0,     0,     0,     0,     0,   217,   218,     0,
+     219,   220,   221,   188,   222,   223,     0,   224,   225,   226,
+     227,   228,     0,     0,     0,     0,     0,   229,     0,   230,
+       0,     0,   231,     0,     0,     0,     0,     0,   419,     0,
+       0,   189,   190,   191,     0,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
+     215,   216,     0,     0,     0,     0,     0,   217,   218,     0,
+     219,   220,   221,   188,   222,   223,     0,   224,   225,   226,
+     227,   228,     0,     0,     0,     0,     0,   229,     0,   230,
+       0,     0,   231,     0,     0,     0,     0,     0,   513,     0,
+       0,   189,   190,   191,     0,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
+     215,   216,     0,     0,     0,   188,     0,   217,   218,   408,
+     219,   220,   221,     0,   222,   223,     0,   224,   225,   226,
+     227,   228,     0,     0,     0,     0,     0,   229,     0,   230,
+       0,     0,   231,   189,   190,   191,     0,   192,   193,   194,
+     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
+     205,   206,   207,   208,   209,   210,     0,   211,   212,   213,
+       0,   214,   215,   216,     0,     0,     0,   188,     0,   217,
+     218,     0,   219,   220,   221,     0,   222,   223,     0,   224,
+     225,   226,   227,   228,     0,     0,     0,     0,     0,   229,
+       0,   230,   410,     0,   231,   189,   190,   191,     0,   192,
+     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
+     203,   204,   205,   206,   207,   208,   209,   210,     0,   211,
+     212,   213,     0,   214,   215,   216,     0,     0,     0,   188,
+       0,   217,   218,     0,   219,   220,   221,     0,   222,   223,
+       0,   224,   225,   226,   227,   228,     0,     0,     0,     0,
+       0,   229,     0,   230,   469,     0,   231,   189,   190,   191,
+       0,   192,   193,   194,   195,   196,   197,   198,   199,   200,
+     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
+       0,   211,   212,   213,     0,   214,   215,   216,     0,     0,
+       0,   188,     0,   217,   218,     0,   219,   220,   221,     0,
+     222,   223,     0,   224,   225,   226,   227,   228,     0,     0,
+       0,     0,     0,   229,     0,   230,   511,     0,   231,   189,
+     190,   191,     0,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
+       0,     0,     0,   188,     0,   217,   218,     0,   219,   220,
+     221,     0,   222,   223,     0,   224,   225,   226,   227,   228,
+       0,     0,     0,     0,     0,   229,     0,   230,   514,     0,
+     231,   189,   190,   191,     0,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   205,   206,
+     207,   208,   209,   210,     0,   211,   212,   213,     0,   214,
+     215,   216,     0,     0,     0,   188,     0,   217,   218,     0,
+     219,   220,   221,     0,   222,   223,     0,   224,   225,   226,
+     227,   228,     0,     0,     0,     0,     0,   229,     0,   230,
+     522,     0,   231,   189,   190,   191,     0,   192,   193,   194,
+     195,   196,   197,   198,   199,   200,   201,   202,   203,   204,
+     205,   206,   207,   208,   209,   210,     0,   211,   212,   213,
+       0,   214,   215,   216,     0,     0,     0,   188,     0,   217,
+     218,   575,   219,   220,   221,     0,   222,   223,     0,   224,
+     225,   226,   227,   228,     0,     0,     0,     0,     0,   229,
+       0,   230,     0,     0,   231,   189,   190,   191,     0,   192,
+     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
+     203,   204,   205,   206,   207,   208,   209,   210,     0,   211,
+     212,   213,     0,   214,   215,   216,     0,     0,     0,   188,
+       0,   217,   218,     0,   219,   220,   221,     0,   222,   223,
+       0,   224,   225,   226,   227,   228,     0,     0,     0,     0,
+       0,   229,     0,   230,   601,     0,   231,   189,   190,   191,
+       0,   192,   193,   194,   195,   196,   197,   198,   199,   200,
+     201,   202,   203,   204,   205,   206,   207,   208,   209,   210,
+       0,   211,   212,   213,     0,   214,   215,   216,     0,     0,
+       0,   188,     0,   217,   218,     0,   219,   220,   221,     0,
+     222,   223,     0,   224,   225,   226,   227,   228,     0,     0,
+       0,     0,     0,   229,     0,   230,     0,     0,   231,   189,
+     190,   191,     0,   192,   193,   194,   195,   196,   197,   198,
+     199,   200,   201,   202,   203,   204,   205,   206,   207,   208,
+     209,   210,     0,   211,   212,   213,     0,   214,   215,   216,
+       0,     0,     0,   188,     0,   217,   218,     0,   219,   220,
+     221,     0,     0,   223,     0,   224,   225,   226,   227,   228,
+       0,     0,     0,     0,     0,   229,     0,   230,     0,     0,
+     231,   189,   190,   191,     0,   192,   193,   194,   195,   196,
+     197,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   210,     0,   211,   212,   213,     0,   214,
+     215,   216,     0,     0,     0,   188,     0,     0,     0,     0,
+     219,   220,   221,     0,   222,   223,     0,   224,   225,   226,
+     227,   228,     0,     0,     0,     0,     0,   229,     0,   230,
+       0,     0,   231,   189,   190,   191,     0,   192,   193,   194,
+     195,   196,   197,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   211,   212,   213,
+       0,   214,   215,   216,     0,     0,     0,   188,     0,     0,
+       0,     0,   219,   220,   221,     0,   222,   223,     0,   224,
+     225,   226,   227,   228,     0,     0,     0,     0,     0,   229,
+       0,   230,     0,     0,   231,   189,   190,   191,     0,   192,
+     193,   194,   195,   196,   197,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   211,
+     212,   213,     0,   214,   215,   216,     0,     0,     0,   188,
+       0,     0,     0,     0,     0,   220,   221,     0,   222,   223,
+       0,   224,   225,   226,   227,   228,     0,     0,     0,     0,
+       0,   229,     0,   230,     0,     0,   231,   189,   190,   191,
+       0,   192,   193,   194,   195,   196,   197,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   189,   190,   191,     0,   192,   193,   194,     0,
-       0,     0,     0,   167,     0,     0,     0,     0,     0,     0,
-     199,   200,   201,     0,   202,   203,   204,   205,   206,     0,
-       0,     0,     0,     0,   207,     0,   208,     0,     0,   209,
-     168,   169,   170,     0,   171,   172,   173,   174,   175,   176,
+       0,   211,   212,   213,     0,   214,   215,   216,     0,     0,
+       0,   188,     0,     0,     0,     0,     0,     0,   221,     0,
+     222,   223,     0,   224,   225,   226,   227,   228,     0,     0,
+       0,     0,     0,   229,     0,   230,     0,     0,   231,   189,
+     190,   191,     0,   192,   193,   194,   195,   196,   197,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   189,   190,   191,     0,   192,   193,   194,
-       0,     0,     0,     0,   167,     0,     0,     0,     0,     0,
-       0,  -154,   200,   201,     0,   202,   203,   204,   205,   206,
-       0,     0,     0,     0,     0,   207,     0,   208,     0,     0,
-     209,   168,   169,   170,     0,  -154,  -154,  -154,  -154,   175,
-     176,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   189,   190,   191,     0,   192,   193,
-     194,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   200,   201,     0,   202,   203,   204,   205,
-     206,     0,     0,     0,     0,     0,   207,     0,   208,     0,
-       0,   209
+       0,     0,     0,   211,   212,   213,     0,   214,   215,   216,
+       0,     0,     0,   188,     0,     0,     0,     0,     0,     0,
+    -337,     0,   222,   223,     0,   224,   225,   226,   227,   228,
+       0,     0,     0,     0,     0,   229,     0,   230,     0,     0,
+     231,   189,   190,   191,     0,  -337,  -337,  -337,  -337,   196,
+     197,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   211,   212,   213,     0,   214,
+     215,   216,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   222,   223,     0,   224,   225,   226,
+     227,   228,     0,     0,     0,     0,     0,   229,     0,   230,
+       0,     0,   231
 };
 
 static const yytype_int16 yycheck[] =
 {
-       0,     0,     0,     0,     0,    39,    91,    20,    58,    98,
-      65,    24,   251,   109,     3,   391,     3,    48,     3,     3,
-     325,    50,     3,   319,    37,     3,    39,    40,    41,     0,
-      43,    44,    45,    92,    47,    19,    91,    46,    19,   100,
-      68,    19,   217,   100,   100,     3,   100,    89,     0,     0,
-     122,   226,    52,    52,    52,    52,    52,     3,    36,     5,
-      34,    19,     8,     9,    10,   124,    12,     3,   127,    18,
-     375,   367,   133,     3,   102,   122,   133,   133,    27,   133,
-     135,    52,   469,    32,   100,   100,   473,   474,    62,    19,
-      14,   125,    18,   122,   107,   104,   109,    46,   122,    45,
-      52,    52,     3,    27,     5,   492,    93,    35,    93,    55,
-      56,   207,   125,     3,   353,    18,   421,   133,   133,   506,
-     129,   130,     3,    51,    27,   126,   513,   122,    31,    32,
-      99,   100,   127,   122,   115,   374,   512,   115,    19,   128,
-      28,    44,   126,    46,     0,    33,   321,   122,   148,   148,
-     148,   148,   148,   166,   167,   168,   169,   170,   171,   172,
-     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-     183,   184,   185,   186,   187,   188,   126,   148,   122,   192,
-     193,   194,   195,   196,   197,   198,   199,   200,   201,   202,
-     203,   204,   205,   206,   207,   208,   148,   148,   232,     3,
-     234,   214,   102,   212,   100,   105,   122,     4,    90,    91,
-      92,   126,   127,   122,   127,   215,   215,   215,   249,   232,
-     459,   234,   231,    20,    21,    22,   322,    24,     3,    26,
-     112,   113,   114,   115,   116,   105,   475,     4,   132,   100,
-     122,    38,   124,   252,   253,   127,   125,   100,     3,    46,
-      47,    48,    49,    20,    21,    22,     3,    24,     3,    26,
-     349,   126,   351,    68,    90,    91,    92,    18,     3,    99,
-      68,    38,    99,     3,     3,     3,     3,   362,   517,   334,
-      47,    48,    49,    14,   127,   127,   122,   342,   114,   115,
-     116,   304,   377,   133,   105,   132,   122,   100,   124,     3,
-     102,   127,    99,   388,   393,    54,    54,   362,     3,   322,
-     133,   311,   311,   311,     3,    89,   122,   132,   126,   319,
-     319,   319,   377,     3,   133,   132,   105,    90,    91,    92,
-     100,   102,   122,   388,    17,   132,   100,   387,   126,   126,
-       4,    40,     3,   356,   378,   126,   132,   100,   437,   383,
-     133,    65,   132,   126,   363,   133,    20,    21,    22,   122,
-      24,   124,    26,   102,   127,   378,   126,   367,   367,   367,
-     383,   456,   122,   458,    38,   133,    75,    76,   132,   105,
-       3,     3,    46,    47,    48,    49,    27,   133,   132,   126,
-     126,    90,    91,    92,   132,    94,    95,    96,   132,   132,
-       3,   456,   122,   458,   126,   148,    52,   132,   132,   132,
-     109,   110,   133,   112,   113,   114,   115,   116,   311,   398,
-      58,   128,   341,   122,   445,   124,   445,    70,   127,   442,
-     498,   484,   399,   427,   427,    99,   466,   419,   438,    27,
-     489,    -1,   371,    -1,    -1,   393,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     460,   460,   460,   460,   460,    -1,   466,    -1,   132,    -1,
+       0,     0,     0,     0,     0,   106,    18,    59,    49,    66,
+     140,    23,   118,   345,   447,    27,     4,   186,     3,     3,
+     359,     4,   462,     4,    11,    37,     3,   231,    40,    41,
+       4,   365,    44,    45,    46,    47,    48,     0,    93,    26,
+      97,     3,    68,   231,   376,   276,    49,     3,    91,    92,
+      93,   510,    11,    53,    53,    53,    53,    53,   112,    15,
+      16,     0,   101,     0,   571,   101,    15,    26,   122,   509,
+     125,   542,    28,   128,   123,    33,     3,   103,   123,   128,
+     123,   588,   125,    95,   423,   128,   545,     3,    15,    16,
+      53,   145,   146,    26,   151,   134,     3,   431,   134,    32,
+     112,    28,   573,    61,   127,   128,   118,   111,    15,    16,
+     122,   115,   444,   123,    53,   319,    53,    94,   123,   106,
+     123,    28,   291,   229,    34,     3,     4,   257,   140,   110,
+     111,   319,    94,   145,   146,   127,    15,   111,   342,   127,
+      50,    15,   127,   127,   127,   123,   127,     3,   482,     3,
+     103,    25,   105,   127,   342,     0,    30,    31,   490,   127,
+     116,    15,    16,   394,   164,   164,   164,   164,   164,    43,
+     603,    45,   184,   129,    28,   187,   188,   189,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
+     202,   203,   204,   205,   206,   207,   208,   209,   210,   430,
+     532,   164,   214,   215,   216,   217,   218,   219,   220,   221,
+     222,   223,   224,   225,   226,   227,   228,   229,   230,   407,
+     127,    15,     3,   277,   278,   164,   238,   164,   416,   398,
+     399,    25,   101,   274,   123,    11,     3,    31,   123,   239,
+     239,   239,   254,     3,   128,   257,   128,   259,   103,   101,
+      17,    45,    19,    20,   241,    22,   362,    24,   133,   105,
+       3,   126,   116,   250,   101,   277,   278,     3,     3,   123,
+      37,   125,    15,    16,     3,   129,   464,     3,    45,    46,
+      47,    48,     3,   471,     3,    28,    15,    16,   127,   390,
+      15,   392,   346,    68,    15,    16,    15,    16,     3,    28,
+       3,   100,   533,    68,   434,   100,    35,    28,     3,    28,
+       3,     3,    17,   134,    19,    20,   373,    22,   101,    24,
+     548,   123,   128,   554,   552,   553,   383,   128,   105,   341,
+     123,   134,    37,   100,   346,   101,   134,   349,   134,   103,
+      45,    46,    47,    48,   133,     3,     3,   575,   449,    53,
+     362,   351,   351,   351,    53,     3,     3,    15,    16,   359,
+     359,   359,   103,   103,   134,   593,   133,    15,    16,   126,
+      28,   133,    90,   116,   361,    90,    90,   605,   609,    90,
+      28,   127,   125,     3,     3,     4,   134,   116,     7,     8,
+       9,   443,   404,   380,   101,   100,   408,   116,   499,   411,
+     128,   413,   133,   390,   105,   392,   125,   103,   420,   100,
+     134,   123,    14,   101,   426,    90,   133,   127,    90,   127,
+      65,   134,   434,   423,   423,   423,   111,   439,   133,   127,
+     101,   133,     3,     4,     5,   103,     7,     8,     9,   133,
+     427,   127,   123,   127,   134,   134,   115,    18,   110,   105,
+     133,     3,    23,     3,    25,    25,    27,    28,   116,   133,
+      31,   115,   449,   127,    35,     3,   127,   133,   116,   134,
+     133,    42,     3,    44,    45,   111,   111,    91,    92,    93,
+     133,    52,   133,    54,    55,   123,    17,   133,    19,    20,
+     127,    22,    63,    24,   133,   507,    53,   164,   351,    70,
+     500,   115,   116,   117,   516,   134,    37,   133,    97,   123,
+     558,   125,   499,   454,   128,    46,    47,    48,    59,   144,
+      91,    92,   382,   488,   519,   519,    71,   488,   563,   582,
+     455,   540,   480,   291,   534,   534,   534,   534,   534,   110,
+     540,   568,   113,    26,   449,    47,   558,   118,   119,   258,
+     427,    -1,   123,    -1,   125,    -1,    -1,    -1,   129,    -1,
+      -1,    -1,    -1,   563,   563,   563,   563,   563,    -1,   581,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   484,   484,   484,   484,   484,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   498,   498,
-     498,   498,   498,     0,    -1,    -1,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    -1,    -1,    40,    -1,    -1,    -1,    36,
-      -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,    -1,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    67,    68,    69,    -1,    63,    64,    -1,    -1,
-      75,    76,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    90,    91,    92,    -1,    94,
-      95,    96,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,   109,   110,    -1,   112,   113,   114,
-     115,   116,    -1,    -1,    -1,   112,    -1,   122,    -1,   124,
-     117,   118,   127,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    -1,    32,    -1,    -1,    -1,    36,
-      37,    38,    39,    -1,    41,    42,    43,    -1,    45,    46,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    66,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   582,   582,   582,   582,   582,     0,    -1,    -1,
+       3,     4,     5,    -1,     7,     8,     9,    10,    11,    12,
+      13,    -1,    -1,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    -1,    -1,    27,    28,    -1,    -1,    39,    -1,
+      -1,    -1,    35,    -1,    37,    38,    -1,    40,    -1,    42,
+      -1,    44,    -1,    46,    47,    48,    -1,    -1,    51,    52,
+      -1,    54,    55,    -1,    -1,    -1,    67,    68,    69,    62,
+      63,    64,    -1,    -1,    75,    76,    -1,    70,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    -1,    32,    -1,    -1,    -1,    36,
-      37,    38,    39,    -1,    41,    42,    43,    -1,    45,    46,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    66,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      91,    92,    93,    -1,    95,    96,    97,    -1,    91,    92,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   100,    -1,   110,
+     111,    -1,   113,   114,   115,   116,   117,   110,    -1,    -1,
+     113,    -1,   123,    -1,   125,   118,   119,   128,    -1,    -1,
+     123,    -1,   125,    -1,   127,    -1,   129,     3,     4,     5,
+     133,     7,     8,     9,    10,    11,    12,    13,    -1,    -1,
+      -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+      -1,    27,    28,    29,    -1,    31,    -1,    -1,    -1,    35,
+      36,    37,    38,    -1,    40,    41,    42,    -1,    44,    45,
+      46,    47,    48,    -1,    -1,    51,    52,    -1,    54,    55,
+      91,    92,    93,    -1,    -1,    -1,    62,    63,    64,    -1,
+      66,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   113,   114,   115,   116,   117,    -1,    -1,    -1,
+      -1,    -1,   123,    -1,   125,    91,    92,   128,    -1,    -1,
+      -1,    -1,    -1,    -1,   100,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   110,    -1,    -1,   113,    -1,    -1,
+      -1,    -1,   118,   119,    -1,    -1,    -1,   123,    -1,   125,
+      -1,   127,    -1,   129,     3,     4,     5,   133,     7,     8,
+       9,    10,    11,    12,    13,    -1,    -1,    -1,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    -1,    27,    28,
+      29,    -1,    31,    -1,    -1,    -1,    35,    36,    37,    38,
+      -1,    40,    41,    42,    -1,    44,    45,    46,    47,    48,
+      -1,    -1,    51,    52,    -1,    54,    55,    -1,    -1,    -1,
+      -1,    -1,    -1,    62,    63,    64,    -1,    66,    -1,    -1,
+      -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      27,    -1,    29,    30,    -1,    32,    -1,    -1,    -1,    36,
-      37,    38,    39,    -1,    41,    42,    43,    -1,    45,    46,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    66,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    91,    92,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   110,    -1,    -1,   113,    -1,    -1,    -1,    -1,   118,
+     119,    -1,    -1,    -1,   123,    -1,   125,    -1,   127,    -1,
+     129,     3,     4,     5,   133,     7,     8,     9,    10,    11,
+      12,    13,    -1,    -1,    -1,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    -1,    27,    28,    29,    -1,    31,
+      -1,    -1,    -1,    35,    36,    37,    38,    -1,    40,    41,
+      42,    -1,    44,    45,    46,    47,    48,    -1,    -1,    51,
+      52,    -1,    54,    55,    -1,    -1,    -1,    -1,    -1,    -1,
+      62,    63,    64,    -1,    66,    -1,    -1,    -1,    70,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,    -1,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    91,
+      92,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   100,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,
+      -1,   113,    -1,    -1,    -1,    -1,   118,   119,    -1,    -1,
+      -1,   123,    -1,   125,    -1,   127,    -1,   129,     3,     4,
+       5,   133,     7,     8,     9,    10,    11,    12,    13,    -1,
+      -1,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      -1,    -1,    27,    28,    -1,    -1,    39,    -1,    -1,    -1,
+      35,    -1,    37,    38,    -1,    40,    -1,    42,    -1,    44,
+      -1,    46,    47,    48,    -1,    -1,    51,    52,    -1,    54,
+      55,    -1,    -1,    -1,    -1,    -1,    -1,    62,    63,    64,
+      -1,    -1,    75,    76,    -1,    70,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    91,    92,
+      93,    -1,    95,    96,    97,    -1,    91,    92,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   100,    -1,   110,   111,    -1,
+     113,   114,   115,   116,   117,   110,    -1,    -1,   113,    -1,
+     123,    -1,   125,   118,   119,   128,    -1,    -1,   123,    -1,
+     125,    -1,   127,    -1,   129,     3,     4,     5,   133,     7,
+       8,     9,    10,    11,    12,    13,    -1,    -1,    -1,    17,
+      18,    19,    20,    21,    22,    23,    24,    -1,    -1,    27,
+      28,    -1,    -1,    -1,    -1,    -1,    -1,    35,    -1,    37,
+      38,    -1,    40,    -1,    42,    -1,    44,    -1,    46,    47,
+      48,    -1,    -1,    51,    52,    -1,    54,    55,    -1,    -1,
+      -1,    -1,    -1,    -1,    62,    63,    64,    -1,    -1,    -1,
+      -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,    -1,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    91,    92,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   110,    -1,    -1,   113,    -1,    -1,    -1,    -1,
+     118,   119,    -1,    -1,    -1,   123,    -1,   125,    -1,   127,
+      -1,   129,     3,     4,     5,   133,     7,     8,     9,    10,
+      11,    12,    13,    -1,    -1,    -1,    17,    18,    19,    20,
+      21,    22,    23,    24,    -1,    -1,    27,    28,    -1,    -1,
+      -1,    -1,    -1,    -1,    35,    -1,    37,    38,    -1,    40,
+      -1,    42,    -1,    44,    -1,    46,    47,    48,    -1,    -1,
+      51,    52,    -1,    54,    55,    -1,    -1,    -1,    -1,    -1,
+      -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    70,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,    -1,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,    -1,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      91,    92,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   100,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
+      -1,    -1,   113,    -1,    -1,    -1,    -1,   118,   119,    -1,
+      -1,    -1,   123,    -1,   125,    -1,   127,    -1,   129,     3,
+       4,     5,   133,     7,     8,     9,    10,    11,    12,    13,
+      -1,    -1,    -1,    17,    18,    19,    20,    21,    22,    23,
+      24,    -1,    -1,    27,    28,    -1,    -1,    -1,    -1,    -1,
+      -1,    35,    -1,    37,    38,    -1,    40,    -1,    42,    -1,
+      44,    -1,    46,    47,    48,    -1,    -1,    51,    52,    -1,
+      54,    55,    -1,    -1,    -1,    -1,    -1,    -1,    62,    63,
+      64,    -1,    -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,    -1,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    -1,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,    -1,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    91,    92,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   100,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,   113,
+      -1,    -1,    -1,    -1,   118,   119,    -1,    -1,    -1,   123,
+      -1,   125,    -1,   127,    -1,   129,     3,     4,     5,   133,
+       7,     8,     9,    10,    11,    12,    13,    -1,    -1,    -1,
+      17,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
+      27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    35,    -1,
+      37,    38,    -1,    40,    -1,    42,    -1,    44,    -1,    46,
+      47,    48,    -1,    -1,    51,    52,    -1,    54,    55,    -1,
+      -1,    -1,     3,    -1,    -1,    62,    63,    64,    -1,    -1,
+      -1,    -1,    -1,    70,    15,    -1,    17,    -1,    19,    20,
+      -1,    22,    -1,    24,    25,    -1,    -1,    -1,    -1,    30,
+      31,    -1,    -1,    -1,    91,    92,    37,    -1,    -1,    -1,
+      -1,    -1,    43,   100,    45,    46,    47,    48,    -1,    -1,
+      -1,    -1,    -1,   110,    -1,    -1,   113,    -1,    -1,    -1,
+      -1,   118,   119,    -1,    -1,    -1,   123,    -1,   125,    -1,
+     127,    -1,   129,    -1,     0,    -1,   133,     3,     4,     5,
+      -1,     7,     8,     9,    10,    11,    12,    13,    -1,    90,
+      16,    17,    18,    19,    20,    21,    22,    23,    24,    -1,
+      -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    35,
+      -1,    37,    38,    -1,    40,    -1,    42,    -1,    44,    -1,
+      46,    47,    48,    -1,    -1,    51,    52,    -1,    54,    55,
+      -1,    -1,    -1,    -1,    -1,    -1,    62,    63,    64,    -1,
+      -1,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,    -1,     0,    -1,   132,     3,     4,     5,     6,
-      -1,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-      -1,    -1,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    38,    39,    -1,    41,    -1,    43,    -1,    45,    -1,
-      47,    48,    49,    -1,    -1,    52,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    91,    92,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   100,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   110,    -1,    -1,   113,    -1,    -1,
+      -1,    -1,   118,   119,    -1,    -1,    -1,   123,    -1,   125,
+      -1,   127,    -1,   129,     3,     4,     5,    -1,     7,     8,
+       9,    10,    11,    12,    13,    -1,    15,    -1,    17,    18,
+      19,    20,    21,    22,    23,    24,    25,    -1,    27,    28,
+      29,    -1,    31,    -1,    -1,    -1,    35,    36,    37,    38,
+      -1,    40,    41,    42,    -1,    44,    45,    46,    47,    48,
+      -1,    -1,    51,    52,    -1,    54,    55,    -1,    -1,    -1,
+      -1,    -1,    -1,    62,    63,    64,    -1,    66,    -1,    -1,
+      -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    -1,    -1,
-     117,   118,    -1,    -1,    -1,   122,    -1,   124,    -1,   126,
-      -1,   128,     3,     4,     5,     6,    -1,     8,     9,    10,
-      11,    12,    13,    14,    15,    16,    -1,    18,    -1,    20,
-      21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
-      -1,    32,    -1,    -1,    -1,    36,    37,    38,    39,    -1,
-      41,    42,    43,    -1,    45,    46,    47,    48,    49,    -1,
-      -1,    52,    53,    -1,    55,    56,    -1,    -1,    -1,    -1,
-      -1,    -1,    63,    64,    -1,    66,    -1,    -1,    -1,    70,
+      -1,    -1,    91,    92,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   110,    -1,    -1,   113,    -1,    -1,    -1,    -1,   118,
+     119,    -1,    -1,    -1,   123,    -1,   125,    -1,   127,    -1,
+     129,     3,     4,     5,    -1,     7,     8,     9,    10,    11,
+      12,    13,    -1,    -1,    -1,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    -1,    27,    28,    29,    -1,    31,
+      -1,    -1,    -1,    35,    36,    37,    38,    -1,    40,    41,
+      42,    -1,    44,    45,    46,    47,    48,    -1,    -1,    51,
+      52,    -1,    54,    55,    -1,    -1,    -1,    -1,    -1,    -1,
+      62,    63,    64,    -1,    66,    -1,    -1,    -1,    70,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
-      91,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,    -1,
+      -1,     3,     4,     5,    -1,     7,     8,     9,    -1,    91,
+      92,    -1,    -1,    -1,    -1,    -1,    18,    -1,   100,    -1,
+      -1,    23,    -1,    25,    -1,    27,    28,    -1,   110,    -1,
+      -1,   113,    -1,    35,    -1,    -1,   118,   119,    -1,    -1,
+      42,   123,    44,   125,    -1,   127,    -1,   129,    -1,    -1,
+      52,    -1,    54,    55,    -1,    -1,    -1,    -1,     3,     4,
+       5,    63,     7,     8,     9,    -1,    -1,    -1,    70,    -1,
+      -1,    -1,    -1,    18,    -1,    -1,    -1,    -1,    23,    -1,
+      25,    -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    91,
+      92,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    44,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,   110,    54,
+      55,   113,    -1,    -1,    -1,    -1,   118,   119,    -1,    -1,
+      -1,   123,    -1,   125,    -1,    70,    -1,   129,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   112,    -1,    -1,    -1,    -1,   117,   118,    -1,    -1,
-      -1,   122,    -1,   124,    -1,   126,    -1,   128,     3,     4,
-       5,     6,    -1,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    -1,    -1,    -1,    20,    21,    22,    23,    24,
-      25,    26,    27,    -1,    29,    30,    -1,    32,    -1,    -1,
-      -1,    36,    37,    38,    39,    -1,    41,    42,    43,    -1,
-      45,    46,    47,    48,    49,    -1,    -1,    52,    53,    -1,
-      55,    56,    -1,    -1,    -1,    -1,    -1,    -1,    63,    64,
-      -1,    66,    -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    91,    92,    -1,    -1,
+      -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    99,    -1,     3,    -1,     5,     6,
-      -1,     8,     9,    10,    11,    12,    -1,   112,    -1,    -1,
-      -1,    -1,   117,   118,    -1,    -1,    -1,   122,    25,   124,
-      27,   126,    29,   128,    -1,    32,    -1,    -1,    -1,    36,
-      -1,    -1,    -1,    -1,    -1,    -1,    43,    -1,    45,    46,
-      -1,    -1,    -1,    -1,    -1,    -1,    53,    -1,    55,    56,
-      -1,    -1,    -1,    -1,    -1,    -1,    63,    -1,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,     3,    -1,     5,     6,
-      -1,     8,     9,    10,    11,    12,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    25,    -1,
-      27,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,
-      -1,    -1,    -1,    -1,    -1,   112,    43,    -1,    45,    -1,
-     117,   118,    -1,    -1,    -1,   122,    53,   124,    55,    56,
-      -1,   128,    -1,    -1,    -1,    -1,    63,    -1,    -1,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,     3,    -1,     5,     6,
-      -1,     8,     9,    10,    11,    12,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    -1,    -1,    -1,    25,    -1,
-      27,    -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   112,    -1,    -1,    45,    -1,
-     117,   118,    -1,    -1,    -1,   122,    53,   124,    55,    56,
-      -1,   128,    -1,    -1,    -1,    -1,    -1,    -1,    40,    -1,
-      -1,    -1,    -1,    70,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    67,    68,    69,    -1,    71,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   123,    -1,
+     125,    67,    68,    69,   129,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    -1,    91,    92,    93,    -1,    95,
+      96,    97,    -1,    -1,    -1,    -1,    -1,   103,   104,    -1,
+     106,   107,   108,    39,   110,   111,    -1,   113,   114,   115,
+     116,   117,    -1,    -1,    -1,    -1,    -1,   123,    -1,   125,
+      -1,    -1,   128,    -1,    -1,    -1,    -1,    -1,   134,    -1,
+      -1,    67,    68,    69,    -1,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    -1,    91,    92,    93,    -1,    95,
+      96,    97,    -1,    -1,    -1,    -1,    -1,   103,   104,    -1,
+     106,   107,   108,    39,   110,   111,    -1,   113,   114,   115,
+     116,   117,    -1,    -1,    -1,    -1,    -1,   123,    -1,   125,
+      -1,    -1,   128,    -1,    -1,    -1,    -1,    -1,   134,    -1,
+      -1,    67,    68,    69,    -1,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    -1,    91,    92,    93,    -1,    95,
+      96,    97,    -1,    -1,    -1,    39,    -1,   103,   104,   105,
+     106,   107,   108,    -1,   110,   111,    -1,   113,   114,   115,
+     116,   117,    -1,    -1,    -1,    -1,    -1,   123,    -1,   125,
+      -1,    -1,   128,    67,    68,    69,    -1,    71,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    85,    86,    87,    88,    89,    -1,    91,    92,    93,
+      -1,    95,    96,    97,    -1,    -1,    -1,    39,    -1,   103,
+     104,    -1,   106,   107,   108,    -1,   110,   111,    -1,   113,
+     114,   115,   116,   117,    -1,    -1,    -1,    -1,    -1,   123,
+      -1,   125,   126,    -1,   128,    67,    68,    69,    -1,    71,
       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,   122,    -1,   124,    -1,    -1,
-     102,   128,   104,    -1,   106,   107,   108,   109,   110,    40,
-     112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,
-     122,    -1,   124,    -1,    -1,   127,    -1,    -1,    -1,    -1,
-      -1,   133,    -1,    -1,    -1,    -1,    67,    68,    69,    -1,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    86,    87,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,    -1,
-      -1,   102,    40,   104,    -1,   106,   107,   108,   109,   110,
-      -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,
-      -1,   122,    -1,   124,    -1,    -1,   127,    -1,    -1,    67,
-      68,    69,   133,    71,    72,    73,    74,    75,    76,    77,
+      82,    83,    84,    85,    86,    87,    88,    89,    -1,    91,
+      92,    93,    -1,    95,    96,    97,    -1,    -1,    -1,    39,
+      -1,   103,   104,    -1,   106,   107,   108,    -1,   110,   111,
+      -1,   113,   114,   115,   116,   117,    -1,    -1,    -1,    -1,
+      -1,   123,    -1,   125,   126,    -1,   128,    67,    68,    69,
+      -1,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      -1,    91,    92,    93,    -1,    95,    96,    97,    -1,    -1,
+      -1,    39,    -1,   103,   104,    -1,   106,   107,   108,    -1,
+     110,   111,    -1,   113,   114,   115,   116,   117,    -1,    -1,
+      -1,    -1,    -1,   123,    -1,   125,   126,    -1,   128,    67,
+      68,    69,    -1,    71,    72,    73,    74,    75,    76,    77,
       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
-      88,    -1,    90,    91,    92,    -1,    94,    95,    96,    -1,
-      -1,    -1,    -1,    -1,   102,    40,   104,    -1,   106,   107,
-     108,   109,   110,    -1,   112,   113,   114,   115,   116,    -1,
-      -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,
-      -1,    -1,    67,    68,    69,   133,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    86,    87,    88,    -1,    90,    91,    92,    -1,    94,
-      95,    96,    -1,    -1,    -1,    -1,    40,   102,    -1,   104,
-     105,   106,   107,   108,   109,   110,    -1,   112,   113,   114,
-     115,   116,    -1,    -1,    -1,    -1,    -1,   122,    -1,   124,
-      -1,    -1,   127,    67,    68,    69,    -1,    71,    72,    73,
+      88,    89,    -1,    91,    92,    93,    -1,    95,    96,    97,
+      -1,    -1,    -1,    39,    -1,   103,   104,    -1,   106,   107,
+     108,    -1,   110,   111,    -1,   113,   114,   115,   116,   117,
+      -1,    -1,    -1,    -1,    -1,   123,    -1,   125,   126,    -1,
+     128,    67,    68,    69,    -1,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,    88,    89,    -1,    91,    92,    93,    -1,    95,
+      96,    97,    -1,    -1,    -1,    39,    -1,   103,   104,    -1,
+     106,   107,   108,    -1,   110,   111,    -1,   113,   114,   115,
+     116,   117,    -1,    -1,    -1,    -1,    -1,   123,    -1,   125,
+     126,    -1,   128,    67,    68,    69,    -1,    71,    72,    73,
       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
-      84,    85,    86,    87,    88,    -1,    90,    91,    92,    -1,
-      94,    95,    96,    -1,    -1,    -1,    -1,    40,   102,    -1,
-     104,    -1,   106,   107,   108,   109,   110,    -1,   112,   113,
-     114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,    -1,
-     124,   125,    -1,   127,    67,    68,    69,    -1,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    86,    87,    88,    -1,    90,    91,    92,
-      -1,    94,    95,    96,    -1,    -1,    -1,    -1,    40,   102,
-      -1,   104,   105,   106,   107,   108,   109,   110,    -1,   112,
-     113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,
-      -1,   124,    -1,    -1,   127,    67,    68,    69,    -1,    71,
+      84,    85,    86,    87,    88,    89,    -1,    91,    92,    93,
+      -1,    95,    96,    97,    -1,    -1,    -1,    39,    -1,   103,
+     104,   105,   106,   107,   108,    -1,   110,   111,    -1,   113,
+     114,   115,   116,   117,    -1,    -1,    -1,    -1,    -1,   123,
+      -1,   125,    -1,    -1,   128,    67,    68,    69,    -1,    71,
       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
-      92,    -1,    94,    95,    96,    -1,    -1,    -1,    -1,    40,
-     102,    -1,   104,    -1,   106,   107,   108,   109,   110,    -1,
-     112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,
-     122,    -1,   124,    -1,    -1,   127,    67,    68,    69,    -1,
-      71,    72,    73,    74,    75,    76,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    88,    -1,    90,
-      91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,    -1,
-      40,    -1,    -1,    -1,    -1,   106,   107,   108,   109,   110,
-      -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,
-      -1,   122,    -1,   124,    -1,    -1,   127,    67,    68,    69,
+      82,    83,    84,    85,    86,    87,    88,    89,    -1,    91,
+      92,    93,    -1,    95,    96,    97,    -1,    -1,    -1,    39,
+      -1,   103,   104,    -1,   106,   107,   108,    -1,   110,   111,
+      -1,   113,   114,   115,   116,   117,    -1,    -1,    -1,    -1,
+      -1,   123,    -1,   125,   126,    -1,   128,    67,    68,    69,
+      -1,    71,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
+      -1,    91,    92,    93,    -1,    95,    96,    97,    -1,    -1,
+      -1,    39,    -1,   103,   104,    -1,   106,   107,   108,    -1,
+     110,   111,    -1,   113,   114,   115,   116,   117,    -1,    -1,
+      -1,    -1,    -1,   123,    -1,   125,    -1,    -1,   128,    67,
+      68,    69,    -1,    71,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
+      88,    89,    -1,    91,    92,    93,    -1,    95,    96,    97,
+      -1,    -1,    -1,    39,    -1,   103,   104,    -1,   106,   107,
+     108,    -1,    -1,   111,    -1,   113,   114,   115,   116,   117,
+      -1,    -1,    -1,    -1,    -1,   123,    -1,   125,    -1,    -1,
+     128,    67,    68,    69,    -1,    71,    72,    73,    74,    75,
+      76,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    89,    -1,    91,    92,    93,    -1,    95,
+      96,    97,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,
+     106,   107,   108,    -1,   110,   111,    -1,   113,   114,   115,
+     116,   117,    -1,    -1,    -1,    -1,    -1,   123,    -1,   125,
+      -1,    -1,   128,    67,    68,    69,    -1,    71,    72,    73,
+      74,    75,    76,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    91,    92,    93,
+      -1,    95,    96,    97,    -1,    -1,    -1,    39,    -1,    -1,
+      -1,    -1,   106,   107,   108,    -1,   110,   111,    -1,   113,
+     114,   115,   116,   117,    -1,    -1,    -1,    -1,    -1,   123,
+      -1,   125,    -1,    -1,   128,    67,    68,    69,    -1,    71,
+      72,    73,    74,    75,    76,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    91,
+      92,    93,    -1,    95,    96,    97,    -1,    -1,    -1,    39,
+      -1,    -1,    -1,    -1,    -1,   107,   108,    -1,   110,   111,
+      -1,   113,   114,   115,   116,   117,    -1,    -1,    -1,    -1,
+      -1,   123,    -1,   125,    -1,    -1,   128,    67,    68,    69,
       -1,    71,    72,    73,    74,    75,    76,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,
-      -1,    40,    -1,    -1,    -1,    -1,   106,   107,   108,   109,
-     110,    -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,
-      -1,    -1,   122,    -1,   124,    -1,    -1,   127,    67,    68,
-      69,    -1,    71,    72,    73,    74,    75,    76,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    90,    91,    92,    -1,    94,    95,    96,    -1,    -1,
-      -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,   107,   108,
-     109,   110,    -1,   112,   113,   114,   115,   116,    -1,    -1,
-      -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,    67,
+      -1,    91,    92,    93,    -1,    95,    96,    97,    -1,    -1,
+      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,
+     110,   111,    -1,   113,   114,   115,   116,   117,    -1,    -1,
+      -1,    -1,    -1,   123,    -1,   125,    -1,    -1,   128,    67,
       68,    69,    -1,    71,    72,    73,    74,    75,    76,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    90,    91,    92,    -1,    94,    95,    96,    -1,
-      -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,
-     108,   109,   110,    -1,   112,   113,   114,   115,   116,    -1,
-      -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,
-      67,    68,    69,    -1,    71,    72,    73,    74,    75,    76,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    90,    91,    92,    -1,    94,    95,    96,
-      -1,    -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,
-      -1,   108,   109,   110,    -1,   112,   113,   114,   115,   116,
-      -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,
-     127,    67,    68,    69,    -1,    71,    72,    73,    74,    75,
+      -1,    -1,    -1,    91,    92,    93,    -1,    95,    96,    97,
+      -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
+     108,    -1,   110,   111,    -1,   113,   114,   115,   116,   117,
+      -1,    -1,    -1,    -1,    -1,   123,    -1,   125,    -1,    -1,
+     128,    67,    68,    69,    -1,    71,    72,    73,    74,    75,
       76,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    90,    91,    92,    -1,    94,    95,
-      96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   109,   110,    -1,   112,   113,   114,   115,
-     116,    -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,
-      -1,   127
+      -1,    -1,    -1,    -1,    -1,    91,    92,    93,    -1,    95,
+      96,    97,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   110,   111,    -1,   113,   114,   115,
+     116,   117,    -1,    -1,    -1,    -1,    -1,   123,    -1,   125,
+      -1,    -1,   128
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
-static const yytype_uint8 yystos[] =
+static const yytype_uint16 yystos[] =
 {
-       0,     3,     4,     5,     6,     8,     9,    10,    11,    12,
-      13,    14,    15,    16,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    29,    36,    38,    39,    41,    43,    45,
-      47,    48,    49,    52,    53,    55,    56,    63,    64,    70,
-      90,    91,    99,   112,   117,   118,   122,   124,   126,   128,
-     135,   136,   137,   138,   144,   147,   148,   154,   158,   159,
-     160,   161,   163,   171,   179,   182,   183,   186,   189,   190,
-     191,   192,   196,   198,   207,   217,   220,   233,   234,   235,
-     238,   239,   240,   241,   244,   246,   247,    89,    50,   122,
-     122,   164,   122,     3,    19,   126,   184,   185,    18,     3,
-     240,     3,   219,   240,   122,   185,   223,   122,   126,   122,
-     127,   240,   122,   237,   240,   242,   243,   240,   240,   240,
-     240,   240,   238,   229,   230,   231,   237,    30,    32,    37,
-      42,    46,    66,    99,   132,   143,   144,   145,   148,   150,
-     165,   166,   181,   190,   236,     3,     0,   138,   126,     3,
-      46,   150,   156,   157,   239,   145,   146,    18,    27,    31,
-      32,    44,    46,   206,   245,   192,   100,    40,    67,    68,
-      69,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    86,    87,    88,    90,
-      91,    92,    94,    95,    96,   102,   104,   106,   107,   108,
-     109,   110,   112,   113,   114,   115,   116,   122,   124,   127,
-       3,   122,   162,   146,   172,   188,   126,   127,     3,   185,
-     222,   223,   224,   232,   122,   238,   127,   240,   180,   229,
-       3,   155,   105,   132,   100,   133,   125,   100,   237,     3,
-       3,   151,   152,   238,   238,   151,     3,   132,   145,   126,
-     136,     3,    99,    68,    99,     3,    35,    51,   216,     3,
-       3,   208,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   240,   240,   240,   240,     3,   240,   240,   240,   240,
-     240,   240,   240,   240,   240,   240,   240,   240,   240,   240,
-     240,   229,   240,     3,   122,   128,   238,    14,   240,    99,
-     139,   140,   141,   147,   148,   196,   198,   207,   217,   187,
-     184,   127,   122,   228,     3,    93,   213,   214,   215,   133,
-       3,   115,   133,   142,   143,   133,   238,   237,   237,   105,
-     227,   100,   143,   132,   227,   238,   238,   102,     3,    54,
-     193,    54,   194,     3,   209,   210,   105,   133,   125,    89,
-     240,     3,   133,   122,   133,   132,   141,   126,   139,   229,
-     102,   105,   211,   215,   133,   100,   132,   133,   105,    36,
-     115,   224,   226,   102,   149,   152,   132,    99,   133,     3,
-       5,   122,   224,    17,   195,   224,   225,   126,   227,   100,
-     240,     3,   133,   146,   238,   126,   139,   132,   133,     3,
-       5,     8,     9,    10,    12,    45,    55,    56,   212,   226,
-     227,    93,   215,    28,    33,   173,   175,   177,   178,   146,
-     237,   237,   239,   146,   213,   225,   126,   100,   199,   149,
-     210,   133,    34,    62,   167,   168,   169,   170,   132,   211,
-     126,   215,   126,   122,   173,   175,    65,   153,   133,   133,
-     197,   224,    46,    99,   190,   203,   204,   205,   240,   105,
-     132,   169,   170,   221,   176,     3,   146,   146,   227,    99,
-     144,   148,   190,   200,   201,   202,   207,   217,     3,    27,
-     132,   205,   105,   142,   142,   142,   227,   126,   126,   132,
-     202,   216,   142,   132,   132,   133,   218,   200,     3,   174,
-     142,   132,   122,   126,   132,   213,   142,   133,   132,   227
+       0,     3,     4,     5,     7,     8,     9,    10,    11,    12,
+      13,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    27,    28,    35,    37,    38,    40,    42,    44,    46,
+      47,    48,    51,    52,    54,    55,    62,    63,    64,    70,
+      91,    92,   100,   110,   113,   118,   119,   123,   125,   127,
+     129,   136,   137,   138,   139,   145,   148,   150,   158,   161,
+     162,   163,   164,   165,   172,   180,   183,   184,   187,   190,
+     191,   192,   193,   197,   199,   208,   213,   214,   215,   226,
+     233,   236,   249,   250,   251,   256,   260,   264,   265,   267,
+     268,   269,    90,    49,   123,   123,   155,   156,   123,     3,
+      15,    16,    28,   127,   185,   186,    15,     3,   260,     3,
+     235,   260,   123,     3,   186,   239,   260,   127,   123,   128,
+      15,   260,   123,     3,     4,     7,     8,     9,   257,   258,
+     259,   260,   260,   260,   260,   260,   255,   260,   245,   246,
+     247,   253,   260,    29,    31,    36,    41,    45,    66,   100,
+     133,   144,   145,   146,   150,   152,   166,   167,   182,   191,
+     252,     3,     0,   139,   127,     3,    45,   152,   159,   160,
+     256,   146,   147,    15,    25,    30,    31,    43,    45,   207,
+     266,     3,   193,     3,   127,   220,   224,   101,    39,    67,
+      68,    69,    71,    72,    73,    74,    75,    76,    77,    78,
+      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+      89,    91,    92,    93,    95,    96,    97,   103,   104,   106,
+     107,   108,   110,   111,   113,   114,   115,   116,   117,   123,
+     125,   128,     3,   123,   254,   255,    11,   147,   173,   189,
+     127,   128,   185,   186,   238,   239,   240,   248,   123,   254,
+     128,   181,   245,     3,   103,   254,   133,   105,   101,   101,
+     134,   126,   101,   253,     3,     3,   153,   154,   254,   254,
+     153,     3,   133,   146,   127,   137,     3,   100,    68,   100,
+       3,    34,    50,   232,     3,     3,   209,   260,     3,   220,
+     225,   227,   228,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,     3,   116,   129,
+     185,   262,   263,   260,   260,   260,   260,   260,   260,   260,
+     260,   260,   260,   260,   260,   260,   260,   260,   245,   260,
+     123,   125,   129,   262,   263,   134,   123,   260,   100,   125,
+     140,   141,   142,   148,   150,   197,   199,   208,   233,   188,
+     185,   128,   123,   244,     3,    94,   229,   230,   231,   134,
+     116,   185,   143,   144,   134,   260,   134,   253,   258,   260,
+     105,   243,   101,   144,   133,   243,   254,   254,   103,     3,
+      53,   194,    53,   195,     3,   210,   211,   221,   103,   103,
+     111,   115,   216,   228,   125,   262,   263,    90,   105,   134,
+     126,   261,   260,   125,   262,   263,    90,   155,   254,   134,
+     149,   133,   142,   127,   140,   245,   103,   105,   212,   231,
+     134,   101,   133,   155,   105,    35,   116,   240,   242,   103,
+     151,   154,   133,   100,   134,     3,     4,   123,   240,    14,
+     196,   240,   241,   127,   243,   101,   133,     4,   220,     4,
+     220,   217,   222,   260,    90,   116,   263,   260,   260,   126,
+     260,    90,   263,   134,   127,   260,   140,   133,   134,   260,
+     242,   243,    94,   231,    26,    32,   174,   176,   178,   179,
+      65,   157,   253,   260,   256,   155,   229,   241,   127,   101,
+     200,   151,   211,   111,     4,   110,   111,   127,   218,   223,
+     226,   126,   263,   134,   126,   263,    33,    61,   168,   169,
+     170,   171,   126,   133,   212,   127,   231,   127,   123,   174,
+     176,   155,   134,   134,   198,   240,    45,   100,   191,   204,
+     205,   206,   115,   260,   110,   226,   222,   260,   105,   133,
+     170,   171,   237,   177,     3,   155,   243,   100,   125,   145,
+     150,   191,   201,   202,   203,   208,   233,     3,    25,   133,
+     206,   224,   219,   115,   222,   105,   143,   143,   143,   243,
+     127,   149,   127,   133,   203,   232,   217,   133,   224,   143,
+     133,   133,   134,   234,   260,   201,     3,   111,   217,   175,
+     143,   126,   133,   123,   111,   127,   133,   229,   143,   134,
+     133,   243
 };
 
 #define yyerrok		(yyerrstatus = 0)
@@ -4326,67 +4694,80 @@ yyreduce:
   switch (yyn)
     {
         
-    case 26:
+    case 13:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2092 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+#line 2010 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
     }
     break;
 
 
   
-    case 27:
+    case 24:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2093 "parser.y"
-    {(yyval.code)=code_new();}
+#line 2022 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
     }
     break;
 
 
   
-    case 28:
+    case 25:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2095 "parser.y"
-    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
+#line 2023 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(2) - (4)].number_int);PASS1 as3_warning("embed command ignored");}
     }
     break;
 
 
   
-    case 29:
+    case 27:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2096 "parser.y"
+#line 2026 "parser.y"
     {(yyval.code)=(yyvsp[(1) - (1)].code);}
     }
     break;
 
 
   
-    case 42:
+    case 28:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2027 "parser.y"
+    {(yyval.code)=code_new();}
+    }
+    break;
+
+
+  
+    case 29:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2111 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (3)].code);}
+#line 2029 "parser.y"
+    {
+    (yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));
+}
     }
     break;
 
 
   
-    case 43:
+    case 30:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2112 "parser.y"
-    {(yyval.code)=0;}
+#line 2032 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
     }
     break;
 
@@ -4396,30 +4777,30 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2115 "parser.y"
-    {(yyval.code)=0;}
+#line 2048 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (3)].code);}
     }
     break;
 
 
   
-    case 51:
+    case 45:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2122 "parser.y"
-    {(yyval.code)=(yyvsp[(3) - (4)].code);}
+#line 2049 "parser.y"
+    {(yyval.code)=0;}
     }
     break;
 
 
   
-    case 52:
+    case 46:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2126 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (2)].code);}
+#line 2052 "parser.y"
+    {(yyval.code)=0;}
     }
     break;
 
@@ -4429,8 +4810,16 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2127 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+#line 2059 "parser.y"
+    {
+    PASS_ALWAYS 
+    if(as3_pass) {
+        (yyval.code) = (yyvsp[(3) - (4)].code);
+    } else {
+        (yyval.code) = 0;
+    }
+    as3_pass=(yyvsp[(1) - (4)].number_int);
+}
     }
     break;
 
@@ -4440,11 +4829,19 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2131 "parser.y"
-    {
-    code_t**cc = &global->init->method->body->code;
-    *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
-}
+#line 2071 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (2)].code);}
+    }
+    break;
+
+
+  
+    case 55:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2072 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
     }
     break;
 
@@ -4454,8 +4851,15 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2142 "parser.y"
-    {(yyval.value)=(yyvsp[(2) - (2)].value);}
+#line 2076 "parser.y"
+    {
+    if((yyvsp[(1) - (1)].code)) {
+        if(!global->init) 
+            global->init = abc_initscript(global->file);
+        code_t**cc = &global->init->method->body->code;
+        *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
+    }
+}
     }
     break;
 
@@ -4465,10 +4869,12 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2143 "parser.y"
-    {(yyval.value).c=abc_pushundefined(0);
-                                  (yyval.value).t=TYPE_ANY;
-                                 }
+#line 2087 "parser.y"
+    {
+    PASS_ALWAYS
+    (yyval.number_int) = as3_pass;
+    as3_pass=0;
+}
     }
     break;
 
@@ -4478,8 +4884,16 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2147 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+#line 2095 "parser.y"
+    {
+    PASS12
+    (yyval.number_int)=as3_pass;
+    char*key = concat3((yyvsp[(1) - (3)].id),"::",(yyvsp[(3) - (3)].id));
+    if(!definitions || !dict_contains(definitions, key)) {
+        as3_pass=0;
+    }
+    free(key);
+}
     }
     break;
 
@@ -4489,8 +4903,8 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2148 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+#line 2122 "parser.y"
+    {(yyval.node)=(yyvsp[(2) - (2)].node);}
     }
     break;
 
@@ -4500,8 +4914,8 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2150 "parser.y"
-    {(yyval.code) = (yyvsp[(1) - (1)].code);}
+#line 2123 "parser.y"
+    {(yyval.node)=mkdummynode();}
     }
     break;
 
@@ -4511,8 +4925,8 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2151 "parser.y"
-    {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
+#line 2125 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
     }
     break;
 
@@ -4522,62 +4936,95 @@ yyreduce:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2154 "parser.y"
-    {
-PASS12
-    if(variable_exists((yyvsp[(1) - (3)].id)))
-        syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));
-PASS1
-    new_variable((yyvsp[(1) - (3)].id), 0, 1, 0);
-PASS2
-   
-    if(!is_subtype_of((yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo))) {
-        syntaxerror("Can't convert %s to %s", (yyvsp[(3) - (3)].value).t->name, 
-                                              (yyvsp[(2) - (3)].classinfo)->name);
+#line 2126 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
     }
+    break;
 
+
+  
+    case 63:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2128 "parser.y"
+    {(yyval.code) = (yyvsp[(1) - (1)].code);}
+    }
+    break;
+
+
+  
+    case 64:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2129 "parser.y"
+    {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
+    }
+    break;
+
+
+  
+    case 65:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2132 "parser.y"
+    {
+PASS12
+    if(variable_exists((yyvsp[(1) - (3)].id))) 
+        syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));
+PASS1
+    new_variable(state->method, (yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
+PASS2
+   
     char slot = 0;
     int index = 0;
+    variable_t*v = 0;
     if(state->method->uses_slots) {
-        variable_t* v = find_slot(state, (yyvsp[(1) - (3)].id));
+        v = find_slot(state->method, (yyvsp[(1) - (3)].id));
         if(v && !v->init) {
             // this variable is stored in a slot
             v->init = 1;
             v->type = (yyvsp[(2) - (3)].classinfo);
             slot = 1;
-            index = v->index;
         }
     }
-    if(!index) {
-        index = new_variable((yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
+    if(!v) {
+        v = new_variable2(state->method, (yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);
     }
 
     (yyval.code) = slot?abc_getscopeobject(0, 1):0;
     
+    typedcode_t val = node_read((yyvsp[(3) - (3)].node));
+    if(!is_subtype_of(val.t, (yyvsp[(2) - (3)].classinfo))) {
+        syntaxerror("Can't convert %s to %s", val.t->name, (yyvsp[(2) - (3)].classinfo)->name);
+    }
     if((yyvsp[(2) - (3)].classinfo)) {
-        if((yyvsp[(3) - (3)].value).c->prev || (yyvsp[(3) - (3)].value).c->opcode != OPCODE_PUSHUNDEFINED) {
-            (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (3)].value).c);
-            (yyval.code) = converttype((yyval.code), (yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo));
+        if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
+            (yyval.code) = code_append((yyval.code), val.c);
+            (yyval.code) = converttype((yyval.code), val.t, (yyvsp[(2) - (3)].classinfo));
         } else {
-            code_free((yyvsp[(3) - (3)].value).c);
+            code_free(val.c);
             (yyval.code) = defaultvalue((yyval.code), (yyvsp[(2) - (3)].classinfo));
         }
     } else {
-        if((yyvsp[(3) - (3)].value).c->prev || (yyvsp[(3) - (3)].value).c->opcode != OPCODE_PUSHUNDEFINED) {
-            (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (3)].value).c);
+        if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {
+            (yyval.code) = code_append((yyval.code), val.c);
             (yyval.code) = abc_coerce_a((yyval.code));
         } else {
             // don't do anything
-            code_free((yyvsp[(3) - (3)].value).c);
+            code_free(val.c);
             code_free((yyval.code));
             (yyval.code) = 0;
             break;
         }
     }
     if(slot) {
-        (yyval.code) = abc_setslot((yyval.code), index);
+        (yyval.code) = abc_setslot((yyval.code), v->index);
     } else {
-        (yyval.code) = abc_setlocal((yyval.code), index);
+        (yyval.code) = abc_setlocal((yyval.code), v->index);
+        v->init = do_init_variable((yyvsp[(1) - (3)].id));
     }
 }
     }
@@ -4585,97 +5032,108 @@ PASS2
 
 
   
-    case 63:
+    case 66:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2214 "parser.y"
-    {(yyval.code) = code_new();}
+#line 2192 "parser.y"
+    {PASS12 new_state();}
     }
     break;
 
 
   
-    case 64:
+    case 67:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2215 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+#line 2192 "parser.y"
+    {
+    (yyval.code) = var_block((yyvsp[(2) - (2)].code), state->vars);
+    PASS12 old_state();
+}
     }
     break;
 
 
   
-    case 65:
+    case 68:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2218 "parser.y"
-    {PASS12 new_state();}
+#line 2196 "parser.y"
+    {(yyval.code) = code_new();}
     }
     break;
 
 
   
-    case 66:
+    case 69:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2197 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+    }
+    break;
+
+
+  
+    case 70:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2218 "parser.y"
+#line 2200 "parser.y"
     {
-     
     (yyval.code) = code_new();
-    (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (7)].value).c);
+    (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (6)].value).c);
     code_t*myjmp,*myif = (yyval.code) = abc_iffalse((yyval.code), 0);
    
-    (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (7)].code));
-    if((yyvsp[(7) - (7)].code)) {
+    (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].code));
+    if((yyvsp[(6) - (6)].code)) {
         myjmp = (yyval.code) = abc_jump((yyval.code), 0);
     }
     myif->branch = (yyval.code) = abc_nop((yyval.code));
-    if((yyvsp[(7) - (7)].code)) {
-        (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (7)].code));
+    if((yyvsp[(6) - (6)].code)) {
+        (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
         myjmp->branch = (yyval.code) = abc_nop((yyval.code));
     }
-    (yyval.code) = var_block((yyval.code));
-    PASS12 old_state();
 }
     }
     break;
 
 
   
-    case 67:
+    case 71:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2237 "parser.y"
+#line 2216 "parser.y"
     {(yyval.code)=code_new();}
     }
     break;
 
 
   
-    case 70:
+    case 74:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2244 "parser.y"
+#line 2223 "parser.y"
     {
-    PASS1 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),0,1,0);
-    PASS2 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1,0);
+    PASS1 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),0,1,0);
+    PASS2 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable(state->method, (yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1,0);
 }
     }
     break;
 
 
   
-    case 71:
+    case 75:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2248 "parser.y"
+#line 2227 "parser.y"
     {
     PASS12
     (yyval.id)=(yyvsp[(1) - (1)].id);
@@ -4685,33 +5143,33 @@ PASS2
 
 
   
-    case 72:
+    case 76:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2253 "parser.y"
+#line 2232 "parser.y"
     {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
     }
     break;
 
 
   
-    case 73:
+    case 77:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2254 "parser.y"
+#line 2233 "parser.y"
     {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
     }
     break;
 
 
   
-    case 74:
+    case 78:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2256 "parser.y"
+#line 2235 "parser.y"
     {
     if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");
     (yyval.code) = code_new();
@@ -4728,7 +5186,7 @@ PASS2
     continuejumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, cont);
     myif->branch = out;
 
-    (yyval.code) = var_block((yyval.code));
+    (yyval.code) = var_block((yyval.code), state->vars);
     PASS12 old_state();
 }
     }
@@ -4736,21 +5194,17 @@ PASS2
 
 
   
-    case 75:
+    case 79:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2276 "parser.y"
+#line 2255 "parser.y"
     {
-    variable_t*var = find_variable(state, (yyvsp[(2) - (6)].id));
-    if(!var) {
-        syntaxerror("variable %s not known in this scope", (yyvsp[(2) - (6)].id));
-    }
-
-    char*tmp1name = concat2((yyvsp[(2) - (6)].id), "__tmp1__");
-    int it = new_variable(tmp1name, TYPE_INT, 0, 0);
-    char*tmp2name = concat2((yyvsp[(2) - (6)].id), "__array__");
-    int array = new_variable(tmp1name, 0, 0, 0);
+    node_t*n = resolve_identifier((yyvsp[(2) - (6)].id));
+    typedcode_t w = node_write(n);
+    
+    int it = alloc_local();
+    int array = alloc_local();
 
     (yyval.code) = code_new();
     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
@@ -4769,8 +5223,9 @@ PASS2
         (yyval.code) = abc_nextname((yyval.code));
     else
         (yyval.code) = abc_nextvalue((yyval.code));
-    (yyval.code) = converttype((yyval.code), 0, var->type);
-    (yyval.code) = abc_setlocal((yyval.code), var->index);
+
+    (yyval.code) = converttype((yyval.code), 0, w.t);
+    (yyval.code) = code_append((yyval.code), w.c);
 
     (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
     (yyval.code) = abc_jump((yyval.code), loopstart);
@@ -4781,11 +5236,10 @@ PASS2
     
     myif->branch = out;
 
-    (yyval.code) = var_block((yyval.code));
-
-    free(tmp1name);
-    free(tmp2name);
+    (yyval.code) = abc_kill((yyval.code), it);
+    (yyval.code) = abc_kill((yyval.code), array);
 
+    (yyval.code) = var_block((yyval.code), state->vars);
     PASS12 old_state();
 }
     }
@@ -4793,85 +5247,57 @@ PASS2
 
 
   
-    case 76:
-    if(as3_pass==2) {
-
-/* Line 1464 of skeleton.m4  */
-#line 2324 "parser.y"
-    {PASS12 new_state();}
-    }
-    break;
-
-
-  
-    case 77:
+    case 80:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2324 "parser.y"
+#line 2299 "parser.y"
     {
 
     (yyval.code) = code_new();
 
     code_t*myjmp = (yyval.code) = abc_jump((yyval.code), 0);
     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
-    (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));
+    (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (5)].code));
     code_t*cont = (yyval.code) = abc_nop((yyval.code));
     myjmp->branch = cont;
-    (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
+    (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (5)].value).c);
     (yyval.code) = abc_iftrue((yyval.code), loopstart);
     code_t*out = (yyval.code) = abc_nop((yyval.code));
-    breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);
-    continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
-
-    (yyval.code) = var_block((yyval.code));
-    PASS12 old_state();
+    breakjumpsto((yyval.code), (yyvsp[(1) - (5)].id), out);
+    continuejumpsto((yyval.code), (yyvsp[(1) - (5)].id), cont);
 }
     }
     break;
 
 
   
-    case 78:
-    if(as3_pass==2) {
-
-/* Line 1464 of skeleton.m4  */
-#line 2343 "parser.y"
-    {PASS12 new_state();}
-    }
-    break;
-
-
-  
-    case 79:
+    case 81:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2343 "parser.y"
+#line 2315 "parser.y"
     {
     (yyval.code) = code_new();
     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
-    (yyval.code) = code_append((yyval.code), (yyvsp[(3) - (7)].code));
+    (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (6)].code));
     code_t*cont = (yyval.code) = abc_nop((yyval.code));
-    (yyval.code) = code_append((yyval.code), (yyvsp[(6) - (7)].value).c);
+    (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].value).c);
     (yyval.code) = abc_iftrue((yyval.code), loopstart);
     code_t*out = (yyval.code) = abc_nop((yyval.code));
-    breakjumpsto((yyval.code), (yyvsp[(1) - (7)].id), out);
-    continuejumpsto((yyval.code), (yyvsp[(1) - (7)].id), cont);
-    
-    (yyval.code) = var_block((yyval.code));
-    PASS12 old_state();
+    breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);
+    continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
 }
     }
     break;
 
 
   
-    case 80:
+    case 82:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2358 "parser.y"
+#line 2327 "parser.y"
     {
     (yyval.code) = abc___break__(0, "");
 }
@@ -4880,11 +5306,11 @@ PASS2
 
 
   
-    case 81:
+    case 83:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2361 "parser.y"
+#line 2330 "parser.y"
     {
     (yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));
 }
@@ -4893,11 +5319,11 @@ PASS2
 
 
   
-    case 82:
+    case 84:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2364 "parser.y"
+#line 2333 "parser.y"
     {
     (yyval.code) = abc___continue__(0, "");
 }
@@ -4906,11 +5332,11 @@ PASS2
 
 
   
-    case 83:
+    case 85:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2367 "parser.y"
+#line 2336 "parser.y"
     {
     (yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));
 }
@@ -4919,80 +5345,80 @@ PASS2
 
 
   
-    case 84:
+    case 86:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2371 "parser.y"
+#line 2340 "parser.y"
     {(yyval.code)=0;}
     }
     break;
 
 
   
-    case 85:
+    case 87:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2372 "parser.y"
+#line 2341 "parser.y"
     {(yyval.code)=(yyvsp[(1) - (1)].code);}
     }
     break;
 
 
   
-    case 86:
+    case 88:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2373 "parser.y"
+#line 2342 "parser.y"
     {(yyval.code)=(yyvsp[(1) - (1)].code);}
     }
     break;
 
 
   
-    case 87:
+    case 89:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2374 "parser.y"
+#line 2343 "parser.y"
     {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
     }
     break;
 
 
   
-    case 88:
+    case 90:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2375 "parser.y"
+#line 2344 "parser.y"
     {(yyval.code)=(yyvsp[(1) - (1)].code);}
     }
     break;
 
 
   
-    case 89:
+    case 91:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2376 "parser.y"
+#line 2345 "parser.y"
     {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}
     }
     break;
 
 
   
-    case 90:
+    case 92:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2378 "parser.y"
+#line 2347 "parser.y"
     {
-    (yyval.code) = abc_dup(0);
-    (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (4)].value).c);
+    (yyval.code) = abc_getlocal(0, state->switch_var);
+    (yyval.code) = code_append((yyval.code), node_read((yyvsp[(2) - (4)].node)).c);
     code_t*j = (yyval.code) = abc_ifne((yyval.code), 0);
     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (4)].code));
     if((yyval.code)->opcode != OPCODE___BREAK__) {
@@ -5006,11 +5432,11 @@ PASS2
 
 
   
-    case 91:
+    case 93:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2389 "parser.y"
+#line 2358 "parser.y"
     {
     (yyval.code) = (yyvsp[(3) - (3)].code);
 }
@@ -5019,26 +5445,28 @@ PASS2
 
 
   
-    case 92:
+    case 94:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2392 "parser.y"
-    {PASS12 new_state();}
+#line 2361 "parser.y"
+    {PASS12 new_state();state->switch_var=alloc_local();}
     }
     break;
 
 
   
-    case 93:
+    case 95:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2392 "parser.y"
+#line 2361 "parser.y"
     {
-    (yyval.code)=(yyvsp[(4) - (8)].value).c;
+    (yyval.code) = node_read((yyvsp[(4) - (8)].node)).c;
+    (yyval.code) = abc_setlocal((yyval.code), state->switch_var);
     (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (8)].code));
-    code_t*out = (yyval.code) = abc_pop((yyval.code));
+
+    code_t*out = (yyval.code) = abc_kill((yyval.code), state->switch_var);
     breakjumpsto((yyval.code), (yyvsp[(1) - (8)].id), out);
     
     code_t*c = (yyval.code),*lastblock=0;
@@ -5058,7 +5486,7 @@ PASS2
         c=c->prev;
     }
    
-    (yyval.code) = var_block((yyval.code));
+    (yyval.code) = var_block((yyval.code), state->vars);
     PASS12 old_state();
 }
     }
@@ -5066,26 +5494,26 @@ PASS2
 
 
   
-    case 94:
+    case 96:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2421 "parser.y"
+#line 2392 "parser.y"
     {PASS12 new_state();
                                                       state->exception_name=(yyvsp[(3) - (5)].id);
-                                               PASS1 new_variable((yyvsp[(3) - (5)].id), 0, 0, 0);
-                                               PASS2 new_variable((yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
+                                               PASS1 new_variable(state->method, (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
+                                               PASS2 new_variable(state->method, (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);
                                               }
     }
     break;
 
 
   
-    case 95:
+    case 97:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2426 "parser.y"
+#line 2397 "parser.y"
     {
     namespace_t name_ns = {ACCESS_PACKAGE, ""};
     multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};
@@ -5103,7 +5531,7 @@ PASS2
     c = code_append(c, (yyvsp[(8) - (9)].code));
     c = abc_kill(c, i);
 
-    c = var_block(c);
+    c = var_block(c, state->vars);
     PASS12 old_state();
 }
     }
@@ -5111,24 +5539,24 @@ PASS2
 
 
   
-    case 96:
+    case 98:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2446 "parser.y"
+#line 2417 "parser.y"
     {PASS12 new_state();state->exception_name=0;}
     }
     break;
 
 
   
-    case 97:
+    case 99:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2446 "parser.y"
+#line 2417 "parser.y"
     {
-    (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code));
+    (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code), state->vars);
     if(!(yyvsp[(4) - (5)].code)) {
         (yyval.exception)=0;
     } else {
@@ -5147,44 +5575,44 @@ PASS2
 
 
   
-    case 98:
+    case 100:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2462 "parser.y"
+#line 2433 "parser.y"
     {(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));}
     }
     break;
 
 
   
-    case 99:
+    case 101:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2463 "parser.y"
+#line 2434 "parser.y"
     {(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));}
     }
     break;
 
 
   
-    case 100:
+    case 102:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2464 "parser.y"
+#line 2435 "parser.y"
     {(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}
     }
     break;
 
 
   
-    case 101:
+    case 103:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2465 "parser.y"
+#line 2436 "parser.y"
     {
     (yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);
     (yyval.catch_list).finally = 0;
@@ -5198,11 +5626,11 @@ PASS2
 
 
   
-    case 102:
+    case 104:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2473 "parser.y"
+#line 2444 "parser.y"
     {
     (yyval.catch_list).l=list_new();
     (yyval.catch_list).finally = 0;
@@ -5216,11 +5644,11 @@ PASS2
 
 
   
-    case 103:
+    case 105:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2482 "parser.y"
+#line 2453 "parser.y"
     {PASS12 new_state();
                  state->method->has_exceptions=1;
                  state->method->late_binding=1;//for invariant scope_code
@@ -5230,11 +5658,11 @@ PASS2
 
 
   
-    case 104:
+    case 106:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2485 "parser.y"
+#line 2456 "parser.y"
     {
     code_t*out = abc_nop(0);
 
@@ -5247,7 +5675,7 @@ PASS2
   
     int tmp;
     if((yyvsp[(6) - (6)].catch_list).finally)
-        tmp = new_variable("__finally__", 0, 0, 0);
+        tmp = alloc_local();
     
     abc_exception_list_t*l = (yyvsp[(6) - (6)].catch_list).l;
     int count=0;
@@ -5275,7 +5703,7 @@ PASS2
         
     list_concat(state->method->exceptions, (yyvsp[(6) - (6)].catch_list).l);
    
-    (yyval.code) = var_block((yyval.code));
+    (yyval.code) = var_block((yyval.code), state->vars);
     PASS12 old_state();
 }
     }
@@ -5283,11 +5711,11 @@ PASS2
 
 
   
-    case 105:
+    case 107:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2531 "parser.y"
+#line 2502 "parser.y"
     {
     (yyval.code)=(yyvsp[(2) - (2)].value).c;
     (yyval.code)=abc_throw((yyval.code));
@@ -5297,11 +5725,11 @@ PASS2
 
 
   
-    case 106:
+    case 108:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2535 "parser.y"
+#line 2506 "parser.y"
     {
     if(!state->exception_name)
         syntaxerror("re-throw only possible within a catch block");
@@ -5315,17 +5743,15 @@ PASS2
 
 
   
-    case 107:
+    case 109:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2546 "parser.y"
+#line 2517 "parser.y"
     {
      new_state();
      if(state->method->has_exceptions) {
-         char var[32];
-         sprintf(var, "#with#_%d", as3_tokencount);
-         int v = new_variable(var,(yyvsp[(3) - (4)].value).t,0,0);
+         int v = alloc_local();
          state->method->scope_code = abc_getlocal(state->method->scope_code, v);
          state->method->scope_code = abc_pushwith(state->method->scope_code);
          (yyval.value_list).number = v;
@@ -5337,11 +5763,11 @@ PASS2
 
 
   
-    case 108:
+    case 110:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2558 "parser.y"
+#line 2527 "parser.y"
     {
      /* remove getlocal;pushwith from scope code again */
      state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
@@ -5361,84 +5787,124 @@ PASS2
 
 
   
-    case 110:
+    case 112:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2576 "parser.y"
+#line 2545 "parser.y"
     {PASS12 (yyval.id)="package";}
     }
     break;
 
 
   
-    case 111:
+    case 113:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2578 "parser.y"
+#line 2546 "parser.y"
+    {PASS12 (yyval.id)="namespace";}
+    }
+    break;
+
+
+  
+    case 114:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2547 "parser.y"
+    {PASS12 (yyval.id)="NaN";}
+    }
+    break;
+
+
+  
+    case 115:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2549 "parser.y"
     {PASS12 (yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;}
     }
     break;
 
 
   
-    case 112:
+    case 116:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2579 "parser.y"
+#line 2550 "parser.y"
     {PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}
     }
     break;
 
 
   
-    case 113:
+    case 117:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2581 "parser.y"
+#line 2552 "parser.y"
     {PASS12 startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;}
     }
     break;
 
 
   
-    case 114:
+    case 118:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2582 "parser.y"
+#line 2553 "parser.y"
     {PASS12 endpackage();(yyval.code)=0;}
     }
     break;
 
 
   
-    case 115:
+    case 119:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2583 "parser.y"
+#line 2554 "parser.y"
     {PASS12 startpackage("");}
     }
     break;
 
 
   
-    case 116:
+    case 120:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2584 "parser.y"
+#line 2555 "parser.y"
     {PASS12 endpackage();(yyval.code)=0;}
     }
     break;
 
 
   
-    case 117:
+    case 121:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2578 "parser.y"
+    {
+       PASS12
+       slotinfo_t*s = registry_find(state->package, (yyvsp[(2) - (2)].id));
+       if(!s && as3_pass==1) {as3_schedule_class(state->package, (yyvsp[(2) - (2)].id));}
+       state_has_imports();
+       dict_put(state->imports, state->package, (yyvsp[(2) - (2)].id));
+       (yyval.code)=0;
+}
+    }
+    break;
+
+
+  
+    case 122:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
@@ -5446,17 +5912,15 @@ PASS2
     {
        PASS12
        slotinfo_t*s = registry_find((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
-       if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {
+       if(!s && as3_pass==1) {
            as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
        }
-
-       PASS2
-       classinfo_t*c = (yyvsp[(2) - (2)].classinfo);
-       if(!c) 
-            syntaxerror("Couldn't import class\n");
+       /*if(s && s->kind == INFOTYPE_VAR && TYPE_IS_NAMESPACE(s->type)) {
+	    trie_put(active_namespaces, (unsigned char*)$2->name, 0);
+       }*/
        state_has_imports();
-       dict_put(state->imports, c->name, c);
-       import_toplevel(c->package);
+       dict_put(state->imports, (yyvsp[(2) - (2)].classinfo)->name, (yyvsp[(2) - (2)].classinfo));
+       import_toplevel((yyvsp[(2) - (2)].classinfo)->package);
        (yyval.code)=0;
 }
     }
@@ -5464,18 +5928,17 @@ PASS2
 
 
   
-    case 118:
+    case 123:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2602 "parser.y"
+#line 2600 "parser.y"
     {
        PASS12
        if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6) && as3_pass==1) {
            as3_schedule_package((yyvsp[(2) - (4)].id));
        }
 
-       PASS2
        NEW(import_t,i);
        i->package = (yyvsp[(2) - (4)].id);
        state_has_imports();
@@ -5488,44 +5951,44 @@ PASS2
 
 
   
-    case 119:
+    case 124:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2619 "parser.y"
+#line 2616 "parser.y"
     {PASS12 (yyval.flags).flags=0;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 120:
+    case 125:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2620 "parser.y"
+#line 2617 "parser.y"
     {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
     }
     break;
 
 
   
-    case 121:
+    case 126:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2621 "parser.y"
+#line 2618 "parser.y"
     {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
     }
     break;
 
 
   
-    case 122:
+    case 127:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2622 "parser.y"
+#line 2619 "parser.y"
     {
     PASS12 
     (yyval.flags).flags=(yyvsp[(1) - (2)].flags).flags|(yyvsp[(2) - (2)].flags).flags;
@@ -5538,110 +6001,110 @@ PASS2
 
 
   
-    case 123:
+    case 128:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2630 "parser.y"
+#line 2626 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_PUBLIC;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 124:
+    case 129:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2631 "parser.y"
+#line 2627 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_PRIVATE;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 125:
+    case 130:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2632 "parser.y"
+#line 2628 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_PROTECTED;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 126:
+    case 131:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2633 "parser.y"
+#line 2629 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_STATIC;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 127:
+    case 132:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2634 "parser.y"
+#line 2630 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_DYNAMIC;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 128:
+    case 133:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2635 "parser.y"
+#line 2631 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_FINAL;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 129:
+    case 134:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2636 "parser.y"
+#line 2632 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_OVERRIDE;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 130:
+    case 135:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2637 "parser.y"
+#line 2633 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_NATIVE;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 131:
+    case 136:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2638 "parser.y"
+#line 2634 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_PACKAGEINTERNAL;(yyval.flags).ns=0;}
     }
     break;
 
 
   
-    case 132:
+    case 137:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2639 "parser.y"
+#line 2635 "parser.y"
     {PASS12 (yyval.flags).flags=FLAG_NAMESPACE;
                                (yyval.flags).ns=(yyvsp[(1) - (1)].id);
                        }
@@ -5650,99 +6113,99 @@ PASS2
 
 
   
-    case 133:
+    case 138:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2643 "parser.y"
+#line 2639 "parser.y"
     {PASS12 (yyval.classinfo)=0;}
     }
     break;
 
 
   
-    case 134:
+    case 139:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2644 "parser.y"
+#line 2640 "parser.y"
     {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
     }
     break;
 
 
   
-    case 135:
+    case 140:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2646 "parser.y"
+#line 2642 "parser.y"
     {PASS12 (yyval.classinfo_list)=list_new();}
     }
     break;
 
 
   
-    case 136:
+    case 141:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2647 "parser.y"
+#line 2643 "parser.y"
     {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
     }
     break;
 
 
   
-    case 137:
+    case 142:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2649 "parser.y"
+#line 2645 "parser.y"
     {PASS12 (yyval.classinfo_list)=list_new();}
     }
     break;
 
 
   
-    case 138:
+    case 143:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2650 "parser.y"
+#line 2646 "parser.y"
     {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
     }
     break;
 
 
   
-    case 139:
+    case 144:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2654 "parser.y"
+#line 2650 "parser.y"
     {PASS12 startclass(&(yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list));}
     }
     break;
 
 
   
-    case 140:
+    case 145:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2656 "parser.y"
+#line 2652 "parser.y"
     {PASS12 endclass();(yyval.code)=0;}
     }
     break;
 
 
   
-    case 141:
+    case 146:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2660 "parser.y"
+#line 2656 "parser.y"
     {PASS12 (yyvsp[(1) - (5)].flags).flags|=FLAG_INTERFACE;
                                           startclass(&(yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list));}
     }
@@ -5750,22 +6213,44 @@ PASS2
 
 
   
-    case 142:
+    case 147:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2663 "parser.y"
+#line 2659 "parser.y"
     {PASS12 endclass();(yyval.code)=0;}
     }
     break;
 
 
   
-    case 151:
+    case 153:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2668 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
+    }
+    break;
+
+
+  
+    case 156:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2671 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(2) - (4)].number_int);PASS1 as3_warning("embed command ignored");}
+    }
+    break;
+
+
+  
+    case 157:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2676 "parser.y"
+#line 2673 "parser.y"
     {
     code_t*c = state->cls->static_init->header;
     c = code_append(c, (yyvsp[(1) - (1)].code));  
@@ -5776,11 +6261,11 @@ PASS2
 
 
   
-    case 157:
+    case 163:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2687 "parser.y"
+#line 2684 "parser.y"
     {
     syntaxerror("variable declarations not allowed in interfaces");
 }
@@ -5789,11 +6274,11 @@ PASS2
 
 
   
-    case 158:
+    case 164:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2690 "parser.y"
+#line 2687 "parser.y"
     {
     PASS12
     (yyvsp[(1) - (8)].flags).flags |= FLAG_PUBLIC;
@@ -5809,122 +6294,131 @@ PASS2
 
 
   
-    case 161:
+    case 167:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2705 "parser.y"
-    {setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}
+#line 2762 "parser.y"
+    {PASS12 setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}
     }
     break;
 
 
   
-    case 162:
+    case 168:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2705 "parser.y"
-    {(yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}
+#line 2762 "parser.y"
+    {PASS12 (yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}
     }
     break;
 
 
   
-    case 163:
+    case 169:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2707 "parser.y"
-    {(yyval.code) = (yyvsp[(1) - (1)].code);}
+#line 2764 "parser.y"
+    {PASS12 (yyval.code)=0;}
     }
     break;
 
 
   
-    case 164:
+    case 170:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2708 "parser.y"
-    {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
+#line 2765 "parser.y"
+    {PASS12 (yyval.code)=0;}
     }
     break;
 
 
   
-    case 165:
+    case 171:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2711 "parser.y"
+#line 2768 "parser.y"
     {
+PASS12
     int flags = slotstate_flags->flags;
     namespace_t ns = modifiers2access(slotstate_flags);
 
-    varinfo_t* info = 0;
-    if(state->cls) {
-        memberinfo_t*i = registry_findmember(state->cls->info, ns.name, (yyvsp[(1) - (3)].id), 1);
-        if(i) {
-            check_override(i, flags);
-        }
-        info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, (yyvsp[(1) - (3)].id));
-    } else {
-        slotinfo_t*i = registry_find(state->package, (yyvsp[(1) - (3)].id));
-        if(i) {
-            syntaxerror("package %s already contains '%s'", state->package, (yyvsp[(1) - (3)].id));
-        }
-        if(ns.name && ns.name[0]) {
-            syntaxerror("namespaces not allowed on package-level variables");
+    if(as3_pass == 1) {
+
+        varinfo_t* info = 0;
+        if(state->cls) {
+            memberinfo_t*i = registry_findmember(state->cls->info, ns.name, (yyvsp[(1) - (3)].id), 1, slotstate_flags->flags&FLAG_STATIC);
+            if(i) {
+                check_override(i, flags);
+            }
+            info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, (yyvsp[(1) - (3)].id), slotstate_flags->flags&FLAG_STATIC);
+        } else {
+            slotinfo_t*i = registry_find(state->package, (yyvsp[(1) - (3)].id));
+            if(i) {
+                syntaxerror("package %s already contains '%s'", state->package, (yyvsp[(1) - (3)].id));
+            }
+            if(ns.name && ns.name[0]) {
+                syntaxerror("namespaces not allowed on package-level variables");
+            }
+            info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));
         }
-        info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));
+
+        info->type = (yyvsp[(2) - (3)].classinfo);
+        info->flags = flags;
+        
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);
     }
 
-    info->type = (yyvsp[(2) - (3)].classinfo);
-    info->flags = flags;
+    if(as3_pass == 2) {
+        varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
 
-    /* slot name */
-    multiname_t mname = {QNAME, &ns, 0, (yyvsp[(1) - (3)].id)};
-  
-    trait_list_t**traits;
-    code_t**code;
-    if(!state->cls) {
-        // global variable
-        ns.name = state->package;
-        traits = &global->init->traits;
-        code = &global->init->method->body->code;
-    } else if(flags&FLAG_STATIC) {
-        // static variable
-        traits = &state->cls->abc->static_traits;
-        code = &state->cls->static_init->header;
-    } else {
-        // instance variable
-        traits = &state->cls->abc->traits;
-        code = &state->cls->init->header;
-    }
-    
-    trait_t*t=0;
-    if((yyvsp[(2) - (3)].classinfo)) {
-        MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
-        t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
-    } else {
-        t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
-    }
-    info->slot = t->slot_id;
-    
-    /* initalization code (if needed) */
-    code_t*c = 0;
-    if((yyvsp[(3) - (3)].value).c && !is_pushundefined((yyvsp[(3) - (3)].value).c)) {
-        c = abc_getlocal_0(c);
-        c = code_append(c, (yyvsp[(3) - (3)].value).c);
-        c = converttype(c, (yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo));
-        c = abc_setslot(c, t->slot_id);
-    }
+        multiname_t mname;
+        code_t**code;
+        trait_t*t = add_abc_slot(slotstate_flags, (yyvsp[(1) - (3)].id), &mname, &code);
 
-    *code = code_append(*code, c);
+        if((yyvsp[(2) - (3)].classinfo)) {
+            MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
+            t->type_name = multiname_clone(&m);
+        }
+        info->slot = t->slot_id;
+        
+        /* workaround for "VerifyError: Error #1053: Illegal override of ::test2 in C1" 
+           FIXME: is there a way to use slots and still don't have conflicting overrides?
+        */
+        info->slot = t->slot_id = 0;
+       
+        constant_t cval = (yyvsp[(3) - (3)].node)->type->eval((yyvsp[(3) - (3)].node));
+        if(cval.type!=CONSTANT_UNKNOWN) {
+            /* compile time constant */
+            t->value = malloc(sizeof(constant_t));
+            memcpy(t->value, &cval, sizeof(constant_t));
+            info->value = constant_clone(t->value);
+        } else {
+            typedcode_t v = node_read((yyvsp[(3) - (3)].node));
+            /* initalization code (if needed) */
+            code_t*c = 0;
+            if(v.c && !is_pushundefined(v.c)) {
+                c = abc_getlocal_0(c);
+                c = code_append(c, v.c);
+                c = converttype(c, v.t, (yyvsp[(2) - (3)].classinfo));
+                if(!t->slot_id) {
+                    c = abc_initproperty2(c, &mname);
+                } else {
+                    c = abc_setslot(c, t->slot_id);
+                }
+            }
+            *code = code_append(*code, c);
+        }
 
-    if(slotstate_varconst==KW_CONST) {
-        t->kind= TRAIT_CONST;
+        if(slotstate_varconst==KW_CONST) {
+            t->kind= TRAIT_CONST;
+            info->flags |= FLAG_CONST;
+        }
     }
 
     (yyval.code)=0;
@@ -5934,342 +6428,714 @@ PASS2
 
 
   
-    case 166:
+    case 172:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2785 "parser.y"
+#line 2851 "parser.y"
     {(yyval.constant)=0;}
     }
     break;
 
 
   
-    case 167:
+    case 173:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2786 "parser.y"
-    {(yyval.constant)=(yyvsp[(2) - (2)].constant);}
+#line 2852 "parser.y"
+    {
+  (yyval.constant) = malloc(sizeof(constant_t));
+  *(yyval.constant) = node_eval((yyvsp[(2) - (2)].node));
+  if((yyval.constant)->type == CONSTANT_UNKNOWN) {
+    syntaxerror("can't evaluate default parameter value (needs to be a compile-time constant)");
+  }
+}
     }
     break;
 
 
   
-    case 168:
+    case 174:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2788 "parser.y"
-    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_uint));}
+#line 2860 "parser.y"
+    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
     }
     break;
 
 
   
-    case 169:
+    case 175:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2789 "parser.y"
-    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
+#line 2861 "parser.y"
+    {
+    (yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));
+}
     }
     break;
 
 
   
-    case 170:
+    case 176:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2790 "parser.y"
-    {(yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));}
+#line 2864 "parser.y"
+    {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
     }
     break;
 
 
   
-    case 171:
+    case 177:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2791 "parser.y"
-    {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
+#line 2865 "parser.y"
+    {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);free((char*)(yyvsp[(1) - (1)].str).str);}
     }
     break;
 
 
   
-    case 172:
+    case 178:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2792 "parser.y"
-    {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);free((char*)(yyvsp[(1) - (1)].str).str);}
+#line 2866 "parser.y"
+    {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
     }
     break;
 
 
   
-    case 173:
+    case 179:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2794 "parser.y"
-    {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
+#line 2867 "parser.y"
+    {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
     }
     break;
 
 
   
-    case 174:
+    case 180:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2795 "parser.y"
-    {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
+#line 2868 "parser.y"
+    {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
     }
     break;
 
 
   
-    case 175:
+    case 181:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2796 "parser.y"
-    {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
+#line 2869 "parser.y"
+    {(yyval.constant) = constant_new_undefined((yyvsp[(1) - (1)].token));}
     }
     break;
 
 
   
-    case 176:
+    case 182:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2797 "parser.y"
-    {
-    if(!strcmp((yyvsp[(1) - (1)].id), "NaN")) {
-        (yyval.constant) = constant_new_float(__builtin_nan(""));
-    } else {
-        as3_warning("Couldn't evaluate constant value of %s", (yyvsp[(1) - (1)].id));
-        (yyval.constant) = constant_new_null((yyvsp[(1) - (1)].id));
-    }
-}
+#line 2870 "parser.y"
+    {(yyval.constant) = constant_new_float(__builtin_nan(""));}
     }
     break;
 
 
   
-    case 177:
+    case 183:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2809 "parser.y"
+#line 2878 "parser.y"
     {
-    PASS12
-    memset(&(yyval.params),0,sizeof((yyval.params)));
+   multiname_t m = {QNAME, &stdns, 0, "XML"};
+   typedcode_t v;
+   v.c = 0;
+   v.c = abc_getlex2(v.c, &m);
+   v.c = code_append(v.c, node_read((yyvsp[(1) - (1)].node)).c);
+   v.c = abc_construct(v.c, 1);
+   v.t = TYPE_XML;
+   (yyval.node) = mkcodenode(v);
 }
     }
     break;
 
 
   
-    case 178:
+    case 184:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2813 "parser.y"
-    {
-    PASS12
-    (yyval.params)=(yyvsp[(1) - (1)].params);
-}
+#line 2889 "parser.y"
+    {PASS_ALWAYS if(!xml_level++) tokenizer_begin_xml();}
     }
     break;
 
 
   
-    case 179:
+    case 185:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2819 "parser.y"
-    {
-    PASS12
-    memset(&(yyval.params),0,sizeof((yyval.params)));
-    (yyval.params).varargs=1;
-    list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
-}
+#line 2890 "parser.y"
+    {PASS_ALWAYS tokenizer_begin_xmltext();}
     }
     break;
 
 
   
-    case 180:
+    case 186:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2825 "parser.y"
-    {
-    PASS12
-    (yyval.params) =(yyvsp[(1) - (4)].params);
-    (yyval.params).varargs=1;
-    list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
-}
+#line 2891 "parser.y"
+    {PASS_ALWAYS if(!--xml_level) tokenizer_end_xml(); else tokenizer_begin_xmltext();}
     }
     break;
 
 
   
-    case 181:
+    case 187:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2833 "parser.y"
-    {
-    PASS12
-    (yyval.params) = (yyvsp[(1) - (3)].params);
-    list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
-}
+#line 2893 "parser.y"
+    {PASS_ALWAYS tokenizer_begin_xmltext();}
     }
     break;
 
 
   
-    case 182:
+    case 188:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2838 "parser.y"
+#line 2893 "parser.y"
     {
-    PASS12
-    memset(&(yyval.params),0,sizeof((yyval.params)));
-    list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
+    (yyval.node) = (yyvsp[(2) - (4)].node);
 }
     }
     break;
 
 
   
-    case 183:
+    case 189:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2844 "parser.y"
-    {
-     PASS12
-     (yyval.param) = rfx_calloc(sizeof(param_t));
-     (yyval.param)->name=(yyvsp[(1) - (4)].id);
-     (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
-     PASS2
-     (yyval.param)->value = (yyvsp[(4) - (4)].constant);
-}
+#line 2896 "parser.y"
+    {PASS_ALWAYS tokenizer_begin_xml();}
     }
     break;
 
 
   
-    case 184:
+    case 190:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2852 "parser.y"
+#line 2896 "parser.y"
     {
-     PASS12
-     (yyval.param) = rfx_calloc(sizeof(param_t));
-     (yyval.param)->name=(yyvsp[(1) - (2)].id);
-     (yyval.param)->type = TYPE_ANY;
-     PASS2
-     (yyval.param)->value = (yyvsp[(2) - (2)].constant);
+    (yyval.node) = (yyvsp[(2) - (4)].node);
 }
     }
     break;
 
 
   
-    case 187:
+    case 191:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2862 "parser.y"
-    {PASS12 (yyval.token)=0;}
+#line 2899 "parser.y"
+    {(yyval.node)=mkstringnode("");}
     }
     break;
 
 
   
-    case 188:
+    case 192:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2865 "parser.y"
-    {PASS12 startfunction(&(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
+#line 2900 "parser.y"
+    {
+    (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
+}
     }
     break;
 
 
   
-    case 189:
+    case 193:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2866 "parser.y"
+#line 2903 "parser.y"
     {
-    PASS1 
-    endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),0,0);
-    PASS2
-    if(!state->method->info) syntaxerror("internal error");
-    
-    code_t*c = method_header(state->method);
-    c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));
-
-    endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
-    PASS12
-    list_deep_free((yyvsp[(6) - (12)].params).list);
-    (yyval.code)=0;
+    char* str = string_cstr(&(yyvsp[(2) - (2)].str));
+    (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),mkstringnode(str));
+    free(str);
 }
     }
     break;
 
 
   
-    case 191:
+    case 194:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2882 "parser.y"
-    {PASS12 (yyval.id)=0;}
+#line 2908 "parser.y"
+    {
+    (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkstringnode(">"));
+}
     }
     break;
 
 
   
-    case 192:
+    case 195:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2884 "parser.y"
-    {PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
+#line 2911 "parser.y"
+    {
+    (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
+}
     }
     break;
 
 
   
-    case 193:
+    case 196:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2885 "parser.y"
+#line 2914 "parser.y"
     {
-    PASS1
-    endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),0,0);
-    PASS2
-    methodinfo_t*f = state->method->info;
-    if(!f || !f->kind) syntaxerror("internal error");
-    
-    code_t*c = method_header(state->method);
-    c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));
+    (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node)));
+}
+    }
+    break;
+
+
+  
+    case 197:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2917 "parser.y"
+    {
+    (yyval.node) = mkstringnode((yyvsp[(1) - (1)].id));
+}
+    }
+    break;
+
+
+  
+    case 198:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2920 "parser.y"
+    {
+    (yyval.node) = (yyvsp[(1) - (1)].node);
+}
+    }
+    break;
+
+
+  
+    case 199:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2924 "parser.y"
+    {
+    (yyval.node) = mkstringnode("");
+}
+    }
+    break;
+
+
+  
+    case 200:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2927 "parser.y"
+    {
+    (yyval.node) = mkaddnode(mkstringnode(" "),(yyvsp[(1) - (1)].node));
+}
+    }
+    break;
+
+
+  
+    case 201:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2931 "parser.y"
+    {
+    //$$ = allocprintf("<%s%s/>", $2, $3, $5, $8);
+    (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkstringnode("<"),(yyvsp[(2) - (6)].node)),(yyvsp[(3) - (6)].node)),mkstringnode("/>"));
+}
+    }
+    break;
+
+
+  
+    case 202:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2935 "parser.y"
+    {
+    //$$ = allocprintf("<%s%s>%s</%s>", $2, $3, $5, $8);
+    (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
+         mkstringnode("<"),(yyvsp[(2) - (10)].node)),(yyvsp[(3) - (10)].node)),mkstringnode(">")),(yyvsp[(5) - (10)].node)),mkstringnode("</")),(yyvsp[(8) - (10)].node)),mkstringnode(">"));
+}
+    }
+    break;
+
+
+  
+    case 203:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2940 "parser.y"
+    {
+    //$$ = allocprintf("<%s%s>%s%s</%s>", $2, $3, $5, $6, $9);
+    (yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(
+         mkstringnode("<"),(yyvsp[(2) - (11)].node)),(yyvsp[(3) - (11)].node)),mkstringnode(">")),(yyvsp[(5) - (11)].node)),(yyvsp[(6) - (11)].node)),mkstringnode("</")),(yyvsp[(9) - (11)].node)),mkstringnode(">"));
+}
+    }
+    break;
+
+
+  
+    case 204:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2946 "parser.y"
+    {
+    (yyval.node) = (yyvsp[(1) - (1)].node);
+}
+    }
+    break;
+
+
+  
+    case 205:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2949 "parser.y"
+    {
+    (yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkaddnode(mkstringnode(" "),(yyvsp[(2) - (2)].node)));
+}
+    }
+    break;
+
+
+  
+    case 206:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2952 "parser.y"
+    {
+    (yyval.node) = (yyvsp[(1) - (1)].node);
+}
+    }
+    break;
+
+
+  
+    case 207:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2955 "parser.y"
+    {
+    char* str = string_cstr(&(yyvsp[(3) - (3)].str));
+    (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkstringnode(concat2("=",str)));
+    free(str);
+}
+    }
+    break;
+
+
+  
+    case 208:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2960 "parser.y"
+    {
+    (yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode(mkstringnode("=\""), mkaddnode((yyvsp[(3) - (3)].node), mkstringnode("\""))));
+}
+    }
+    break;
+
+
+  
+    case 209:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2963 "parser.y"
+    {
+    (yyval.node) = mkaddnode(mkaddnode(mkstringnode(concat2((yyvsp[(1) - (3)].id),"=\"")), (yyvsp[(3) - (3)].node)), mkstringnode("\""));
+}
+    }
+    break;
+
+
+  
+    case 210:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2966 "parser.y"
+    {
+    char* str = string_cstr(&(yyvsp[(3) - (3)].str));
+    (yyval.node)=mkstringnode(allocprintf("%s=%s", (yyvsp[(1) - (3)].id),str));
+    free(str);
+    free((yyvsp[(1) - (3)].id));free((char*)(yyvsp[(3) - (3)].str).str);
+}
+    }
+    break;
+
+
+  
+    case 211:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2976 "parser.y"
+    {
+    PASS12
+    memset(&(yyval.params),0,sizeof((yyval.params)));
+}
+    }
+    break;
+
+
+  
+    case 212:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2980 "parser.y"
+    {
+    PASS12
+    (yyval.params)=(yyvsp[(1) - (1)].params);
+}
+    }
+    break;
+
+
+  
+    case 213:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2986 "parser.y"
+    {
+    PASS12
+    memset(&(yyval.params),0,sizeof((yyval.params)));
+    (yyval.params).varargs=1;
+    list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
+}
+    }
+    break;
+
+
+  
+    case 214:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2992 "parser.y"
+    {
+    PASS12
+    (yyval.params) =(yyvsp[(1) - (4)].params);
+    (yyval.params).varargs=1;
+    list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
+}
+    }
+    break;
+
+
+  
+    case 215:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3000 "parser.y"
+    {
+    PASS12
+    (yyval.params) = (yyvsp[(1) - (3)].params);
+    list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
+}
+    }
+    break;
+
+
+  
+    case 216:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3005 "parser.y"
+    {
+    PASS12
+    memset(&(yyval.params),0,sizeof((yyval.params)));
+    list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
+}
+    }
+    break;
+
+
+  
+    case 217:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3011 "parser.y"
+    {
+     PASS12
+     (yyval.param) = rfx_calloc(sizeof(param_t));
+     (yyval.param)->name=(yyvsp[(1) - (4)].id);
+     (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
+     PASS2
+     (yyval.param)->value = (yyvsp[(4) - (4)].constant);
+}
+    }
+    break;
+
+
+  
+    case 218:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3019 "parser.y"
+    {
+     PASS12
+     (yyval.param) = rfx_calloc(sizeof(param_t));
+     (yyval.param)->name=(yyvsp[(1) - (2)].id);
+     (yyval.param)->type = TYPE_ANY;
+     PASS2
+     (yyval.param)->value = (yyvsp[(2) - (2)].constant);
+}
+    }
+    break;
+
+
+  
+    case 221:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3029 "parser.y"
+    {PASS12 (yyval.token)=0;}
+    }
+    break;
+
+
+  
+    case 222:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3032 "parser.y"
+    {PASS12 startfunction(&(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
+    }
+    break;
+
+
+  
+    case 223:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3033 "parser.y"
+    {
+    PASS1 
+    endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),0,0);
+    PASS2
+    if(!state->method->info) syntaxerror("internal error");
+    
+    code_t*c = method_header(state->method);
+    c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));
+
+    endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
+    PASS12
+    list_deep_free((yyvsp[(6) - (12)].params).list);
+    (yyval.code)=0;
+}
+    }
+    break;
+
+
+  
+    case 225:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3049 "parser.y"
+    {PASS12 (yyval.id)=0;}
+    }
+    break;
+
+
+  
+    case 226:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3051 "parser.y"
+    {PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
+    }
+    break;
+
+
+  
+    case 227:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3052 "parser.y"
+    {
+    PASS1
+    endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),0,0);
+    PASS2
+    methodinfo_t*f = state->method->info;
+    if(!f || !f->kind) syntaxerror("internal error");
+    
+    code_t*c = method_header(state->method);
+    c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));
 
     int index = state->method->var_index;
     endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);
@@ -6284,11 +7150,11 @@ PASS2
 
 
   
-    case 194:
+    case 228:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2907 "parser.y"
+#line 3074 "parser.y"
     {
     PASS1 NEW(unresolvedinfo_t,c);
           memset(c, 0, sizeof(*c));
@@ -6306,17 +7172,18 @@ PASS2
     slotinfo_t*s = find_class((yyvsp[(1) - (1)].id));
     if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", (yyvsp[(1) - (1)].id), state->package);
     (yyval.classinfo) = (classinfo_t*)s;
+    registry_use(s);
 }
     }
     break;
 
 
   
-    case 195:
+    case 229:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2926 "parser.y"
+#line 3094 "parser.y"
     {
     PASS1 NEW(unresolvedinfo_t,c);
           memset(c, 0, sizeof(*c));
@@ -6329,127 +7196,128 @@ PASS2
     if(!s) syntaxerror("Couldn't find class/method %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
     free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;
     (yyval.classinfo) = (classinfo_t*)s;
+    registry_use(s);
 }
     }
     break;
 
 
   
-    case 198:
+    case 232:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2943 "parser.y"
+#line 3112 "parser.y"
     {PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}
     }
     break;
 
 
   
-    case 199:
+    case 233:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2944 "parser.y"
+#line 3113 "parser.y"
     {PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}
     }
     break;
 
 
   
-    case 200:
+    case 234:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2946 "parser.y"
+#line 3115 "parser.y"
     {PASS12 (yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
     }
     break;
 
 
   
-    case 201:
+    case 235:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2947 "parser.y"
-    {PASS12 (yyval.classinfo)=registry_getanytype();}
+#line 3116 "parser.y"
+    {PASS12 (yyval.classinfo)=TYPE_ANY;}
     }
     break;
 
 
   
-    case 202:
+    case 236:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2948 "parser.y"
-    {PASS12 (yyval.classinfo)=registry_getanytype();}
+#line 3117 "parser.y"
+    {PASS12 (yyval.classinfo)=TYPE_VOID;}
     }
     break;
 
 
   
-    case 203:
+    case 237:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2957 "parser.y"
+#line 3126 "parser.y"
     {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
     }
     break;
 
 
   
-    case 204:
+    case 238:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2958 "parser.y"
+#line 3127 "parser.y"
     {PASS12 (yyval.classinfo)=0;}
     }
     break;
 
 
   
-    case 205:
+    case 239:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2962 "parser.y"
+#line 3131 "parser.y"
     {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
     }
     break;
 
 
   
-    case 206:
+    case 240:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2963 "parser.y"
+#line 3132 "parser.y"
     {(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
     }
     break;
 
 
   
-    case 207:
+    case 241:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2965 "parser.y"
+#line 3134 "parser.y"
     {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
     }
     break;
 
 
   
-    case 210:
+    case 244:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2969 "parser.y"
+#line 3138 "parser.y"
     {(yyval.value_list).number=1;
                                                   (yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
                                                  }
@@ -6458,22 +7326,22 @@ PASS2
 
 
   
-    case 211:
+    case 245:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2973 "parser.y"
+#line 3142 "parser.y"
     {(yyval.value_list) = (yyvsp[(1) - (2)].value_list);}
     }
     break;
 
 
   
-    case 212:
+    case 246:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2974 "parser.y"
+#line 3143 "parser.y"
     {
                                                   (yyval.value_list).number= (yyvsp[(1) - (2)].value_list).number+1;
                                                   (yyval.value_list).cc = code_append((yyvsp[(1) - (2)].value_list).cc, (yyvsp[(2) - (2)].value).c);
@@ -6483,13 +7351,14 @@ PASS2
 
 
   
-    case 214:
+    case 248:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 2980 "parser.y"
+#line 3149 "parser.y"
     {
-    (yyval.value).c = (yyvsp[(2) - (4)].value).c;
+    typedcode_t v = node_read((yyvsp[(2) - (4)].node));
+    (yyval.value).c = v.c;
     if((yyval.value).c->opcode == OPCODE_COERCE_A) (yyval.value).c = code_cutlast((yyval.value).c);
     
     code_t*paramcode = (yyvsp[(4) - (4)].value_list).cc;
@@ -6499,21 +7368,31 @@ PASS2
         (yyval.value).c = code_append((yyval.value).c, paramcode);
         (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);
         multiname_destroy(name);
-    } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
-        int slot = (int)(ptroff_t)(yyval.value).c->data[0];
+    } else if(is_getlocal((yyval.value).c)) {
+        (yyval.value).c = code_append((yyval.value).c, paramcode);
+        (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
+    } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
+        code_free((yyval.value).c);
+        classinfo_t*c = v.t->data;
+        MULTINAME(m, c);
+        (yyval.value).c = abc_findpropstrict2(0, &m);
+        (yyval.value).c = code_append((yyval.value).c, paramcode);
+        (yyval.value).c = abc_constructprop2((yyval.value).c, &m, (yyvsp[(4) - (4)].value_list).number);
+    /*} else if($$.c->opcode == OPCODE_GETSLOT) {
+        int slot = (int)(ptroff_t)$$.c->data[0];
         trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);//FIXME
         multiname_t*name = t->name;
-        (yyval.value).c = code_cutlast((yyval.value).c);
-        (yyval.value).c = code_append((yyval.value).c, paramcode);
-        (yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);
+        $$.c = code_cutlast($$.c);
+        $$.c = code_append($$.c, paramcode);
+        $$.c = abc_constructprop2($$.c, name, $4.number);*/
     } else {
         (yyval.value).c = code_append((yyval.value).c, paramcode);
         (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);
     }
    
     (yyval.value).t = TYPE_ANY;
-    if(TYPE_IS_CLASS((yyvsp[(2) - (4)].value).t) && (yyvsp[(2) - (4)].value).t->data) {
-        (yyval.value).t = (yyvsp[(2) - (4)].value).t->data;
+    if(TYPE_IS_CLASS(v.t) && v.t->data) {
+        (yyval.value).t = v.t->data;
     } else {
         (yyval.value).c = abc_coerce_a((yyval.value).c);
         (yyval.value).t = TYPE_ANY;
@@ -6524,14 +7403,15 @@ PASS2
 
 
   
-    case 215:
+    case 249:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3016 "parser.y"
+#line 3196 "parser.y"
     {
-    
-    (yyval.value).c = (yyvsp[(1) - (4)].value).c;
+   
+    typedcode_t v = node_read((yyvsp[(1) - (4)].node));
+    (yyval.value).c = v.c;
     if((yyval.value).c->opcode == OPCODE_COERCE_A) {
         (yyval.value).c = code_cutlast((yyval.value).c);
     }
@@ -6544,17 +7424,17 @@ PASS2
         (yyval.value).c = code_append((yyval.value).c, paramcode);
         (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
         multiname_destroy(name);
-    } else if((yyval.value).c->opcode == OPCODE_GETSLOT && (yyval.value).c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
-        int slot = (int)(ptroff_t)(yyval.value).c->data[0];
+/*    } else if($$.c->opcode == OPCODE_GETSLOT && $$.c->prev->opcode != OPCODE_GETSCOPEOBJECT) {
+        int slot = (int)(ptroff_t)$$.c->data[0];
         trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);
         if(t->kind!=TRAIT_METHOD) {
             //ok: flash allows to assign closures to members.
         }
         multiname_t*name = t->name;
-        (yyval.value).c = code_cutlast((yyval.value).c);
-        (yyval.value).c = code_append((yyval.value).c, paramcode);
+        $$.c = code_cutlast($$.c);
+        $$.c = code_append($$.c, paramcode);
         //$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding
-        (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
+        $$.c = abc_callproperty2($$.c, name, $3.number);*/
     } else if((yyval.value).c->opcode == OPCODE_GETSUPER) {
         multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
         (yyval.value).c = code_cutlast((yyval.value).c);
@@ -6567,11 +7447,14 @@ PASS2
         (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
     }
    
-    if(TYPE_IS_FUNCTION((yyvsp[(1) - (4)].value).t) && (yyvsp[(1) - (4)].value).t->data) {
-        (yyval.value).t = ((methodinfo_t*)((yyvsp[(1) - (4)].value).t->data))->return_type;
+    if(TYPE_IS_FUNCTION(v.t) && v.t->data) {
+        (yyval.value).t = ((methodinfo_t*)(v.t->data))->return_type;
+    } else if(TYPE_IS_CLASS(v.t) && v.t->data) {
+        // calling a class is like a typecast
+        (yyval.value).t = (classinfo_t*)v.t->data;
     } else {
-        (yyval.value).c = abc_coerce_a((yyval.value).c);
         (yyval.value).t = TYPE_ANY;
+        (yyval.value).c = abc_coerce_a((yyval.value).c);
     }
 }
     }
@@ -6579,11 +7462,11 @@ PASS2
 
 
   
-    case 216:
+    case 250:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3062 "parser.y"
+#line 3246 "parser.y"
     {
     if(!state->cls) syntaxerror("super() not allowed outside of a class");
     if(!state->method) syntaxerror("super() not allowed outside of a function");
@@ -6609,13 +7492,14 @@ PASS2
 
 
   
-    case 217:
+    case 251:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3083 "parser.y"
+#line 3267 "parser.y"
     {
-    (yyval.value).c = (yyvsp[(2) - (2)].value).c;
+    typedcode_t v = node_read((yyvsp[(2) - (2)].node));
+    (yyval.value).c = v.c;
     if((yyval.value).c->opcode == OPCODE_COERCE_A) {
         (yyval.value).c = code_cutlast((yyval.value).c);
     }
@@ -6629,7 +7513,7 @@ PASS2
         (yyval.value).c = abc_deleteproperty2((yyval.value).c, name);
     } else {
         (yyval.value).c = abc_getlocal_0((yyval.value).c);
-        MULTINAME_LATE(m, (yyvsp[(2) - (2)].value).t?(yyvsp[(2) - (2)].value).t->access:ACCESS_PACKAGE, "");
+        MULTINAME_LATE(m, v.t?v.t->access:ACCESS_PACKAGE, "");
         (yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
     }
     (yyval.value).t = TYPE_BOOLEAN;
@@ -6639,11 +7523,11 @@ PASS2
 
 
   
-    case 218:
+    case 252:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3104 "parser.y"
+#line 3289 "parser.y"
     {
     (yyval.code) = abc_returnvoid(0);
 }
@@ -6652,11 +7536,11 @@ PASS2
 
 
   
-    case 219:
+    case 253:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3107 "parser.y"
+#line 3292 "parser.y"
     {
     (yyval.code) = (yyvsp[(2) - (2)].value).c;
     (yyval.code) = abc_returnvalue((yyval.code));
@@ -6666,1295 +7550,1263 @@ PASS2
 
 
   
-    case 220:
+    case 254:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3114 "parser.y"
-    {(yyval.value)=(yyvsp[(1) - (1)].value);}
+#line 3299 "parser.y"
+    {
+    (yyval.value) = node_read((yyvsp[(1) - (1)].node));
+}
     }
     break;
 
 
   
-    case 221:
+    case 255:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3115 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3302 "parser.y"
+    {
+    (yyval.value) = node_read((yyvsp[(1) - (1)].node));
+}
     }
     break;
 
 
   
-    case 222:
+    case 256:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3116 "parser.y"
+#line 3305 "parser.y"
     {
-    (yyval.value).c = (yyvsp[(1) - (3)].value).c;
-    (yyval.value).c = cut_last_push((yyval.value).c);
-    (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
-    (yyval.value).t = (yyvsp[(3) - (3)].value).t;
+    (yyval.node) = mkmultinode(&node_comma, (yyvsp[(1) - (1)].node));
 }
     }
     break;
 
 
   
-    case 223:
+    case 257:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3122 "parser.y"
+#line 3308 "parser.y"
     {
-    (yyval.code)=cut_last_push((yyvsp[(1) - (1)].value).c);
+    (yyval.node) = multinode_extend((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
 }
     }
     break;
 
 
   
-    case 224:
+    case 258:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3128 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3311 "parser.y"
+    { 
+    (yyval.code) = node_exec((yyvsp[(1) - (1)].node)); 
+}
     }
     break;
 
 
   
-    case 226:
+    case 259:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3132 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3314 "parser.y"
+    { 
+    (yyval.code) = (yyvsp[(1) - (3)].code);
+    (yyval.code) = code_append((yyval.code), node_exec((yyvsp[(3) - (3)].node))); 
+}
     }
     break;
 
 
   
-    case 227:
+    case 260:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3134 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3319 "parser.y"
+    {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
     }
     break;
 
 
   
-    case 228:
+    case 261:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3320 "parser.y"
+    {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
+    }
+    break;
+
+
+  
+    case 262:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3322 "parser.y"
+    {(yyval.code)=abc_pushstring(0,(yyvsp[(1) - (1)].id));}
+    }
+    break;
+
+
+  
+    case 263:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3323 "parser.y"
+    {(yyval.code)=abc_pushstring2(0,&(yyvsp[(1) - (1)].str));}
+    }
+    break;
+
+
+  
+    case 264:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3324 "parser.y"
+    {syntaxerror("dictionary keys must be strings");}
+    }
+    break;
+
+
+  
+    case 265:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3325 "parser.y"
+    {syntaxerror("dictionary keys must be strings");}
+    }
+    break;
+
+
+  
+    case 266:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3136 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+#line 3326 "parser.y"
+    {syntaxerror("dictionary keys must be strings");}
     }
     break;
 
 
   
-    case 230:
+    case 267:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3140 "parser.y"
+#line 3328 "parser.y"
     {
-    (yyval.value).c = 0;
-    namespace_t ns = {ACCESS_PACKAGE, ""};
-    multiname_t m = {QNAME, &ns, 0, "RegExp"};
-    if(!(yyvsp[(1) - (1)].regexp).options) {
-        (yyval.value).c = abc_getlex2((yyval.value).c, &m);
-        (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).pattern);
-        (yyval.value).c = abc_construct((yyval.value).c, 1);
-    } else {
-        (yyval.value).c = abc_getlex2((yyval.value).c, &m);
-        (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).pattern);
-        (yyval.value).c = abc_pushstring((yyval.value).c, (yyvsp[(1) - (1)].regexp).options);
-        (yyval.value).c = abc_construct((yyval.value).c, 2);
+    (yyval.value_list).cc = 0;
+    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].code));
+    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);
+    (yyval.value_list).number = 2;
+}
+    }
+    break;
+
+
+  
+    case 268:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3334 "parser.y"
+    {
+    (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
+    (yyval.value_list).number = (yyvsp[(1) - (5)].value_list).number+2;
+    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].code));
+    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);
+}
+    }
+    break;
+
+
+  
+    case 269:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3343 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
+    break;
+
+
+  
+    case 270:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3344 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
+    break;
+
+
+  
+    case 271:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3345 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
+    break;
+
+
+  
+    case 272:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3346 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
+    break;
+
+
+  
+    case 273:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3347 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
+    break;
+
+
+  
+    case 274:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3348 "parser.y"
+    {(yyval.node) = (yyvsp[(1) - (1)].node);}
+    }
+    break;
+
+
+  
+    case 275:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3350 "parser.y"
+    { 
+    (yyval.node) = mkconstnode((yyvsp[(1) - (1)].constant));
+}
     }
-    (yyval.value).t = TYPE_REGEXP;
+    break;
+
+
+  
+    case 276:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3354 "parser.y"
+    {
+    (yyval.node) = (yyvsp[(1) - (1)].node);
 }
     }
     break;
 
 
   
-    case 231:
+    case 277:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3157 "parser.y"
-    {(yyval.value).c = abc_pushbyte(0, (yyvsp[(1) - (1)].number_uint));
-                   //MULTINAME(m, registry_getintclass());
-                   //$$.c = abc_coerce2($$.c, &m); // FIXME
-                   (yyval.value).t = TYPE_INT;
-                  }
+#line 3359 "parser.y"
+    {
+    typedcode_t v;
+    v.c = 0;
+    multiname_t m = {QNAME, &stdns, 0, "RegExp"};
+    if(!(yyvsp[(1) - (1)].regexp).options) {
+        v.c = abc_getlex2(v.c, &m);
+        v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
+        v.c = abc_construct(v.c, 1);
+    } else {
+        v.c = abc_getlex2(v.c, &m);
+        v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);
+        v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).options);
+        v.c = abc_construct(v.c, 2);
+    }
+    v.t = TYPE_REGEXP;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 232:
+    case 278:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3162 "parser.y"
-    {(yyval.value).c = abc_pushshort(0, (yyvsp[(1) - (1)].number_uint));
-                    (yyval.value).t = TYPE_INT;
-                   }
+#line 3377 "parser.y"
+    {
+    PASS1
+    state->method->need_arguments = 1;
+    PASS2
+    typedcode_t v;
+    v.c = abc_getlocal(0, state->method->need_arguments);
+    v.t = TYPE_ARRAY;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 233:
+    case 279:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3165 "parser.y"
-    {(yyval.value).c = abc_pushint(0, (yyvsp[(1) - (1)].number_int));
-                  (yyval.value).t = TYPE_INT;
-                 }
+#line 3388 "parser.y"
+    {
+    typedcode_t v;
+    v.c = code_new();
+    v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
+    v.c = abc_newarray(v.c, (yyvsp[(2) - (3)].value_list).number);
+    v.t = registry_getarrayclass();
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 234:
+    case 280:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3168 "parser.y"
-    {(yyval.value).c = abc_pushuint(0, (yyvsp[(1) - (1)].number_uint));
-                   (yyval.value).t = TYPE_UINT;
-                  }
+#line 3398 "parser.y"
+    {
+    typedcode_t v;
+    v.c = code_new();
+    v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);
+    v.c = abc_newobject(v.c, (yyvsp[(2) - (3)].value_list).number/2);
+    v.t = registry_getobjectclass();
+    (yyval.node) =  mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 235:
+    case 281:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3171 "parser.y"
-    {(yyval.value).c = abc_pushdouble(0, (yyvsp[(1) - (1)].number_float));
-                    (yyval.value).t = TYPE_FLOAT;
-                   }
+#line 3407 "parser.y"
+    {(yyval.node) = mknode2(&node_lt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 236:
+    case 282:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3174 "parser.y"
-    {(yyval.value).c = abc_pushstring2(0, &(yyvsp[(1) - (1)].str));free((char*)(yyvsp[(1) - (1)].str).str);
-                     (yyval.value).t = TYPE_STRING;
-                    }
+#line 3408 "parser.y"
+    {(yyval.node) = mknode2(&node_gt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 237:
+    case 283:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3177 "parser.y"
-    {(yyval.value).c = abc_pushundefined(0);
-                    (yyval.value).t = TYPE_ANY;
-                   }
+#line 3409 "parser.y"
+    {(yyval.node) = mknode2(&node_le,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 238:
+    case 284:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3180 "parser.y"
-    {(yyval.value).c = abc_pushtrue(0);
-                    (yyval.value).t = TYPE_BOOLEAN;
-                   }
+#line 3410 "parser.y"
+    {(yyval.node) = mknode2(&node_ge,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 239:
+    case 285:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3183 "parser.y"
-    {(yyval.value).c = abc_pushfalse(0);
-                     (yyval.value).t = TYPE_BOOLEAN;
-                    }
+#line 3411 "parser.y"
+    {(yyval.node) = mknode2(&node_eqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 240:
+    case 286:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3186 "parser.y"
-    {(yyval.value).c = abc_pushnull(0);
-                    (yyval.value).t = TYPE_NULL;
-                   }
+#line 3412 "parser.y"
+    {(yyval.node) = mknode2(&node_eqeqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 241:
+    case 287:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3190 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterequals((yyval.value).c);(yyval.value).c=abc_not((yyval.value).c);
-             (yyval.value).t = TYPE_BOOLEAN;
-            }
+#line 3413 "parser.y"
+    {(yyval.node) = mknode2(&node_noteqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 242:
+    case 288:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3193 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterthan((yyval.value).c);
-             (yyval.value).t = TYPE_BOOLEAN;
-            }
+#line 3414 "parser.y"
+    {(yyval.node) = mknode2(&node_noteq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 243:
+    case 289:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3196 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterthan((yyval.value).c);(yyval.value).c=abc_not((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3415 "parser.y"
+    {(yyval.node) = mknode2(&node_oror,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 244:
+    case 290:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3199 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_greaterequals((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3416 "parser.y"
+    {(yyval.node) = mknode2(&node_andand,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 245:
+    case 291:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3202 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_equals((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3417 "parser.y"
+    {(yyval.node) = mknode1(&node_not, (yyvsp[(2) - (2)].node));}
     }
     break;
 
 
   
-    case 246:
+    case 292:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3205 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_strictequals((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-              }
+#line 3418 "parser.y"
+    {(yyval.node) = mknode1(&node_bitnot, (yyvsp[(2) - (2)].node));}
     }
     break;
 
 
   
-    case 247:
+    case 293:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3208 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_strictequals((yyval.value).c);(yyval.value).c = abc_not((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3419 "parser.y"
+    {(yyval.node) = mknode2(&node_bitand, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 248:
+    case 294:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3211 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);(yyval.value).c = abc_equals((yyval.value).c);(yyval.value).c = abc_not((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3420 "parser.y"
+    {(yyval.node) = mknode2(&node_bitxor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 249:
+    case 295:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3215 "parser.y"
-    {(yyval.value).t = join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'O');
-              (yyval.value).c = (yyvsp[(1) - (3)].value).c;
-              (yyval.value).c = converttype((yyval.value).c, (yyvsp[(1) - (3)].value).t, (yyval.value).t);
-              (yyval.value).c = abc_dup((yyval.value).c);
-              code_t*jmp = (yyval.value).c = abc_iftrue((yyval.value).c, 0);
-              (yyval.value).c = cut_last_push((yyval.value).c);
-              (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
-              (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (3)].value).t, (yyval.value).t);
-              code_t*label = (yyval.value).c = abc_label((yyval.value).c);
-              jmp->branch = label;
-             }
+#line 3421 "parser.y"
+    {(yyval.node) = mknode2(&node_bitor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 250:
+    case 296:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3226 "parser.y"
-    {
-              (yyval.value).t = join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'A');
-              /*printf("%08x:\n",$1.t);
-              code_dump($1.c, 0, 0, "", stdout);
-              printf("%08x:\n",$3.t);
-              code_dump($3.c, 0, 0, "", stdout);
-              printf("joining %08x and %08x to %08x\n", $1.t, $3.t, $$.t);*/
-              (yyval.value).c = (yyvsp[(1) - (3)].value).c;
-              (yyval.value).c = converttype((yyval.value).c, (yyvsp[(1) - (3)].value).t, (yyval.value).t);
-              (yyval.value).c = abc_dup((yyval.value).c);
-              code_t*jmp = (yyval.value).c = abc_iffalse((yyval.value).c, 0);
-              (yyval.value).c = cut_last_push((yyval.value).c);
-              (yyval.value).c = code_append((yyval.value).c,(yyvsp[(3) - (3)].value).c);
-              (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (3)].value).t, (yyval.value).t);
-              code_t*label = (yyval.value).c = abc_label((yyval.value).c);
-              jmp->branch = label;              
-             }
+#line 3422 "parser.y"
+    {(yyval.node) = mknode2(&node_shr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 251:
+    case 297:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3244 "parser.y"
-    {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
-              (yyval.value).c = abc_not((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3423 "parser.y"
+    {(yyval.node) = mknode2(&node_ushr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 252:
+    case 298:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3249 "parser.y"
-    {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
-              (yyval.value).c = abc_bitnot((yyval.value).c);
-              (yyval.value).t = TYPE_INT;
-             }
+#line 3424 "parser.y"
+    {(yyval.node) = mknode2(&node_shl, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 253:
+    case 299:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3254 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_bitand((yyval.value).c);
-             (yyval.value).t = TYPE_INT;
-            }
+#line 3425 "parser.y"
+    {(yyval.node) = mknode2(&node_div, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 254:
+    case 300:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3259 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_bitxor((yyval.value).c);
-             (yyval.value).t = TYPE_INT;
-            }
+#line 3426 "parser.y"
+    {(yyval.node) = mknode2(&node_mod, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 255:
+    case 301:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3264 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_bitor((yyval.value).c);
-             (yyval.value).t = TYPE_INT;
-            }
+#line 3427 "parser.y"
+    {(yyval.node) = mknode2(&node_plus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 256:
+    case 302:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3269 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_rshift((yyval.value).c);
-             (yyval.value).t = TYPE_INT;
-            }
+#line 3428 "parser.y"
+    {(yyval.node) = mknode2(&node_minus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 257:
+    case 303:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3273 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_urshift((yyval.value).c);
-             (yyval.value).t = TYPE_INT;
-            }
+#line 3429 "parser.y"
+    {(yyval.node) = mknode2(&node_multiply, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 258:
+    case 304:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3277 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_lshift((yyval.value).c);
-             (yyval.value).t = TYPE_INT;
-            }
+#line 3430 "parser.y"
+    {(yyval.node) = mknode2(&node_in, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 259:
+    case 305:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3282 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_divide((yyval.value).c);
-             (yyval.value).t = TYPE_NUMBER;
-            }
+#line 3431 "parser.y"
+    {(yyval.node) = mknode2(&node_as, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 260:
+    case 306:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3286 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             (yyval.value).c = abc_modulo((yyval.value).c);
-             (yyval.value).t = TYPE_NUMBER;
-            }
+#line 3432 "parser.y"
+    {(yyval.node) = mknode2(&node_instanceof, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 261:
+    case 307:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3290 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             if(BOTH_INT((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t)) {
-                (yyval.value).c = abc_add_i((yyval.value).c);
-                (yyval.value).t = TYPE_INT;
-             } else {
-                (yyval.value).c = abc_add((yyval.value).c);
-                (yyval.value).t = join_types((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t,'+');
-             }
-            }
+#line 3433 "parser.y"
+    {(yyval.node) = mknode2(&node_is, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 262:
+    case 308:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3299 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
-                (yyval.value).c = abc_subtract_i((yyval.value).c);
-                (yyval.value).t = TYPE_INT;
-             } else {
-                (yyval.value).c = abc_subtract((yyval.value).c);
-                (yyval.value).t = TYPE_NUMBER;
-             }
-            }
+#line 3434 "parser.y"
+    {(yyval.node) = mknode1(&node_typeof, (yyvsp[(2) - (2)].node));}
     }
     break;
 
 
   
-    case 263:
+    case 309:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3308 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-             if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
-                (yyval.value).c = abc_multiply_i((yyval.value).c);
-                (yyval.value).t = TYPE_INT;
-             } else {
-                (yyval.value).c = abc_multiply((yyval.value).c);
-                (yyval.value).t = TYPE_NUMBER;
-             }
-            }
+#line 3435 "parser.y"
+    {(yyval.node) = mknode1(&node_void, (yyvsp[(2) - (2)].node));}
     }
     break;
 
 
   
-    case 264:
+    case 310:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3318 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c,(yyvsp[(3) - (3)].value).c);
-              (yyval.value).c = abc_in((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3436 "parser.y"
+    { (yyval.node) = mkconstnode(constant_new_undefined());}
     }
     break;
 
 
   
-    case 265:
+    case 311:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3323 "parser.y"
-    {char use_astype=0; // flash player's astype works differently than astypelate
-              if(use_astype && TYPE_IS_CLASS((yyvsp[(3) - (3)].value).t) && (yyvsp[(3) - (3)].value).t->data) {
-                MULTINAME(m, (classinfo_t*)((yyvsp[(3) - (3)].value).t->data));
-                (yyval.value).c = abc_astype2((yyvsp[(1) - (3)].value).c, &m);
-                (yyval.value).t = (yyvsp[(3) - (3)].value).t->data;
-              } else {
-                (yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
-                (yyval.value).c = abc_astypelate((yyval.value).c);
-                (yyval.value).t = TYPE_ANY;
-              }
-             }
+#line 3437 "parser.y"
+    { (yyval.node)=(yyvsp[(2) - (3)].node);}
     }
     break;
 
 
   
-    case 266:
+    case 312:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3336 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
-              (yyval.value).c = abc_instanceof((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3438 "parser.y"
+    {(yyval.node) = mknode1(&node_neg, (yyvsp[(2) - (2)].node));}
     }
     break;
 
 
   
-    case 267:
+    case 313:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3341 "parser.y"
-    {(yyval.value).c = code_append((yyvsp[(1) - (3)].value).c, (yyvsp[(3) - (3)].value).c);
-              (yyval.value).c = abc_istypelate((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             }
+#line 3439 "parser.y"
+    {(yyval.node) = mknode2(&node_arraylookup, (yyvsp[(1) - (4)].node),(yyvsp[(3) - (4)].node));}
     }
     break;
 
 
   
-    case 268:
+    case 314:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3346 "parser.y"
-    {
-              (yyval.value).c = (yyvsp[(3) - (4)].value).c;
-              (yyval.value).c = abc_typeof((yyval.value).c);
-              (yyval.value).t = TYPE_STRING;
-             }
+#line 3440 "parser.y"
+    {(yyval.node) = mknode2(&node_muleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 269:
+    case 315:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3352 "parser.y"
-    {
-              (yyval.value).c = cut_last_push((yyvsp[(2) - (2)].value).c);
-              (yyval.value).c = abc_pushundefined((yyval.value).c);
-              (yyval.value).t = TYPE_ANY;
-             }
+#line 3441 "parser.y"
+    {(yyval.node) = mknode2(&node_modeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 270:
+    case 316:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3358 "parser.y"
-    { (yyval.value).c = abc_pushundefined(0);
-             (yyval.value).t = TYPE_ANY;
-           }
+#line 3442 "parser.y"
+    {(yyval.node) = mknode2(&node_shleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 271:
+    case 317:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3362 "parser.y"
-    {(yyval.value)=(yyvsp[(2) - (3)].value);}
+#line 3443 "parser.y"
+    {(yyval.node) = mknode2(&node_shreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 272:
+    case 318:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3364 "parser.y"
-    {
-  (yyval.value)=(yyvsp[(2) - (2)].value);
-  if(IS_INT((yyvsp[(2) - (2)].value).t)) {
-   (yyval.value).c=abc_negate_i((yyval.value).c);
-   (yyval.value).t = TYPE_INT;
-  } else {
-   (yyval.value).c=abc_negate((yyval.value).c);
-   (yyval.value).t = TYPE_NUMBER;
-  }
-}
+#line 3444 "parser.y"
+    {(yyval.node) = mknode2(&node_ushreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 273:
+    case 319:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3375 "parser.y"
-    {
-  (yyval.value).c = (yyvsp[(1) - (4)].value).c;
-  (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value).c);
-
-  MULTINAME_LATE(m, (yyvsp[(1) - (4)].value).t?(yyvsp[(1) - (4)].value).t->access:ACCESS_PACKAGE, "");
-  (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
-  (yyval.value).t = 0; // array elements have unknown type
-}
+#line 3445 "parser.y"
+    { (yyval.node) = mknode2(&node_diveq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 274:
+    case 320:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3384 "parser.y"
-    {
-    (yyval.value).c = code_new();
-    (yyval.value).c = code_append((yyval.value).c, (yyvsp[(2) - (3)].value_list).cc);
-    (yyval.value).c = abc_newarray((yyval.value).c, (yyvsp[(2) - (3)].value_list).number);
-    (yyval.value).t = registry_getarrayclass();
-}
+#line 3446 "parser.y"
+    { (yyval.node) = mknode2(&node_bitoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 275:
+    case 321:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3391 "parser.y"
-    {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
+#line 3447 "parser.y"
+    { (yyval.node) = mknode2(&node_bitxoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 276:
+    case 322:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3392 "parser.y"
-    {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
+#line 3448 "parser.y"
+    { (yyval.node) = mknode2(&node_bitandeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 277:
+    case 323:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3394 "parser.y"
-    {
-    (yyval.value_list).cc = 0;
-    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].value).c);
-    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);
-    (yyval.value_list).number = 2;
-}
+#line 3449 "parser.y"
+    { (yyval.node) = mknode2(&node_pluseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 278:
+    case 324:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3400 "parser.y"
-    {
-    (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
-    (yyval.value_list).number = (yyvsp[(1) - (5)].value_list).number+2;
-    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].value).c);
-    (yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);
-}
+#line 3450 "parser.y"
+    { (yyval.node) = mknode2(&node_minuseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 279:
+    case 325:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3409 "parser.y"
-    {
-    (yyval.value).c = code_new();
-    (yyval.value).c = code_append((yyval.value).c, (yyvsp[(2) - (3)].value_list).cc);
-    (yyval.value).c = abc_newobject((yyval.value).c, (yyvsp[(2) - (3)].value_list).number/2);
-    (yyval.value).t = registry_getobjectclass();
-}
+#line 3451 "parser.y"
+    { (yyval.node) = mknode2(&node_assign, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
     break;
 
 
   
-    case 280:
+    case 326:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3416 "parser.y"
-    { 
-               code_t*c = (yyvsp[(3) - (3)].value).c;
-               if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
-                c=abc_multiply_i(c);
-               } else {
-                c=abc_multiply(c);
-               }
-               c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '*'), (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3452 "parser.y"
+    { (yyval.node) = mknode3(&node_tenary, (yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));}
     }
     break;
 
 
   
-    case 281:
+    case 327:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3428 "parser.y"
-    { 
-               code_t*c = abc_modulo((yyvsp[(3) - (3)].value).c);
-               c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '%'), (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3454 "parser.y"
+    { (yyval.node) = mknode1(&node_rplusplus, (yyvsp[(1) - (2)].node));}
     }
     break;
 
 
   
-    case 282:
+    case 328:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3434 "parser.y"
-    { 
-               code_t*c = abc_lshift((yyvsp[(3) - (3)].value).c);
-               c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '<'), (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3455 "parser.y"
+    { (yyval.node) = mknode1(&node_rminusminus, (yyvsp[(1) - (2)].node));}
     }
     break;
 
 
   
-    case 283:
+    case 329:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3440 "parser.y"
-    { 
-               code_t*c = abc_rshift((yyvsp[(3) - (3)].value).c);
-               c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '>'), (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3456 "parser.y"
+    {(yyval.node) = mknode1(&node_lplusplus, (yyvsp[(2) - (2)].node)); }
     }
     break;
 
 
   
-    case 284:
+    case 330:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3446 "parser.y"
-    { 
-               code_t*c = abc_urshift((yyvsp[(3) - (3)].value).c);
-               c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'U'), (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3457 "parser.y"
+    {(yyval.node) = mknode1(&node_lminusminus, (yyvsp[(2) - (2)].node)); }
     }
     break;
 
 
   
-    case 285:
+    case 331:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3452 "parser.y"
-    { 
-               code_t*c = abc_divide((yyvsp[(3) - (3)].value).c);
-               c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '/'), (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3460 "parser.y"
+    { if(!state->cls->info)
+                  syntaxerror("super keyword not allowed outside a class");
+              classinfo_t*t = state->cls->info->superclass;
+              if(!t) t = TYPE_OBJECT;
+              memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, 0);
+              MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
+              typedcode_t v;
+              v.c = 0;
+              v.c = abc_getlocal_0(v.c);
+              v.c = abc_getsuper2(v.c, &m);
+              v.t = slotinfo_gettype((slotinfo_t*)f);
+              (yyval.node) = mkcodenode(v);
+           }
     }
     break;
 
 
   
-    case 286:
+    case 332:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3458 "parser.y"
-    { 
-               code_t*c = abc_bitor((yyvsp[(3) - (3)].value).c);
-               c=converttype(c, TYPE_INT, (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3474 "parser.y"
+    {
+    typedcode_t v;
+    multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(2) - (2)].id)};
+    v.c = abc_getlex2(0, &m);
+    v.t = TYPE_STRING;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 287:
+    case 333:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3464 "parser.y"
-    { 
-               code_t*c = abc_bitxor((yyvsp[(3) - (3)].value).c);
-               c=converttype(c, TYPE_INT, (yyvsp[(1) - (3)].value).t);
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3482 "parser.y"
+    {PASS12 new_state();state->xmlfilter=1;}
     }
     break;
 
 
   
-    case 288:
+    case 334:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3470 "parser.y"
-    { 
-               code_t*c = (yyvsp[(3) - (3)].value).c;
-
-               if(TYPE_IS_INT((yyvsp[(1) - (3)].value).t)) {
-                c=abc_add_i(c);
-               } else {
-                c=abc_add(c);
-                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '+'), (yyvsp[(1) - (3)].value).t);
-               }
-               
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-              }
+#line 3482 "parser.y"
+    {
+    PASS1 old_state();
+    PASS2
+    typedcode_t v = node_read((yyvsp[(1) - (6)].node));
+    typedcode_t w = node_read((yyvsp[(5) - (6)].node));
+    code_t*c = 0;
+    int index = alloc_local();
+    int result = alloc_local();
+    int tmp = alloc_local();
+    int xml = alloc_local();
+    
+    c = code_append(c, v.c);
+    c = abc_checkfilter(c);
+    c = abc_coerce_a(c); //hasnext2 converts to *
+    c = abc_setlocal(c, xml);
+    multiname_t m = {QNAME, &stdns, 0, "XMLList"};
+    c = abc_getlex2(c, &m);
+    c = abc_construct(c, 0);
+    c = abc_setlocal(c, result);
+    c = abc_pushbyte(c, 0);
+    c = abc_setlocal(c, index);
+    code_t*jmp = c = abc_jump(c, 0);
+    code_t*loop = c = abc_label(c);
+    c = abc_getlocal(c, xml);
+    c = abc_getlocal(c, index);
+    c = abc_nextvalue(c);
+    c = abc_dup(c);
+    c = abc_setlocal(c, tmp);
+    c = abc_pushwith(c);
+    c = code_append(c, w.c);
+    c = abc_popscope(c);
+    code_t*b = c = abc_iffalse(c, 0);
+    c = abc_getlocal(c, result);
+    c = abc_getlocal(c, index);
+    c = abc_getlocal(c, tmp);
+    multiname_t m2 = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
+    c = abc_setproperty2(c, &m2);
+    c = b->branch = jmp->branch = abc_nop(c);
+    c = abc_kill(c, tmp);
+    c = abc_hasnext2(c, xml, index);
+    c = abc_iftrue(c, loop);
+    c = abc_getlocal(c, result);
+    c = abc_kill(c, xml);
+    c = abc_kill(c, result);
+    c = abc_kill(c, index);
+    
+    c = var_block(c, state->vars);
+    old_state();
+    typedcode_t r;
+    r.c = c;
+    r.t = TYPE_XMLLIST;
+    (yyval.node) = mkcodenode(r);
+}
     }
     break;
 
 
   
-    case 289:
+    case 335:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3483 "parser.y"
-    { code_t*c = (yyvsp[(3) - (3)].value).c; 
-               if(TYPE_IS_INT((yyvsp[(1) - (3)].value).t)) {
-                c=abc_subtract_i(c);
-               } else {
-                c=abc_subtract(c);
-                c=converttype(c, join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, '-'), (yyvsp[(1) - (3)].value).t);
-               }
-               
-               (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 0, 0);
-               (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-             }
+#line 3536 "parser.y"
+    {(yyval.id)=(yyvsp[(1) - (1)].id);}
     }
     break;
 
 
   
-    case 290:
+    case 336:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3494 "parser.y"
-    { code_t*c = 0;
-              c = code_append(c, (yyvsp[(3) - (3)].value).c);
-              c = converttype(c, (yyvsp[(3) - (3)].value).t, (yyvsp[(1) - (3)].value).t);
-              (yyval.value).c = toreadwrite((yyvsp[(1) - (3)].value).c, c, 1, 0);
-              (yyval.value).t = (yyvsp[(1) - (3)].value).t;
-            }
+#line 3537 "parser.y"
+    {(yyval.id)="*";}
     }
     break;
 
 
   
-    case 291:
+    case 338:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3501 "parser.y"
-    { 
-              (yyval.value).t = join_types((yyvsp[(3) - (5)].value).t,(yyvsp[(5) - (5)].value).t,'?');
-              (yyval.value).c = (yyvsp[(1) - (5)].value).c;
-              code_t*j1 = (yyval.value).c = abc_iffalse((yyval.value).c, 0);
-              (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (5)].value).c);
-              (yyval.value).c = converttype((yyval.value).c, (yyvsp[(3) - (5)].value).t, (yyval.value).t);
-              code_t*j2 = (yyval.value).c = abc_jump((yyval.value).c, 0);
-              (yyval.value).c = j1->branch = abc_label((yyval.value).c);
-              (yyval.value).c = code_append((yyval.value).c, (yyvsp[(5) - (5)].value).c);
-              (yyval.value).c = converttype((yyval.value).c, (yyvsp[(5) - (5)].value).t, (yyval.value).t);
-              (yyval.value).c = j2->branch = abc_label((yyval.value).c);
-            }
+#line 3539 "parser.y"
+    {(yyval.id)="*";}
     }
     break;
 
 
   
-    case 292:
+    case 339:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3514 "parser.y"
-    { code_t*c = 0;
-             classinfo_t*type = (yyvsp[(1) - (2)].value).t;
-             if(is_getlocal((yyvsp[(1) - (2)].value).c) && (TYPE_IS_INT((yyvsp[(1) - (2)].value).t) || TYPE_IS_NUMBER((yyvsp[(1) - (2)].value).t))) {
-                 int nr = getlocalnr((yyvsp[(1) - (2)].value).c);
-                 code_free((yyvsp[(1) - (2)].value).c);(yyvsp[(1) - (2)].value).c=0;
-                 if(TYPE_IS_INT((yyvsp[(1) - (2)].value).t)) {
-                    (yyval.value).c = abc_getlocal(0, nr);
-                    (yyval.value).c = abc_inclocal_i((yyval.value).c, nr);
-                 } else if(TYPE_IS_NUMBER((yyvsp[(1) - (2)].value).t)) {
-                    (yyval.value).c = abc_getlocal(0, nr);
-                    (yyval.value).c = abc_inclocal((yyval.value).c, nr);
-                 } else syntaxerror("internal error");
-             } else {
-                 if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
-                     c=abc_increment_i(c);
-                     type = TYPE_INT;
-                 } else {
-                     c=abc_increment(c);
-                     type = TYPE_NUMBER;
-                 }
-                 c=converttype(c, type, (yyvsp[(1) - (2)].value).t);
-                 (yyval.value).c = toreadwrite((yyvsp[(1) - (2)].value).c, c, 0, 1);
-                 (yyval.value).t = (yyvsp[(1) - (2)].value).t;
-             }
-           }
+#line 3579 "parser.y"
+    {
+    (yyval.node) = get_descendants((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].id), 0, 0);
+}
     }
     break;
 
 
   
-    case 293:
+    case 340:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3541 "parser.y"
-    { code_t*c = 0;
-             classinfo_t*type = (yyvsp[(1) - (2)].value).t;
-             if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
-                 c=abc_decrement_i(c);
-                 type = TYPE_INT;
-             } else {
-                 c=abc_decrement(c);
-                 type = TYPE_NUMBER;
-             }
-             c=converttype(c, type, (yyvsp[(1) - (2)].value).t);
-             (yyval.value).c = toreadwrite((yyvsp[(1) - (2)].value).c, c, 0, 1);
-             (yyval.value).t = (yyvsp[(1) - (2)].value).t;
-            }
+#line 3582 "parser.y"
+    {
+    typedcode_t v = node_read((yyvsp[(1) - (3)].node));
+    multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
+    v.c = abc_getdescendants2(v.c, &m);
+    v.t = TYPE_XMLLIST;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 294:
+    case 341:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3555 "parser.y"
-    { code_t*c = 0;
-             classinfo_t*type = (yyvsp[(2) - (2)].value).t;
-             if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
-                 c=abc_increment_i(c);
-                 type = TYPE_INT;
-             } else {
-                 c=abc_increment(c);
-                 type = TYPE_NUMBER;
-             }
-             c=converttype(c, type, (yyvsp[(2) - (2)].value).t);
-             (yyval.value).c = toreadwrite((yyvsp[(2) - (2)].value).c, c, 0, 0);
-             (yyval.value).t = (yyvsp[(2) - (2)].value).t;
-           }
+#line 3589 "parser.y"
+    {
+    (yyval.node) = get_descendants((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].id), 1, 0);
+}
     }
     break;
 
 
   
-    case 295:
+    case 342:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3569 "parser.y"
-    { code_t*c = 0;
-             classinfo_t*type = (yyvsp[(2) - (2)].value).t;
-             if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
-                 c=abc_decrement_i(c);
-                 type = TYPE_INT;
-             } else {
-                 c=abc_decrement(c);
-                 type = TYPE_NUMBER;
-             }
-             c=converttype(c, type, (yyvsp[(2) - (2)].value).t);
-             (yyval.value).c = toreadwrite((yyvsp[(2) - (2)].value).c, c, 0, 0);
-             (yyval.value).t = (yyvsp[(2) - (2)].value).t;
-           }
+#line 3592 "parser.y"
+    {
+    typedcode_t v = node_read((yyvsp[(1) - (5)].node));
+    typedcode_t w = node_read((yyvsp[(4) - (5)].node));
+    multiname_t m = {MULTINAMEL, 0, &nopackage_namespace_set, 0};
+    v.c = code_append(v.c, w.c);
+    v.c = converttype(w.c, w.t, TYPE_STRING);
+    v.c = abc_getproperty2(v.c, &m);
+    v.t = TYPE_XMLLIST;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 296:
+    case 343:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3584 "parser.y"
-    { if(!state->cls->info)
-                  syntaxerror("super keyword not allowed outside a class");
-              classinfo_t*t = state->cls->info->superclass;
-              if(!t) t = TYPE_OBJECT;
-
-              memberinfo_t*f = registry_findmember_nsset(t, state->active_namespaces, (yyvsp[(3) - (3)].id), 1);
-
-              MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
-              (yyval.value).c = 0;
-              (yyval.value).c = abc_getlocal_0((yyval.value).c);
-              (yyval.value).c = abc_getsuper2((yyval.value).c, &m);
-              (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
-           }
+#line 3603 "parser.y"
+    {
+    typedcode_t v = node_read((yyvsp[(1) - (4)].node));
+    multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
+    v.c = abc_getproperty2(v.c, &m);
+    v.t = TYPE_STRING;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 297:
+    case 344:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3598 "parser.y"
+#line 3611 "parser.y"
     {
-              // attribute TODO
-              (yyval.value).c = abc_pushundefined(0);
-              (yyval.value).t = 0;
-              as3_warning("ignored @ operator");
-           }
+    (yyval.node) = get_descendants((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].id), (yyvsp[(6) - (6)].id), 0, 1);
+}
     }
     break;
 
 
   
-    case 298:
+    case 345:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3605 "parser.y"
+#line 3615 "parser.y"
     {
-              // child attribute  TODO
-              (yyval.value).c = abc_pushundefined(0);
-              (yyval.value).t = 0;
-              as3_warning("ignored .@ operator");
-           }
+    typedcode_t v = node_read((yyvsp[(1) - (4)].node));
+    multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};
+    v.c = abc_getdescendants2(v.c, &m);
+    v.t = TYPE_STRING;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 299:
+    case 346:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3612 "parser.y"
+#line 3622 "parser.y"
     {
-              // namespace declaration TODO
-              (yyval.value).c = abc_pushundefined(0);
-              (yyval.value).t = 0;
-              as3_warning("ignored :: operator");
-           }
+    (yyval.node) = get_descendants((yyvsp[(1) - (6)].node), (yyvsp[(4) - (6)].id), (yyvsp[(6) - (6)].id), 1, 1);
+}
     }
     break;
 
 
   
-    case 300:
+    case 347:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3619 "parser.y"
+#line 3626 "parser.y"
     {
-              // descendants TODO
-              (yyval.value).c = abc_pushundefined(0);
-              (yyval.value).t = 0;
-              as3_warning("ignored .. operator");
-           }
+    typedcode_t v = node_read((yyvsp[(1) - (6)].node));
+    typedcode_t w = node_read((yyvsp[(5) - (6)].node));
+    multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
+    v.c = code_append(v.c, w.c);
+    v.c = converttype(w.c, w.t, TYPE_STRING);
+    v.c = abc_getproperty2(v.c, &m);
+    v.t = TYPE_STRING;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 301:
+    case 348:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3626 "parser.y"
+#line 3636 "parser.y"
     {
-              // filter TODO
-              (yyval.value).c = abc_pushundefined(0);
-              (yyval.value).t = 0;
-              as3_warning("ignored .() operator");
-           }
+    typedcode_t v = node_read((yyvsp[(1) - (6)].node));
+    typedcode_t w = node_read((yyvsp[(5) - (6)].node));
+    multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};
+    v.c = code_append(v.c, w.c);
+    v.c = converttype(w.c, w.t, TYPE_STRING);
+    v.c = abc_getdescendants2(v.c, &m);
+    v.t = TYPE_STRING;
+    (yyval.node) = mkcodenode(v);
+}
     }
     break;
 
 
   
-    case 302:
+    case 349:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3637 "parser.y"
+#line 3647 "parser.y"
     {
-    (yyval.value).c = (yyvsp[(1) - (3)].value).c;
-    classinfo_t*t = (yyvsp[(1) - (3)].value).t;
+    typedcode_t v1 = node_read((yyvsp[(1) - (3)].node));
+    (yyval.value).c = v1.c;
+    classinfo_t*t = v1.t;
     char is_static = 0;
     if(TYPE_IS_CLASS(t) && t->data) {
         t = t->data;
         is_static = 1;
     }
-    if(t) {
+    if(TYPE_IS_XML(t) && !findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, is_static)) {
+        multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
+        (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
+        (yyval.value).c = abc_coerce_a((yyval.value).c);
+        (yyval.value).t = TYPE_XMLLIST;
+    } else if(t) {
         if(t->subtype==INFOTYPE_UNRESOLVED) {
             syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", (yyvsp[(3) - (3)].id), t->name);
         }
-        memberinfo_t*f = registry_findmember_nsset(t, state->active_namespaces, (yyvsp[(3) - (3)].id), 1);
+        memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1, is_static);
         char noslot = 0;
         if(f && !is_static != !(f->flags&FLAG_STATIC))
            noslot=1;
         if(f && f->slot && !noslot) {
             (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
         } else {
+            if(!f) {
+                if(!TYPE_IS_XMLLIST(t)) {
+                    as3_softwarning("Access of undefined property '%s' in %s", (yyvsp[(3) - (3)].id), t->name);
+                }
+            }
             MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
             (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
         }
@@ -7962,27 +8814,31 @@ PASS2
         (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
         if(!(yyval.value).t)
            (yyval.value).c = abc_coerce_a((yyval.value).c);
-    } else if((yyvsp[(1) - (3)].value).c && (yyvsp[(1) - (3)].value).c->opcode == OPCODE___PUSHPACKAGE__) {
-        string_t*package = (yyvsp[(1) - (3)].value).c->data[0];
+        
+    } else if(v1.c && v1.c->opcode == OPCODE___PUSHPACKAGE__) {
+        string_t*package = v1.c->data[0];
         char*package2 = concat3(package->str, ".", (yyvsp[(3) - (3)].id));
-        if(dict_contains(state->import_toplevel_packages, package2)) {
-            (yyval.value).c = (yyvsp[(1) - (3)].value).c;
+
+        slotinfo_t*a = registry_find(package->str, (yyvsp[(3) - (3)].id));
+        if(a) {
+            (yyval.value) = push_class(a);
+        } else if(dict_contains(state->import_toplevel_packages, package2) ||
+                  registry_ispackage(package2)) {
+            (yyval.value).c = v1.c;
             (yyval.value).c->data[0] = string_new4(package2);
             (yyval.value).t = 0;
         } else {
-            slotinfo_t*a = registry_find(package->str, (yyvsp[(3) - (3)].id));
-            if(!a) 
-                syntaxerror("couldn't resolve %s", package2);
-            (yyval.value) = push_class(a);
+            syntaxerror("couldn't resolve %s", package2);
         }
     } else {
         /* when resolving a property on an unknown type, we do know the
            name of the property (and don't seem to need the package), but
            we need to make avm2 try out all access modes */
+        as3_softwarning("Resolving %s on unknown type", (yyvsp[(3) - (3)].id));
         multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};
         (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
         (yyval.value).c = abc_coerce_a((yyval.value).c);
-        (yyval.value).t = registry_getanytype();
+        (yyval.value).t = TYPE_ANY;
     }
 }
     }
@@ -7990,11 +8846,11 @@ PASS2
 
 
   
-    case 303:
+    case 350:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3687 "parser.y"
+#line 3844 "parser.y"
     {
     PASS1
     /* Queue unresolved identifiers for checking against the parent
@@ -8004,114 +8860,34 @@ PASS2
        etc. which is *correct* because local variables of the parent function
        would shadow those.
        */
-    if(state->method->inner && !find_variable(state, (yyvsp[(1) - (1)].id))) {
+
+    if(!find_variable(state, (yyvsp[(1) - (1)].id))) {
         unknown_variable((yyvsp[(1) - (1)].id));
+        /* let the compiler know that it might want to check the current directory/package
+           for this identifier- maybe there's a file $1.as defining $1. */
+        as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
     }
    
-    /* let the compiler know that it might check the current directory/package
-       for this identifier- maybe there's a file $1.as defining $1. */
-    as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
+    (yyval.node) = 0;
     PASS2
 
-    (yyval.value).t = 0;
-    (yyval.value).c = 0;
-    slotinfo_t*a = 0;
-    memberinfo_t*f = 0;
-
-    variable_t*v;
-    /* look at variables */
-    if((v = find_variable(state, (yyvsp[(1) - (1)].id)))) {
-        // $1 is a local variable
-        (yyval.value).c = abc_getlocal((yyval.value).c, v->index);
-        (yyval.value).t = v->type;
-        break;
-    }
-    if((v = find_slot(state, (yyvsp[(1) - (1)].id)))) {
-        (yyval.value).c = abc_getscopeobject((yyval.value).c, 1);
-        (yyval.value).c = abc_getslot((yyval.value).c, v->index);
-        (yyval.value).t = v->type;
-        break;
-    }
-
-    int i_am_static = (state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC;
-
-    /* look at current class' members */
-    if(state->cls && (f = registry_findmember_nsset(state->cls->info, state->active_namespaces, (yyvsp[(1) - (1)].id), 1)) &&
-        (f->flags&FLAG_STATIC) >= i_am_static) {
-        // $1 is a function in this class
-        int var_is_static = (f->flags&FLAG_STATIC);
-
-        if(f->kind == INFOTYPE_METHOD) {
-            (yyval.value).t = TYPE_FUNCTION(f);
-        } else {
-            (yyval.value).t = f->type;
-        }
-        if(var_is_static && !i_am_static) {
-        /* access to a static member from a non-static location.
-           do this via findpropstrict:
-           there doesn't seem to be any non-lookup way to access
-           static properties of a class */
-            state->method->late_binding = 1;
-            (yyval.value).t = f->type;
-            namespace_t ns = {f->access, ""};
-            multiname_t m = {QNAME, &ns, 0, (yyvsp[(1) - (1)].id)};
-            (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
-            (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
-            break;
-        } else if(f->slot>0) {
-            (yyval.value).c = abc_getlocal_0((yyval.value).c);
-            (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
-            break;
-        } else {
-            namespace_t ns = {f->access, ""};
-            multiname_t m = {QNAME, &ns, 0, (yyvsp[(1) - (1)].id)};
-            (yyval.value).c = abc_getlocal_0((yyval.value).c);
-            (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
-            break;
-        }
-    } 
-    
-    /* look at actual classes, in the current package and imported */
-    if((a = find_class((yyvsp[(1) - (1)].id)))) {
-        (yyval.value) = push_class(a);
-        break;
-    }
-
-    /* look through package prefixes */
-    if(dict_contains(state->import_toplevel_packages, (yyvsp[(1) - (1)].id))) {
-        (yyval.value).c = abc___pushpackage__((yyval.value).c, (yyvsp[(1) - (1)].id));
-        (yyval.value).t = 0;
-        break;
-    }
-
-    /* unknown object, let the avm2 resolve it */
-    if(1) {
-        //as3_softwarning("Couldn't resolve '%s', doing late binding", $1);
-        as3_warning("Couldn't resolve '%s', doing late binding", (yyvsp[(1) - (1)].id));
-        state->method->late_binding = 1;
-                
-        multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(1) - (1)].id)};
-
-        (yyval.value).t = 0;
-        (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
-        (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
-    }
+    (yyval.node) = resolve_identifier((yyvsp[(1) - (1)].id));
 }
     }
     break;
 
 
   
-    case 304:
+    case 351:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3792 "parser.y"
+#line 3878 "parser.y"
     {
     PASS12
     NEW(namespace_decl_t,n);
     n->name = (yyvsp[(2) - (2)].id);
-    n->url = 0;
+    n->url = (yyvsp[(2) - (2)].id);
     (yyval.namespace_decl)=n;
 }
     }
@@ -8119,11 +8895,11 @@ PASS2
 
 
   
-    case 305:
+    case 352:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3799 "parser.y"
+#line 3885 "parser.y"
     {
     PASS12
     NEW(namespace_decl_t,n);
@@ -8136,11 +8912,11 @@ PASS2
 
 
   
-    case 306:
+    case 353:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3806 "parser.y"
+#line 3892 "parser.y"
     {
     PASS12
     NEW(namespace_decl_t,n);
@@ -8153,15 +8929,30 @@ PASS2
 
 
   
-    case 307:
+    case 354:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3813 "parser.y"
+#line 3899 "parser.y"
     {
     PASS12
-    list_append(state->new_namespaces, (yyvsp[(2) - (2)].namespace_decl));
-    tokenizer_register_namespace((yyvsp[(2) - (2)].namespace_decl)->name);
+    dict_put(state->namespaces, (unsigned char*)(yyvsp[(2) - (2)].namespace_decl)->name, (void*)(yyvsp[(2) - (2)].namespace_decl)->url);
+
+    namespace_t access = modifiers2access(&(yyvsp[(1) - (2)].flags));
+    varinfo_t* var = varinfo_register_global(access.access, state->package, (yyvsp[(2) - (2)].namespace_decl)->name);
+    var->type = TYPE_NAMESPACE;
+    namespace_t ns;
+    ns.access = ACCESS_NAMESPACE;
+    ns.name = (yyvsp[(2) - (2)].namespace_decl)->url;
+    var->value = constant_new_namespace(&ns);
+      
+    if(as3_pass==2) {
+        MULTINAME(m, TYPE_NAMESPACE);
+        trait_t*t = add_abc_slot(&(yyvsp[(1) - (2)].flags), (yyvsp[(2) - (2)].namespace_decl)->name, 0, 0);
+        t->value = var->value;
+        t->type_name = multiname_clone(&m);
+    }
+
     (yyval.code)=0;
 }
     }
@@ -8169,20 +8960,44 @@ PASS2
 
 
   
-    case 308:
+    case 355:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3922 "parser.y"
+    {
+    (yyval.code) = 0;
+    (yyval.code) = code_append((yyval.code), node_read((yyvsp[(4) - (4)].node)).c);
+    (yyval.code) = abc_dxnslate((yyval.code));
+}
+    }
+    break;
+
+
+  
+    case 356:
     if(as3_pass==2) {
 
 /* Line 1464 of skeleton.m4  */
-#line 3820 "parser.y"
+#line 3928 "parser.y"
     {
     PASS12
-    NEW(namespace_decl_t,n);
-    n->name = (yyvsp[(3) - (3)].classinfo)->name;
-    n->url = 0;
-    /* FIXME: for pass2, we should now try to figure out what the URL of 
-              this thing is */
-    list_append(state->new_namespaces, n);
-    tokenizer_register_namespace((yyvsp[(3) - (3)].classinfo)->name);
+
+    varinfo_t*s = (varinfo_t*)(yyvsp[(3) - (3)].classinfo);
+    if(s->kind == INFOTYPE_UNRESOLVED) {
+        s = (varinfo_t*)registry_resolve((slotinfo_t*)s);
+        if(!s)
+            syntaxerror("Couldn't resolve namespace %s", (yyvsp[(3) - (3)].classinfo)->name);
+    }
+
+    if(!s || s->kind != INFOTYPE_VAR)
+        syntaxerror("%s.%s is not a public namespace (%d)", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name, s?s->kind:-1);
+    if(!s->value || !NS_TYPE(s->value->type))
+        syntaxerror("%s.%s is not a namespace", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name);
+
+    const char*url = s->value->ns->name;
+    dict_put(state->namespaces, (unsigned char*)(yyvsp[(3) - (3)].classinfo)->name, (void*)url);
+    add_active_url(url);
     (yyval.code)=0;
 }
     }
@@ -8192,7 +9007,7 @@ PASS2
 
 
 /* Line 1464 of skeleton.m4  */
-#line 8196 "parser.tab.c"
+#line 9011 "parser.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);