X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fparser.tab.c;h=ddea058619cd332dd1539dacaac326db41f3111e;hb=e4687b3aa2aed49fb16ba9e9561344d808750297;hp=f0079b17eff6afde496daaf4470a68fab9e45909;hpb=15983c1c1825073cd732196122da30c1157cf215;p=swftools.git

diff --git a/lib/as3/parser.tab.c b/lib/as3/parser.tab.c
index f0079b1..ddea058 100644
--- a/lib/as3/parser.tab.c
+++ b/lib/as3/parser.tab.c
@@ -49,7 +49,7 @@
 #define YYBISON_VERSION "2.4"
 
 /* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
+#define YYSKELETON_NAME "./skeleton.m4"
 
 /* Pure parsers.  */
 #define YYPURE 0
@@ -64,18 +64,18 @@
 #define YYLSP_NEEDED 0
 
 /* Substitute the variable and function names.  */
-#define yyparse         avm2_parse
-#define yylex           avm2_lex
-#define yyerror         avm2_error
-#define yylval          avm2_lval
-#define yychar          avm2_char
-#define yydebug         avm2_debug
-#define yynerrs         avm2_nerrs
+#define yyparse         a3_parse
+#define yylex           a3_lex
+#define yyerror         a3_error
+#define yylval          a3_lval
+#define yychar          a3_char
+#define yydebug         a3_debug
+#define yynerrs         a3_nerrs
 
 
 /* Copy the first part of user declarations.  */
 
-/* Line 189 of yacc.c  */
+/* Line 198 of skeleton.m4  */
 #line 23 "parser.y"
 
 #include <stdlib.h>
@@ -84,15 +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 189 of yacc.c  */
-#line 96 "parser.tab.c"
+
+/* Line 198 of skeleton.m4  */
+#line 102 "parser.tab.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -120,31 +126,31 @@
       know about them.  */
    enum yytokentype {
      T_IDENTIFIER = 258,
-     T_STRING = 259,
-     T_REGEXP = 260,
-     T_EMPTY = 261,
-     T_INT = 262,
-     T_UINT = 263,
-     T_BYTE = 264,
-     T_SHORT = 265,
-     T_FLOAT = 266,
-     T_FOR = 267,
-     T_WHILE = 268,
-     T_DO = 269,
-     T_SWITCH = 270,
-     KW_IMPLEMENTS = 271,
-     KW_NAMESPACE = 272,
-     KW_PACKAGE = 273,
-     KW_PROTECTED = 274,
-     KW_PUBLIC = 275,
-     KW_PRIVATE = 276,
-     KW_USE = 277,
-     KW_INTERNAL = 278,
-     KW_NEW = 279,
-     KW_NATIVE = 280,
-     KW_FUNCTION = 281,
-     KW_FINALLY = 282,
-     KW_UNDEFINED = 283,
+     T_NAMESPACE = 259,
+     T_STRING = 260,
+     T_REGEXP = 261,
+     T_EMPTY = 262,
+     T_INT = 263,
+     T_UINT = 264,
+     T_FLOAT = 265,
+     T_FOR = 266,
+     T_WHILE = 267,
+     T_DO = 268,
+     T_SWITCH = 269,
+     KW_IMPLEMENTS = 270,
+     KW_NAMESPACE = 271,
+     KW_PACKAGE = 272,
+     KW_PROTECTED = 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,
@@ -185,41 +191,46 @@
      KW_IS = 321,
      KW_IN = 322,
      KW_AS = 323,
-     T_EQEQ = 324,
-     T_EQEQEQ = 325,
-     T_NE = 326,
-     T_NEE = 327,
-     T_LE = 328,
-     T_GE = 329,
-     T_ORBY = 330,
-     T_DIVBY = 331,
-     T_MODBY = 332,
-     T_MULBY = 333,
-     T_PLUSBY = 334,
-     T_MINUSBY = 335,
-     T_SHRBY = 336,
-     T_SHLBY = 337,
-     T_USHRBY = 338,
-     T_OROR = 339,
-     T_ANDAND = 340,
-     T_COLONCOLON = 341,
-     T_MINUSMINUS = 342,
-     T_PLUSPLUS = 343,
-     T_DOTDOT = 344,
-     T_DOTDOTDOT = 345,
-     T_SHL = 346,
-     T_USHR = 347,
-     T_SHR = 348,
-     prec_none = 349,
-     below_semicolon = 350,
-     below_assignment = 351,
-     below_minus = 354,
-     minusminus_prefix = 355,
-     plusplus_prefix = 356,
-     below_curly = 357,
-     above_identifier = 358,
-     below_else = 359,
-     above_function = 360
+     T_DICTSTART = 324,
+     T_EQEQ = 325,
+     T_EQEQEQ = 326,
+     T_NE = 327,
+     T_NEE = 328,
+     T_LE = 329,
+     T_GE = 330,
+     T_ORBY = 331,
+     T_DIVBY = 332,
+     T_MODBY = 333,
+     T_MULBY = 334,
+     T_ANDBY = 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_lt = 355,
+     below_minus = 356,
+     minusminus_prefix = 357,
+     plusplus_prefix = 358,
+     below_curly = 359,
+     new2 = 360,
+     above_identifier = 361,
+     below_else = 362,
+     above_function = 363
    };
 #endif
 
@@ -227,19 +238,20 @@
 
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union 
-/* Line 214 of yacc.c  */
-#line 41 "parser.y"
+/* Line 223 of skeleton.m4  */
+#line 47 "parser.y"
 tokenunion
 {
 
-/* Line 214 of yacc.c  */
-#line 41 "parser.y"
+/* Line 223 of skeleton.m4  */
+#line 47 "parser.y"
 
     enum yytokentype token;
-    int flags;
 
     classinfo_t*classinfo;
     classinfo_list_t*classinfo_list;
+    slotinfo_t*slotinfo;
+    slotinfo_list_t*slotinfo_list;
 
     int number_int;
     unsigned int number_uint;
@@ -256,6 +268,9 @@ tokenunion
     for_start_t for_start;
     abc_exception_t *exception;
     regexp_t regexp;
+    modifiers_t flags;
+    namespace_decl_t* namespace_decl;
+    node_t*node;
     struct {
         abc_exception_list_t *l;
         code_t*finally;
@@ -263,8 +278,8 @@ tokenunion
 
 
 
-/* Line 214 of yacc.c  */
-#line 268 "parser.tab.c"
+/* Line 223 of skeleton.m4  */
+#line 283 "parser.tab.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -274,16 +289,24 @@ tokenunion
 
 /* Copy the second part of user declarations.  */
 
-/* Line 264 of yacc.c  */
-#line 251 "parser.y"
+/* Line 273 of skeleton.m4  */
+#line 273 "parser.y"
 
 
-static int yyerror(char*s)
+static int a3_error(char*s)
 {
    syntaxerror("%s", 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)
 {
     int l1 = strlen(t1);
@@ -310,27 +333,54 @@ static char* concat3(const char* t1, const char* t2, const char* t3)
 typedef struct _import {
     char*package;
 } import_t;
-
 DECLARE_LIST(import);
 
+DECLARE(methodstate);
+DECLARE_LIST(methodstate);
+
 typedef struct _classstate {
     /* class data */
     classinfo_t*info;
     abc_class_t*abc;
-    code_t*init;
-    code_t*static_init;
+   
+    methodstate_t*init;
+    methodstate_t*static_init;
+    //code_t*init;
+    //code_t*static_init;
+
     char has_constructor;
 } classstate_t;
 
-typedef struct _methodstate {
+struct _methodstate {
     /* method data */
-    memberinfo_t*info;
+    methodinfo_t*info;
+    char has_exceptions;
     char late_binding;
     char is_constructor;
     char has_super;
     char is_global;
+    int variable_count;
+
+    dict_t*unresolved_variables;
+
+    char inner;
+    char uses_parent_function;
+    int uses_slots;
+    dict_t*slots;
+    int activation_var;
+
+    abc_method_t*abc;
+    int var_index; // for inner methods
+    int slot_index; // for inner methods
+    char is_a_slot; // for inner methods
+
+    code_t*header;
+
+    code_t*scope_code;
     abc_exception_list_t*exceptions;
-} methodstate_t;
+    
+    methodstate_list_t*innerfunctions;
+};
 
 typedef struct _state {
     struct _state*old;
@@ -338,22 +388,35 @@ typedef struct _state {
     
     char*package;     
     import_list_t*wildcard_imports;
+    dict_t*import_toplevel_packages;
     dict_t*imports;
+
+    namespace_list_t*active_namespace_urls;
+    
     char has_own_imports;
+    char new_vars; // e.g. transition between two functions
   
     classstate_t*cls;   
     methodstate_t*method;
 
     char*exception_name;
+
+    int switch_var;
     
     dict_t*vars;
+    dict_t*allvars; // also contains variables from sublevels
 } state_t;
 
 typedef struct _global {
     abc_file_t*file;
-    abc_script_t*init;
 
-    int variable_count;
+    parsedclass_list_t*classes;
+    abc_script_t*classinit;
+
+    abc_script_t*init; //package-level code
+
+    dict_t*token2info;
+    dict_t*file2token2info;
 } global_t;
 
 static global_t*global = 0;
@@ -361,20 +424,18 @@ static state_t* state = 0;
 
 DECLARE_LIST(state);
 
-#define MULTINAME(m,x) \
-    multiname_t m;\
-    namespace_t m##_ns;\
-    registry_fill_multiname(&m, &m##_ns, x);
-                    
 #define MEMBER_MULTINAME(m,f,n) \
     multiname_t m;\
     namespace_t m##_ns;\
     if(f) { \
-        m##_ns = flags2namespace(f->flags, ""); \
+        if((m##_ns.access = ((slotinfo_t*)(f))->access)==ACCESS_NAMESPACE) \
+            m##_ns.name = ((slotinfo_t*)(f))->package; \
+        else \
+            m##_ns.name = ""; \
         m.type = QNAME; \
         m.ns = &m##_ns; \
         m.namespace_set = 0; \
-        m.name = f->name; \
+        m.name = ((slotinfo_t*)(f))->name; \
     } else { \
         m.type = MULTINAME; \
         m.ns =0; \
@@ -402,6 +463,15 @@ 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);
@@ -411,17 +481,20 @@ static void new_state()
     if(!s->imports) {
         s->imports = dict_new();
     }
+    if(!s->import_toplevel_packages) {
+        s->import_toplevel_packages = dict_new(); 
+    }
     state = s;
     state->level++;
     state->has_own_imports = 0;    
     state->vars = dict_new(); 
     state->old = oldstate;
-}
-static void state_has_imports()
-{
-    state->wildcard_imports = list_clone(state->wildcard_imports);
-    state->imports = dict_clone(state->imports);
-    state->has_own_imports = 1;
+    state->new_vars = 0;
+
+    trie_remember(active_namespaces);
+   
+    if(oldstate)
+        state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);
 }
 
 static void state_destroy(state_t*state)
@@ -434,156 +507,226 @@ 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;
     }
+    if(state->new_vars && state->allvars) {
+        parserassert(!state->old || state->old->allvars != state->allvars);
+        DICT_ITERATE_DATA(state->allvars, void*, data) {
+            free(data);
+        }
+        dict_destroy(state->allvars);
+    }
+    
+    list_free(state->active_namespace_urls)
+    state->active_namespace_urls = 0;
     
     free(state);
 }
 
 static void old_state()
 {
+    trie_rollback(active_namespaces);
+
     if(!state || !state->old)
         syntaxerror("invalid nesting");
     state_t*leaving = state;
     
     state = state->old;
+
+    if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {
+        free(leaving->method);
+        leaving->method=0;
+    }
+    if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {
+        free(leaving->cls);
+        leaving->cls=0;
+    }
+
     state_destroy(leaving);
 }
 
-void initialize_parser()
-{
-    global = rfx_calloc(sizeof(global_t));
-    global->file = abc_file_new();
-    global->file->flags &= ~ABCFILE_LAZY;
-    global->variable_count = 1;
-    global->init = abc_initscript(global->file);
-    code_t*c = global->init->method->body->code;
-    c = abc_getlocal_0(c);
-    c = abc_pushscope(c);
-    /*c = abc_findpropstrict(c, "[package]::trace");
-    c = abc_pushstring(c, "[entering global init function]");
-    c = abc_callpropvoid(c, "[package]::trace", 1);*/
-    global->init->method->body->code = c;
-}
+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 char* internal_filename_package = 0;
 void initialize_file(char*filename)
 {
+    if(state) {
+        syntaxerror("invalid call to initialize_file during parsing of another file");
+    }
+    
+    active_namespaces = trie_new();
+
     new_state();
-    state->package = filename;
-    // needed for state->method->late_binding:
-    state->method = rfx_calloc(sizeof(methodstate_t));
+    state->package = internal_filename_package = strdup(filename);
+    state->allvars = dict_new();
+    
+    global->token2info = dict_lookup(global->file2token2info, 
+                                     current_filename // use long version
+                                    );
+    if(!global->token2info) {
+        global->token2info = dict_new2(&ptr_type);
+        dict_put(global->file2token2info, current_filename, global->token2info);
+    }
+  
+    if(as3_pass==1) {
+        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
+    } else {
+        state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+        if(!state->method)
+            syntaxerror("internal error: skewed tokencount");
+        function_initvars(state->method, 0, 0, 1);
+        global->init = abc_initscript(global->file);
+    }
 }
+
 void finish_file()
 {
     if(!state || state->level!=1) {
-        syntaxerror("unexpected end of file");
+        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 = abc_returnvoid(c);
+        free(state->method);state->method=0;
     }
+
+    //free(state->package);state->package=0; // used in registry
     state_destroy(state);state=0;
 }
 
-void* finish_parser()
+void initialize_parser()
 {
-    code_t*c = global->init->method->body->code;
-    /*c = abc_findpropstrict(c, "[package]::trace");
-      c = abc_pushstring(c, "[leaving global init function]");
-      c = abc_callpropvoid(c, "[package]::trace", 1);*/
-    c = abc_returnvoid(c);
-    global->init->method->body->code = c;
-    return global->file;
+    global = rfx_calloc(sizeof(global_t));
+    global->file = abc_file_new();
+    global->file->flags &= ~ABCFILE_LAZY;
+    global->file2token2info = dict_new();
+    global->token2info = 0;
+    global->classinit = abc_initscript(global->file);
 }
 
-
-static void xx_scopetest() 
+void* finish_parser()
 {
-    /* 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");
+    dict_free_all(global->file2token2info, 1, (void*)dict_destroy);
+    global->token2info=0;
     
-    /*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 is_parameter;
+    methodstate_t*is_inner_method;
 } variable_t;
 
-static variable_t* find_variable(char*name)
+static variable_t* find_variable(state_t*s, char*name)
 {
-    state_t* s = state;
+    state_t*top = s;
     while(s) {
         variable_t*v = 0;
-        if(s->method)
-            v = dict_lookup(s->vars, name);
-        if(v) {
-            return v;
-        }
+        v = dict_lookup(s->vars, name);
+        if(v) return v;
+        if(s->new_vars) break;
         s = s->old;
     }
+    return dict_lookup(top->allvars, name);
+}
+static variable_t* find_slot(state_t*s, const char*name)
+{
+    if(s->method && s->method->slots)
+        return dict_lookup(s->method->slots, name);
     return 0;
-} 
-static variable_t* find_variable_safe(char*name)
+}
+
+static variable_t* find_variable_safe(state_t*s, char*name)
 {
-    variable_t* v = find_variable(name);
+    variable_t* v = find_variable(s, name);
     if(!v)
         syntaxerror("undefined variable: %s", name);
     return v;
 }
+
 static char variable_exists(char*name) 
 {
-    return dict_lookup(state->vars, name)!=0;
+    return dict_contains(state->vars, name);
+}
+
+static code_t*defaultvalue(code_t*c, classinfo_t*type)
+{
+    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);
+        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++;
 }
-code_t*defaultvalue(code_t*c, classinfo_t*type);
-static int new_variable(char*name, classinfo_t*type, char init)
+
+static variable_t* new_variable2(const char*name, classinfo_t*type, char init, char maybeslot)
 {
+    if(maybeslot) {
+        variable_t*v = find_slot(state, name);
+        if(v)
+            return v;
+    }
+
     NEW(variable_t, v);
-    v->index = global->variable_count;
+    v->index = alloc_local();
     v->type = type;
     v->init = init;
-    
-    dict_put(state->vars, name, v);
+ 
+    if(name) {
+        dict_put(state->vars, name, v);
+        dict_put(state->allvars, name, v);
+    }
 
-    return global->variable_count++;
+    return v;
+}
+static int new_variable(const char*name, classinfo_t*type, char init, char maybeslot)
+{
+    return new_variable2(name, type, init, maybeslot)->index;
 }
+
 #define TEMPVARNAME "__as3_temp__"
-static int gettempvar()
+int gettempvar()
 {
-    variable_t*v = find_variable(TEMPVARNAME);
+    variable_t*v = find_variable(state, TEMPVARNAME);
+    int i;
     if(v) 
-        return v->index;
-    return new_variable(TEMPVARNAME, 0, 0);
+        i = v->index;
+    else
+        i = new_variable(TEMPVARNAME, 0, 0, 0);
+    parserassert(i);
+    return i;
 }
 
-code_t* var_block(code_t*body) 
+static code_t* var_block(code_t*body) 
 {
     code_t*c = 0;
     code_t*k = 0;
@@ -627,6 +770,88 @@ code_t* var_block(code_t*body)
     return c;
 }
 
+static void unknown_variable(char*name) 
+{
+    if(!state->method->unresolved_variables)
+        state->method->unresolved_variables = dict_new();
+    if(!dict_contains(state->method->unresolved_variables, name))
+        dict_put(state->method->unresolved_variables, name, 0);
+}
+
+static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)
+{
+    if(m->uses_slots || (m->late_binding && !m->inner)) { //???? especially inner functions need the pushscope
+        c = abc_getlocal_0(c);
+        c = abc_pushscope(c);
+    }
+    if(m->uses_slots) {
+        /* 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;
+}
+
+static code_t* method_header(methodstate_t*m)
+{
+    code_t*c = 0;
+
+    c = add_scope_code(c, m, 1);
+
+    methodstate_list_t*l = m->innerfunctions;
+    while(l) {
+        parserassert(l->methodstate->abc);
+        if(m->uses_slots && l->methodstate->is_a_slot) {
+            c = abc_getscopeobject(c, 1);
+            c = abc_newfunction(c, l->methodstate->abc);
+            c = abc_dup(c);
+            c = abc_setlocal(c, l->methodstate->var_index);
+            c = abc_setslot(c, l->methodstate->slot_index);
+        } else {
+            c = abc_newfunction(c, l->methodstate->abc);
+            c = abc_setlocal(c, l->methodstate->var_index);
+        }
+        free(l->methodstate);l->methodstate=0;
+        l = l->next;
+    }
+    if(m->header) {
+        c = code_append(c, m->header);
+        m->header = 0;
+    }
+    if(m->is_constructor && !m->has_super) {
+        // call default constructor
+        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;
+}
+    
+
 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
 {
     c = code_append(c, header);
@@ -639,183 +864,280 @@ 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);
-    global->variable_count = 1;
 }
 static void endpackage()
 {
-    /*printf("leaving package \"%s\"\n", state->package);*/
-
     //used e.g. in classinfo_register:
     //free(state->package);state->package=0;
-
     old_state();
 }
 
+#define FLAG_PUBLIC 256
+#define FLAG_PROTECTED 512
+#define FLAG_PRIVATE 1024
+#define FLAG_PACKAGEINTERNAL 2048
+#define FLAG_NAMESPACE 4096
+
+static namespace_t modifiers2access(modifiers_t*mod)
+{
+    namespace_t ns;
+    ns.access = 0;
+    ns.name = "";
+    if(mod->flags&FLAG_NAMESPACE)  {
+        if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
+            syntaxerror("invalid combination of access levels and namespaces");
+        ns.access = ACCESS_NAMESPACE;
+        state_t*s = state;
+        const char*url = (const char*)trie_lookup(active_namespaces, mod->ns);
+        if(!url) {
+            /* shouldn't happen- the tokenizer only reports something as a namespace
+               if it was already registered */
+            trie_dump(active_namespaces);
+            syntaxerror("unknown namespace: %s", 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");
+        ns.access = ACCESS_PACKAGE;
+    } else if(mod->flags&FLAG_PRIVATE) {
+        if(mod->flags&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
+            syntaxerror("invalid combination of access levels");
+        ns.access = ACCESS_PRIVATE;
+    } else if(mod->flags&FLAG_PROTECTED) {
+        if(mod->flags&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL)) 
+            syntaxerror("invalid combination of access levels");
+        ns.access = ACCESS_PROTECTED;
+    } else {
+        ns.access = ACCESS_PACKAGEINTERNAL;
+    }
+    return ns;
+}
+static slotinfo_t* find_class(const char*name);
+
+static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse)
+{
+    return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse);
+}
+
+static void function_initvars(methodstate_t*m, params_t*params, int flags, char var0)
+{
+    if(var0) {
+        int index = -1;
+        if(m->inner)
+            index = new_variable("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);
+        else
+            index = new_variable("globalscope", 0, 0, 0);
+        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) {
+        param_list_t*p=0;
+        for(p=params->list;p;p=p->next) {
+            variable_t*v = new_variable2(p->param->name, p->param->type, 0, 1);
+            v->is_parameter = 1;
+        }
+    }
+
+    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;
+    }
+    
+    if(as3_pass==2) {
+        m->scope_code = add_scope_code(m->scope_code, m, 0);
+    }
+    
+    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) {
+                classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);
+                if(!type || type->kind != INFOTYPE_CLASS) {
+                    syntaxerror("Couldn't find class %s::%s (%s)", v->type->package, v->type->name, name);
+                }
+                v->type = type;
+            }
+        }
+    }
+}
+
+
 char*as3_globalclass=0;
-static void startclass(int flags, char*classname, classinfo_t*extends, classinfo_list_t*implements, char interface)
+static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, classinfo_list_t*implements)
 {
     if(state->cls) {
         syntaxerror("inner classes now allowed"); 
     }
-    new_state();
-    global->variable_count = 1;
-    state->cls = rfx_calloc(sizeof(classstate_t));
-    state->method = rfx_calloc(sizeof(methodstate_t)); // method state, for static constructor
 
+    new_state();
     token_list_t*t=0;
     classinfo_list_t*mlist=0;
 
-    if(flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC))
+    if(mod->flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))
         syntaxerror("invalid modifier(s)");
 
-    if((flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))
+    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_INTERFACE) && !extends) {
+    if(!(mod->flags&FLAG_INTERFACE) && !extends) {
+        // all classes extend object
+        extends = registry_getobjectclass();
+    }
 
     /* create the class name, together with the proper attributes */
     int access=0;
     char*package=0;
 
-    if(!(flags&FLAG_PUBLIC) && !state->package) {
-        access = ACCESS_PRIVATE; package = current_filename;
-    } else if(!(flags&FLAG_PUBLIC) && state->package) {
+    if(!(mod->flags&FLAG_PUBLIC) && state->package==internal_filename_package) {
+        access = ACCESS_PRIVATE; package = internal_filename_package;
+    } else if(!(mod->flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {
         access = ACCESS_PACKAGEINTERNAL; package = state->package;
-    } else if(state->package) {
+    } else if(state->package!=internal_filename_package) {
         access = ACCESS_PACKAGE; package = state->package;
     } else {
         syntaxerror("public classes only allowed inside a package");
     }
 
-    if(registry_findclass(package, classname)) {
-        syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
-    }
-   
+    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->static_init->variable_count=1;
+        /* notice: we make no effort to initialize the top variable (local0) here,
+           even though it has special meaning. We just rely on the facat
+           that pass 1 won't do anything with variables */
+        
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);
+
+        /* set current method to constructor- all code within the class-level (except
+           static variable initializations) will be executed during construction time */
+        state->method = state->cls->init;
 
-    /* build info struct */
-    int num_interfaces = (list_length(implements));
-    state->cls->info = classinfo_register(access, package, classname, num_interfaces);
-    state->cls->info->superclass = extends?extends:TYPE_OBJECT;
-    int pos = 0;
-    classinfo_list_t*l = implements;
-    for(l=implements;l;l=l->next) {
-        state->cls->info->interfaces[pos++] = l->classinfo;
+        if(registry_find(package, classname)) {
+            syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);
+        }
+        /* build info struct */
+        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;
+        for(l=implements;l;l=l->next) {
+            state->cls->info->interfaces[pos++] = l->classinfo;
+        }
     }
     
-    multiname_t*extends2 = sig2mname(extends);
+    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);
 
-    MULTINAME(classname2,state->cls->info);
+        if(extends && (extends->flags & FLAG_FINAL))
+            syntaxerror("Can't extend final class '%s'", extends->name);
+        
+        int pos = 0;
+        while(state->cls->info->interfaces[pos]) {
+            if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))
+                syntaxerror("'%s' is not an interface", 
+                    state->cls->info->interfaces[pos]->name);
+            pos++;
+        }
 
-    /*if(extends) {
-        state->cls_init = abc_getlocal_0(state->cls_init);
-        state->cls_init = abc_constructsuper(state->cls_init, 0);
-    }*/
+        /* 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);
-    if(flags&FLAG_FINAL) abc_class_final(state->cls->abc);
-    if(!(flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);
-    if(interface) {
-        state->cls->info->flags |= CLASS_INTERFACE;
-        abc_class_interface(state->cls->abc);
-    }
+        /* 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;
 
-    abc_class_protectedNS(state->cls->abc, classname);
+        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);
+        }
 
-    for(mlist=implements;mlist;mlist=mlist->next) {
-        MULTINAME(m, mlist->classinfo);
-        abc_class_add_interface(state->cls->abc, &m);
-    }
+        abc_class_protectedNS(state->cls->abc, classname);
 
-    /* now write the construction code for this class */
-    int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
+        for(mlist=implements;mlist;mlist=mlist->next) {
+            MULTINAME(m, mlist->classinfo);
+            abc_class_add_interface(state->cls->abc, &m);
+        }
 
-    abc_method_body_t*m = global->init->method->body;
-    __ getglobalscope(m);
-    classinfo_t*s = extends;
+        NEW(parsedclass_t,p);
+        p->cls = state->cls->info;
+        p->abc = state->cls->abc;
+        list_append(global->classes, p);
 
-    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);
-
-    /* flash.display.MovieClip handling */
-    if(!as3_globalclass && (flags&FLAG_PUBLIC) && classinfo_equals(registry_getMovieClip(),extends)) {
-        if(state->package && state->package[0]) {
-            as3_globalclass = concat3(state->package, ".", classname);
-        } else {
-            as3_globalclass = strdup(classname);
+        /* 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);
+            } else {
+                as3_globalclass = strdup(classname);
+            }
         }
     }
-    multiname_destroy(extends2);
 }
 
 static void endclass()
 {
-    if(!state->cls->has_constructor && !(state->cls->info->flags&CLASS_INTERFACE)) {
-        code_t*c = 0;
-        c = abc_getlocal_0(c);
-        c = abc_constructsuper(c, 0);
-        state->cls->init = code_append(state->cls->init, c);
-    }
-    if(!state->method->late_binding) {
-        // class initialization code uses late binding
-        code_t*c = 0;
-        c = abc_getlocal_0(c);
-        c = abc_pushscope(c);
-        state->cls->static_init = code_append(c, state->cls->static_init);
-    }
-
-    if(state->cls->init) {
-        abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
-        m->body->code = wrap_function(0, state->cls->init, m->body->code);
-    }
-    if(state->cls->static_init) {
-        abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
-        m->body->code = wrap_function(0, state->cls->static_init, m->body->code);
+    if(as3_pass == 2) {
+        if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {
+            code_t*c = 0;
+            c = abc_getlocal_0(c);
+            c = abc_constructsuper(c, 0);
+            state->cls->init->header = code_append(state->cls->init->header, c);
+            state->cls->has_constructor=1;
+        }
+        if(state->cls->init) {
+            if(state->cls->info->flags&FLAG_INTERFACE) {
+                if(state->cls->init->header) 
+                    syntaxerror("interface can not have class-level code");
+            } else {
+                abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);
+                code_t*c = method_header(state->cls->init);
+                m->body->code = wrap_function(c, 0, m->body->code);
+            }
+        }
+        if(state->cls->static_init) {
+            abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);
+            code_t*c = method_header(state->cls->static_init);
+            m->body->code = wrap_function(c, 0, m->body->code);
+        }
     }
 
-    free(state->cls);state->cls=0;
-    free(state->method);state->method=0;
     old_state();
 }
 
@@ -830,11 +1152,20 @@ 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);
+        }
         c=c->prev;
     }
 }
 
-
 static void check_constant_against_type(classinfo_t*t, constant_t*c)
 {
 #define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)
@@ -844,7 +1175,7 @@ static void check_constant_against_type(classinfo_t*t, constant_t*c)
              || c->type == CONSTANT_UINT);
    } else if(TYPE_IS_UINT(t)) {
         xassert(c->type == CONSTANT_UINT ||
-               (c->type == CONSTANT_INT && c->i>0));
+               (c->type == CONSTANT_INT && c->i>=0));
    } else if(TYPE_IS_INT(t)) {
         xassert(c->type == CONSTANT_INT);
    } else if(TYPE_IS_BOOLEAN(t)) {
@@ -853,192 +1184,348 @@ static void check_constant_against_type(classinfo_t*t, constant_t*c)
    }
 }
 
-
-static int flags2access(int flags)
+static void check_override(memberinfo_t*m, int flags)
 {
-    int access = 0;
-    if(flags&FLAG_PUBLIC)  {
-        if(access&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
-            syntaxerror("invalid combination of access levels");
-        access = ACCESS_PACKAGE;
-    } else if(flags&FLAG_PRIVATE) {
-        if(access&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL)) 
-            syntaxerror("invalid combination of access levels");
-        access = ACCESS_PRIVATE;
-    } else if(flags&FLAG_PROTECTED) {
-        if(access&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL)) 
-            syntaxerror("invalid combination of access levels");
-        access = ACCESS_PROTECTED;
-    } else {
-        access = ACCESS_PACKAGEINTERNAL;
+    if(!m)
+        return;
+    if(m->parent == state->cls->info)
+        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);
+    if(m->access==ACCESS_PRIVATE)
+        return;
+    if(m->flags & FLAG_FINAL)
+        syntaxerror("can't override final member %s", m->name);
+    
+    /* allow this. it's no issue.
+    if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))
+        syntaxerror("can't override static member %s", m->name);*/
+
+    if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))
+        syntaxerror("can't override non-static member %s with static declaration", m->name);
+
+    if(!(flags&FLAG_OVERRIDE) && !(flags&FLAG_STATIC) && !(m->flags&FLAG_STATIC)) {
+        if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {
+            if(m->kind == INFOTYPE_METHOD)
+                syntaxerror("can't override without explicit 'override' declaration");
+            else
+                syntaxerror("can't override '%s'", m->name);
+        }
     }
-    return access;
 }
 
-
-static memberinfo_t*registerfunction(enum yytokentype getset, int flags, char*name, params_t*params, classinfo_t*return_type, int slot)
+static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, char*name, params_t*params, classinfo_t*return_type, int slot)
 {
-    memberinfo_t*minfo = 0;
+    methodinfo_t*minfo = 0;
+    namespace_t ns = modifiers2access(mod);
     if(!state->cls) {
         //package method
-        minfo = memberinfo_register_global(flags2access(flags), state->package, name, MEMBER_METHOD);
+        minfo = methodinfo_register_global(ns.access, state->package, name);
         minfo->return_type = return_type;
     } else if(getset != KW_GET && getset != KW_SET) {
         //class method
-        if((minfo = registry_findmember(state->cls->info, name, 0))) {
-            if(minfo->parent == state->cls->info) {
-                syntaxerror("class already contains a member/method called '%s'", name);
-            } else if(!minfo->parent) {
-                syntaxerror("internal error: overriding method %s, which doesn't have parent", name);
-            } else {
-                if(!(minfo->flags&(FLAG_STATIC|FLAG_PRIVATE)))
-                    syntaxerror("function %s already exists in superclass. Did you forget the 'override' keyword?");
-            }
+        memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);
+        if(m) {
+            syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);
         }
-        minfo = memberinfo_register(state->cls->info, name, MEMBER_METHOD);
+        minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
         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;
     } else {
         //class getter/setter
-        int gs = getset==KW_GET?MEMBER_GET:MEMBER_SET;
+        int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;
         classinfo_t*type=0;
-        if(getset == KW_GET)
+        if(getset == KW_GET) {
             type = return_type;
-        else if(params->list)
+        } else if(params->list && params->list->param && !params->list->next) {
             type = params->list->param->type;
+        } else
+            syntaxerror("setter function needs to take exactly one argument");
         // not sure wether to look into superclasses here, too
-        if((minfo=registry_findmember(state->cls->info, name, 0))) {
-            if(minfo->kind & ~(MEMBER_GET|MEMBER_SET))
-                syntaxerror("class already contains a member or method called '%s'", name);
-            if(minfo->kind & gs)
+        minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1);
+        if(minfo) {
+            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);
+            if(minfo->subtype & gs)
                 syntaxerror("getter/setter for '%s' already defined", name);
             /* make a setter or getter into a getset */
-            minfo->kind |= gs;
-            if(!minfo->type) 
-                minfo->type = type;
-            else
-                if(type && minfo->type != type)
-                    syntaxerror("different type in getter and setter");
+            minfo->subtype |= gs;
+            
+            /*
+            FIXME: this check needs to be done in pass 2
+            
+            if((!minfo->return_type != !type) ||
+                (minfo->return_type && type && 
+                 !strcmp(minfo->return_type->name, type->name))) {
+                syntaxerror("different type in getter and setter: %s and %s", 
+                    minfo->return_type?minfo->return_type->name:"*", 
+                    type?type->name:"*");
+            }*/
         } else {
-            minfo = memberinfo_register(state->cls->info, name, gs);
-            minfo->type = type;
+            minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);
+            minfo->kind = INFOTYPE_VAR; //hack
+            minfo->subtype = gs;
+            minfo->return_type = type;
         }
+
         /* can't assign a slot as getter and setter might have different slots */
         //minfo->slot = slot;
     }
-    if(flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
-    if(flags&FLAG_PUBLIC) minfo->flags |= FLAG_PUBLIC;
-    if(flags&FLAG_PRIVATE) minfo->flags |= FLAG_PRIVATE;
-    if(flags&FLAG_PROTECTED) minfo->flags |= FLAG_PROTECTED;
-    if(flags&FLAG_PACKAGEINTERNAL) minfo->flags |= FLAG_PACKAGEINTERNAL;
-    if(flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
+    if(mod->flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;
+    if(mod->flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;
+    if(mod->flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;
+
     return minfo;
 }
 
-static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
-                          params_t*params, classinfo_t*return_type)
+static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
 {
-    if(state->method && state->method->info) {
-        syntaxerror("not able to start another method scope");
+    //parserassert(state->method && state->method->info);
+
+    methodstate_t*parent_method = state->method;
+
+    if(as3_pass==1) {
+        return_type = 0; // not valid in pass 1
     }
+
     new_state();
-    global->variable_count = 0;
-    state->method = rfx_calloc(sizeof(methodstate_t));
-    state->method->has_super = 0;
+    state->new_vars = 1;
+    state->allvars = dict_new();
+   
+    if(as3_pass == 1) {
+        state->method = rfx_calloc(sizeof(methodstate_t));
+        state->method->inner = 1;
+        state->method->variable_count = 0;
+        state->method->abc = rfx_calloc(sizeof(abc_method_t));
+
+        NEW(methodinfo_t,minfo);
+        minfo->kind = INFOTYPE_METHOD;
+        minfo->access = ACCESS_PACKAGEINTERNAL;
+        minfo->name = name;
+        state->method->info = minfo;
+
+        if(parent_method)
+            list_append(parent_method->innerfunctions, state->method);
+
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
+    
+        function_initvars(state->method, params, 0, 1);
+    }
 
-    if(state->cls) {
-        state->method->is_constructor = !strcmp(state->cls->info->name,name);
-        state->cls->has_constructor |= state->method->is_constructor;
-        
-        new_variable((flags&FLAG_STATIC)?"class":"this", state->cls->info, 0);
-    } else {
-        state->method->is_global = 1;
-        state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack
+    if(as3_pass == 2) {
+        state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+        state->method->variable_count = 0;
+        parserassert(state->method);
+
+        state->method->info->return_type = return_type;
+        function_initvars(state->method, params, 0, 1);
+    }
+}
 
-        new_variable("globalscope", 0, 0);
+static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,
+                          params_t*params, classinfo_t*return_type)
+{
+    if(state->method && state->method->info) {
+        syntaxerror("not able to start another method scope");
     }
+    new_state();
+    state->new_vars = 1;
+    state->allvars = dict_new();
+
+    if(as3_pass == 1) {
+        state->method = rfx_calloc(sizeof(methodstate_t));
+        state->method->has_super = 0;
 
-    /* state->vars is initialized by state_new */
+        if(state->cls) {
+            state->method->is_constructor = !strcmp(state->cls->info->name,name);
+        } else {
+            state->method->is_global = 1;
+            state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack
+        }
+        if(state->method->is_constructor)
+            name = "__as3_constructor__";
 
-    param_list_t*p=0;
-    for(p=params->list;p;p=p->next) {
-        new_variable(p->param->name, p->param->type, 0);
+        state->method->info = registerfunction(getset, mod, name, params, return_type, 0);
+       
+        function_initvars(state->method, params, mod->flags, 1);
+        
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
     }
-    if(state->method->is_constructor)
-        name = "__as3_constructor__";
-    state->method->info = registerfunction(getset, flags, name, params, return_type, 0);
+
+    if(as3_pass == 2) {
+        state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+        state->method->variable_count = 0;
+        parserassert(state->method);
+                
+        if(state->cls) {
+            memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2);
+            check_override(m, mod->flags);
+        }
+            
+        if(state->cls) { 
+            state->cls->has_constructor |= state->method->is_constructor;
+        }
+        
+        function_initvars(state->method, params, mod->flags, 1);
+    } 
 }
 
-static void endfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
+static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,
                           params_t*params, classinfo_t*return_type, code_t*body)
 {
-    abc_method_t*f = 0;
-
-    multiname_t*type2 = sig2mname(return_type);
-    int slot = 0;
-    if(state->method->is_constructor) {
-        f = abc_class_getconstructor(state->cls->abc, type2);
-    } else if(!state->method->is_global) {
-        namespace_t mname_ns = flags2namespace(flags, "");
-        multiname_t mname = {QNAME, &mname_ns, 0, name};
-
-        if(flags&FLAG_STATIC)
-            f = abc_class_staticmethod(state->cls->abc, type2, &mname);
-        else
-            f = abc_class_method(state->cls->abc, type2, &mname);
-        slot = f->trait->slot_id;
-    } else {
-        namespace_t mname_ns = flags2namespace(flags, state->package);
-        multiname_t mname = {QNAME, &mname_ns, 0, name};
-
-        f = abc_method_new(global->file, type2, 1);
-        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(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;
-
-    char opt=0;
-    param_list_t*p=0;
-    for(p=params->list;p;p=p->next) {
-        if(params->varargs && !p->next) {
-            break; //varargs: omit last parameter in function signature
+    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(l) break;
+                }
+
+                dict_destroy(m->unresolved_variables);
+                m->unresolved_variables = 0;
+            }
+            ml = ml->next;
         }
-        multiname_t*m = sig2mname(p->param->type);
-	list_append(f->parameters, m);
-        if(p->param->value) {
-            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");
+        
+        if(state->method->uses_slots) {
+            state->method->slots = dict_new();
+            int i = 1;
+            DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {
+                if(!name) syntaxerror("internal error");
+                if(v->index && dict_contains(xvars, name)) {
+                    v->init = 0;
+                    v->index = i++;
+                    if(v->is_inner_method) {
+                        v->is_inner_method->is_a_slot = 1;
+                    }
+                    //v->type = 0;
+                    dict_put(state->method->slots, name, v);
+                }
+            }
+            state->method->uses_slots = i;
+            dict_destroy(state->vars);state->vars = 0;
+            parserassert(state->new_vars);
+            dict_destroy(state->allvars);state->allvars = 0;
         }
+        old_state();
+        return 0;
     }
-    check_code_for_break(body);
 
-    if(f->body) {
-        f->body->code = body;
-        f->body->exceptions = state->method->exceptions;
-    } else { //interface
-        if(body)
-            syntaxerror("interface methods can't have a method body");
-    }
-       
-    free(state->method);state->method=0;
-    old_state();
-}
+    if(as3_pass==2) {
+        /*if(state->method->uses_parent_function){
+            syntaxerror("accessing variables of parent function from inner functions not supported yet");
+        }*/
+
+        abc_method_t*f = 0;
+
+        multiname_t*type2 = sig2mname(return_type);
+        int slot = 0;
+        if(state->method->inner) {
+            f = state->method->abc;
+            abc_method_init(f, global->file, type2, 1);
+        } else if(state->method->is_constructor) {
+            f = abc_class_getconstructor(state->cls->abc, type2);
+        } else if(!state->method->is_global) {
+            namespace_t ns = modifiers2access(mod);
+          
+            /* deal with protected */
+            if(ns.access == ACCESS_PROTECTED && state->cls)
+                ns.name = state->cls->info->name;
+
+            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);
+            slot = f->trait->slot_id;
+        } else {
+            namespace_t mname_ns = {state->method->info->access, state->package};
+            multiname_t mname = {QNAME, &mname_ns, 0, name};
 
+            f = abc_method_new(global->file, type2, 1);
+            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(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;
+
+        char opt=0;
+        param_list_t*p=0;
+        for(p=params->list;p;p=p->next) {
+            if(params->varargs && !p->next) {
+                break; //varargs: omit last parameter in function signature
+            }
+            multiname_t*m = sig2mname(p->param->type);
+            list_append(f->parameters, m);
+            if(p->param->value) {
+                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");
+            }
+        }
+        if(state->method->slots) {
+            DICT_ITERATE_ITEMS(state->method->slots, char*, name, variable_t*, v) {
+                if(v->index) {
+                    multiname_t*mname = multiname_new(namespace_new(ACCESS_PACKAGE, ""), name);
+                    multiname_t*type = sig2mname(v->type);
+                    trait_t*t = trait_new_member(&f->body->traits, type, mname, 0);
+                    t->slot_id = v->index;
+                }
+            }
+        }
 
+        check_code_for_break(body);
 
-char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
-{
-    return 1; // FIXME
+        /* Seems this works now.
+        if(state->method->exceptions && state->method->uses_slots) {
+           as3_warning("try/catch and activation not supported yet within the same method");
+        }*/
+
+        if(f->body) {
+            f->body->code = body;
+            f->body->exceptions = state->method->exceptions;
+        } else { //interface
+            if(body)
+                syntaxerror("interface methods can't have a method body");
+        }
+
+        old_state();
+        return f;
+    }
+        
+    return 0;
 }
 
 void breakjumpsto(code_t*c, char*name, code_t*jump) 
@@ -1068,29 +1555,8 @@ 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)
@@ -1108,10 +1574,21 @@ 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);
+
+    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_convert_o(c);
 
     classinfo_t*supertype = from;
     while(supertype) {
@@ -1133,45 +1610,57 @@ code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)
         return c;
     if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))
         return c;
-    syntaxerror("can't convert type %s to %s", from->name, to->name);
-    return 0; // make gcc happy
-}
+    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[0]?".":"", from->name, 
+        to->package, to->package[0]?".":"", to->name);
 
-code_t*defaultvalue(code_t*c, classinfo_t*type)
-{
-    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);
-    } else {
-       c = abc_pushnull(c);
-       MULTINAME(m, type);
-       c = abc_coerce2(c, &m);
-    }
     return c;
 }
+/* move to ast.c todo end */
 
 char is_pushundefined(code_t*c)
 {
     return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
 }
 
-void parserassert(int b)
+static const char* get_package_from_name(const char*name)
+{
+    /* try explicit imports */
+    dictentry_t* e = dict_get_slot(state->imports, name);
+    while(e) {
+        if(!strcmp(e->key, name)) {
+            slotinfo_t*c = (slotinfo_t*)e->data;
+            if(c) return c->package;
+        }
+        e = e->next;
+    }
+    return 0;
+}
+static namespace_list_t*get_current_imports()
 {
-    if(!b) syntaxerror("internal error: assertion failed");
+    namespace_list_t*searchlist = 0;
+    
+    list_append(searchlist, namespace_new_package(state->package));
+
+    import_list_t*l = state->wildcard_imports;
+    while(l) {
+        namespace_t*ns = namespace_new_package(l->import->package);
+        list_append(searchlist, ns);
+        l = l->next;
+    }
+    list_append(searchlist, namespace_new_package(""));
+    list_append(searchlist, namespace_new_package(internal_filename_package));
+    return searchlist;
 }
 
-static classinfo_t* find_class(char*name)
+static slotinfo_t* find_class(const char*name)
 {
-    classinfo_t*c=0;
+    slotinfo_t*c=0;
 
-    c = registry_findclass(state->package, name);
+    c = registry_find(state->package, name);
     if(c) return c;
 
     /* try explicit imports */
@@ -1179,7 +1668,7 @@ static classinfo_t* find_class(char*name)
     if(c) return c;
     while(e) {
         if(!strcmp(e->key, name)) {
-            c = (classinfo_t*)e->data;
+            c = (slotinfo_t*)e->data;
             if(c) return c;
         }
         e = e->next;
@@ -1189,188 +1678,60 @@ static classinfo_t* find_class(char*name)
     import_list_t*l = state->wildcard_imports;
     while(l) {
         //printf("does package %s contain a class %s?\n", l->import->package, name);
-        c = registry_findclass(l->import->package, name);
+        c = registry_find(l->import->package, name);
         if(c) return c;
         l = l->next;
     }
 
     /* try global package */
-    c = registry_findclass("", name);
+    c = registry_find("", name);
     if(c) return c;
-   
+  
     /* try local "filename" package */
-    c = registry_findclass(current_filename, name);
+    c = registry_find(internal_filename_package, name);
     if(c) return c;
 
     return 0;
 }
-
-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)
+typedcode_t push_class(slotinfo_t*a)
 {
-    /* 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;
+    typedcode_t x;
+    x.c = 0;
+    x.t = 0;
+    if(a->access == ACCESS_PACKAGEINTERNAL &&
+       strcmp(a->package, state->package) &&
+       strcmp(a->package, internal_filename_package)
+       ) {
+       syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",
+            infotypename(a), a->name, a->package, state->package);
     }
 
-    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 {
-        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);
+    if(a->kind != INFOTYPE_CLASS) {
+        MULTINAME(m, a);
+        x.c = abc_findpropstrict2(x.c, &m);
+        x.c = abc_getproperty2(x.c, &m);
+        if(a->kind == INFOTYPE_METHOD) {
+            methodinfo_t*f = (methodinfo_t*)a;
+            x.t = TYPE_FUNCTION(f);
         } 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);
+            varinfo_t*v = (varinfo_t*)a;
+            x.t = v->type;
         }
     } 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);
+        classinfo_t*c = (classinfo_t*)a;
+        if(c->slot) {
+            x.c = abc_getglobalscope(x.c);
+            x.c = abc_getslot(x.c, c->slot);
         } else {
-            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);
+            MULTINAME(m, c);
+            x.c = abc_getlex2(x.c, &m);
         }
+        x.t = TYPE_CLASS(c);
     }
-    return c;
+    return x;
 }
 
+
 char is_break_or_jump(code_t*c)
 {
     if(!c)
@@ -1386,7 +1747,6 @@ char is_break_or_jump(code_t*c)
     return 0;
 }
 
-
 #define IS_FINALLY_TARGET(op) \
         ((op) == OPCODE___CONTINUE__ || \
          (op) == OPCODE___BREAK__ || \
@@ -1494,18 +1854,243 @@ code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
     int lookup_version_cost = 4*num_insertion_points + 5;
 
     if(cantdup || simple_version_cost > lookup_version_cost) {
-        printf("lookup %d > *%d*\n", simple_version_cost, lookup_version_cost);
+        //printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);
         return insert_finally_lookup(c, finally, tempvar);
     } else {
-        printf("simple *%d* < %d\n", simple_version_cost, lookup_version_cost);
+        //printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);
         return insert_finally_simple(c, finally, tempvar);
     }
 }
 
+#define PASS1 }} if(as3_pass == 1) {{
+#define PASS1END }} if(as3_pass == 2) {{
+#define PASS2 }} if(as3_pass == 2) {{
+#define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{
+#define PASS12END }} if(as3_pass == 2) {{
+#define PASS_ALWAYS }} {{
+
+
+
+/* Line 273 of skeleton.m4  */
+#line 1876 "parser.tab.c"
+/* Unqualified %code blocks.  */
+
+/* Line 274 of skeleton.m4  */
+#line 1952 "parser.y"
+
+    char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
+    {
+        return 1; // FIXME
+    }
+
+
+/* Line 274 of skeleton.m4  */
+#line 2401 "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 2534 "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 && flags->flags&FLAG_STATIC) {
+                state->method = state->cls->static_init;
+            } else {
+                state->method = state->cls->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);
+        /* deal with protected */
+        if(ns.access == ACCESS_PROTECTED && state->cls)
+            ns.name = state->cls->info->name;
+
+        /* slot name */
+        multiname_t mname = {QNAME, &ns, 0, name};
+      
+        trait_list_t**traits;
+        code_t**code=0;
+        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;
+        }
+        if(c)
+            *c = code;
+        if(m) 
+            memcpy(m, &mname, sizeof(multiname_t));
+            
+        return trait_new_member(traits, 0, multiname_clone(&mname), 0);
+    }
+
+
+/* Line 274 of skeleton.m4  */
+#line 2712 "parser.y"
+
+    static int xml_level = 0;
+
+
+/* Line 274 of skeleton.m4  */
+#line 3390 "parser.y"
+
+    node_t* resolve_identifier(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
+            o.c = abc_getlocal(o.c, v->index);
+            o.t = v->type;
+            return mkcodenode(o);
+        }
+        if((v = find_slot(state, 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 && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC;
+
+        /* look at current class' members */
+        if(!state->method->inner && 
+            state->cls && 
+            (f = findmember_nsset(state->cls->info, name, 1)))
+        {
+            // 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 {
+                    namespace_t ns = {f->access, f->package};
+                    multiname_t m = {QNAME, &ns, 0, name};
+                    o.c = abc_getlocal_0(o.c);
+                    o.c = abc_getproperty2(o.c, &m);
+                    return mkcodenode(o);
+                }
+            }
+        } 
+        
+        /* look at actual classes, in the current package and imported */
+        if((a = find_class(name))) {
+            o = push_class(a);
+            return mkcodenode(o);
+        }
+
+        /* look through package prefixes */
+        if(dict_contains(state->import_toplevel_packages, name) || 
+           registry_ispackage(name)) {
+            o.c = abc___pushpackage__(o.c, name);
+            o.t = 0;
+            return mkcodenode(o); //?
+        }
+
+        /* unknown object, let the avm2 resolve it */
+        if(1) {
+            //as3_softwarning("Couldn't resolve '%s', doing late binding", name);
+            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 3523 "parser.y"
+
+    void add_active_url(const char*url)
+    {
+        NEW(namespace_t,n);
+        n->name = url;
+        list_append(state->active_namespace_urls, n);
+    }
+
 
 
-/* Line 264 of yacc.c  */
-#line 1509 "parser.tab.c"
+/* Line 274 of skeleton.m4  */
+#line 2094 "parser.tab.c"
 
 #ifdef short
 # undef short
@@ -1718,22 +2303,22 @@ union yyalloc
 #endif
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  119
+#define YYFINAL  153
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   2463
+#define YYLAST   3311
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  130
+#define YYNTOKENS  134
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  105
+#define YYNNTS  128
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  285
+#define YYNRULES  331
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  478
+#define YYNSTATES  570
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   360
+#define YYMAXUTOK   363
 
 #define YYTRANSLATE(YYX)						\
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -1744,16 +2329,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,   116,     2,     2,     2,   114,   106,     2,
-     126,   129,   113,   111,    97,   110,   123,   112,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,   103,    96,
-     107,    99,   108,   102,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,   118,     2,     2,     2,   116,   107,     2,
+     122,   133,   115,   113,   100,   112,   127,   114,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,   104,    99,
+     109,   102,   110,   103,   128,     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,   120,     2,   121,   105,     2,     2,     2,     2,     2,
+       2,   124,     2,   125,   106,     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,   122,   104,   128,   115,     2,     2,     2,
+       2,     2,     2,   126,   105,   132,   117,     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,
@@ -1776,8 +2361,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,    98,   100,   101,   109,   117,   118,   119,   124,   125,
-     127
+      95,    96,    97,    98,   101,   108,   111,   119,   120,   121,
+     123,   129,   130,   131
 };
 
 #if YYDEBUG
@@ -1786,158 +2371,185 @@ static const yytype_uint8 yytranslate[] =
 static const yytype_uint16 yyprhs[] =
 {
        0,     0,     3,     5,     6,     8,    10,    13,    15,    17,
-      19,    21,    23,    25,    27,    28,    30,    32,    35,    37,
-      39,    41,    43,    45,    47,    49,    50,    53,    55,    57,
-      59,    61,    63,    65,    67,    69,    71,    73,    75,    77,
-      79,    81,    83,    85,    87,    89,    91,    93,    97,   100,
-     103,   105,   107,   110,   111,   114,   117,   119,   123,   127,
-     128,   131,   132,   140,   141,   143,   145,   149,   151,   154,
-     158,   167,   174,   175,   182,   183,   191,   193,   196,   198,
-     201,   202,   204,   206,   209,   211,   214,   219,   223,   224,
-     233,   234,   244,   245,   251,   253,   256,   258,   261,   263,
-     264,   271,   274,   276,   282,   284,   286,   290,   292,   293,
-     300,   301,   307,   310,   315,   316,   318,   320,   323,   325,
-     327,   329,   331,   333,   335,   337,   339,   341,   342,   345,
-     346,   349,   350,   353,   354,   364,   365,   374,   375,   377,
-     379,   382,   384,   386,   388,   390,   391,   393,   395,   398,
-     400,   403,   412,   414,   416,   422,   423,   426,   428,   430,
-     432,   434,   436,   438,   440,   442,   443,   445,   448,   453,
-     457,   459,   464,   467,   469,   471,   472,   473,   486,   488,
-     489,   499,   501,   505,   507,   509,   511,   515,   517,   519,
-     521,   524,   525,   526,   530,   531,   533,   535,   539,   543,
-     548,   553,   556,   558,   561,   563,   565,   569,   571,   573,
-     575,   577,   579,   581,   583,   585,   587,   589,   591,   593,
-     595,   597,   599,   601,   603,   605,   609,   613,   617,   621,
-     625,   629,   633,   637,   641,   645,   648,   651,   655,   659,
-     663,   667,   671,   675,   679,   683,   687,   691,   695,   699,
-     703,   707,   711,   716,   719,   721,   725,   728,   733,   737,
-     738,   740,   744,   750,   754,   758,   762,   766,   770,   774,
-     778,   782,   786,   790,   794,   800,   803,   806,   809,   812,
-     816,   820,   822,   826,   832,   838
+      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,   309,   313,   315,   316,   323,   324,   330,   333,
+     338,   339,   341,   343,   346,   348,   350,   352,   354,   356,
+     358,   360,   362,   364,   366,   367,   370,   371,   374,   375,
+     378,   379,   389,   390,   399,   400,   402,   404,   407,   409,
+     414,   416,   418,   420,   421,   423,   425,   428,   430,   433,
+     442,   444,   446,   447,   452,   454,   458,   462,   463,   466,
+     468,   470,   472,   474,   476,   478,   480,   482,   484,   486,
+     488,   490,   491,   492,   495,   498,   501,   505,   516,   523,
+     535,   536,   538,   540,   543,   547,   548,   550,   553,   558,
+     562,   564,   569,   572,   574,   576,   577,   578,   591,   593,
+     594,   595,   606,   608,   612,   614,   616,   618,   622,   624,
+     626,   628,   631,   632,   633,   637,   638,   640,   642,   644,
+     647,   650,   651,   656,   661,   666,   669,   671,   674,   676,
+     678,   680,   684,   686,   690,   691,   693,   695,   697,   701,
+     707,   709,   711,   713,   715,   717,   719,   721,   723,   725,
+     729,   733,   737,   741,   745,   749,   753,   757,   761,   765,
+     769,   773,   776,   779,   783,   787,   791,   795,   799,   803,
+     807,   811,   815,   819,   823,   827,   831,   835,   839,   844,
+     847,   849,   853,   856,   861,   865,   869,   873,   877,   881,
+     885,   889,   893,   897,   901,   905,   909,   915,   918,   921,
+     924,   927,   931,   934,   940,   942,   944,   946,   948,   954,
+     958,   964,   969,   974,   981,   988,   992,   994,   997,  1002,
+    1007,  1010
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int16 yyrhs[] =
 {
-     131,     0,    -1,   132,    -1,    -1,   133,    -1,   134,    -1,
-     133,   134,    -1,   180,    -1,   192,    -1,   190,    -1,   208,
-      -1,   201,    -1,   143,    -1,    96,    -1,    -1,   136,    -1,
-     137,    -1,   136,   137,    -1,   192,    -1,   190,    -1,   208,
-      -1,   201,    -1,   143,    -1,    96,    -1,   139,    -1,    -1,
-     139,   141,    -1,   141,    -1,   183,    -1,   154,    -1,   155,
-      -1,   156,    -1,   158,    -1,   166,    -1,   149,    -1,   177,
-      -1,   174,    -1,   227,    -1,    96,    -1,   140,    -1,   145,
-      -1,   160,    -1,   161,    -1,   224,    -1,   176,    -1,   233,
-      -1,   234,    -1,   122,   139,   128,    -1,   122,   128,    -1,
-     141,    96,    -1,   141,    -1,   140,    -1,    99,   225,    -1,
-      -1,    45,   146,    -1,    31,   146,    -1,   147,    -1,   146,
-      97,   147,    -1,     3,   217,   144,    -1,    -1,    64,   142,
-      -1,    -1,    63,   126,   150,   226,   129,   142,   148,    -1,
-      -1,   145,    -1,   227,    -1,    45,     3,   217,    -1,     3,
-      -1,    12,   126,    -1,    12,    49,   126,    -1,   153,   151,
-      96,   226,    96,   227,   129,   142,    -1,   153,   152,    67,
-     226,   129,   142,    -1,    -1,    13,   126,   157,   226,   129,
-     142,    -1,    -1,    14,   159,   142,    13,   126,   226,   129,
-      -1,    65,    -1,    65,     3,    -1,    29,    -1,    29,     3,
-      -1,    -1,   163,    -1,   165,    -1,   163,   165,    -1,   164,
-      -1,   163,   164,    -1,    33,   228,   103,   138,    -1,    61,
-     103,   138,    -1,    -1,    15,   126,   167,   228,   129,   122,
-     162,   128,    -1,    -1,    32,   126,     3,   217,   129,   169,
-     122,   138,   128,    -1,    -1,    27,   122,   171,   138,   128,
-      -1,   168,    -1,   172,   168,    -1,   172,    -1,   172,   170,
-      -1,   170,    -1,    -1,    51,   122,   175,   138,   128,   173,
-      -1,    36,   226,    -1,    36,    -1,    38,   126,   226,   129,
-     142,    -1,     3,    -1,    18,    -1,   179,   123,   178,    -1,
-     178,    -1,    -1,    18,   179,   122,   181,   135,   128,    -1,
-      -1,    18,   122,   182,   135,   128,    -1,    40,   214,    -1,
-      40,   179,   123,   113,    -1,    -1,   185,    -1,   186,    -1,
-     185,   186,    -1,    20,    -1,    21,    -1,    19,    -1,    37,
-      -1,    46,    -1,    48,    -1,    47,    -1,    25,    -1,    23,
-      -1,    -1,    53,   214,    -1,    -1,    53,   215,    -1,    -1,
-      16,   215,    -1,    -1,   184,    30,     3,   187,   189,   122,
-     191,   194,   128,    -1,    -1,   184,    43,     3,   188,   122,
-     193,   197,   128,    -1,    -1,   195,    -1,   196,    -1,   195,
-     196,    -1,    96,    -1,   201,    -1,   208,    -1,   140,    -1,
-      -1,   198,    -1,   199,    -1,   198,   199,    -1,    96,    -1,
-      45,     3,    -1,   184,    26,   207,     3,   126,   204,   129,
-     217,    -1,    45,    -1,    31,    -1,   184,   200,     3,   217,
-     144,    -1,    -1,    99,   203,    -1,     9,    -1,     7,    -1,
-       8,    -1,    11,    -1,     4,    -1,    55,    -1,    54,    -1,
-      44,    -1,    -1,   205,    -1,    90,   206,    -1,   205,    97,
-      90,   206,    -1,   205,    97,   206,    -1,   206,    -1,     3,
-     103,   216,   202,    -1,     3,   202,    -1,    50,    -1,    34,
-      -1,    -1,    -1,   184,    26,   207,     3,   126,   204,   129,
-     217,   122,   209,   138,   128,    -1,     3,    -1,    -1,    26,
-     210,   126,   204,   129,   217,   122,   138,   128,    -1,     3,
-      -1,   179,   123,     3,    -1,   213,    -1,   212,    -1,   214,
-      -1,   215,    97,   214,    -1,   214,    -1,   113,    -1,    35,
-      -1,   103,   216,    -1,    -1,    -1,   126,   219,   129,    -1,
-      -1,   220,    -1,   225,    -1,   220,    97,   225,    -1,    24,
-     212,   218,    -1,   228,   126,   219,   129,    -1,    52,   126,
-     219,   129,    -1,    62,   228,    -1,    41,    -1,    41,   226,
-      -1,   228,    -1,   228,    -1,   226,    97,   228,    -1,   226,
-      -1,   211,    -1,   229,    -1,   232,    -1,   221,    -1,   223,
-      -1,     5,    -1,     9,    -1,    10,    -1,     7,    -1,     8,
-      -1,    11,    -1,     4,    -1,    28,    -1,    55,    -1,    54,
-      -1,    44,    -1,   222,    -1,   228,   107,   228,    -1,   228,
-     108,   228,    -1,   228,    73,   228,    -1,   228,    74,   228,
-      -1,   228,    69,   228,    -1,   228,    70,   228,    -1,   228,
-      72,   228,    -1,   228,    71,   228,    -1,   228,    84,   228,
-      -1,   228,    85,   228,    -1,   116,   228,    -1,   115,   228,
-      -1,   228,   106,   228,    -1,   228,   105,   228,    -1,   228,
-     104,   228,    -1,   228,    93,   228,    -1,   228,    92,   228,
-      -1,   228,    91,   228,    -1,   228,   112,   228,    -1,   228,
-     114,   228,    -1,   228,   111,   228,    -1,   228,   110,   228,
-      -1,   228,   113,   228,    -1,   228,    67,   228,    -1,   228,
-      68,   228,    -1,   228,    39,   228,    -1,   228,    66,   228,
-      -1,    42,   126,   228,   129,    -1,    35,   228,    -1,    35,
-      -1,   126,   226,   129,    -1,   110,   228,    -1,   228,   120,
-     228,   121,    -1,   120,   219,   121,    -1,    -1,   231,    -1,
-     225,   103,   225,    -1,   231,    97,   225,   103,   225,    -1,
-     122,   230,   128,    -1,   228,    78,   228,    -1,   228,    77,
-     228,    -1,   228,    82,   228,    -1,   228,    81,   228,    -1,
-     228,    83,   228,    -1,   228,    76,   228,    -1,   228,    75,
-     228,    -1,   228,    79,   228,    -1,   228,    80,   228,    -1,
-     228,    99,   228,    -1,   228,   102,   228,   103,   228,    -1,
-     228,    88,    -1,   228,    87,    -1,    88,   228,    -1,    87,
-     228,    -1,    52,   123,     3,    -1,   228,   123,     3,    -1,
-       3,    -1,   184,    17,     3,    -1,   184,    17,     3,    99,
-       3,    -1,   184,    17,     3,    99,     4,    -1,    22,    17,
-       3,    -1
+     135,     0,    -1,   136,    -1,    -1,   137,    -1,   138,    -1,
+     137,   138,    -1,   186,    -1,   198,    -1,   196,    -1,   227,
+      -1,   207,    -1,   147,    -1,   148,   126,   136,   132,    -1,
+      99,    -1,    -1,   140,    -1,   141,    -1,   140,   141,    -1,
+     198,    -1,   196,    -1,   227,    -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,   250,    -1,   261,    -1,   260,    -1,   126,
+     143,   132,    -1,   126,   132,    -1,    99,    -1,   144,    -1,
+     150,    -1,   165,    -1,   166,    -1,   246,    -1,   181,    -1,
+     148,   126,   143,   132,    -1,   145,    99,    -1,   145,    -1,
+     144,    -1,     3,    89,     3,    -1,   102,   254,    -1,    -1,
+      45,   151,    -1,    31,   151,    -1,   152,    -1,   151,   100,
+     152,    -1,     3,   237,   149,    -1,    -1,    64,   146,    -1,
+      -1,    63,   122,   155,   248,   133,   146,   153,    -1,    -1,
+     150,    -1,   250,    -1,    45,     3,   237,    -1,     3,    -1,
+      11,   122,    -1,    11,    49,   122,    -1,   158,   156,    99,
+     248,    99,   250,   133,   146,    -1,   158,   157,    67,   248,
+     133,   146,    -1,    -1,    12,   122,   162,   248,   133,   146,
+      -1,    -1,    13,   164,   146,    12,   122,   248,   133,    -1,
+      65,    -1,    65,     3,    -1,    29,    -1,    29,     3,    -1,
+      -1,   168,    -1,   170,    -1,   168,   170,    -1,   169,    -1,
+     168,   169,    -1,    33,   254,   104,   142,    -1,    61,   104,
+     142,    -1,    -1,    14,   122,   172,   254,   133,   126,   167,
+     132,    -1,    -1,    32,   122,     3,   237,   133,   174,   126,
+     142,   132,    -1,    -1,    26,   126,   176,   142,   132,    -1,
+     173,    -1,   177,   173,    -1,   177,    -1,   177,   175,    -1,
+     175,    -1,    -1,    51,   126,   180,   142,   132,   178,    -1,
+      36,   248,    -1,    36,    -1,    38,   122,   248,   133,    -1,
+     182,   146,    -1,     3,    -1,    17,    -1,     4,    -1,   185,
+     127,   184,    -1,   184,    -1,    -1,    17,   185,   126,   187,
+     139,   132,    -1,    -1,    17,   126,   188,   139,   132,    -1,
+      40,   233,    -1,    40,   185,   127,   115,    -1,    -1,   191,
+      -1,   192,    -1,   191,   192,    -1,    19,    -1,    20,    -1,
+      18,    -1,    37,    -1,    46,    -1,    48,    -1,    47,    -1,
+      24,    -1,    22,    -1,     4,    -1,    -1,    53,   234,    -1,
+      -1,    53,   235,    -1,    -1,    15,   235,    -1,    -1,   190,
+      30,     3,   193,   195,   126,   197,   200,   132,    -1,    -1,
+     190,    43,     3,   194,   126,   199,   203,   132,    -1,    -1,
+     201,    -1,   202,    -1,   201,   202,    -1,    99,    -1,   148,
+     126,   200,   132,    -1,   207,    -1,   227,    -1,   144,    -1,
+      -1,   204,    -1,   205,    -1,   204,   205,    -1,    99,    -1,
+      45,     3,    -1,   190,    25,   226,     3,   122,   223,   133,
+     237,    -1,    45,    -1,    31,    -1,    -1,   190,   206,   208,
+     209,    -1,   210,    -1,   209,   100,   210,    -1,     3,   237,
+     149,    -1,    -1,   102,   254,    -1,     8,    -1,     9,    -1,
+      10,    -1,     5,    -1,    55,    -1,    54,    -1,    44,    -1,
+      27,    -1,    28,    -1,   219,    -1,   109,    -1,   110,    -1,
+      -1,    -1,   217,     5,    -1,   217,   110,    -1,   219,   217,
+      -1,   218,   219,   217,    -1,   214,     3,   220,   215,   217,
+     109,   114,     3,   216,   110,    -1,   214,     3,   220,   114,
+     216,   110,    -1,   214,     3,   220,   215,   217,   218,   109,
+     114,     3,   216,   110,    -1,    -1,   221,    -1,   222,    -1,
+     221,   222,    -1,     3,   102,     5,    -1,    -1,   224,    -1,
+      93,   225,    -1,   224,   100,    93,   225,    -1,   224,   100,
+     225,    -1,   225,    -1,     3,   104,   236,   211,    -1,     3,
+     211,    -1,    50,    -1,    34,    -1,    -1,    -1,   190,    25,
+     226,     3,   122,   223,   133,   237,   126,   228,   142,   132,
+      -1,     3,    -1,    -1,    -1,    25,   229,   122,   223,   133,
+     237,   126,   231,   142,   132,    -1,   184,    -1,   185,   127,
+     184,    -1,   233,    -1,   232,    -1,   234,    -1,   235,   100,
+     234,    -1,   234,    -1,   115,    -1,    35,    -1,   104,   236,
+      -1,    -1,    -1,   122,   239,   133,    -1,    -1,   240,    -1,
+     241,    -1,   247,    -1,   240,   100,    -1,   241,   247,    -1,
+      -1,    23,   254,   242,   238,    -1,   254,   122,   239,   133,
+      -1,    52,   122,   239,   133,    -1,    62,   254,    -1,    41,
+      -1,    41,   248,    -1,   254,    -1,   249,    -1,   254,    -1,
+     249,   100,   254,    -1,   254,    -1,   250,   100,   254,    -1,
+      -1,   253,    -1,     3,    -1,     5,    -1,   252,   104,   247,
+      -1,   253,   100,   252,   104,   247,    -1,   230,    -1,   257,
+      -1,   243,    -1,   245,    -1,   244,    -1,   258,    -1,   212,
+      -1,   213,    -1,     6,    -1,   124,   239,   125,    -1,    69,
+     251,   132,    -1,   254,   109,   254,    -1,   254,   110,   254,
+      -1,   254,    74,   254,    -1,   254,    75,   254,    -1,   254,
+      70,   254,    -1,   254,    71,   254,    -1,   254,    73,   254,
+      -1,   254,    72,   254,    -1,   254,    87,   254,    -1,   254,
+      88,   254,    -1,   118,   254,    -1,   117,   254,    -1,   254,
+     107,   254,    -1,   254,   106,   254,    -1,   254,   105,   254,
+      -1,   254,    96,   254,    -1,   254,    95,   254,    -1,   254,
+      94,   254,    -1,   254,   114,   254,    -1,   254,   116,   254,
+      -1,   254,   113,   254,    -1,   254,   112,   254,    -1,   254,
+     115,   254,    -1,   254,    67,   254,    -1,   254,    68,   254,
+      -1,   254,    39,   254,    -1,   254,    66,   254,    -1,    42,
+     122,   254,   133,    -1,    35,   254,    -1,    35,    -1,   122,
+     249,   133,    -1,   112,   254,    -1,   254,   124,   254,   125,
+      -1,   254,    79,   254,    -1,   254,    78,   254,    -1,   254,
+      85,   254,    -1,   254,    84,   254,    -1,   254,    86,   254,
+      -1,   254,    77,   254,    -1,   254,    76,   254,    -1,   254,
+      83,   254,    -1,   254,    80,   254,    -1,   254,    81,   254,
+      -1,   254,    82,   254,    -1,   254,   102,   254,    -1,   254,
+     103,   254,   104,   254,    -1,   254,    91,    -1,   254,    90,
+      -1,    91,   254,    -1,    90,   254,    -1,    52,   127,     3,
+      -1,   128,     3,    -1,   254,   127,   122,   254,   133,    -1,
+       3,    -1,     4,    -1,     3,    -1,   115,    -1,   254,   127,
+     255,    89,   256,    -1,   254,    92,   256,    -1,   254,   127,
+     124,   254,   125,    -1,   254,   127,   128,   256,    -1,   254,
+      92,   128,   256,    -1,   254,   127,   128,   124,   254,   125,
+      -1,   254,    92,   128,   124,   254,   125,    -1,   254,   127,
+     256,    -1,     3,    -1,    16,     3,    -1,    16,     3,   102,
+       3,    -1,    16,     3,   102,     5,    -1,   190,   259,    -1,
+      21,    16,   234,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,  1484,  1484,  1486,  1486,  1487,  1488,  1490,  1491,  1492,
-    1493,  1494,  1495,  1496,  1498,  1498,  1499,  1500,  1502,  1503,
-    1504,  1505,  1506,  1507,  1509,  1510,  1512,  1513,  1516,  1517,
-    1518,  1519,  1520,  1521,  1522,  1523,  1524,  1525,  1528,  1529,
-    1530,  1531,  1532,  1533,  1534,  1536,  1537,  1539,  1540,  1541,
-    1542,  1546,  1553,  1554,  1558,  1559,  1561,  1562,  1564,  1605,
-    1606,  1609,  1609,  1628,  1629,  1630,  1633,  1636,  1640,  1641,
-    1643,  1663,  1706,  1706,  1725,  1725,  1740,  1743,  1746,  1749,
-    1753,  1754,  1755,  1756,  1757,  1758,  1760,  1771,  1774,  1774,
-    1803,  1803,  1823,  1823,  1840,  1841,  1842,  1843,  1851,  1860,
-    1860,  1905,  1909,  1920,  1929,  1930,  1932,  1933,  1935,  1935,
-    1936,  1936,  1938,  1946,  1956,  1957,  1958,  1959,  1961,  1962,
-    1963,  1964,  1965,  1966,  1967,  1968,  1969,  1971,  1972,  1974,
-    1975,  1977,  1978,  1982,  1980,  1988,  1986,  1994,  1995,  1996,
-    1997,  1998,  1999,  2000,  2002,  2008,  2009,  2010,  2011,  2012,
-    2013,  2016,  2027,  2027,  2029,  2087,  2088,  2090,  2091,  2092,
-    2093,  2094,  2096,  2097,  2098,  2103,  2106,  2111,  2116,  2123,
-    2127,  2132,  2138,  2144,  2145,  2146,  2149,  2148,  2166,  2167,
-    2168,  2176,  2183,  2189,  2190,  2192,  2193,  2195,  2196,  2197,
-    2206,  2207,  2211,  2212,  2214,  2215,  2216,  2219,  2224,  2248,
-    2296,  2316,  2337,  2340,  2347,  2348,  2349,  2355,  2361,  2363,
-    2365,  2367,  2369,  2371,  2388,  2393,  2396,  2399,  2402,  2405,
-    2408,  2411,  2414,  2417,  2421,  2422,  2425,  2428,  2431,  2434,
-    2437,  2440,  2443,  2447,  2458,  2476,  2481,  2486,  2491,  2496,
-    2501,  2505,  2509,  2514,  2518,  2522,  2531,  2540,  2550,  2555,
-    2567,  2573,  2578,  2584,  2590,  2594,  2596,  2607,  2616,  2623,
-    2624,  2626,  2632,  2641,  2648,  2660,  2666,  2672,  2678,  2684,
-    2690,  2696,  2709,  2720,  2727,  2740,  2767,  2781,  2795,  2809,
-    2824,  2858,  2956,  2957,  2958,  2960
+       0,  1857,  1857,  1859,  1859,  1860,  1861,  1863,  1864,  1865,
+    1866,  1867,  1868,  1869,  1870,  1872,  1872,  1873,  1874,  1876,
+    1877,  1878,  1879,  1880,  1881,  1882,  1884,  1885,  1887,  1890,
+    1893,  1894,  1895,  1896,  1897,  1898,  1899,  1900,  1901,  1902,
+    1903,  1904,  1905,  1906,  1909,  1910,  1911,  1912,  1913,  1914,
+    1915,  1916,  1928,  1929,  1933,  1940,  1959,  1960,  1962,  1963,
+    1965,  1966,  1968,  2028,  2029,  2032,  2032,  2051,  2052,  2053,
+    2058,  2062,  2067,  2068,  2070,  2090,  2138,  2138,  2157,  2157,
+    2172,  2175,  2178,  2181,  2185,  2186,  2187,  2188,  2189,  2190,
+    2192,  2203,  2206,  2206,  2237,  2237,  2262,  2262,  2278,  2279,
+    2280,  2281,  2289,  2298,  2298,  2347,  2351,  2362,  2372,  2389,
+    2390,  2391,  2393,  2394,  2396,  2396,  2398,  2398,  2421,  2435,
+    2451,  2452,  2453,  2454,  2461,  2462,  2463,  2464,  2465,  2466,
+    2467,  2468,  2469,  2470,  2474,  2475,  2477,  2478,  2480,  2481,
+    2485,  2483,  2491,  2489,  2498,  2499,  2500,  2501,  2502,  2503,
+    2504,  2505,  2507,  2513,  2514,  2515,  2516,  2517,  2518,  2521,
+    2587,  2587,  2589,  2589,  2591,  2592,  2594,  2678,  2679,  2688,
+    2689,  2692,  2693,  2694,  2695,  2696,  2697,  2698,  2716,  2718,
+    2719,  2720,  2722,  2723,  2724,  2726,  2727,  2729,  2733,  2736,
+    2741,  2742,  2743,  2744,  2745,  2755,  2759,  2765,  2771,  2779,
+    2784,  2790,  2798,  2806,  2807,  2808,  2811,  2810,  2827,  2828,
+    2830,  2829,  2853,  2872,  2886,  2887,  2889,  2890,  2892,  2893,
+    2894,  2903,  2904,  2908,  2909,  2911,  2912,  2913,  2915,  2919,
+    2920,  2925,  2926,  2963,  3013,  3034,  3056,  3059,  3066,  3069,
+    3072,  3075,  3078,  3081,  3086,  3087,  3089,  3090,  3092,  3098,
+    3107,  3108,  3109,  3110,  3111,  3112,  3114,  3118,  3131,  3151,
+    3161,  3170,  3171,  3172,  3173,  3174,  3175,  3176,  3177,  3178,
+    3179,  3180,  3181,  3182,  3183,  3184,  3185,  3186,  3187,  3188,
+    3189,  3190,  3191,  3192,  3193,  3194,  3195,  3196,  3197,  3198,
+    3199,  3200,  3201,  3202,  3203,  3204,  3205,  3206,  3207,  3208,
+    3209,  3210,  3211,  3212,  3213,  3214,  3215,  3217,  3218,  3219,
+    3220,  3222,  3237,  3244,  3251,  3252,  3253,  3254,  3256,  3274,
+    3281,  3292,  3299,  3306,  3316,  3327,  3497,  3532,  3539,  3546,
+    3553,  3575
 };
 #endif
 
@@ -1946,51 +2558,57 @@ static const yytype_uint16 yyrline[] =
    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 static const char *const yytname[] =
 {
-  "$end", "error", "$undefined", "T_IDENTIFIER", "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\"",
+  "$end", "error", "$undefined", "T_IDENTIFIER", "T_NAMESPACE",
+  "T_STRING", "T_REGEXP", "T_EMPTY", "T_INT", "T_UINT", "T_FLOAT",
+  "\"for\"", "\"while\"", "\"do\"", "\"switch\"", "\"implements\"",
+  "\"namespace\"", "\"package\"", "\"protected\"", "\"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\"", "\"delete\"",
   "\"if\"", "\"else\"", "\"break\"", "\"is\"", "\"in\"", "\"as\"",
-  "\"==\"", "\"===\"", "\"!=\"", "\"!==\"", "\"<=\"", "\">=\"", "\"|=\"",
-  "\"/=\"", "\"%=\"", "\"*=\"", "\"+=\"", "\"-=\"", "\">>=\"", "\"<<=\"",
-  "\">>>=\"", "\"||\"", "\"&&\"", "\"::\"", "\"--\"", "\"++\"", "\"..\"",
-  "\"...\"", "\"<<\"", "\">>>\"", "\">>\"", "prec_none", "below_semicolon",
-  "';'", "','", "below_assignment", "'='", "\"&=\"", "\"^=\"", "'?'",
-  "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "below_minus", "'-'", "'+'",
-  "'/'", "'*'", "'%'", "'~'", "'!'", "minusminus_prefix",
-  "plusplus_prefix", "below_curly", "'['", "']'", "'{'", "'.'",
-  "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", "MAYBEEXPRESSION",
+  "\"{ (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", "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", "X_IDENTIFIER", "PACKAGE",
+  "TRY", "$@7", "THROW", "WITH_HEAD", "WITH", "X_IDENTIFIER", "PACKAGE",
   "PACKAGE_DECLARATION", "$@8", "$@9", "IMPORT", "MAYBE_MODIFIERS",
   "MODIFIER_LIST", "MODIFIER", "EXTENDS", "EXTENDS_LIST",
   "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@10", "INTERFACE_DECLARATION",
   "$@11", "MAYBE_CLASS_BODY", "CLASS_BODY", "CLASS_BODY_ITEM",
   "MAYBE_INTERFACE_BODY", "INTERFACE_BODY", "IDECLARATION", "VARCONST",
-  "SLOT_DECLARATION", "MAYBESTATICCONSTANT", "STATICCONSTANT",
+  "SLOT_DECLARATION", "$@12", "SLOT_LIST", "ONE_SLOT", "MAYBECONSTANT",
+  "CONSTANT", "XML", "OPEN", "CLOSE", "CLOSE2", "XMLTEXT", "XML2",
+  "XMLNODE", "MAYBE_XMLATTRIBUTES", "XMLATTRIBUTES", "XMLATTRIBUTE",
   "MAYBE_PARAM_LIST", "PARAM_LIST", "PARAM", "GETSET",
-  "FUNCTION_DECLARATION", "$@12", "MAYBE_IDENTIFIER", "INNERFUNCTION",
-  "CLASS", "PACKAGEANDCLASS", "QNAME", "QNAME_LIST", "TYPE", "MAYBETYPE",
-  "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST", "EXPRESSION_LIST", "NEW",
+  "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_DECLARATION", "USE_NAMESPACE", 0
+  "COMMA_EXPRESSION", "VOIDEXPRESSION", "MAYBE_DICT_EXPRPAIR_LIST",
+  "DICTLH", "DICT_EXPRPAIR_LIST", "E", "ID_OR_NS", "SUBNODE", "MEMBER",
+  "VAR_READ", "NAMESPACE_ID", "NAMESPACE_DECLARATION", "USE_NAMESPACE", 0
 };
 #endif
 
@@ -2008,79 +2626,90 @@ 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,    59,    44,   351,    61,
-     352,   353,    63,    58,   124,    94,    38,    60,    62,   354,
-      45,    43,    47,    42,    37,   126,    33,   355,   356,   357,
-      91,    93,   123,    46,   358,   359,    40,   360,   125,    41
+     345,   346,   347,   348,   349,   350,   351,   352,   353,    59,
+      44,   354,    61,    63,    58,   124,    94,    38,   355,    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
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const yytype_uint8 yyr1[] =
+static const yytype_uint16 yyr1[] =
 {
-       0,   130,   131,   132,   132,   133,   133,   134,   134,   134,
-     134,   134,   134,   134,   135,   135,   136,   136,   137,   137,
-     137,   137,   137,   137,   138,   138,   139,   139,   140,   140,
-     140,   140,   140,   140,   140,   140,   140,   140,   141,   141,
-     141,   141,   141,   141,   141,   141,   141,   142,   142,   142,
-     142,   143,   144,   144,   145,   145,   146,   146,   147,   148,
-     148,   150,   149,   151,   151,   151,   152,   152,   153,   153,
-     154,   155,   157,   156,   159,   158,   160,   160,   161,   161,
-     162,   162,   162,   162,   163,   163,   164,   165,   167,   166,
-     169,   168,   171,   170,   172,   172,   173,   173,   173,   175,
-     174,   176,   176,   177,   178,   178,   179,   179,   181,   180,
-     182,   180,   183,   183,   184,   184,   185,   185,   186,   186,
-     186,   186,   186,   186,   186,   186,   186,   187,   187,   188,
-     188,   189,   189,   191,   190,   193,   192,   194,   194,   195,
-     195,   196,   196,   196,   196,   197,   197,   198,   198,   199,
-     199,   199,   200,   200,   201,   202,   202,   203,   203,   203,
-     203,   203,   203,   203,   203,   204,   204,   204,   204,   205,
-     205,   206,   206,   207,   207,   207,   209,   208,   210,   210,
-     211,   212,   213,   214,   214,   215,   215,   216,   216,   216,
-     217,   217,   218,   218,   219,   219,   220,   220,   221,   222,
-     222,   223,   224,   224,   225,   226,   226,   227,   228,   228,
-     228,   228,   228,   228,   229,   229,   229,   229,   229,   229,
-     229,   229,   229,   229,   228,   228,   228,   228,   228,   228,
-     228,   228,   228,   228,   228,   228,   228,   228,   228,   228,
-     228,   228,   228,   228,   228,   228,   228,   228,   228,   228,
-     228,   228,   228,   228,   228,   228,   228,   228,   228,   230,
-     230,   231,   231,   228,   228,   228,   228,   228,   228,   228,
-     228,   228,   228,   228,   228,   228,   228,   228,   228,   228,
-     228,   232,   233,   233,   233,   234
+       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,   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,   214,
+     215,   216,   217,   217,   217,   218,   218,   219,   219,   219,
+     220,   220,   221,   221,   222,   223,   223,   223,   223,   224,
+     224,   225,   225,   226,   226,   226,   228,   227,   229,   229,
+     231,   230,   232,   233,   234,   234,   235,   235,   236,   236,
+     236,   237,   237,   238,   238,   239,   239,   239,   240,   241,
+     240,   242,   243,   244,   244,   245,   246,   246,   247,   248,
+     249,   249,   250,   250,   251,   251,   252,   252,   253,   253,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   255,   255,   256,   256,   254,   254,
+     254,   254,   254,   254,   254,   257,   258,   259,   259,   259,
+     260,   261
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 static const yytype_uint8 yyr2[] =
 {
        0,     2,     1,     0,     1,     1,     2,     1,     1,     1,
-       1,     1,     1,     1,     0,     1,     1,     2,     1,     1,
-       1,     1,     1,     1,     1,     0,     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,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     3,     2,     2,
-       1,     1,     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,     5,     1,     1,     3,     1,     0,     6,
-       0,     5,     2,     4,     0,     1,     1,     2,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     0,     2,     0,
-       2,     0,     2,     0,     9,     0,     8,     0,     1,     1,
-       2,     1,     1,     1,     1,     0,     1,     1,     2,     1,
-       2,     8,     1,     1,     5,     0,     2,     1,     1,     1,
-       1,     1,     1,     1,     1,     0,     1,     2,     4,     3,
-       1,     4,     2,     1,     1,     0,     0,    12,     1,     0,
-       9,     1,     3,     1,     1,     1,     3,     1,     1,     1,
-       2,     0,     0,     3,     0,     1,     1,     3,     3,     4,
-       4,     2,     1,     2,     1,     1,     3,     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,     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,     1,     1,
-       1,     1,     1,     1,     1,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     2,     2,     3,     3,     3,
+       1,     0,     0,     2,     2,     2,     3,    10,     6,    11,
+       0,     1,     1,     2,     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,     3,     5,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     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,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     5,     2,     2,     2,     2,     3,
-       3,     1,     3,     5,     5,     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,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     5,     2,     2,     2,
+       2,     3,     2,     5,     1,     1,     1,     1,     5,     3,
+       5,     4,     4,     6,     6,     3,     1,     2,     4,     4,
+       2,     3
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -2088,702 +2717,903 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint16 yydefact[] =
 {
-     114,   281,   219,   213,   216,   217,   214,   215,   218,     0,
-       0,    74,     0,     0,   120,   118,   119,   126,     0,   125,
-     179,   220,   254,   121,     0,     0,     0,   223,   122,   124,
-     123,     0,     0,   222,   221,     0,     0,     0,     0,    13,
-       0,     0,     0,   194,   259,     0,     0,     2,   114,     5,
-      51,    12,    34,    63,    29,    30,    31,    32,    33,    36,
-      35,     7,    28,     0,   115,   116,     9,     8,    11,    10,
-     208,   211,   224,   212,   207,    37,   205,   209,   210,     0,
-      68,    72,   114,    88,   104,   105,   110,   107,     0,   181,
-     192,   178,     0,   253,     0,   181,     0,   184,   183,   112,
-       0,    99,     0,   194,   201,    61,   278,   277,   256,   236,
-     235,     0,   195,   196,   204,     0,     0,   260,     0,     1,
-       6,   281,     0,     0,    64,     0,     0,    65,   175,     0,
-     153,     0,   152,     0,   117,     0,     0,     0,     0,     0,
+     120,   326,   133,   172,   258,   169,   170,   171,     0,     0,
+      78,     0,     0,   126,   124,   125,     0,   132,     0,   131,
+     209,   176,   177,   290,   127,     0,     0,     0,   175,   128,
+     130,   129,     0,     0,   174,   173,     0,     0,   244,     0,
+       0,    14,   179,     0,     0,     0,     0,   225,   120,     0,
+       0,     2,   120,     5,    54,    12,     0,    36,    67,    31,
+      32,    33,    34,    35,    38,   120,    37,     7,    30,     0,
+     121,   122,     9,     8,    11,   256,   257,     0,   178,    10,
+     250,   252,   254,   253,    39,   242,   251,   255,    41,    40,
+       0,     0,    72,    76,   120,    92,   109,   111,   110,   116,
+     113,     0,     0,   326,   231,   208,     0,   289,     0,     0,
+     118,     0,   103,   225,     0,   235,    65,   246,   247,     0,
+       0,   245,   310,   309,   292,   272,   271,     0,   240,     0,
+     226,   227,   228,   238,    82,     0,   106,   236,     0,    80,
+      44,    43,   120,    45,    29,     0,    46,    47,    48,    50,
+       0,    49,   312,     1,     6,   120,   326,     0,    68,     0,
+       0,    69,    53,   108,     0,   205,     0,   161,     0,   160,
+     162,   330,   123,   190,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   276,   275,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   308,   307,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   194,    69,     0,     0,
-      78,   102,   202,     0,    76,    38,   114,    39,    50,     0,
-      40,    41,    42,    44,     0,    43,    45,    46,     0,   114,
-     108,     0,   194,   198,   165,     0,     0,     0,    25,   279,
-       0,     0,   258,     0,     0,   263,     0,   255,   191,    55,
-      56,   191,    54,     0,     0,   174,   173,     0,   127,   129,
-     191,   206,   250,   251,   248,   249,   229,   230,   232,   231,
-     227,   228,   270,   269,   265,   264,   271,   272,   267,   266,
-     268,   233,   234,   242,   241,   240,   273,     0,   239,   238,
-     237,   225,   226,   246,   245,   243,   247,   244,     0,   280,
-       0,     0,     0,    79,   101,   203,    77,    48,   114,    27,
-     205,    49,     0,     0,     0,    23,     0,   114,    16,    22,
-      19,    18,    21,    20,   114,   106,     0,   155,     0,     0,
-     166,   170,   114,   182,   113,   252,     0,    24,   200,     0,
-     197,   261,     0,     0,    53,     0,    53,     0,     0,     0,
-       0,   131,     0,     0,    53,     0,   257,   199,   114,   285,
-      47,    26,     0,   282,     0,   111,    17,     0,   193,     0,
-       0,   172,   167,   191,     0,   103,     0,   114,     0,   189,
-     188,     0,   187,   190,     0,    58,    57,     0,   114,   165,
-     128,     0,     0,   185,   130,   135,   154,   274,    73,     0,
-       0,    80,   109,   161,   158,   159,   157,   160,   164,   163,
-     162,   156,   155,     0,     0,   169,     0,     0,    94,    98,
-      96,   100,    59,   262,     0,    52,     0,    71,     0,   132,
-     133,     0,   114,    75,   283,   284,     0,     0,     0,    81,
-      84,    82,   171,    25,   168,    92,     0,    95,    97,   114,
-      62,   114,   191,   114,   186,     0,   149,     0,     0,   114,
-     147,     0,    25,    89,    85,    83,     0,    25,   191,    60,
-      70,     0,   141,   144,     0,     0,   114,   139,   142,   143,
-     150,   175,   136,   148,    25,    87,   180,     0,     0,   176,
-     134,   140,     0,    86,    93,    90,    25,     0,     0,     0,
-     165,    25,   177,     0,     0,   191,    91,   151
+       0,     0,     0,     0,     0,     0,   225,     0,     0,    55,
+      73,     0,     0,     0,   120,   114,     0,   212,     0,   215,
+     214,   331,   223,   195,     0,   239,     0,     0,    27,     0,
+     311,     0,   260,     0,     0,     0,   291,   259,   229,   230,
+      83,   222,    59,    60,   105,   237,    58,    81,    42,    28,
+     120,     0,   222,     0,     0,    52,   327,   204,   203,     0,
+     134,   136,     0,     0,     0,   191,   192,   243,   286,   287,
+     284,   285,   265,   266,   268,   267,   263,   264,   300,   299,
+     295,   294,   302,   303,   304,   301,   297,   296,   298,   269,
+     270,   316,   317,     0,   319,   278,   277,   276,   305,     0,
+     275,   274,   273,   261,   262,   282,   281,   279,   283,   280,
+       0,     0,   316,   315,     0,     0,     0,     0,   325,     0,
+       0,     0,    25,     0,   120,    17,    23,     0,    20,    19,
+      22,    21,   120,   112,     0,   225,   232,   167,     0,     0,
+     196,   200,   107,   119,   213,   288,     0,    26,   234,     0,
+     248,     0,   241,     0,    57,     0,   120,    13,    57,     0,
+       0,     0,     0,     0,   138,     0,     0,   222,   163,   164,
+       0,   180,   181,   182,   193,     0,   322,     0,   233,   293,
+       0,     0,     0,   321,     0,   120,     0,     0,   117,    18,
+     120,     0,     0,     0,     0,   202,   197,   222,     0,     0,
+     120,     0,   220,   219,   218,   221,     0,    62,    61,    51,
+       0,   120,   328,   329,   195,   135,     0,     0,   216,   137,
+     142,    57,     0,   194,     0,     0,     0,   306,   313,   320,
+       0,   318,    77,     0,    84,     0,   115,   224,   168,   167,
+       0,     0,   199,     0,     0,    98,   102,   100,   104,    63,
+     249,    56,     0,    75,     0,   139,   140,     0,   120,   166,
+     165,   188,   183,   179,   184,     0,   182,   324,   323,    79,
+       0,     0,     0,    85,    88,    86,    24,   201,   210,   198,
+      96,     0,    99,   101,   120,    66,   120,   222,   120,   217,
+       0,   157,     0,     0,   120,   155,     0,   179,   182,   185,
+       0,    27,    93,    89,    87,    27,    27,   222,    64,    74,
+       0,   148,   152,     0,     0,     0,   120,   146,   150,   151,
+     158,   205,   143,   156,   181,     0,   186,    27,    91,     0,
+       0,     0,   206,   120,   141,   147,     0,     0,   181,    90,
+     211,    97,    94,    27,     0,     0,   187,     0,     0,     0,
+     149,   195,   189,    27,   207,     0,     0,   222,    95,   159
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,    46,    47,    48,    49,   286,   287,   288,   306,   307,
-     187,   279,   189,   289,   355,   190,   222,   220,   420,    52,
-     211,   125,   126,    53,    54,    55,    56,   178,    57,    82,
-     191,   192,   408,   409,   410,   411,    58,   198,   388,   468,
-     389,   437,   390,   391,    59,   208,   193,    60,    87,   351,
-      61,   294,   199,    62,   194,    64,    65,   321,   323,   362,
-     290,   423,   291,   402,   445,   446,   447,   428,   429,   430,
-     133,   292,   341,   381,   299,   300,   301,   227,   293,   466,
-      92,    70,    97,    98,   352,   364,   353,   314,   203,   111,
-     112,    71,    72,    73,   195,   113,    74,    75,    76,    77,
-     116,   117,    78,   196,   197
+      -1,    50,    51,    52,    53,   333,   334,   335,   356,   357,
+     143,   144,   163,   336,   145,   417,   146,   256,   253,   495,
+      57,   241,   159,   160,    58,    59,    60,    61,   221,    62,
+      94,   147,   148,   482,   483,   484,   485,    63,   223,   455,
+     558,   456,   516,   457,   458,    64,   238,   149,    65,    66,
+     227,   228,    67,   342,   224,    68,   150,    70,    71,   374,
+     376,   427,   338,   498,   339,   468,   525,   526,   527,   503,
+     504,   505,   170,   340,   272,   378,   379,   405,    75,    76,
+      77,   383,   434,   435,   475,    78,   274,   275,   276,   349,
+     350,   351,   269,   341,   553,   106,    80,   515,   229,   230,
+     414,   429,   415,   364,   346,   129,   130,   131,   232,    81,
+      82,    83,   151,   132,   234,   235,    84,   119,   120,   121,
+      85,   327,   304,    86,    87,   171,    88,    89
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -308
+#define YYPACT_NINF -467
 static const yytype_int16 yypact[] =
 {
-     349,  -308,  -308,  -308,  -308,  -308,  -308,  -308,  -308,   -38,
-     -86,  -308,   -72,    35,  -308,  -308,  -308,  -308,    30,  -308,
-      97,  -308,    52,  -308,   -14,    18,    36,  -308,  -308,  -308,
-    -308,    57,    44,  -308,  -308,  1538,    40,  1538,  1538,  -308,
-    1538,  1538,  1538,  1538,  1538,  1538,   102,  -308,   473,  -308,
-    -308,  -308,  -308,   211,  -308,  -308,  -308,  -308,  -308,  -308,
-    -308,  -308,  -308,   275,   640,  -308,  -308,  -308,  -308,  -308,
-    -308,  -308,  -308,  -308,    96,  -308,  1971,  -308,  -308,    82,
-    -308,  -308,  1469,  -308,  -308,  -308,  -308,  -308,   -32,  -308,
-      83,  -308,    84,   104,  1538,    88,    89,  -308,  -308,  -308,
-    1538,  -308,   186,  1538,   104,  -308,   104,   104,   163,   104,
-     104,   108,   116,  -308,  1971,   114,   105,   128,   -88,  -308,
-    -308,   165,   231,   233,  -308,   144,   174,  -308,    -5,   240,
-    -308,   241,  -308,   244,  -308,  1538,  1538,  1538,  1538,  1538,
-    1538,  1538,  1538,  1538,  1538,  1538,  1538,  1538,  1538,  1538,
-    1538,  1538,  1538,  1538,  1538,  1538,  1538,  -308,  -308,  1538,
-    1538,  1538,  1538,  1538,  1538,  1538,  1538,  1538,  1538,  1538,
-    1538,  1538,  1538,  1538,  1538,   245,  1538,  -308,  1538,   232,
-     255,  1538,  1538,   231,   256,  -308,   593,  -308,   164,   248,
-    -308,  -308,  -308,  -308,   247,  -308,  -308,  -308,  1538,   845,
-    -308,    90,  1538,  -308,     9,   -82,    68,  1599,  1349,  -308,
-     138,  1538,  -308,  1538,  1538,  -308,  1538,  -308,   166,   171,
-    -308,   166,   171,  1538,  1538,  -308,  -308,   267,   219,   221,
-     166,  1971,   962,   836,   836,   836,  2337,  2337,  2337,  2337,
-     962,   962,  1971,  1971,  1971,  1971,  1971,  1971,  1971,  1971,
-    1971,  2032,  2093,   340,   340,   340,  1971,  1727,  2154,  2215,
-    2276,   962,   962,   163,   163,   104,   104,   104,  1788,  -308,
-     149,   -62,   276,  -308,    96,    96,  -308,  -308,   719,  -308,
-    1849,  -308,   154,   278,  1663,  -308,   156,   971,  -308,  -308,
-    -308,  -308,  -308,  -308,   845,  -308,   161,   -69,   282,   167,
-     195,  -308,  1469,    88,  -308,  -308,   169,  1349,  -308,   -55,
-    -308,  -308,   190,    63,   204,   231,   -24,    86,    74,   178,
-      18,   292,    18,   187,   204,  1538,  -308,  -308,  1469,  -308,
-    -308,  -308,  1538,   213,   188,  -308,  -308,   185,  -308,    61,
-      63,  -308,  -308,   166,    11,  -308,    62,  1469,  1538,  -308,
-    -308,   191,  -308,  -308,  1538,  -308,  -308,  1538,  1469,     9,
-    -308,    18,   194,  -308,   220,  -308,  -308,  1971,  -308,    76,
-     182,   136,  -308,  -308,  -308,  -308,  -308,  -308,  -308,  -308,
-    -308,  -308,   224,   197,   282,  -308,   202,   199,  -308,  -308,
-      62,  -308,   265,  -308,    92,  -308,   203,  -308,   205,   220,
-    -308,    18,   394,  -308,  -308,  -308,  1538,   235,   207,   136,
-    -308,  -308,  -308,  1349,  -308,  -308,   336,  -308,  -308,  1469,
-    -308,  1469,   166,  1097,  -308,   337,  -308,   316,   216,   529,
-    -308,  1910,  1349,  -308,  -308,  -308,   218,  1349,   166,  -308,
-    -308,   225,  -308,  -308,    66,   222,  1223,  -308,  -308,  -308,
-    -308,    -5,  -308,  -308,  1349,  -308,  -308,   223,   226,  -308,
-    -308,  -308,   345,  -308,  -308,  -308,  1349,   239,   249,   238,
-       9,  1349,  -308,   246,   250,   166,  -308,  -308
+    1718,   -46,  -467,  -467,  -467,  -467,  -467,  -467,   -29,   -54,
+    -467,   -32,    60,  -467,  -467,  -467,    46,  -467,  2165,  -467,
+      99,  -467,  -467,  2236,  -467,   -10,    82,    -2,  -467,  -467,
+    -467,  -467,    22,   -61,  -467,  -467,  2165,    25,   110,  2165,
+    2165,  -467,  -467,  2165,  2165,  2165,  2165,  2165,   678,   150,
+     211,  -467,   548,  -467,  -467,  -467,    88,  -467,  2094,  -467,
+    -467,  -467,  -467,  -467,  -467,  1970,  -467,  -467,  -467,    49,
+     347,  -467,  -467,  -467,  -467,  -467,  -467,   213,  -467,  -467,
+    -467,  -467,  -467,  -467,   120,  2936,  -467,  -467,  -467,  -467,
+     220,   105,  -467,  -467,  1970,  -467,  -467,  -467,  -467,  -467,
+    -467,    92,    82,  -467,   -55,  -467,   109,   157,  2165,    94,
+    -467,  2165,  -467,  2165,   230,   157,  -467,  -467,  -467,   107,
+     130,   141,   157,   157,   397,   157,   157,   -60,  2874,   118,
+     152,  2165,  -467,  2874,   253,   254,  2165,  2165,   254,   255,
+    -467,  -467,   808,  -467,  -467,   134,  -467,  -467,  -467,  -467,
+     245,  -467,  -467,  -467,  -467,  1068,   195,   264,  -467,   176,
+     209,   120,   178,  -467,   275,    33,   277,  -467,   279,  -467,
+    -467,  -467,  -467,   280,  2165,  2165,  2165,  2165,  2165,  2165,
+    2165,  2165,  2165,  2165,  2165,  2165,  2165,  2165,  2165,  2165,
+    2165,  2165,  2165,  2165,  2165,  2165,  2165,  2165,  -467,  -467,
+      13,  2165,  2165,  2165,  2165,  2165,  2165,  2165,  2165,  2165,
+    2165,  2165,  2165,  2165,  2165,  2165,  2165,  2165,    21,  -467,
+    -467,  2165,   273,  2165,  1198,  -467,    82,   163,   164,  -467,
+    -467,  -467,   170,    39,   160,   194,   102,  2295,  1844,   167,
+    -467,  2165,  -467,  2165,   110,  2165,  -467,  -467,  -467,  -467,
+    -467,   197,   202,  -467,  -467,  -467,   202,  -467,  -467,  -467,
+    1970,   171,   197,  2165,  2165,  -467,   207,  -467,  -467,   301,
+     257,   260,   303,   212,    32,   280,  -467,  2874,  1060,   540,
+     540,   540,  3184,  3184,  3184,  3184,  1060,  1060,  2874,  2874,
+    2874,  2874,  2874,  2874,  2874,  2874,  2874,  2874,  2874,   349,
+    2998,  -467,  -467,    16,  -467,   393,   393,   393,  2874,  2502,
+    2229,  3060,  3122,  1060,  1060,   397,   397,   157,   157,   157,
+     182,  2564,   227,  -467,  2165,  2165,    36,   229,  -467,   186,
+     198,  2364,  -467,   189,  1328,  -467,  -467,   200,  -467,  -467,
+    -467,  -467,  1198,  -467,    82,  2165,  -467,    50,   320,   191,
+     231,  -467,  -467,  -467,   201,  -467,   206,  1844,  -467,   196,
+    -467,   223,  2874,    72,   238,   254,   938,  -467,   -20,   242,
+     214,   204,   208,    82,   330,    82,   222,   197,   246,  -467,
+     350,  -467,  -467,  -467,  -467,  2165,  -467,  2165,  -467,  -467,
+    2433,  2626,  2165,  -467,    15,  1970,  2165,   232,  -467,  -467,
+    1198,   224,   221,  2165,    72,  -467,  -467,   197,    41,   103,
+    1970,  2165,  -467,  -467,  -467,  -467,  2165,  -467,  -467,  -467,
+    2165,  1970,  -467,  -467,    39,  -467,    82,   233,  -467,   261,
+    -467,   238,   303,  -467,   247,    17,  2688,  2874,  -467,  -467,
+    2750,  -467,  -467,   235,    27,   241,  -467,  -467,  2874,   258,
+     236,   320,  -467,   251,   256,  -467,  -467,   103,  -467,   300,
+    -467,  2874,   -52,  -467,   243,   261,  -467,    82,   218,  -467,
+    -467,  -467,  -467,   267,  -467,   276,  -467,  -467,  -467,  -467,
+    2165,   282,   259,    27,  -467,  -467,  -467,  -467,  -467,  -467,
+    -467,   384,  -467,  -467,  1970,  -467,  1970,   197,  1458,  -467,
+     386,  -467,   367,   265,   250,  -467,   396,   290,  -467,    23,
+    2812,  1844,  -467,  -467,  -467,  1844,  1844,   197,  -467,  -467,
+     270,  -467,  -467,   281,   228,   278,  1588,  -467,  -467,  -467,
+    -467,    33,  -467,  -467,  -467,   402,    23,  1844,  -467,   286,
+     293,   294,  -467,  1458,  -467,  -467,   406,   302,  -467,  -467,
+    -467,  -467,  -467,  1844,   296,   289,  -467,   304,   287,   297,
+    -467,    39,  -467,  1844,  -467,   298,   310,   197,  -467,  -467
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -308,  -308,  -308,  -308,   328,    85,  -308,    93,  -209,   196,
-       1,   -76,  -244,    16,    59,   332,   268,    77,  -308,  -308,
-    -308,  -308,  -308,  -308,  -308,  -308,  -308,  -308,  -308,  -308,
-    -308,  -308,  -308,  -308,   -15,   -11,  -308,  -308,    15,  -308,
-      17,  -308,  -308,  -308,  -308,  -308,  -308,  -308,  -193,    19,
-    -308,  -308,  -308,  -308,     0,  -308,   335,  -308,  -308,  -308,
-      31,  -308,    39,  -308,  -308,  -308,   -40,  -308,  -308,   -21,
-    -308,     2,    27,  -308,  -307,  -308,  -271,   -41,     3,  -308,
-    -308,  -308,   398,  -308,   -20,    60,    78,  -184,  -308,   -93,
-    -308,  -308,  -308,  -308,  -308,   -26,   -17,   -46,   -18,  -308,
-    -308,  -308,  -308,  -308,  -308
+    -467,  -467,   271,  -467,   378,  -296,  -467,    98,  -466,   -31,
+       1,   -58,   -88,    51,     2,    18,   375,   299,    70,  -467,
+    -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,
+    -467,  -467,  -467,  -467,  -467,   -37,   -36,  -467,  -467,    -9,
+    -467,    -7,  -467,  -467,  -467,  -467,  -467,  -467,  -467,  -467,
+       9,    96,  -467,  -467,  -467,  -467,     0,  -467,   381,  -467,
+    -467,  -467,    57,  -467,    58,  -467,   -91,  -467,   -73,  -467,
+    -467,   -47,  -467,     3,  -467,  -467,    28,    20,  -467,  -467,
+    -467,  -467,  -423,  -417,  -467,  -397,  -467,  -467,   199,  -411,
+    -467,  -307,   -65,     4,  -467,  -467,  -467,  -467,  -467,   444,
+     -87,    52,    68,  -192,  -467,   -99,  -467,  -467,  -467,  -467,
+    -467,  -467,  -467,  -122,  -125,   429,   -50,  -467,   237,  -467,
+     -13,  -467,  -189,  -467,  -467,  -467,  -467,  -467
 };
 
 /* 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 -205
+#define YYTABLE_NINF -315
 static const yytype_int16 yytable[] =
 {
-      63,    50,    68,    69,    93,    99,   188,   127,   295,   135,
-     210,    79,   297,   295,   297,   135,    51,   104,   115,   106,
-     107,    95,   108,   109,   110,   114,   114,   342,   118,   225,
-     339,    66,    88,    89,   340,   135,    85,   316,    84,    67,
-      81,   217,   135,   -66,    96,   226,   324,   302,    63,    50,
-      68,    69,   398,    85,    83,     1,     2,     3,   345,     4,
-       5,     6,     7,     8,    51,   373,    95,   328,   374,   375,
-     376,   303,   377,   385,   347,   354,    18,   205,    20,    66,
-      21,    85,   207,   270,   368,   114,    85,    67,    80,   386,
-     200,   201,   128,    84,   387,   303,    27,   130,   349,   298,
-      91,   384,   119,   392,    32,   378,    33,    34,    85,   296,
-      85,   132,    94,   414,   397,   379,   380,   231,   232,   233,
-     234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
-     244,   245,   246,   247,   248,   249,   250,   251,   252,    37,
-      38,   253,   254,   255,   256,   257,   258,   259,   260,   261,
-     262,   263,   264,   265,   266,   267,   268,    86,   114,   383,
-     115,   271,   100,   473,   274,   275,   105,   102,   280,   406,
-     103,   135,    43,   135,    44,   439,   350,   440,    45,   101,
-     284,   304,   357,   135,   114,   404,   405,   310,   311,   209,
-     312,   157,   158,   135,   309,   114,   114,   407,   114,    63,
-      50,   295,   331,   358,   436,   403,   317,   318,   177,   202,
-     204,  -104,   206,   213,   121,     2,     3,   214,     4,     5,
-       6,     7,     8,   455,   174,   216,   188,   175,   457,   212,
-     176,   331,   -67,   215,   218,    18,   221,    20,   441,    21,
-     223,   224,   122,   228,   229,   463,    22,   230,   269,   272,
-     157,   158,   188,    26,   458,    27,   123,   469,   273,   276,
-     281,   282,   474,    32,   283,    33,    34,   308,   315,   313,
-     319,   188,   320,    35,   322,   171,   172,   173,   327,   329,
-     332,   333,   188,   174,   335,   297,   175,    63,    50,   176,
-     338,   477,   344,   348,    63,    50,   343,   346,    37,    38,
-     360,   128,   363,   354,   359,   129,   130,   367,   361,   365,
-     371,   396,   370,   372,   394,   369,   400,   401,   131,   413,
-     132,    40,   393,   339,   415,   416,    41,    42,   395,   419,
-     114,    43,   421,    44,   422,   433,   114,    45,   432,   438,
-     450,   363,   451,   188,   452,   188,   456,   459,   467,    -3,
-     460,   464,     1,     2,     3,   465,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,   470,   472,    13,    14,    15,
-      16,   471,    17,    18,    19,   475,   120,    21,   476,   337,
-     336,   424,   278,   366,    22,   124,    23,    24,   431,    25,
-     219,    26,   356,    27,   434,    28,    29,    30,   435,   134,
-      31,    32,   427,    33,    34,   417,   461,   418,   453,   412,
-     462,    35,    36,    14,    15,    16,    90,    17,   382,    19,
-       0,   399,     0,   444,   443,   448,   449,   157,   158,   427,
-       0,    23,     0,     0,     0,     0,    37,    38,     0,   425,
-      28,    29,    30,     0,     0,    39,   444,   443,   448,   449,
-     169,   170,   171,   172,   173,     0,     0,     0,     0,    40,
-     174,     0,     0,   175,    41,    42,   176,     0,     0,    43,
-       0,    44,     0,    -4,     0,    45,     1,     2,     3,     0,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,     0,
-     426,    13,    14,    15,    16,     0,    17,    18,    19,     0,
-       0,    21,     0,     0,     0,     0,     0,     0,    22,     0,
-      23,    24,     0,    25,     0,    26,     0,    27,     0,    28,
-      29,    30,  -145,     0,    31,    32,     0,    33,    34,     0,
-       0,     0,     0,     0,     0,    35,    36,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    14,    15,
-      16,     0,    17,     0,    19,     0,     0,     0,     0,     0,
-      37,    38,     0,     0,     0,     0,    23,     0,     0,    39,
-       0,     0,     0,     0,   425,    28,    29,    30,     0,     0,
-       0,     0,     0,    40,     0,     0,     0,     0,    41,    42,
-       0,     0,     0,    43,     0,    44,     1,     2,     3,    45,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,     0,
-       0,     0,    14,    15,    16,   179,    17,    18,    19,    20,
-       0,    21,   180,     0,   122,   426,     0,     0,    22,   181,
-      23,    24,     0,    25,   182,    26,     0,    27,   183,    28,
-      29,    30,     0,     0,    31,    32,     0,    33,    34,     0,
-       0,     0,     0,     0,     0,    35,    36,  -146,   184,    14,
-      15,    16,     0,    17,     0,    19,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    23,     0,     0,
-      37,    38,     0,     0,     0,     0,    28,    29,    30,   185,
+      69,    54,    56,    74,    79,   104,   222,   162,   161,   249,
+     107,   254,   255,   464,   239,   231,   301,   142,   301,   301,
+      91,   100,   472,   115,   322,   323,   122,   123,   472,   328,
+     124,   125,   126,   128,   133,   100,   162,   200,   476,   301,
+     245,   406,   347,    90,   347,   538,   401,   -70,   174,   539,
+     540,    55,    69,    54,    56,    74,    79,    72,    73,   509,
+     480,   113,   102,    96,    97,   164,   114,   267,    93,   217,
+     368,   549,   218,   246,   165,    96,    97,    98,   508,   166,
+     167,   496,   416,   268,   259,    96,    97,   559,   481,    98,
+      95,   536,   168,    92,   169,   128,   329,   566,   237,    98,
+     133,   452,   105,    55,   445,    96,    97,   412,   101,    72,
+      73,   547,   108,   117,   386,   118,   359,   320,   133,    98,
+     111,   360,   109,   128,   128,   557,   473,   474,   302,   453,
+     302,   302,   348,   474,   451,   454,   302,   393,   369,   370,
+     385,   303,   381,   324,   489,   325,   382,   116,   112,   326,
+     565,   302,   403,   152,   404,    69,    54,    56,    74,    79,
+     392,   277,   278,   279,   280,   281,   282,   283,   284,   285,
+     286,   287,   288,   289,   290,   291,   292,   293,   294,   295,
+     296,   297,   298,   299,   300,   431,    99,   413,   305,   306,
+     307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
+     317,   318,   319,   133,   321,   441,    55,   422,   128,   423,
+     331,   153,    72,    73,   155,   450,   173,   353,   225,   226,
+     174,   236,     2,   219,    69,    54,   337,   220,   128,   366,
+     133,   233,   362,   240,   243,   343,    13,    14,    15,   242,
+      17,   244,    19,   247,   164,   354,   402,   198,   199,   200,
+     128,   128,   248,   165,     2,    24,   250,   251,   257,   167,
+     260,   164,   -71,   500,    29,    30,    31,   262,    13,    14,
+      15,   443,    17,   169,    19,   263,   264,   265,   266,   216,
+     270,   217,   271,   273,   218,   330,   425,    24,   428,   460,
+    -113,   344,   345,   352,   245,   500,    29,    30,    31,   259,
+     358,   363,   365,   367,   372,   520,   377,   442,   259,   371,
+     373,   390,   391,   375,   380,   388,  -314,   501,   394,   395,
+     396,   398,   459,   347,   407,   541,   400,   411,  -112,   410,
+     424,   408,   133,   463,    69,    54,   337,   162,   409,   428,
+     416,   420,    69,    54,   337,   426,   432,   421,   430,   501,
+    -153,     2,   162,   354,   447,   433,   446,   471,   444,   466,
+     403,   467,   488,   162,   494,    13,    14,    15,   479,    17,
+     462,    19,   436,   486,   437,   569,   497,   490,   491,   440,
+     499,   506,  -154,   128,    24,   507,   511,   517,   175,   530,
+     448,   512,   531,    29,    30,    31,   542,   532,   133,   534,
+      69,    54,   337,   461,   535,   548,   518,   543,   519,   555,
+     544,   561,   556,   563,   562,   176,   177,   178,   550,   179,
+     180,   181,   182,   183,   184,   551,   261,   552,   560,   564,
+     154,   567,   399,   158,   252,   418,   162,   197,   162,   198,
+     199,   200,   568,   201,   202,   203,   513,   514,   492,   469,
+     493,   172,   554,   545,   206,   207,   208,   533,   209,   210,
+     470,   211,   212,   213,   214,   215,   546,   510,   502,   487,
+     110,   216,   449,   217,   384,   127,   218,     0,   465,     0,
+       0,   361,     0,   198,   199,   200,     0,   198,   199,   200,
+       0,     0,     0,     0,     0,     0,     0,     0,   524,   522,
+     523,   528,   529,     0,   502,   211,   212,   213,   214,   215,
+       0,   213,   214,   215,     0,   216,     0,   217,     0,   216,
+     218,   217,     0,     0,   218,     0,   524,   522,   523,   528,
+     529,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   524,   522,   523,   528,   529,    -4,     0,
+       0,     1,     2,     3,     4,     0,     5,     6,     7,     8,
+       9,    10,    11,     0,     0,    12,    13,    14,    15,    16,
+      17,    18,    19,     0,     0,    21,    22,     0,     0,   175,
+       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,  -315,  -315,  -315,     0,
+      36,    37,     0,     0,   183,   184,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,     0,     0,     0,     0,    41,    42,
-       0,     0,     0,    43,     0,    44,     0,     0,     0,    45,
-       0,   277,     1,     2,     3,     0,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,     0,     0,     0,    14,    15,
-      16,   179,    17,    18,    19,    20,     0,    21,   180,     0,
-     122,     0,     0,     0,    22,   181,    23,    24,     0,    25,
-     182,    26,     0,    27,   183,    28,    29,    30,     0,     0,
-      31,    32,     0,    33,    34,     0,     0,     0,     0,     0,
-       0,    35,    36,     0,   184,     0,     0,     0,     0,     0,
+     198,   199,   200,     0,   201,   202,   203,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,    41,     0,   209,
+     210,     0,   211,   212,   213,   214,   215,    42,     0,     0,
+      43,     0,   216,     0,   217,    44,    45,   218,     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,     0,     0,     0,    13,    14,    15,    16,
+      17,    18,    19,    20,     0,    21,    22,   134,     0,   135,
+       0,     0,     0,    23,   136,    24,    25,     0,    26,   137,
+      27,     0,    28,   138,    29,    30,    31,     0,     0,    32,
+      33,     0,    34,    35,     0,     0,     0,     0,     0,     0,
+      36,    37,     0,   139,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,     0,     0,   185,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    40,
-       0,     0,     0,     0,    41,    42,     0,     0,     0,    43,
-       0,    44,     0,     0,     0,    45,     0,   330,     1,     2,
-       3,     0,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,     0,     0,     0,    14,    15,    16,     0,    17,    18,
-      19,     0,     0,    21,     0,   136,     0,     0,     0,     0,
-      22,     0,    23,    24,     0,    25,     0,    26,     0,    27,
-       0,    28,    29,    30,     0,     0,    31,    32,     0,    33,
-      34,     0,  -205,  -205,  -205,     0,     0,    35,    36,   144,
-     145,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   157,   158,     0,     0,   159,   160,   161,
-       0,     0,    37,    38,     0,     0,     0,     0,     0,     0,
-       0,   285,     0,   167,   168,     0,   169,   170,   171,   172,
-     173,     0,     0,     0,     0,    40,   174,     0,     0,   175,
-      41,    42,   176,     0,     0,    43,     0,    44,     0,     0,
-       0,    45,     0,   -14,     1,     2,     3,     0,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,     0,     0,     0,
-      14,    15,    16,     0,    17,    18,    19,     0,     0,    21,
-       0,  -205,     0,     0,     0,     0,    22,     0,    23,    24,
-       0,    25,     0,    26,     0,    27,     0,    28,    29,    30,
-       0,     0,    31,    32,     0,    33,    34,     0,     0,     0,
-       0,     0,     0,    35,    36,  -205,  -205,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   157,
-     158,     0,     0,   159,   160,   161,     0,     0,    37,    38,
-       0,     0,     0,     0,     0,     0,     0,   285,     0,  -205,
-    -205,     0,   169,   170,   171,   172,   173,     0,     0,     0,
-       0,    40,   174,     0,     0,   175,    41,    42,   176,     0,
-       0,    43,     0,    44,     0,     0,     0,    45,     0,   -15,
-       1,     2,     3,     0,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,     0,     0,     0,    14,    15,    16,     0,
-      17,    18,    19,     0,     0,    21,     0,     0,     0,     0,
-       0,     0,    22,     0,    23,    24,     0,    25,     0,    26,
-       0,    27,     0,    28,    29,    30,     0,     0,    31,    32,
-       0,    33,    34,     0,     0,     0,     0,     0,     0,    35,
-      36,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,   140,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     0,     0,
+      43,     0,     0,     0,     0,    44,    45,     0,     0,     0,
+      46,     0,    47,     0,    48,     0,    49,     0,     0,     0,
+     141,     1,     2,     3,     4,     0,     5,     6,     7,     8,
+       9,    10,    11,     0,     0,     0,    13,    14,    15,    16,
+      17,    18,    19,    20,     0,    21,    22,   134,     0,   135,
+       0,     0,     0,    23,   136,    24,    25,     0,    26,   137,
+      27,     0,    28,   138,    29,    30,    31,     0,     0,    32,
+      33,     0,    34,    35,     0,     0,     0,     0,     0,     0,
+      36,    37,     0,   139,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    37,    38,     0,     0,     0,     0,
-       0,     0,     0,   442,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    40,     0,     0,
-       0,     0,    41,    42,     0,     0,     0,    43,     0,    44,
-       0,     0,     0,    45,     0,  -137,     1,     2,     3,     0,
-       4,     5,     6,     7,     8,     9,    10,    11,    12,     0,
-       0,     0,    14,    15,    16,     0,    17,    18,    19,     0,
-       0,    21,     0,     0,     0,     0,     0,     0,    22,     0,
-      23,    24,     0,    25,     0,    26,     0,    27,     0,    28,
-      29,    30,     0,     0,    31,    32,     0,    33,    34,     0,
-       0,     0,     0,     0,     0,    35,    36,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,   140,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     0,     0,
+      43,     0,     0,     0,     0,    44,    45,     0,     0,     0,
+      46,     0,    47,     0,    48,     0,    49,     0,     0,     0,
+     258,     1,     2,     3,     4,     0,     5,     6,     7,     8,
+       9,    10,    11,     0,     0,     0,    13,    14,    15,    16,
+      17,    18,    19,    20,     0,    21,    22,   134,     0,   135,
+       0,     0,     0,    23,   136,    24,    25,     0,    26,   137,
+      27,     0,    28,   138,    29,    30,    31,     0,     0,    32,
+      33,     0,    34,    35,     0,     0,     0,     0,     0,     0,
+      36,    37,     0,   139,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,   140,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     0,     0,
+      43,     0,     0,     0,     0,    44,    45,     0,     0,     0,
+      46,     0,    47,     0,    48,     0,    49,     0,     0,     0,
+     419,     1,     2,     3,     4,     0,     5,     6,     7,     8,
+       9,    10,    11,     0,     0,    12,    13,    14,    15,    16,
+      17,    18,    19,     0,     0,    21,    22,     0,     0,  -315,
+       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,     0,     0,  -315,  -315,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      37,    38,     0,     0,     0,     0,     0,     0,     0,   442,
+     198,   199,   200,     0,   201,   202,   203,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,    41,     0,  -315,
+    -315,     0,   211,   212,   213,   214,   215,    42,     0,     0,
+      43,     0,   216,     0,   217,    44,    45,   218,     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,     0,     0,     0,    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,     0,     0,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    40,     0,     0,     0,     0,    41,    42,
-       0,     0,     0,    43,     0,    44,     0,     0,     0,    45,
-       0,  -138,     1,     2,     3,     0,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,     0,  -114,     0,    14,    15,
-      16,   179,    17,    18,    19,    20,     0,    21,   180,     0,
-     122,     0,     0,     0,    22,   181,    23,    24,     0,    25,
-     182,    26,     0,    27,   183,    28,    29,    30,     0,     0,
-      31,    32,     0,    33,    34,     0,     0,     0,     0,     0,
-       0,    35,    36,     0,   184,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,   332,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     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,     0,     0,     0,    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,     0,     0,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,     0,     0,     0,   185,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    40,
-       0,     0,     0,     0,    41,    42,     0,     0,     0,    43,
-       0,    44,     1,     2,     3,    45,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,     0,     0,     0,    14,    15,
-      16,   179,    17,    18,    19,    20,     0,    21,   180,     0,
-     122,     0,     0,     0,    22,   181,    23,    24,     0,    25,
-     182,    26,     0,    27,   183,    28,    29,    30,     0,     0,
-      31,    32,     0,    33,    34,     0,     0,     0,     0,     0,
-       0,    35,    36,     0,   184,     0,     0,     0,     0,     0,
-       0,     1,     2,     3,     0,     4,     5,     6,     7,     8,
-       0,     0,     0,     0,     0,     0,    37,    38,     0,     0,
-       0,     0,    18,     0,    20,   185,    21,     0,     0,     0,
-       0,     0,     0,    22,     0,     0,     0,     0,     0,    40,
-      26,     0,    27,     0,    41,    42,     0,     0,     0,    43,
-      32,   186,    33,    34,     0,    45,     0,     0,     0,     0,
-      35,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,   332,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     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,     0,     0,     0,    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,     0,     0,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    37,    38,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   136,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    40,     0,
-       0,     0,     0,    41,    42,     0,     0,     0,    43,     0,
-      44,     0,     0,     0,    45,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,     0,   157,   158,     0,     0,
-     159,   160,   161,     0,     0,     0,     0,     0,   162,     0,
-       0,   163,   136,   164,   165,   166,   167,   168,     0,   169,
-     170,   171,   172,   173,     0,     0,     0,     0,     0,   174,
-       0,     0,   175,     0,     0,   176,     0,     0,   305,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,     0,
-     157,   158,     0,     0,   159,   160,   161,     0,     0,     0,
-       0,     0,   162,     0,     0,   163,   136,   164,   165,   166,
-     167,   168,     0,   169,   170,   171,   172,   173,     0,     0,
-       0,     0,     0,   174,     0,     0,   175,     0,     0,   176,
-       0,     0,   334,   137,   138,   139,   140,   141,   142,   143,
-     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
-     154,   155,   156,     0,   157,   158,     0,     0,   159,   160,
-     161,     0,     0,     0,     0,     0,   162,   136,     0,   163,
-     325,   164,   165,   166,   167,   168,     0,   169,   170,   171,
-     172,   173,     0,     0,     0,     0,     0,   174,     0,     0,
-     175,     0,     0,   176,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
-     153,   154,   155,   156,     0,   157,   158,     0,     0,   159,
-     160,   161,     0,     0,     0,     0,     0,   162,   136,     0,
-     163,     0,   164,   165,   166,   167,   168,     0,   169,   170,
-     171,   172,   173,     0,     0,     0,     0,     0,   174,   326,
-       0,   175,     0,     0,   176,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
-     152,   153,   154,   155,   156,     0,   157,   158,     0,     0,
-     159,   160,   161,     0,     0,     0,     0,     0,   162,   136,
-       0,   163,  -204,   164,   165,   166,   167,   168,     0,   169,
-     170,   171,   172,   173,     0,     0,     0,     0,     0,   174,
-       0,     0,   175,     0,     0,   176,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
-     151,   152,   153,   154,   155,   156,     0,   157,   158,     0,
-       0,   159,   160,   161,     0,     0,     0,     0,     0,   162,
-     136,     0,   163,   454,   164,   165,   166,   167,   168,     0,
-     169,   170,   171,   172,   173,     0,     0,     0,     0,     0,
-     174,     0,     0,   175,     0,     0,   176,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,     0,   157,   158,
-       0,     0,   159,   160,   161,     0,     0,     0,     0,     0,
-     162,   136,     0,   163,     0,   164,   165,   166,   167,   168,
-       0,   169,   170,   171,   172,   173,     0,     0,     0,     0,
-       0,   174,     0,     0,   175,     0,     0,   176,   137,   138,
-     139,   140,   141,   142,   143,   144,   145,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   156,     0,   157,
-     158,     0,     0,   159,   160,   161,     0,     0,     0,     0,
-       0,     0,   136,     0,     0,     0,   164,   165,   166,   167,
-     168,     0,   169,   170,   171,   172,   173,     0,     0,     0,
-       0,     0,   174,     0,     0,   175,     0,     0,   176,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,   521,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     0,     0,
+      43,     0,     0,     0,     0,    44,    45,     0,     0,     0,
+      46,     0,    47,     0,    48,     0,    49,     0,     0,     0,
+    -144,     1,     2,     3,     4,     0,     5,     6,     7,     8,
+       9,    10,    11,     0,     0,     0,    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,     0,     0,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     157,   158,     0,     0,   159,   160,   161,     0,     0,     0,
-       0,     0,     0,   136,     0,     0,     0,   164,   165,   166,
-     167,   168,     0,   169,   170,   171,   172,   173,     0,     0,
-       0,     0,     0,   174,     0,     0,   175,     0,     0,   176,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,   521,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     0,     0,
+      43,     0,     0,     0,     0,    44,    45,     0,     0,     0,
+      46,     0,    47,     0,    48,     0,    49,     0,    -3,     0,
+    -145,     1,     2,     3,     4,     0,     5,     6,     7,     8,
+       9,    10,    11,     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,     0,     0,     0,     0,     0,    38,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   157,   158,     0,     0,   159,   160,   161,     0,     0,
-       0,     0,     0,     0,   136,     0,     0,     0,     0,   165,
-     166,   167,   168,     0,   169,   170,   171,   172,   173,     0,
-       0,     0,     0,     0,   174,     0,     0,   175,     0,     0,
-     176,   137,   138,   139,   140,   141,   142,   143,   144,   145,
+       0,     0,     0,     0,     0,     0,     0,     0,    39,    40,
+       0,     0,     0,     0,     0,     0,     0,    41,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    42,     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,     0,
+    -120,     0,    13,    14,    15,    16,    17,    18,    19,    20,
+       0,    21,    22,   134,     0,   135,     0,     0,     0,    23,
+     136,    24,    25,     0,    26,   137,    27,     0,    28,   138,
+      29,    30,    31,     0,     0,    32,    33,     0,    34,    35,
+       0,     0,     0,     0,     0,     0,    36,    37,     0,   139,
+       0,     0,     0,    38,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   157,   158,     0,     0,   159,   160,   161,     0,
-       0,     0,     0,     0,     0,   136,     0,     0,     0,     0,
-       0,   166,   167,   168,     0,   169,   170,   171,   172,   173,
-       0,     0,     0,     0,     0,   174,     0,     0,   175,     0,
-       0,   176,   137,   138,   139,   140,   141,   142,   143,   144,
-     145,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   157,   158,     0,     0,   159,   160,   161,
-       0,     0,     0,     0,     0,     0,   136,     0,     0,     0,
-       0,     0,  -205,   167,   168,     0,   169,   170,   171,   172,
-     173,     0,     0,     0,     0,     0,   174,     0,     0,   175,
-       0,     0,   176,   137,   138,   139,  -205,  -205,  -205,  -205,
-     144,   145,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   157,   158,     0,     0,   159,   160,
-     161,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   167,   168,     0,   169,   170,   171,
-     172,   173,     0,     0,     0,     0,     0,   174,     0,     0,
-     175,     0,     0,   176
+       0,     0,     0,     0,    39,    40,     0,     0,     0,     0,
+       0,     0,     0,   140,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    42,     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,     0,     0,     0,    13,    14,
+      15,    16,    17,    18,    19,    20,     0,    21,    22,   134,
+       0,   135,     0,     0,     0,    23,   136,    24,    25,     0,
+      26,   137,    27,     0,    28,   138,    29,    30,    31,     0,
+       0,    32,    33,     0,    34,    35,     0,     0,     0,     0,
+       0,     0,    36,    37,     0,   139,     0,     0,     0,    38,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      39,    40,     0,     0,     0,     0,     0,     0,     0,   140,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    42,
+       0,     0,    43,     0,     0,     0,     0,    44,    45,     0,
+       0,     0,    46,     0,    47,     0,    48,   156,    49,     3,
+       4,     0,     5,     6,     7,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    18,     0,    20,
+       0,    21,    22,     0,     0,   135,     0,     0,     0,    23,
+       0,     0,     0,     0,     0,     0,    27,     0,    28,   157,
+       0,     0,     0,     0,     0,     0,    33,     0,    34,    35,
+       0,     0,     0,     0,     0,     0,    36,     0,     0,     0,
+       0,     0,     0,    38,     0,     0,     0,     0,   103,     0,
+       3,     4,     0,     5,     6,     7,     0,     0,     0,     0,
+       0,     0,     0,     0,    39,    40,     0,     0,    18,     0,
+      20,     0,    21,    22,     0,     0,     0,     0,     0,     0,
+      23,     0,     0,    42,     0,     0,    43,    27,     0,    28,
+       0,    44,    45,     0,     0,     0,    46,    33,    47,    34,
+      35,     0,    49,     0,     0,     0,     0,    36,     0,     0,
+       0,     0,     0,     0,    38,     0,     0,     0,     0,   103,
+       0,     3,     4,     0,     5,     6,     7,     0,     0,     0,
+       0,     0,     0,     0,     0,    39,    40,     0,     0,    18,
+       0,    20,     0,    21,    22,     0,     0,     0,   175,     0,
+       0,     0,     0,     0,    42,     0,     0,    43,     0,     0,
+      28,     0,    44,    45,     0,     0,     0,    46,    33,    47,
+      34,    35,     0,    49,     0,   176,   177,   178,     0,   179,
+     180,   181,   182,   183,   184,    38,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   198,
+     199,   200,     0,   201,   202,   203,    39,    40,     0,     0,
+       0,     0,     0,     0,   175,   207,   208,     0,   209,   210,
+       0,   211,   212,   213,   214,   215,     0,     0,     0,     0,
+       0,   216,     0,   217,     0,     0,   218,     0,    46,     0,
+      47,   176,   177,   178,    49,   179,   180,   181,   182,   183,
+     184,   185,   186,   187,   188,   189,   190,   191,   192,   193,
+     194,   195,   196,   197,     0,   198,   199,   200,     0,   201,
+     202,   203,     0,     0,     0,     0,     0,   204,   205,     0,
+     206,   207,   208,   175,   209,   210,     0,   211,   212,   213,
+     214,   215,     0,     0,     0,     0,     0,   216,     0,   217,
+       0,     0,   218,     0,     0,     0,     0,     0,   355,     0,
+     176,   177,   178,     0,   179,   180,   181,   182,   183,   184,
+     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
+     195,   196,   197,     0,   198,   199,   200,     0,   201,   202,
+     203,     0,     0,     0,     0,     0,   204,   205,     0,   206,
+     207,   208,   175,   209,   210,     0,   211,   212,   213,   214,
+     215,     0,     0,     0,     0,     0,   216,     0,   217,     0,
+       0,   218,     0,     0,     0,     0,     0,   397,     0,   176,
+     177,   178,     0,   179,   180,   181,   182,   183,   184,   185,
+     186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
+     196,   197,     0,   198,   199,   200,     0,   201,   202,   203,
+       0,     0,     0,     0,     0,   204,   205,     0,   206,   207,
+     208,   175,   209,   210,     0,   211,   212,   213,   214,   215,
+       0,     0,     0,     0,     0,   216,     0,   217,     0,     0,
+     218,     0,     0,     0,     0,     0,   438,     0,   176,   177,
+     178,     0,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,     0,   198,   199,   200,     0,   201,   202,   203,     0,
+       0,     0,     0,   175,   204,   205,   387,   206,   207,   208,
+       0,   209,   210,     0,   211,   212,   213,   214,   215,     0,
+       0,     0,     0,     0,   216,     0,   217,     0,     0,   218,
+     176,   177,   178,     0,   179,   180,   181,   182,   183,   184,
+     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
+     195,   196,   197,     0,   198,   199,   200,     0,   201,   202,
+     203,     0,     0,     0,     0,   175,   204,   205,     0,   206,
+     207,   208,     0,   209,   210,     0,   211,   212,   213,   214,
+     215,     0,     0,     0,     0,     0,   216,     0,   217,   389,
+       0,   218,   176,   177,   178,     0,   179,   180,   181,   182,
+     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,     0,   198,   199,   200,     0,
+     201,   202,   203,     0,     0,     0,     0,   175,   204,   205,
+       0,   206,   207,   208,     0,   209,   210,     0,   211,   212,
+     213,   214,   215,     0,     0,     0,     0,     0,   216,     0,
+     217,   439,     0,   218,   176,   177,   178,     0,   179,   180,
+     181,   182,   183,   184,   185,   186,   187,   188,   189,   190,
+     191,   192,   193,   194,   195,   196,   197,     0,   198,   199,
+     200,     0,   201,   202,   203,     0,     0,     0,     0,   175,
+     204,   205,     0,   206,   207,   208,     0,   209,   210,     0,
+     211,   212,   213,   214,   215,     0,     0,     0,     0,     0,
+     216,     0,   217,   477,     0,   218,   176,   177,   178,     0,
+     179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
+     189,   190,   191,   192,   193,   194,   195,   196,   197,     0,
+     198,   199,   200,     0,   201,   202,   203,     0,     0,     0,
+       0,   175,   204,   205,     0,   206,   207,   208,     0,   209,
+     210,     0,   211,   212,   213,   214,   215,     0,     0,     0,
+       0,     0,   216,     0,   217,   478,     0,   218,   176,   177,
+     178,     0,   179,   180,   181,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,     0,   198,   199,   200,     0,   201,   202,   203,     0,
+       0,     0,     0,   175,   204,   205,   537,   206,   207,   208,
+       0,   209,   210,     0,   211,   212,   213,   214,   215,     0,
+       0,     0,     0,     0,   216,     0,   217,     0,     0,   218,
+     176,   177,   178,     0,   179,   180,   181,   182,   183,   184,
+     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
+     195,   196,   197,     0,   198,   199,   200,     0,   201,   202,
+     203,     0,     0,     0,     0,   175,   204,   205,     0,   206,
+     207,   208,     0,   209,   210,     0,   211,   212,   213,   214,
+     215,     0,     0,     0,     0,     0,   216,     0,   217,     0,
+       0,   218,   176,   177,   178,     0,   179,   180,   181,   182,
+     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,     0,   198,   199,   200,     0,
+     201,   202,   203,     0,     0,     0,     0,   175,   204,   205,
+       0,   206,   207,   208,     0,     0,   210,     0,   211,   212,
+     213,   214,   215,     0,     0,     0,     0,     0,   216,     0,
+     217,     0,     0,   218,   176,   177,   178,     0,   179,   180,
+     181,   182,   183,   184,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   198,   199,
+     200,     0,   201,   202,   203,     0,     0,     0,     0,   175,
+       0,     0,     0,   206,   207,   208,     0,   209,   210,     0,
+     211,   212,   213,   214,   215,     0,     0,     0,     0,     0,
+     216,     0,   217,     0,     0,   218,   176,   177,   178,     0,
+     179,   180,   181,   182,   183,   184,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     198,   199,   200,     0,   201,   202,   203,     0,     0,     0,
+       0,   175,     0,     0,     0,     0,     0,   208,     0,   209,
+     210,     0,   211,   212,   213,   214,   215,     0,     0,     0,
+       0,     0,   216,     0,   217,     0,     0,   218,   176,   177,
+     178,     0,   179,   180,   181,   182,   183,   184,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   198,   199,   200,     0,   201,   202,   203,     0,
+       0,     0,     0,   175,     0,     0,     0,     0,     0,  -315,
+       0,   209,   210,     0,   211,   212,   213,   214,   215,     0,
+       0,     0,     0,     0,   216,     0,   217,     0,     0,   218,
+     176,   177,   178,     0,  -315,  -315,  -315,  -315,   183,   184,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   198,   199,   200,     0,   201,   202,
+     203,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   209,   210,     0,   211,   212,   213,   214,
+     215,     0,     0,     0,     0,     0,   216,     0,   217,     0,
+       0,   218
 };
 
 static const yytype_int16 yycheck[] =
 {
-       0,     0,     0,     0,    22,    25,    82,    53,   201,    97,
-     103,    49,     3,   206,     3,    97,     0,    35,    44,    37,
-      38,     3,    40,    41,    42,    43,    44,   298,    45,    34,
-      99,     0,    13,     3,   103,    97,    18,   221,     3,     0,
-     126,   129,    97,    67,    25,    50,   230,   129,    48,    48,
-      48,    48,   359,    18,   126,     3,     4,     5,   302,     7,
-       8,     9,    10,    11,    48,     4,     3,   129,     7,     8,
-       9,     3,    11,   344,   129,    99,    24,    94,    26,    48,
-      28,    18,   100,   176,   328,   103,    18,    48,   126,    27,
-     122,   123,    26,     3,    32,     3,    44,    31,    35,    90,
-       3,    90,     0,   347,    52,    44,    54,    55,    18,   202,
-      18,    45,   126,   384,   358,    54,    55,   135,   136,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
-     148,   149,   150,   151,   152,   153,   154,   155,   156,    87,
-      88,   159,   160,   161,   162,   163,   164,   165,   166,   167,
-     168,   169,   170,   171,   172,   173,   174,   122,   176,   343,
-     186,   178,   126,   470,   181,   182,   126,   123,   186,    33,
-     126,    97,   120,    97,   122,   419,   113,   421,   126,   122,
-     198,   113,    96,    97,   202,     3,     4,   213,   214,     3,
-     216,    87,    88,    97,   211,   213,   214,    61,   216,   199,
-     199,   394,   278,   129,   413,   129,   223,   224,   126,   126,
-     126,   123,   123,    97,     3,     4,     5,   103,     7,     8,
-       9,    10,    11,   432,   120,    97,   302,   123,   437,   121,
-     126,   307,    67,   128,     3,    24,     3,    26,   422,    28,
-      96,    67,    31,     3,     3,   454,    35,     3,     3,    17,
-      87,    88,   328,    42,   438,    44,    45,   466,     3,     3,
-      96,    13,   471,    52,    17,    54,    55,   129,    97,   103,
-       3,   347,    53,    62,    53,   112,   113,   114,   129,     3,
-     126,     3,   358,   120,   128,     3,   123,   287,   287,   126,
-     129,   475,    97,   103,   294,   294,   129,   128,    87,    88,
-     320,    26,   322,    99,   126,    30,    31,   325,    16,   122,
-     122,   357,    99,   128,   123,   332,   122,    97,    43,   122,
-      45,   110,   348,    99,   122,   126,   115,   116,   354,    64,
-     348,   120,   129,   122,   129,   128,   354,   126,   103,     3,
-       3,   361,    26,   419,   128,   421,   128,   122,     3,     0,
-     128,   128,     3,     4,     5,   129,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,   126,   128,    18,    19,    20,
-      21,   122,    23,    24,    25,   129,    48,    28,   128,   294,
-     287,   401,   186,   324,    35,    53,    37,    38,   406,    40,
-     122,    42,   315,    44,   409,    46,    47,    48,   409,    64,
-      51,    52,   402,    54,    55,   390,   446,   390,   429,   382,
-     451,    62,    63,    19,    20,    21,    18,    23,   340,    25,
-      -1,   361,    -1,   423,   423,   423,   423,    87,    88,   429,
-      -1,    37,    -1,    -1,    -1,    -1,    87,    88,    -1,    45,
-      46,    47,    48,    -1,    -1,    96,   446,   446,   446,   446,
-     110,   111,   112,   113,   114,    -1,    -1,    -1,    -1,   110,
-     120,    -1,    -1,   123,   115,   116,   126,    -1,    -1,   120,
-      -1,   122,    -1,     0,    -1,   126,     3,     4,     5,    -1,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    -1,
-      96,    18,    19,    20,    21,    -1,    23,    24,    25,    -1,
-      -1,    28,    -1,    -1,    -1,    -1,    -1,    -1,    35,    -1,
-      37,    38,    -1,    40,    -1,    42,    -1,    44,    -1,    46,
-      47,    48,   128,    -1,    51,    52,    -1,    54,    55,    -1,
-      -1,    -1,    -1,    -1,    -1,    62,    63,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,    20,
-      21,    -1,    23,    -1,    25,    -1,    -1,    -1,    -1,    -1,
-      87,    88,    -1,    -1,    -1,    -1,    37,    -1,    -1,    96,
-      -1,    -1,    -1,    -1,    45,    46,    47,    48,    -1,    -1,
-      -1,    -1,    -1,   110,    -1,    -1,    -1,    -1,   115,   116,
-      -1,    -1,    -1,   120,    -1,   122,     3,     4,     5,   126,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    -1,
-      -1,    -1,    19,    20,    21,    22,    23,    24,    25,    26,
-      -1,    28,    29,    -1,    31,    96,    -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,   128,    65,    19,
-      20,    21,    -1,    23,    -1,    25,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    -1,    -1,
-      87,    88,    -1,    -1,    -1,    -1,    46,    47,    48,    96,
+       0,     0,     0,     0,     0,    18,    94,    65,    58,   131,
+      23,   136,   137,   424,   113,   102,     3,    48,     3,     3,
+      49,    12,     5,    36,     3,     4,    39,    40,     5,   218,
+      43,    44,    45,    46,    47,    26,    94,    92,   435,     3,
+     100,   348,     3,    89,     3,   511,   342,    67,   100,   515,
+     516,     0,    52,    52,    52,    52,    52,     0,     0,   476,
+      33,   122,    16,     3,     4,    16,   127,    34,   122,   124,
+     262,   537,   127,   133,    25,     3,     4,    17,   475,    30,
+      31,   133,   102,    50,   142,     3,     4,   553,    61,    17,
+     122,   508,    43,   122,    45,   108,   221,   563,   111,    17,
+     113,   408,     3,    52,   400,     3,     4,    35,    12,    52,
+      52,   534,   122,     3,   303,     5,   241,   216,   131,    17,
+     122,   243,    26,   136,   137,   548,   109,   110,   115,    26,
+     115,   115,    93,   110,    93,    32,   115,   326,   263,   264,
+     124,   128,   110,   122,   451,   124,   114,   122,   126,   128,
+     561,   115,   102,     3,   104,   155,   155,   155,   155,   155,
+     124,   174,   175,   176,   177,   178,   179,   180,   181,   182,
+     183,   184,   185,   186,   187,   188,   189,   190,   191,   192,
+     193,   194,   195,   196,   197,   377,   126,   115,   201,   202,
+     203,   204,   205,   206,   207,   208,   209,   210,   211,   212,
+     213,   214,   215,   216,   217,   394,   155,     3,   221,     5,
+     223,     0,   155,   155,   126,   407,     3,   115,   126,   127,
+     100,   127,     4,     3,   224,   224,   224,   122,   241,   260,
+     243,   122,   245,     3,   104,   226,    18,    19,    20,   132,
+      22,   100,    24,   125,    16,   236,   345,    90,    91,    92,
+     263,   264,   100,    25,     4,    37,     3,     3,     3,    31,
+     126,    16,    67,    45,    46,    47,    48,     3,    18,    19,
+      20,   396,    22,    45,    24,    99,    67,    99,     3,   122,
+       3,   124,     3,     3,   127,    12,   373,    37,   375,   411,
+     127,   127,   122,   133,   100,    45,    46,    47,    48,   357,
+     133,   104,   100,   132,     3,   497,     3,   395,   366,   102,
+      53,   324,   325,    53,   102,   133,    89,    99,    89,   133,
+     122,   132,   410,     3,   133,   517,   126,   104,   127,   133,
+     122,   100,   345,   421,   334,   334,   334,   395,   132,   426,
+     102,    99,   342,   342,   342,    15,   100,   133,   126,    99,
+     132,     4,   410,   344,   133,     5,   132,   110,   126,   126,
+     102,   100,   126,   421,    64,    18,    19,    20,   133,    22,
+     420,    24,   385,   132,   387,   567,   133,   126,   122,   392,
+     467,   114,   132,   396,    37,   109,   104,     3,    39,     3,
+     403,   132,    25,    46,    47,    48,   126,   132,   411,     3,
+     400,   400,   400,   416,   114,     3,   494,   126,   496,     3,
+     132,   122,   110,   126,   110,    66,    67,    68,   132,    70,
+      71,    72,    73,    74,    75,   132,   155,   133,   132,   132,
+      52,   133,   334,    58,   135,   365,   494,    88,   496,    90,
+      91,    92,   132,    94,    95,    96,   483,   483,   457,   431,
+     457,    70,   543,   526,   105,   106,   107,   504,   109,   110,
+     432,   112,   113,   114,   115,   116,   531,   480,   468,   449,
+      26,   122,   404,   124,   275,    46,   127,    -1,   426,    -1,
+      -1,   244,    -1,    90,    91,    92,    -1,    90,    91,    92,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   498,   498,
+     498,   498,   498,    -1,   504,   112,   113,   114,   115,   116,
+      -1,   114,   115,   116,    -1,   122,    -1,   124,    -1,   122,
+     127,   124,    -1,    -1,   127,    -1,   526,   526,   526,   526,
+     526,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   543,   543,   543,   543,   543,     0,    -1,
+      -1,     3,     4,     5,     6,    -1,     8,     9,    10,    11,
+      12,    13,    14,    -1,    -1,    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,    66,    67,    68,    -1,
+      62,    63,    -1,    -1,    74,    75,    -1,    69,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   110,    -1,    -1,    -1,    -1,   115,   116,
-      -1,    -1,    -1,   120,    -1,   122,    -1,    -1,    -1,   126,
-      -1,   128,     3,     4,     5,    -1,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    -1,    -1,    -1,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    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,    -1,    65,    -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,   109,    -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,    -1,    -1,    -1,    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,    -1,    65,    -1,    -1,    -1,    69,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    87,    88,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    96,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
-      -1,    -1,    -1,    -1,   115,   116,    -1,    -1,    -1,   120,
-      -1,   122,    -1,    -1,    -1,   126,    -1,   128,     3,     4,
-       5,    -1,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    -1,    -1,    -1,    19,    20,    21,    -1,    23,    24,
-      25,    -1,    -1,    28,    -1,    39,    -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,    66,    67,    68,    -1,    -1,    62,    63,    73,
-      74,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    87,    88,    -1,    -1,    91,    92,    93,
-      -1,    -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    96,    -1,   107,   108,    -1,   110,   111,   112,   113,
-     114,    -1,    -1,    -1,    -1,   110,   120,    -1,    -1,   123,
-     115,   116,   126,    -1,    -1,   120,    -1,   122,    -1,    -1,
-      -1,   126,    -1,   128,     3,     4,     5,    -1,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    -1,    -1,    -1,
-      19,    20,    21,    -1,    23,    24,    25,    -1,    -1,    28,
-      -1,    39,    -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,    73,    74,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    87,
-      88,    -1,    -1,    91,    92,    93,    -1,    -1,    87,    88,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    96,    -1,   107,
-     108,    -1,   110,   111,   112,   113,   114,    -1,    -1,    -1,
-      -1,   110,   120,    -1,    -1,   123,   115,   116,   126,    -1,
-      -1,   120,    -1,   122,    -1,    -1,    -1,   126,    -1,   128,
-       3,     4,     5,    -1,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    -1,    -1,    -1,    19,    20,    21,    -1,
-      23,    24,    25,    -1,    -1,    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,    -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,   109,    -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,    -1,    -1,    -1,    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,    -1,    65,    -1,    -1,    -1,    69,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    87,    88,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    96,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,
-      -1,    -1,   115,   116,    -1,    -1,    -1,   120,    -1,   122,
-      -1,    -1,    -1,   126,    -1,   128,     3,     4,     5,    -1,
-       7,     8,     9,    10,    11,    12,    13,    14,    15,    -1,
-      -1,    -1,    19,    20,    21,    -1,    23,    24,    25,    -1,
-      -1,    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,    -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,   109,    -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,    -1,    -1,    -1,    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,    -1,    65,    -1,    -1,    -1,    69,    -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,   109,    -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,    -1,    -1,    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,    -1,    -1,    74,    75,    -1,    69,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    96,
+      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,   109,    -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,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,    69,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   110,    -1,    -1,    -1,    -1,   115,   116,
-      -1,    -1,    -1,   120,    -1,   122,    -1,    -1,    -1,   126,
-      -1,   128,     3,     4,     5,    -1,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    -1,    17,    -1,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    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,    -1,    65,    -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,   109,    -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,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,    69,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    87,    88,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    96,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
-      -1,    -1,    -1,    -1,   115,   116,    -1,    -1,    -1,   120,
-      -1,   122,     3,     4,     5,   126,     7,     8,     9,    10,
-      11,    12,    13,    14,    15,    -1,    -1,    -1,    19,    20,
-      21,    22,    23,    24,    25,    26,    -1,    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,    -1,    65,    -1,    -1,    -1,    -1,    -1,
-      -1,     3,     4,     5,    -1,     7,     8,     9,    10,    11,
-      -1,    -1,    -1,    -1,    -1,    -1,    87,    88,    -1,    -1,
-      -1,    -1,    24,    -1,    26,    96,    28,    -1,    -1,    -1,
-      -1,    -1,    -1,    35,    -1,    -1,    -1,    -1,    -1,   110,
-      42,    -1,    44,    -1,   115,   116,    -1,    -1,    -1,   120,
-      52,   122,    54,    55,    -1,   126,    -1,    -1,    -1,    -1,
-      62,    -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,   109,    -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,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,    69,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    87,    88,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,
-      -1,    -1,    -1,   115,   116,    -1,    -1,    -1,   120,    -1,
-     122,    -1,    -1,    -1,   126,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    -1,    87,    88,    -1,    -1,
-      91,    92,    93,    -1,    -1,    -1,    -1,    -1,    99,    -1,
-      -1,   102,    39,   104,   105,   106,   107,   108,    -1,   110,
-     111,   112,   113,   114,    -1,    -1,    -1,    -1,    -1,   120,
-      -1,    -1,   123,    -1,    -1,   126,    -1,    -1,   129,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,    -1,
-      87,    88,    -1,    -1,    91,    92,    93,    -1,    -1,    -1,
-      -1,    -1,    99,    -1,    -1,   102,    39,   104,   105,   106,
-     107,   108,    -1,   110,   111,   112,   113,   114,    -1,    -1,
-      -1,    -1,    -1,   120,    -1,    -1,   123,    -1,    -1,   126,
-      -1,    -1,   129,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    85,    -1,    87,    88,    -1,    -1,    91,    92,
-      93,    -1,    -1,    -1,    -1,    -1,    99,    39,    -1,   102,
-     103,   104,   105,   106,   107,   108,    -1,   110,   111,   112,
-     113,   114,    -1,    -1,    -1,    -1,    -1,   120,    -1,    -1,
-     123,    -1,    -1,   126,    66,    67,    68,    69,    70,    71,
+      -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,   109,    -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,    -1,    -1,    -1,    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,    -1,    -1,    -1,    -1,    -1,    69,    -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,   109,    -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,    -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,    -1,    -1,    -1,    -1,    -1,    69,    -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,   109,    -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,    -1,
+      16,    -1,    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,    -1,    65,
+      -1,    -1,    -1,    69,    -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,   109,    -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,    -1,    -1,    -1,    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,    -1,    65,    -1,    -1,    -1,    69,
+      -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,   109,
+      -1,    -1,   112,    -1,    -1,    -1,    -1,   117,   118,    -1,
+      -1,    -1,   122,    -1,   124,    -1,   126,     3,   128,     5,
+       6,    -1,     8,     9,    10,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    23,    -1,    25,
+      -1,    27,    28,    -1,    -1,    31,    -1,    -1,    -1,    35,
+      -1,    -1,    -1,    -1,    -1,    -1,    42,    -1,    44,    45,
+      -1,    -1,    -1,    -1,    -1,    -1,    52,    -1,    54,    55,
+      -1,    -1,    -1,    -1,    -1,    -1,    62,    -1,    -1,    -1,
+      -1,    -1,    -1,    69,    -1,    -1,    -1,    -1,     3,    -1,
+       5,     6,    -1,     8,     9,    10,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    23,    -1,
+      25,    -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,
+      35,    -1,    -1,   109,    -1,    -1,   112,    42,    -1,    44,
+      -1,   117,   118,    -1,    -1,    -1,   122,    52,   124,    54,
+      55,    -1,   128,    -1,    -1,    -1,    -1,    62,    -1,    -1,
+      -1,    -1,    -1,    -1,    69,    -1,    -1,    -1,    -1,     3,
+      -1,     5,     6,    -1,     8,     9,    10,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    90,    91,    -1,    -1,    23,
+      -1,    25,    -1,    27,    28,    -1,    -1,    -1,    39,    -1,
+      -1,    -1,    -1,    -1,   109,    -1,    -1,   112,    -1,    -1,
+      44,    -1,   117,   118,    -1,    -1,    -1,   122,    52,   124,
+      54,    55,    -1,   128,    -1,    66,    67,    68,    -1,    70,
+      71,    72,    73,    74,    75,    69,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
+      91,    92,    -1,    94,    95,    96,    90,    91,    -1,    -1,
+      -1,    -1,    -1,    -1,    39,   106,   107,    -1,   109,   110,
+      -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,
+      -1,   122,    -1,   124,    -1,    -1,   127,    -1,   122,    -1,
+     124,    66,    67,    68,   128,    70,    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,   103,    -1,
+     105,   106,   107,    39,   109,   110,    -1,   112,   113,   114,
+     115,   116,    -1,    -1,    -1,    -1,    -1,   122,    -1,   124,
+      -1,    -1,   127,    -1,    -1,    -1,    -1,    -1,   133,    -1,
+      66,    67,    68,    -1,    70,    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,   103,    -1,   105,
+     106,   107,    39,   109,   110,    -1,   112,   113,   114,   115,
+     116,    -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,
+      -1,   127,    -1,    -1,    -1,    -1,    -1,   133,    -1,    66,
+      67,    68,    -1,    70,    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,   103,    -1,   105,   106,
+     107,    39,   109,   110,    -1,   112,   113,   114,   115,   116,
+      -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,
+     127,    -1,    -1,    -1,    -1,    -1,   133,    -1,    66,    67,
+      68,    -1,    70,    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,    39,   102,   103,   104,   105,   106,   107,
+      -1,   109,   110,    -1,   112,   113,   114,   115,   116,    -1,
+      -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,
+      66,    67,    68,    -1,    70,    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,    39,   102,   103,    -1,   105,
+     106,   107,    -1,   109,   110,    -1,   112,   113,   114,   115,
+     116,    -1,    -1,    -1,    -1,    -1,   122,    -1,   124,   125,
+      -1,   127,    66,    67,    68,    -1,    70,    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,    39,   102,   103,
+      -1,   105,   106,   107,    -1,   109,   110,    -1,   112,   113,
+     114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,    -1,
+     124,   125,    -1,   127,    66,    67,    68,    -1,    70,    71,
       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    -1,    87,    88,    -1,    -1,    91,
-      92,    93,    -1,    -1,    -1,    -1,    -1,    99,    39,    -1,
-     102,    -1,   104,   105,   106,   107,   108,    -1,   110,   111,
-     112,   113,   114,    -1,    -1,    -1,    -1,    -1,   120,   121,
-      -1,   123,    -1,    -1,   126,    66,    67,    68,    69,    70,
-      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    85,    -1,    87,    88,    -1,    -1,
-      91,    92,    93,    -1,    -1,    -1,    -1,    -1,    99,    39,
-      -1,   102,   103,   104,   105,   106,   107,   108,    -1,   110,
-     111,   112,   113,   114,    -1,    -1,    -1,    -1,    -1,   120,
-      -1,    -1,   123,    -1,    -1,   126,    66,    67,    68,    69,
+      82,    83,    84,    85,    86,    87,    88,    -1,    90,    91,
+      92,    -1,    94,    95,    96,    -1,    -1,    -1,    -1,    39,
+     102,   103,    -1,   105,   106,   107,    -1,   109,   110,    -1,
+     112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,
+     122,    -1,   124,   125,    -1,   127,    66,    67,    68,    -1,
       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
-      80,    81,    82,    83,    84,    85,    -1,    87,    88,    -1,
-      -1,    91,    92,    93,    -1,    -1,    -1,    -1,    -1,    99,
-      39,    -1,   102,   103,   104,   105,   106,   107,   108,    -1,
-     110,   111,   112,   113,   114,    -1,    -1,    -1,    -1,    -1,
-     120,    -1,    -1,   123,    -1,    -1,   126,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    -1,    87,    88,
-      -1,    -1,    91,    92,    93,    -1,    -1,    -1,    -1,    -1,
-      99,    39,    -1,   102,    -1,   104,   105,   106,   107,   108,
-      -1,   110,   111,   112,   113,   114,    -1,    -1,    -1,    -1,
-      -1,   120,    -1,    -1,   123,    -1,    -1,   126,    66,    67,
-      68,    69,    70,    71,    72,    73,    74,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    85,    -1,    87,
-      88,    -1,    -1,    91,    92,    93,    -1,    -1,    -1,    -1,
-      -1,    -1,    39,    -1,    -1,    -1,   104,   105,   106,   107,
-     108,    -1,   110,   111,   112,   113,   114,    -1,    -1,    -1,
-      -1,    -1,   120,    -1,    -1,   123,    -1,    -1,   126,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
+      80,    81,    82,    83,    84,    85,    86,    87,    88,    -1,
+      90,    91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,
+      -1,    39,   102,   103,    -1,   105,   106,   107,    -1,   109,
+     110,    -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,
+      -1,    -1,   122,    -1,   124,   125,    -1,   127,    66,    67,
+      68,    -1,    70,    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,    39,   102,   103,   104,   105,   106,   107,
+      -1,   109,   110,    -1,   112,   113,   114,   115,   116,    -1,
+      -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,
+      66,    67,    68,    -1,    70,    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,    39,   102,   103,    -1,   105,
+     106,   107,    -1,   109,   110,    -1,   112,   113,   114,   115,
+     116,    -1,    -1,    -1,    -1,    -1,   122,    -1,   124,    -1,
+      -1,   127,    66,    67,    68,    -1,    70,    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,    39,   102,   103,
+      -1,   105,   106,   107,    -1,    -1,   110,    -1,   112,   113,
+     114,   115,   116,    -1,    -1,    -1,    -1,    -1,   122,    -1,
+     124,    -1,    -1,   127,    66,    67,    68,    -1,    70,    71,
+      72,    73,    74,    75,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    91,
+      92,    -1,    94,    95,    96,    -1,    -1,    -1,    -1,    39,
+      -1,    -1,    -1,   105,   106,   107,    -1,   109,   110,    -1,
+     112,   113,   114,   115,   116,    -1,    -1,    -1,    -1,    -1,
+     122,    -1,   124,    -1,    -1,   127,    66,    67,    68,    -1,
+      70,    71,    72,    73,    74,    75,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      87,    88,    -1,    -1,    91,    92,    93,    -1,    -1,    -1,
-      -1,    -1,    -1,    39,    -1,    -1,    -1,   104,   105,   106,
-     107,   108,    -1,   110,   111,   112,   113,   114,    -1,    -1,
-      -1,    -1,    -1,   120,    -1,    -1,   123,    -1,    -1,   126,
-      66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
+      90,    91,    92,    -1,    94,    95,    96,    -1,    -1,    -1,
+      -1,    39,    -1,    -1,    -1,    -1,    -1,   107,    -1,   109,
+     110,    -1,   112,   113,   114,   115,   116,    -1,    -1,    -1,
+      -1,    -1,   122,    -1,   124,    -1,    -1,   127,    66,    67,
+      68,    -1,    70,    71,    72,    73,    74,    75,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    87,    88,    -1,    -1,    91,    92,    93,    -1,    -1,
-      -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,   105,
-     106,   107,   108,    -1,   110,   111,   112,   113,   114,    -1,
-      -1,    -1,    -1,    -1,   120,    -1,    -1,   123,    -1,    -1,
-     126,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      -1,    -1,    90,    91,    92,    -1,    94,    95,    96,    -1,
+      -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,   107,
+      -1,   109,   110,    -1,   112,   113,   114,   115,   116,    -1,
+      -1,    -1,    -1,    -1,   122,    -1,   124,    -1,    -1,   127,
+      66,    67,    68,    -1,    70,    71,    72,    73,    74,    75,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    87,    88,    -1,    -1,    91,    92,    93,    -1,
-      -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,   106,   107,   108,    -1,   110,   111,   112,   113,   114,
-      -1,    -1,    -1,    -1,    -1,   120,    -1,    -1,   123,    -1,
-      -1,   126,    66,    67,    68,    69,    70,    71,    72,    73,
-      74,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    87,    88,    -1,    -1,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,
-      -1,    -1,   106,   107,   108,    -1,   110,   111,   112,   113,
-     114,    -1,    -1,    -1,    -1,    -1,   120,    -1,    -1,   123,
-      -1,    -1,   126,    66,    67,    68,    69,    70,    71,    72,
-      73,    74,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    87,    88,    -1,    -1,    91,    92,
-      93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   107,   108,    -1,   110,   111,   112,
-     113,   114,    -1,    -1,    -1,    -1,    -1,   120,    -1,    -1,
-     123,    -1,    -1,   126
+      -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
 };
 
 /* 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,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    18,    19,    20,    21,    23,    24,    25,
-      26,    28,    35,    37,    38,    40,    42,    44,    46,    47,
-      48,    51,    52,    54,    55,    62,    63,    87,    88,    96,
-     110,   115,   116,   120,   122,   126,   131,   132,   133,   134,
-     140,   143,   149,   153,   154,   155,   156,   158,   166,   174,
-     177,   180,   183,   184,   185,   186,   190,   192,   201,   208,
-     211,   221,   222,   223,   226,   227,   228,   229,   232,    49,
-     126,   126,   159,   126,     3,    18,   122,   178,   179,     3,
-     212,     3,   210,   228,   126,     3,   179,   212,   213,   214,
-     126,   122,   123,   126,   228,   126,   228,   228,   228,   228,
-     228,   219,   220,   225,   228,   225,   230,   231,   226,     0,
-     134,     3,    31,    45,   145,   151,   152,   227,    26,    30,
-      31,    43,    45,   200,   186,    97,    39,    66,    67,    68,
-      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    85,    87,    88,    91,
-      92,    93,    99,   102,   104,   105,   106,   107,   108,   110,
-     111,   112,   113,   114,   120,   123,   126,   126,   157,    22,
-      29,    36,    41,    45,    65,    96,   122,   140,   141,   142,
-     145,   160,   161,   176,   184,   224,   233,   234,   167,   182,
-     122,   123,   126,   218,   126,   226,   123,   228,   175,     3,
-     219,   150,   121,    97,   103,   128,    97,   129,     3,   146,
-     147,     3,   146,    96,    67,    34,    50,   207,     3,     3,
-       3,   228,   228,   228,   228,   228,   228,   228,   228,   228,
-     228,   228,   228,   228,   228,   228,   228,   228,   228,   228,
-     228,   228,   228,   228,   228,   228,   228,   228,   228,   228,
-     228,   228,   228,   228,   228,   228,   228,   228,   228,     3,
-     219,   226,    17,     3,   226,   226,     3,   128,   139,   141,
-     228,    96,    13,    17,   228,    96,   135,   136,   137,   143,
-     190,   192,   201,   208,   181,   178,   219,     3,    90,   204,
-     205,   206,   129,     3,   113,   129,   138,   139,   129,   226,
-     225,   225,   225,   103,   217,    97,   217,   226,   226,     3,
-      53,   187,    53,   188,   217,   103,   121,   129,   129,     3,
-     128,   141,   126,     3,   129,   128,   137,   135,   129,    99,
-     103,   202,   206,   129,    97,   142,   128,   129,   103,    35,
-     113,   179,   214,   216,    99,   144,   147,    96,   129,   126,
-     214,    16,   189,   214,   215,   122,   144,   228,   142,   226,
-      99,   122,   128,     4,     7,     8,     9,    11,    44,    54,
-      55,   203,   216,   217,    90,   206,    27,    32,   168,   170,
-     172,   173,   142,   225,   123,   225,   227,   142,   204,   215,
-     122,    97,   193,   129,     3,     4,    33,    61,   162,   163,
-     164,   165,   202,   122,   206,   122,   126,   168,   170,    64,
-     148,   129,   129,   191,   214,    45,    96,   184,   197,   198,
-     199,   228,   103,   128,   164,   165,   138,   171,     3,   142,
-     142,   217,    96,   140,   184,   194,   195,   196,   201,   208,
-       3,    26,   128,   199,   103,   138,   128,   138,   217,   122,
-     128,   196,   207,   138,   128,   129,   209,     3,   169,   138,
-     126,   122,   128,   204,   138,   129,   128,   217
+       0,     3,     4,     5,     6,     8,     9,    10,    11,    12,
+      13,    14,    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,    69,    90,
+      91,    99,   109,   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,   212,   213,   214,   219,   227,
+     230,   243,   244,   245,   250,   254,   257,   258,   260,   261,
+      89,    49,   122,   122,   164,   122,     3,     4,    17,   126,
+     184,   185,    16,     3,   254,     3,   229,   254,   122,   185,
+     233,   122,   126,   122,   127,   254,   122,     3,     5,   251,
+     252,   253,   254,   254,   254,   254,   254,   249,   254,   239,
+     240,   241,   247,   254,    29,    31,    36,    41,    45,    65,
+      99,   132,   143,   144,   145,   148,   150,   165,   166,   181,
+     190,   246,     3,     0,   138,   126,     3,    45,   150,   156,
+     157,   250,   145,   146,    16,    25,    30,    31,    43,    45,
+     206,   259,   192,     3,   100,    39,    66,    67,    68,    70,
+      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,   103,   105,   106,   107,   109,
+     110,   112,   113,   114,   115,   116,   122,   124,   127,     3,
+     122,   162,   146,   172,   188,   126,   127,   184,   185,   232,
+     233,   234,   242,   122,   248,   249,   127,   254,   180,   239,
+       3,   155,   132,   104,   100,   100,   133,   125,   100,   247,
+       3,     3,   151,   152,   248,   248,   151,     3,   132,   145,
+     126,   136,     3,    99,    67,    99,     3,    34,    50,   226,
+       3,     3,   208,     3,   220,   221,   222,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,     3,   115,   128,   256,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     239,   254,     3,     4,   122,   124,   128,   255,   256,   248,
+      12,   254,    99,   139,   140,   141,   147,   148,   196,   198,
+     207,   227,   187,   184,   127,   122,   238,     3,    93,   223,
+     224,   225,   133,   115,   184,   133,   142,   143,   133,   248,
+     247,   252,   254,   104,   237,   100,   143,   132,   237,   248,
+     248,   102,     3,    53,   193,    53,   194,     3,   209,   210,
+     102,   110,   114,   215,   222,   124,   256,   104,   133,   125,
+     254,   254,   124,   256,    89,   133,   122,   133,   132,   141,
+     126,   139,   239,   102,   104,   211,   225,   133,   100,   132,
+     133,   104,    35,   115,   234,   236,   102,   149,   152,   132,
+      99,   133,     3,     5,   122,   234,    15,   195,   234,   235,
+     126,   237,   100,     5,   216,   217,   254,   254,   133,   125,
+     254,   256,   146,   248,   126,   139,   132,   133,   254,   236,
+     237,    93,   225,    26,    32,   173,   175,   177,   178,   146,
+     247,   254,   250,   146,   223,   235,   126,   100,   199,   149,
+     210,   110,     5,   109,   110,   218,   219,   125,   125,   133,
+      33,    61,   167,   168,   169,   170,   132,   211,   126,   225,
+     126,   122,   173,   175,    64,   153,   133,   133,   197,   234,
+      45,    99,   190,   203,   204,   205,   114,   109,   219,   217,
+     254,   104,   132,   169,   170,   231,   176,     3,   146,   146,
+     237,    99,   144,   148,   190,   200,   201,   202,   207,   227,
+       3,    25,   132,   205,     3,   114,   217,   104,   142,   142,
+     142,   237,   126,   126,   132,   202,   226,   216,     3,   142,
+     132,   132,   133,   228,   200,     3,   110,   216,   174,   142,
+     132,   122,   110,   126,   132,   223,   142,   133,   132,   237
 };
 
 #define yyerrok		(yyerrstatus = 0)
@@ -3594,205 +4424,352 @@ yyreduce:
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-        case 24:
+        
+    case 13:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1509 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+/* Line 1464 of skeleton.m4  */
+#line 1869 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
+    }
     break;
 
-  case 25:
 
-/* Line 1455 of yacc.c  */
-#line 1510 "parser.y"
-    {(yyval.code)=code_new();;}
-    break;
-
-  case 26:
+  
+    case 24:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1512 "parser.y"
-    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));;}
+/* Line 1464 of skeleton.m4  */
+#line 1881 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
+    }
     break;
 
-  case 27:
 
-/* Line 1455 of yacc.c  */
-#line 1513 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
-    break;
-
-  case 38:
+  
+    case 26:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1528 "parser.y"
-    {(yyval.code)=0;;}
+/* Line 1464 of skeleton.m4  */
+#line 1884 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 45:
-
-/* Line 1455 of yacc.c  */
-#line 1536 "parser.y"
-    {/*TODO*/(yyval.code)=0;;}
-    break;
 
-  case 46:
+  
+    case 27:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1537 "parser.y"
-    {/*TODO*/(yyval.code)=0;;}
+/* Line 1464 of skeleton.m4  */
+#line 1885 "parser.y"
+    {(yyval.code)=code_new();}
+    }
     break;
 
-  case 47:
-
-/* Line 1455 of yacc.c  */
-#line 1539 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (3)].code);;}
-    break;
 
-  case 48:
+  
+    case 28:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1540 "parser.y"
-    {(yyval.code)=0;;}
+/* Line 1464 of skeleton.m4  */
+#line 1887 "parser.y"
+    {
+    (yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));
+}
+    }
     break;
 
-  case 49:
-
-/* Line 1455 of yacc.c  */
-#line 1541 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (2)].code);;}
-    break;
 
-  case 50:
+  
+    case 29:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1542 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+/* Line 1464 of skeleton.m4  */
+#line 1890 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 51:
 
-/* Line 1455 of yacc.c  */
-#line 1546 "parser.y"
-    {
-    code_t**cc = &global->init->method->body->code;
-    *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
-;}
-    break;
-
-  case 52:
+  
+    case 42:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1553 "parser.y"
-    {(yyval.value)=(yyvsp[(2) - (2)].value);;}
+/* Line 1464 of skeleton.m4  */
+#line 1905 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (3)].code);}
+    }
     break;
 
-  case 53:
 
-/* Line 1455 of yacc.c  */
-#line 1554 "parser.y"
-    {(yyval.value).c=abc_pushundefined(0);
-                                  (yyval.value).t=TYPE_ANY;
-                                 ;}
-    break;
-
-  case 54:
+  
+    case 43:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1558 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);;}
+/* Line 1464 of skeleton.m4  */
+#line 1906 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 55:
 
-/* Line 1455 of yacc.c  */
-#line 1559 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);;}
+  
+    case 44:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1909 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 56:
 
-/* Line 1455 of yacc.c  */
-#line 1561 "parser.y"
-    {(yyval.code) = (yyvsp[(1) - (1)].code);;}
+  
+    case 51:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1916 "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;
+
+
+  
+    case 52:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1928 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (2)].code);}
+    }
+    break;
+
+
+  
+    case 53:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1929 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
+    break;
+
+
+  
+    case 54:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1933 "parser.y"
+    {
+    code_t**cc = &global->init->method->body->code;
+    *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
+}
+    }
+    break;
+
+
+  
+    case 55:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1940 "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;
+
+
+  
+    case 56:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1959 "parser.y"
+    {(yyval.node)=(yyvsp[(2) - (2)].node);}
+    }
+    break;
+
+
+  
+    case 57:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1960 "parser.y"
+    {(yyval.node)=mkdummynode();}
+    }
+    break;
+
+
+  
+    case 58:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1962 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+    }
+    break;
+
+
+  
+    case 59:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1963 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+    }
+    break;
+
+
+  
+    case 60:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1965 "parser.y"
+    {(yyval.code) = (yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 57:
 
-/* Line 1455 of yacc.c  */
-#line 1562 "parser.y"
-    {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));;}
+  
+    case 61:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1966 "parser.y"
+    {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
+    }
     break;
 
-  case 58:
 
-/* Line 1455 of yacc.c  */
-#line 1565 "parser.y"
+  
+    case 62:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1969 "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);
+    char slot = 0;
+    int index = 0;
+    if(state->method->uses_slots) {
+        variable_t* v = find_slot(state, (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);
     }
 
-    int index = new_variable((yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1);
+    (yyval.code) = slot?abc_getscopeobject(0, 1):0;
     
+    typedcode_t v = node_read((yyvsp[(3) - (3)].node));
+    if(!is_subtype_of(v.t, (yyvsp[(2) - (3)].classinfo))) {
+        syntaxerror("Can't convert %s to %s", v.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) = (yyvsp[(3) - (3)].value).c;
-            (yyval.code) = converttype((yyval.code), (yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo));
-            (yyval.code) = abc_setlocal((yyval.code), index);
+        if(v.c->prev || v.c->opcode != OPCODE_PUSHUNDEFINED) {
+            (yyval.code) = code_append((yyval.code), v.c);
+            (yyval.code) = converttype((yyval.code), v.t, (yyvsp[(2) - (3)].classinfo));
         } else {
-            (yyval.code) = defaultvalue(0, (yyvsp[(2) - (3)].classinfo));
-            (yyval.code) = abc_setlocal((yyval.code), index);
+            code_free(v.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) = (yyvsp[(3) - (3)].value).c;
+        if(v.c->prev || v.c->opcode != OPCODE_PUSHUNDEFINED) {
+            (yyval.code) = code_append((yyval.code), v.c);
             (yyval.code) = abc_coerce_a((yyval.code));
-            (yyval.code) = abc_setlocal((yyval.code), index);
         } else {
-            (yyval.code) = code_new();
+            // don't do anything
+            code_free(v.c);
+            code_free((yyval.code));
+            (yyval.code) = 0;
+            break;
         }
     }
-    
-    /* that's the default for a local register, anyway
-        else {
-        state->method->initcode = abc_pushundefined(state->method->initcode);
-        state->method->initcode = abc_setlocal(state->method->initcode, index);
-    }*/
-    //printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
-;}
+    if(slot) {
+        (yyval.code) = abc_setslot((yyval.code), index);
+    } else {
+        (yyval.code) = abc_setlocal((yyval.code), index);
+    }
+}
+    }
     break;
 
-  case 59:
 
-/* Line 1455 of yacc.c  */
-#line 1605 "parser.y"
-    {(yyval.code) = code_new();;}
+  
+    case 63:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2028 "parser.y"
+    {(yyval.code) = code_new();}
+    }
     break;
 
-  case 60:
 
-/* Line 1455 of yacc.c  */
-#line 1606 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);;}
+  
+    case 64:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2029 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+    }
     break;
 
-  case 61:
 
-/* Line 1455 of yacc.c  */
-#line 1609 "parser.y"
-    {new_state();;}
+  
+    case 65:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2032 "parser.y"
+    {PASS12 new_state();}
+    }
     break;
 
-  case 62:
 
-/* Line 1455 of yacc.c  */
-#line 1609 "parser.y"
+  
+    case 66:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2032 "parser.y"
     {
      
     (yyval.code) = code_new();
@@ -3809,53 +4786,79 @@ yyreduce:
         myjmp->branch = (yyval.code) = abc_nop((yyval.code));
     }
     (yyval.code) = var_block((yyval.code));
-    old_state();
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 63:
 
-/* Line 1455 of yacc.c  */
-#line 1628 "parser.y"
-    {(yyval.code)=code_new();;}
+  
+    case 67:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2051 "parser.y"
+    {(yyval.code)=code_new();}
+    }
     break;
 
-  case 66:
 
-/* Line 1455 of yacc.c  */
-#line 1633 "parser.y"
+  
+    case 70:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2058 "parser.y"
     {
-    (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1);
-;}
+    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);
+}
+    }
     break;
 
-  case 67:
 
-/* Line 1455 of yacc.c  */
-#line 1636 "parser.y"
+  
+    case 71:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2062 "parser.y"
     {
+    PASS12
     (yyval.id)=(yyvsp[(1) - (1)].id);
-;}
+}
+    }
     break;
 
-  case 68:
 
-/* Line 1455 of yacc.c  */
-#line 1640 "parser.y"
-    {new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;;}
+  
+    case 72:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2067 "parser.y"
+    {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
+    }
     break;
 
-  case 69:
 
-/* Line 1455 of yacc.c  */
-#line 1641 "parser.y"
-    {new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;;}
+  
+    case 73:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2068 "parser.y"
+    {PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
+    }
     break;
 
-  case 70:
 
-/* Line 1455 of yacc.c  */
-#line 1643 "parser.y"
+  
+    case 74:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2070 "parser.y"
     {
     if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");
     (yyval.code) = code_new();
@@ -3873,20 +4876,28 @@ yyreduce:
     myif->branch = out;
 
     (yyval.code) = var_block((yyval.code));
-    old_state();
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 71:
 
-/* Line 1455 of yacc.c  */
-#line 1663 "parser.y"
+  
+    case 75:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2090 "parser.y"
     {
-    variable_t*var = find_variable((yyvsp[(2) - (6)].id));
+    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);
+    int it = new_variable(tmp1name, TYPE_INT, 0, 0);
     char*tmp2name = concat2((yyvsp[(2) - (6)].id), "__array__");
-    int array = new_variable(tmp1name, 0, 0);
+    int array = new_variable(tmp1name, 0, 0, 0);
 
     (yyval.code) = code_new();
     (yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);
@@ -3918,24 +4929,33 @@ yyreduce:
     myif->branch = out;
 
     (yyval.code) = var_block((yyval.code));
-    old_state();
 
     free(tmp1name);
     free(tmp2name);
-;}
+
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 72:
 
-/* Line 1455 of yacc.c  */
-#line 1706 "parser.y"
-    {new_state();;}
+  
+    case 76:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2138 "parser.y"
+    {PASS12 new_state();}
+    }
     break;
 
-  case 73:
 
-/* Line 1455 of yacc.c  */
-#line 1706 "parser.y"
+  
+    case 77:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2138 "parser.y"
     {
 
     (yyval.code) = code_new();
@@ -3952,21 +4972,29 @@ yyreduce:
     continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);
 
     (yyval.code) = var_block((yyval.code));
-    old_state();
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 74:
 
-/* Line 1455 of yacc.c  */
-#line 1725 "parser.y"
-    {new_state();;}
+  
+    case 78:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2157 "parser.y"
+    {PASS12 new_state();}
+    }
     break;
 
-  case 75:
 
-/* Line 1455 of yacc.c  */
-#line 1725 "parser.y"
+  
+    case 79:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2157 "parser.y"
     {
     (yyval.code) = code_new();
     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
@@ -3979,95 +5007,139 @@ yyreduce:
     continuejumpsto((yyval.code), (yyvsp[(1) - (7)].id), cont);
     
     (yyval.code) = var_block((yyval.code));
-    old_state();
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 76:
 
-/* Line 1455 of yacc.c  */
-#line 1740 "parser.y"
+  
+    case 80:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2172 "parser.y"
     {
     (yyval.code) = abc___break__(0, "");
-;}
+}
+    }
     break;
 
-  case 77:
 
-/* Line 1455 of yacc.c  */
-#line 1743 "parser.y"
+  
+    case 81:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2175 "parser.y"
     {
     (yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));
-;}
+}
+    }
     break;
 
-  case 78:
 
-/* Line 1455 of yacc.c  */
-#line 1746 "parser.y"
+  
+    case 82:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2178 "parser.y"
     {
     (yyval.code) = abc___continue__(0, "");
-;}
+}
+    }
     break;
 
-  case 79:
 
-/* Line 1455 of yacc.c  */
-#line 1749 "parser.y"
+  
+    case 83:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2181 "parser.y"
     {
     (yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));
-;}
+}
+    }
     break;
 
-  case 80:
 
-/* Line 1455 of yacc.c  */
-#line 1753 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 84:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2185 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 81:
 
-/* Line 1455 of yacc.c  */
-#line 1754 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+  
+    case 85:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2186 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 82:
 
-/* Line 1455 of yacc.c  */
-#line 1755 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+  
+    case 86:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2187 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 83:
 
-/* Line 1455 of yacc.c  */
-#line 1756 "parser.y"
-    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));;}
+  
+    case 87:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2188 "parser.y"
+    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
+    }
     break;
 
-  case 84:
 
-/* Line 1455 of yacc.c  */
-#line 1757 "parser.y"
+  
+    case 88:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2189 "parser.y"
     {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 85:
 
-/* Line 1455 of yacc.c  */
-#line 1758 "parser.y"
-    {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));;}
+  
+    case 89:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2190 "parser.y"
+    {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}
+    }
     break;
 
-  case 86:
 
-/* Line 1455 of yacc.c  */
-#line 1760 "parser.y"
+  
+    case 90:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2192 "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__) {
@@ -4075,33 +5147,47 @@ yyreduce:
     }
     code_t*e = (yyval.code) = abc_nop((yyval.code));
     j->branch = e;
-;}
+}
+    }
     break;
 
-  case 87:
 
-/* Line 1455 of yacc.c  */
-#line 1771 "parser.y"
+  
+    case 91:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2203 "parser.y"
     {
     (yyval.code) = (yyvsp[(3) - (3)].code);
-;}
+}
+    }
     break;
 
-  case 88:
 
-/* Line 1455 of yacc.c  */
-#line 1774 "parser.y"
-    {new_state();;}
+  
+    case 92:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2206 "parser.y"
+    {PASS12 new_state();state->switch_var=alloc_local();}
+    }
     break;
 
-  case 89:
 
-/* Line 1455 of yacc.c  */
-#line 1774 "parser.y"
+  
+    case 93:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2206 "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;
@@ -4122,21 +5208,33 @@ yyreduce:
     }
    
     (yyval.code) = var_block((yyval.code));
-    old_state();
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 90:
 
-/* Line 1455 of yacc.c  */
-#line 1803 "parser.y"
-    {new_state();state->exception_name=(yyvsp[(3) - (5)].id);new_variable((yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0);;}
+  
+    case 94:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2237 "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);
+                                              }
+    }
     break;
 
-  case 91:
 
-/* Line 1455 of yacc.c  */
-#line 1804 "parser.y"
+  
+    case 95:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2242 "parser.y"
     {
     namespace_t name_ns = {ACCESS_PACKAGE, ""};
     multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};
@@ -4147,33 +5245,41 @@ yyreduce:
     (yyval.exception) = e;
 
     code_t*c = 0;
-    int i = find_variable_safe((yyvsp[(3) - (9)].id))->index;
+    int i = find_variable_safe(state, (yyvsp[(3) - (9)].id))->index;
     e->target = c = abc_nop(0);
     c = abc_setlocal(c, i);
+    c = code_append(c, code_dup(state->method->scope_code));
     c = code_append(c, (yyvsp[(8) - (9)].code));
     c = abc_kill(c, i);
 
     c = var_block(c);
-    old_state();
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 92:
 
-/* Line 1455 of yacc.c  */
-#line 1823 "parser.y"
-    {new_state();state->exception_name=0;;}
+  
+    case 96:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2262 "parser.y"
+    {PASS12 new_state();state->exception_name=0;}
+    }
     break;
 
-  case 93:
 
-/* Line 1455 of yacc.c  */
-#line 1823 "parser.y"
+  
+    case 97:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2262 "parser.y"
     {
     (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code));
     if(!(yyvsp[(4) - (5)].code)) {
         (yyval.exception)=0;
-        old_state();
     } else {
         NEW(abc_exception_t, e)
         e->exc_type = 0; //all exceptions
@@ -4181,37 +5287,53 @@ yyreduce:
         e->target = 0;
         e->to = abc_nop(0);
         e->to = code_append(e->to, (yyvsp[(4) - (5)].code));
-        old_state();
         (yyval.exception) = e;
     }
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 94:
 
-/* Line 1455 of yacc.c  */
-#line 1840 "parser.y"
-    {(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));;}
+  
+    case 98:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2278 "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 95:
 
-/* Line 1455 of yacc.c  */
-#line 1841 "parser.y"
-    {(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));;}
+  
+    case 99:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2279 "parser.y"
+    {(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));}
+    }
     break;
 
-  case 96:
 
-/* Line 1455 of yacc.c  */
-#line 1842 "parser.y"
+  
+    case 100:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2280 "parser.y"
     {(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}
+    }
     break;
 
-  case 97:
 
-/* Line 1455 of yacc.c  */
-#line 1843 "parser.y"
+  
+    case 101:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2281 "parser.y"
     {
     (yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);
     (yyval.catch_list).finally = 0;
@@ -4219,13 +5341,17 @@ yyreduce:
         list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));
         (yyval.catch_list).finally = (yyvsp[(2) - (2)].exception)->to;(yyvsp[(2) - (2)].exception)->to=0;
     }
-;}
+}
+    }
     break;
 
-  case 98:
 
-/* Line 1455 of yacc.c  */
-#line 1851 "parser.y"
+  
+    case 102:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2289 "parser.y"
     {
     (yyval.catch_list).l=list_new();
     (yyval.catch_list).finally = 0;
@@ -4233,20 +5359,31 @@ yyreduce:
         list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));
         (yyval.catch_list).finally = (yyvsp[(1) - (1)].exception)->to;(yyvsp[(1) - (1)].exception)->to=0;
     }
-;}
+}
+    }
     break;
 
-  case 99:
 
-/* Line 1455 of yacc.c  */
-#line 1860 "parser.y"
-    {new_state();;}
+  
+    case 103:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2298 "parser.y"
+    {PASS12 new_state();
+                 state->method->has_exceptions=1;
+                 state->method->late_binding=1;//for invariant scope_code
+                }
+    }
     break;
 
-  case 100:
 
-/* Line 1455 of yacc.c  */
-#line 1860 "parser.y"
+  
+    case 104:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2301 "parser.y"
     {
     code_t*out = abc_nop(0);
 
@@ -4259,7 +5396,7 @@ yyreduce:
   
     int tmp;
     if((yyvsp[(6) - (6)].catch_list).finally)
-        tmp = new_variable("__finally__", 0, 0);
+        tmp = new_variable("__finally__", 0, 0, 0);
     
     abc_exception_list_t*l = (yyvsp[(6) - (6)].catch_list).l;
     int count=0;
@@ -4272,6 +5409,7 @@ yyreduce:
             parserassert((ptroff_t)(yyvsp[(6) - (6)].catch_list).finally);
             // finally block
             e->target = (yyval.code) = abc_nop((yyval.code));
+            (yyval.code) = code_append((yyval.code), code_dup(state->method->scope_code));
             (yyval.code) = abc___rethrow__((yyval.code));
         }
         
@@ -4287,1897 +5425,2935 @@ yyreduce:
     list_concat(state->method->exceptions, (yyvsp[(6) - (6)].catch_list).l);
    
     (yyval.code) = var_block((yyval.code));
-    old_state();
-;}
+    PASS12 old_state();
+}
+    }
     break;
 
-  case 101:
 
-/* Line 1455 of yacc.c  */
-#line 1905 "parser.y"
+  
+    case 105:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2347 "parser.y"
     {
     (yyval.code)=(yyvsp[(2) - (2)].value).c;
     (yyval.code)=abc_throw((yyval.code));
-;}
-    break;
+}
+    }
+    break;
 
-  case 102:
 
-/* Line 1455 of yacc.c  */
-#line 1909 "parser.y"
+  
+    case 106:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2351 "parser.y"
     {
     if(!state->exception_name)
         syntaxerror("re-throw only possible within a catch block");
-    variable_t*v = find_variable(state->exception_name);
+    variable_t*v = find_variable(state, state->exception_name);
     (yyval.code)=code_new();
     (yyval.code)=abc_getlocal((yyval.code), v->index);
     (yyval.code)=abc_throw((yyval.code));
-;}
+}
+    }
+    break;
+
+
+  
+    case 107:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2362 "parser.y"
+    {
+     new_state();
+     if(state->method->has_exceptions) {
+         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;
+     }
+     (yyval.value_list).cc = (yyvsp[(3) - (4)].value).c;
+}
+    }
     break;
 
-  case 103:
 
-/* Line 1455 of yacc.c  */
-#line 1920 "parser.y"
+  
+    case 108:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2372 "parser.y"
     {
-     (yyval.code) = (yyvsp[(3) - (5)].value).c;
-     (yyval.code) = abc_pushscope((yyval.code));
-     (yyval.code) = code_append((yyval.code), (yyvsp[(5) - (5)].code));
+     /* remove getlocal;pushwith from scope code again */
+     state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));
+
+     (yyval.code) = (yyvsp[(1) - (2)].value_list).cc;
+     if(state->method->has_exceptions) {
+         (yyval.code) = abc_dup((yyval.code));
+         (yyval.code) = abc_setlocal((yyval.code), (yyvsp[(1) - (2)].value_list).number);
+     }
+     (yyval.code) = abc_pushwith((yyval.code));
+     (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (2)].code));
      (yyval.code) = abc_popscope((yyval.code));
-;}
+     old_state();
+}
+    }
     break;
 
-  case 105:
 
-/* Line 1455 of yacc.c  */
-#line 1930 "parser.y"
-    {(yyval.id)="package";;}
+  
+    case 110:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2390 "parser.y"
+    {PASS12 (yyval.id)="package";}
+    }
     break;
 
-  case 106:
 
-/* Line 1455 of yacc.c  */
-#line 1932 "parser.y"
-    {(yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;;}
+  
+    case 111:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2391 "parser.y"
+    {PASS12 (yyval.id)=(yyvsp[(1) - (1)].id);}
+    }
     break;
 
-  case 107:
 
-/* Line 1455 of yacc.c  */
-#line 1933 "parser.y"
-    {(yyval.id)=strdup((yyvsp[(1) - (1)].id));;}
+  
+    case 112:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2393 "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 113:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2394 "parser.y"
+    {PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}
+    }
     break;
 
-  case 108:
 
-/* Line 1455 of yacc.c  */
-#line 1935 "parser.y"
-    {startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;;}
+  
+    case 114:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2396 "parser.y"
+    {PASS12 startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;}
+    }
     break;
 
-  case 109:
 
-/* Line 1455 of yacc.c  */
-#line 1935 "parser.y"
-    {endpackage();(yyval.code)=0;;}
+  
+    case 115:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2397 "parser.y"
+    {PASS12 endpackage();(yyval.code)=0;}
+    }
     break;
 
-  case 110:
 
-/* Line 1455 of yacc.c  */
-#line 1936 "parser.y"
-    {startpackage("");}
+  
+    case 116:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2398 "parser.y"
+    {PASS12 startpackage("");}
+    }
     break;
 
-  case 111:
 
-/* Line 1455 of yacc.c  */
-#line 1936 "parser.y"
-    {endpackage();(yyval.code)=0;;}
+  
+    case 117:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2399 "parser.y"
+    {PASS12 endpackage();(yyval.code)=0;}
+    }
     break;
 
-  case 112:
 
-/* Line 1455 of yacc.c  */
-#line 1938 "parser.y"
+  
+    case 118:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2421 "parser.y"
     {
+       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)) {
+           as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
+       }
        classinfo_t*c = (yyvsp[(2) - (2)].classinfo);
        if(!c) 
             syntaxerror("Couldn't import class\n");
        state_has_imports();
        dict_put(state->imports, c->name, c);
+       import_toplevel(c->package);
        (yyval.code)=0;
-;}
+}
+    }
     break;
 
-  case 113:
 
-/* Line 1455 of yacc.c  */
-#line 1946 "parser.y"
+  
+    case 119:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2435 "parser.y"
     {
+       PASS12
+       if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6) && as3_pass==1) {
+           as3_schedule_package((yyvsp[(2) - (4)].id));
+       }
+
        NEW(import_t,i);
        i->package = (yyvsp[(2) - (4)].id);
        state_has_imports();
        list_append(state->wildcard_imports, i);
+       import_toplevel(i->package);
        (yyval.code)=0;
-;}
+}
+    }
     break;
 
-  case 114:
 
-/* Line 1455 of yacc.c  */
-#line 1956 "parser.y"
-    {(yyval.flags)=0;;}
+  
+    case 120:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2451 "parser.y"
+    {PASS12 (yyval.flags).flags=0;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 115:
 
-/* Line 1455 of yacc.c  */
-#line 1957 "parser.y"
-    {(yyval.flags)=(yyvsp[(1) - (1)].flags);}
+  
+    case 121:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2452 "parser.y"
+    {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
+    }
     break;
 
-  case 116:
 
-/* Line 1455 of yacc.c  */
-#line 1958 "parser.y"
-    {(yyval.flags)=(yyvsp[(1) - (1)].token);;}
+  
+    case 122:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2453 "parser.y"
+    {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
+    }
     break;
 
-  case 117:
 
-/* Line 1455 of yacc.c  */
-#line 1959 "parser.y"
-    {(yyval.flags)=(yyvsp[(1) - (2)].flags)|(yyvsp[(2) - (2)].token);;}
+  
+    case 123:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2454 "parser.y"
+    {
+    PASS12 
+    (yyval.flags).flags=(yyvsp[(1) - (2)].flags).flags|(yyvsp[(2) - (2)].flags).flags;
+    if((yyvsp[(1) - (2)].flags).ns && (yyvsp[(2) - (2)].flags).ns) syntaxerror("only one namespace allowed in one declaration");
+    (yyval.flags).ns=(yyvsp[(1) - (2)].flags).ns?(yyvsp[(1) - (2)].flags).ns:(yyvsp[(2) - (2)].flags).ns;
+
+}
+    }
     break;
 
-  case 118:
 
-/* Line 1455 of yacc.c  */
-#line 1961 "parser.y"
-    {(yyval.token)=FLAG_PUBLIC;;}
+  
+    case 124:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2461 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_PUBLIC;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 119:
 
-/* Line 1455 of yacc.c  */
-#line 1962 "parser.y"
-    {(yyval.token)=FLAG_PRIVATE;;}
+  
+    case 125:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2462 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_PRIVATE;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 120:
 
-/* Line 1455 of yacc.c  */
-#line 1963 "parser.y"
-    {(yyval.token)=FLAG_PROTECTED;;}
+  
+    case 126:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2463 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_PROTECTED;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 121:
 
-/* Line 1455 of yacc.c  */
-#line 1964 "parser.y"
-    {(yyval.token)=FLAG_STATIC;;}
+  
+    case 127:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2464 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_STATIC;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 122:
 
-/* Line 1455 of yacc.c  */
-#line 1965 "parser.y"
-    {(yyval.token)=FLAG_DYNAMIC;;}
+  
+    case 128:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2465 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_DYNAMIC;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 123:
 
-/* Line 1455 of yacc.c  */
-#line 1966 "parser.y"
-    {(yyval.token)=FLAG_FINAL;;}
+  
+    case 129:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2466 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_FINAL;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 124:
 
-/* Line 1455 of yacc.c  */
-#line 1967 "parser.y"
-    {(yyval.token)=FLAG_OVERRIDE;;}
+  
+    case 130:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2467 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_OVERRIDE;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 125:
 
-/* Line 1455 of yacc.c  */
-#line 1968 "parser.y"
-    {(yyval.token)=FLAG_NATIVE;;}
+  
+    case 131:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2468 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_NATIVE;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 126:
 
-/* Line 1455 of yacc.c  */
-#line 1969 "parser.y"
-    {(yyval.token)=FLAG_PACKAGEINTERNAL;;}
+  
+    case 132:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2469 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_PACKAGEINTERNAL;(yyval.flags).ns=0;}
+    }
     break;
 
-  case 127:
 
-/* Line 1455 of yacc.c  */
-#line 1971 "parser.y"
-    {(yyval.classinfo)=registry_getobjectclass();;}
+  
+    case 133:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2470 "parser.y"
+    {PASS12 (yyval.flags).flags=FLAG_NAMESPACE;
+                               (yyval.flags).ns=(yyvsp[(1) - (1)].id);
+                       }
+    }
     break;
 
-  case 128:
 
-/* Line 1455 of yacc.c  */
-#line 1972 "parser.y"
-    {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);;}
+  
+    case 134:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2474 "parser.y"
+    {PASS12 (yyval.classinfo)=0;}
+    }
     break;
 
-  case 129:
 
-/* Line 1455 of yacc.c  */
-#line 1974 "parser.y"
-    {(yyval.classinfo_list)=list_new();;}
+  
+    case 135:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2475 "parser.y"
+    {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
+    }
     break;
 
-  case 130:
 
-/* Line 1455 of yacc.c  */
-#line 1975 "parser.y"
-    {(yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);;}
+  
+    case 136:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2477 "parser.y"
+    {PASS12 (yyval.classinfo_list)=list_new();}
+    }
     break;
 
-  case 131:
 
-/* Line 1455 of yacc.c  */
-#line 1977 "parser.y"
-    {(yyval.classinfo_list)=list_new();;}
+  
+    case 137:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2478 "parser.y"
+    {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
+    }
     break;
 
-  case 132:
 
-/* Line 1455 of yacc.c  */
-#line 1978 "parser.y"
-    {(yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);;}
+  
+    case 138:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2480 "parser.y"
+    {PASS12 (yyval.classinfo_list)=list_new();}
+    }
     break;
 
-  case 133:
 
-/* Line 1455 of yacc.c  */
-#line 1982 "parser.y"
-    {startclass((yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list), 0);;}
+  
+    case 139:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2481 "parser.y"
+    {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
+    }
     break;
 
-  case 134:
 
-/* Line 1455 of yacc.c  */
-#line 1984 "parser.y"
-    {endclass();(yyval.code)=0;;}
+  
+    case 140:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2485 "parser.y"
+    {PASS12 startclass(&(yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list));}
+    }
     break;
 
-  case 135:
 
-/* Line 1455 of yacc.c  */
-#line 1988 "parser.y"
-    {startclass((yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list),1);;}
+  
+    case 141:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2487 "parser.y"
+    {PASS12 endclass();(yyval.code)=0;}
+    }
     break;
 
-  case 136:
 
-/* Line 1455 of yacc.c  */
-#line 1990 "parser.y"
-    {endclass();(yyval.code)=0;;}
+  
+    case 142:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2491 "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));}
+    }
     break;
 
-  case 144:
 
-/* Line 1455 of yacc.c  */
-#line 2002 "parser.y"
-    {
-    code_t*c = state->cls->static_init;
-    c = code_append(c, (yyvsp[(1) - (1)].code));  
-    state->cls->static_init = c;
-;}
+  
+    case 143:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2494 "parser.y"
+    {PASS12 endclass();(yyval.code)=0;}
+    }
     break;
 
-  case 150:
 
-/* Line 1455 of yacc.c  */
-#line 2013 "parser.y"
-    {
-    syntaxerror("variable declarations not allowed in interfaces");
-;}
+  
+    case 149:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2503 "parser.y"
+    {PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}
+    }
     break;
 
-  case 151:
 
-/* Line 1455 of yacc.c  */
-#line 2016 "parser.y"
+  
+    case 152:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2507 "parser.y"
     {
-    (yyvsp[(1) - (8)].flags) |= FLAG_PUBLIC;
-    if((yyvsp[(1) - (8)].flags)&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
-        syntaxerror("invalid method modifiers: interface methods always need to be public");
+    code_t*c = state->cls->static_init->header;
+    c = code_append(c, (yyvsp[(1) - (1)].code));  
+    state->cls->static_init->header = c;
+}
     }
-    startfunction(0,(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));
-    endfunction(0,(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);
-;}
     break;
 
-  case 154:
 
-/* Line 1455 of yacc.c  */
-#line 2029 "parser.y"
+  
+    case 158:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2518 "parser.y"
     {
-    int flags = (yyvsp[(1) - (5)].flags);
-    memberinfo_t* info = state->cls?
-            memberinfo_register(state->cls->info, (yyvsp[(3) - (5)].id), MEMBER_SLOT):
-            memberinfo_register_global(flags2access((yyvsp[(1) - (5)].flags)), state->package, (yyvsp[(3) - (5)].id), MEMBER_SLOT);
+    syntaxerror("variable declarations not allowed in interfaces");
+}
+    }
+    break;
 
-    info->type = (yyvsp[(4) - (5)].classinfo);
-    info->flags = flags;
 
-    /* slot name */
-    namespace_t mname_ns = {flags2access(flags), ""};
-    multiname_t mname = {QNAME, &mname_ns, 0, (yyvsp[(3) - (5)].id)};
   
-    trait_list_t**traits;
-    code_t**code;
-    if(!state->cls) {
-        // global variable
-        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;
-    } else {
-        // instance variable
-        traits = &state->cls->abc->traits;
-        code = &state->cls->init;
-    }
-    
-    trait_t*t=0;
-    if((yyvsp[(4) - (5)].classinfo)) {
-        MULTINAME(m, (yyvsp[(4) - (5)].classinfo));
-        t = trait_new_member(traits, multiname_clone(&m), multiname_clone(&mname), 0);
-    } else {
-        t = trait_new_member(traits, 0, multiname_clone(&mname), 0);
+    case 159:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2521 "parser.y"
+    {
+    PASS12
+    (yyvsp[(1) - (8)].flags).flags |= FLAG_PUBLIC;
+    if((yyvsp[(1) - (8)].flags).flags&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {
+        syntaxerror("invalid method modifiers: interface methods always need to be public");
     }
-    info->slot = t->slot_id;
-    
-    /* initalization code (if needed) */
-    code_t*c = 0;
-    if((yyvsp[(5) - (5)].value).c && !is_pushundefined((yyvsp[(5) - (5)].value).c)) {
-        c = abc_getlocal_0(c);
-        c = code_append(c, (yyvsp[(5) - (5)].value).c);
-        c = converttype(c, (yyvsp[(5) - (5)].value).t, (yyvsp[(4) - (5)].classinfo));
-        c = abc_setslot(c, t->slot_id);
+    startfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));
+    endfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);
+    list_deep_free((yyvsp[(6) - (8)].params).list);
+}
     }
+    break;
 
-    *code = code_append(*code, c);
 
-    if((yyvsp[(2) - (5)].token)==KW_CONST) {
-        t->kind= TRAIT_CONST;
-    }
+  
+    case 162:
+    if(as3_pass==2) {
 
-    (yyval.code)=0;
-;}
+/* Line 1464 of skeleton.m4  */
+#line 2589 "parser.y"
+    {PASS12 setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}
+    }
     break;
 
-  case 155:
-
-/* Line 1455 of yacc.c  */
-#line 2087 "parser.y"
-    {(yyval.constant)=0;;}
-    break;
 
-  case 156:
+  
+    case 163:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 2088 "parser.y"
-    {(yyval.constant)=(yyvsp[(2) - (2)].constant);;}
+/* Line 1464 of skeleton.m4  */
+#line 2589 "parser.y"
+    {PASS12 (yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}
+    }
     break;
 
-  case 157:
-
-/* Line 1455 of yacc.c  */
-#line 2090 "parser.y"
-    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_uint));;}
-    break;
 
-  case 158:
+  
+    case 164:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 2091 "parser.y"
-    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));;}
+/* Line 1464 of skeleton.m4  */
+#line 2591 "parser.y"
+    {PASS12 (yyval.code)=0;}
+    }
     break;
 
-  case 159:
 
-/* Line 1455 of yacc.c  */
-#line 2092 "parser.y"
-    {(yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));;}
+  
+    case 165:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2592 "parser.y"
+    {PASS12 (yyval.code)=0;}
+    }
     break;
 
-  case 160:
 
-/* Line 1455 of yacc.c  */
-#line 2093 "parser.y"
-    {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));;}
-    break;
+  
+    case 166:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2595 "parser.y"
+    {
+PASS12
+    int flags = slotstate_flags->flags;
+    namespace_t ns = modifiers2access(slotstate_flags);
 
-  case 161:
+    if(as3_pass == 1) {
 
-/* Line 1455 of yacc.c  */
-#line 2094 "parser.y"
-    {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);;}
-    break;
+        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");
+            }
+            info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));
+        }
 
-  case 162:
+        info->type = (yyvsp[(2) - (3)].classinfo);
+        info->flags = flags;
+        
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);
+    }
 
-/* Line 1455 of yacc.c  */
-#line 2096 "parser.y"
-    {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));;}
-    break;
+    if(as3_pass == 2) {
+        varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
 
-  case 163:
+        multiname_t mname;
+        code_t**code;
+        trait_t*t = add_abc_slot(slotstate_flags, (yyvsp[(1) - (3)].id), &mname, &code);
 
-/* Line 1455 of yacc.c  */
-#line 2097 "parser.y"
-    {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));;}
-    break;
+        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_setproperty2(c, &mname);
+                } else {
+                    c = abc_setslot(c, t->slot_id);
+                }
+            }
+            *code = code_append(*code, c);
+        }
 
-  case 164:
+        if(slotstate_varconst==KW_CONST) {
+            t->kind= TRAIT_CONST;
+            info->flags |= FLAG_CONST;
+        }
+    }
 
-/* Line 1455 of yacc.c  */
-#line 2098 "parser.y"
-    {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));;}
+    (yyval.code)=0;
+}
+    }
     break;
 
-  case 165:
 
-/* Line 1455 of yacc.c  */
-#line 2103 "parser.y"
-    {
-    memset(&(yyval.params),0,sizeof((yyval.params)));
-;}
+  
+    case 167:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2678 "parser.y"
+    {(yyval.constant)=0;}
+    }
     break;
 
-  case 166:
 
-/* Line 1455 of yacc.c  */
-#line 2106 "parser.y"
+  
+    case 168:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2679 "parser.y"
     {
-    (yyval.params)=(yyvsp[(1) - (1)].params);
-;}
+  (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 167:
 
-/* Line 1455 of yacc.c  */
-#line 2111 "parser.y"
-    {
-    memset(&(yyval.params),0,sizeof((yyval.params)));
-    (yyval.params).varargs=1;
-    list_append((yyval.params).list, (yyvsp[(2) - (2)].param));
-;}
+  
+    case 169:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2688 "parser.y"
+    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
+    }
     break;
 
-  case 168:
 
-/* Line 1455 of yacc.c  */
-#line 2116 "parser.y"
+  
+    case 170:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2689 "parser.y"
     {
-    (yyval.params) =(yyvsp[(1) - (4)].params);
-    (yyval.params).varargs=1;
-    list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
-;}
+    (yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));
+}
+    }
     break;
 
-  case 169:
 
-/* Line 1455 of yacc.c  */
-#line 2123 "parser.y"
-    {
-    (yyval.params) = (yyvsp[(1) - (3)].params);
-    list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
-;}
+  
+    case 171:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2692 "parser.y"
+    {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
+    }
     break;
 
-  case 170:
 
-/* Line 1455 of yacc.c  */
-#line 2127 "parser.y"
-    {
-    memset(&(yyval.params),0,sizeof((yyval.params)));
-    list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
-;}
+  
+    case 172:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2693 "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 171:
 
-/* Line 1455 of yacc.c  */
-#line 2132 "parser.y"
-    {
-     (yyval.param) = malloc(sizeof(param_t));
+  
+    case 173:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2694 "parser.y"
+    {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
+    }
+    break;
+
+
+  
+    case 174:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2695 "parser.y"
+    {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
+    }
+    break;
+
+
+  
+    case 175:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2696 "parser.y"
+    {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
+    }
+    break;
+
+
+  
+    case 176:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2697 "parser.y"
+    {(yyval.constant) = constant_new_undefined((yyvsp[(1) - (1)].token));}
+    }
+    break;
+
+
+  
+    case 177:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2698 "parser.y"
+    {(yyval.constant) = constant_new_float(__builtin_nan(""));}
+    }
+    break;
+
+
+  
+    case 179:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2718 "parser.y"
+    {PASS_ALWAYS tokenizer_begin_xml();xml_level++;}
+    }
+    break;
+
+
+  
+    case 180:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2719 "parser.y"
+    {PASS_ALWAYS tokenizer_begin_xmltext();}
+    }
+    break;
+
+
+  
+    case 181:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2720 "parser.y"
+    {PASS_ALWAYS if(!--xml_level) tokenizer_end_xml(); else tokenizer_begin_xmltext();}
+    }
+    break;
+
+
+  
+    case 182:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2722 "parser.y"
+    {(yyval.id)="";}
+    }
+    break;
+
+
+  
+    case 183:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2723 "parser.y"
+    {(yyval.id)=concat2((yyvsp[(1) - (2)].id), string_cstr(&(yyvsp[(2) - (2)].str)));}
+    }
+    break;
+
+
+  
+    case 184:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2724 "parser.y"
+    {(yyval.id)=concat2((yyvsp[(1) - (2)].id), ">");}
+    }
+    break;
+
+
+  
+    case 185:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2726 "parser.y"
+    {(yyval.id)=concat2((yyvsp[(1) - (2)].id),(yyvsp[(2) - (2)].id));}
+    }
+    break;
+
+
+  
+    case 186:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2727 "parser.y"
+    {(yyval.id)=concat3((yyvsp[(1) - (3)].id),(yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));free((yyvsp[(2) - (3)].id));free((yyvsp[(3) - (3)].id));}
+    }
+    break;
+
+
+  
+    case 187:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2729 "parser.y"
+    {
+    (yyval.id) = allocprintf("<%s%s>%s</%s>", (yyvsp[(2) - (10)].id), (yyvsp[(3) - (10)].id), (yyvsp[(5) - (10)].id), (yyvsp[(8) - (10)].id));
+    free((yyvsp[(2) - (10)].id));free((yyvsp[(3) - (10)].id));free((yyvsp[(5) - (10)].id));free((yyvsp[(8) - (10)].id));
+}
+    }
+    break;
+
+
+  
+    case 188:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2733 "parser.y"
+    {
+    (yyval.id) = allocprintf("<%s%s/>", (yyvsp[(2) - (6)].id), (yyvsp[(3) - (6)].id));
+}
+    }
+    break;
+
+
+  
+    case 189:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2736 "parser.y"
+    {
+    (yyval.id) = allocprintf("<%s%s>%s%s</%s>", (yyvsp[(2) - (11)].id), (yyvsp[(3) - (11)].id), (yyvsp[(5) - (11)].id), (yyvsp[(6) - (11)].id), (yyvsp[(9) - (11)].id));
+    free((yyvsp[(2) - (11)].id));free((yyvsp[(3) - (11)].id));free((yyvsp[(5) - (11)].id));free((yyvsp[(6) - (11)].id));free((yyvsp[(6) - (11)].id));free((yyvsp[(9) - (11)].id));
+}
+    }
+    break;
+
+
+  
+    case 190:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2741 "parser.y"
+    {(yyval.id)=strdup("");}
+    }
+    break;
+
+
+  
+    case 191:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2742 "parser.y"
+    {(yyval.id)=concat2(" ",(yyvsp[(1) - (1)].id));}
+    }
+    break;
+
+
+  
+    case 192:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2743 "parser.y"
+    {(yyval.id)=(yyvsp[(1) - (1)].id);}
+    }
+    break;
+
+
+  
+    case 193:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2744 "parser.y"
+    {(yyval.id)=concat3((yyvsp[(1) - (2)].id)," ",(yyvsp[(2) - (2)].id));free((yyvsp[(1) - (2)].id));free((yyvsp[(2) - (2)].id));}
+    }
+    break;
+
+
+  
+    case 194:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2745 "parser.y"
+    {
+    char* str = string_cstr(&(yyvsp[(3) - (3)].str));
+    (yyval.id)=allocprintf("%s=\"%s\"", (yyvsp[(1) - (3)].id),str);
+    free(str);
+    free((yyvsp[(1) - (3)].id));free((char*)(yyvsp[(3) - (3)].str).str);
+}
+    }
+    break;
+
+
+  
+    case 195:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2755 "parser.y"
+    {
+    PASS12
+    memset(&(yyval.params),0,sizeof((yyval.params)));
+}
+    }
+    break;
+
+
+  
+    case 196:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2759 "parser.y"
+    {
+    PASS12
+    (yyval.params)=(yyvsp[(1) - (1)].params);
+}
+    }
+    break;
+
+
+  
+    case 197:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2765 "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 198:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2771 "parser.y"
+    {
+    PASS12
+    (yyval.params) =(yyvsp[(1) - (4)].params);
+    (yyval.params).varargs=1;
+    list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
+}
+    }
+    break;
+
+
+  
+    case 199:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2779 "parser.y"
+    {
+    PASS12
+    (yyval.params) = (yyvsp[(1) - (3)].params);
+    list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
+}
+    }
+    break;
+
+
+  
+    case 200:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2784 "parser.y"
+    {
+    PASS12
+    memset(&(yyval.params),0,sizeof((yyval.params)));
+    list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
+}
+    }
+    break;
+
+
+  
+    case 201:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2790 "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 202:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2798 "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 205:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2808 "parser.y"
+    {PASS12 (yyval.token)=0;}
+    }
+    break;
+
+
+  
+    case 206:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2811 "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 207:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2812 "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 209:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2828 "parser.y"
+    {PASS12 (yyval.id)=0;}
+    }
+    break;
+
+
+  
+    case 210:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2830 "parser.y"
+    {PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
+    }
     break;
 
-  case 172:
 
-/* Line 1455 of yacc.c  */
-#line 2138 "parser.y"
+  
+    case 211:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2831 "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);
+    
+    (yyval.value).c = abc_getlocal(0, index);
+    (yyval.value).t = TYPE_FUNCTION(f);
+
+    PASS12 list_deep_free((yyvsp[(4) - (10)].params).list);
+}
+    }
+    break;
+
+
+  
+    case 212:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2853 "parser.y"
+    {
+    PASS1 NEW(unresolvedinfo_t,c);
+          memset(c, 0, sizeof(*c));
+          c->kind = INFOTYPE_UNRESOLVED;
+          c->name = (yyvsp[(1) - (1)].id);
+          c->package = get_package_from_name((yyvsp[(1) - (1)].id));
+          if(!c->package) {
+              c->nsset = get_current_imports();
+              /* make the compiler look for this class in the current directory,
+                 just in case: */
+              as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));
+          }
+          (yyval.classinfo) = (classinfo_t*)c;
+    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;
+}
+    }
+    break;
+
+
+  
+    case 213:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2872 "parser.y"
+    {
+    PASS1 NEW(unresolvedinfo_t,c);
+          memset(c, 0, sizeof(*c));
+          c->kind = INFOTYPE_UNRESOLVED;
+          c->package = (yyvsp[(1) - (3)].id);
+          c->name = (yyvsp[(3) - (3)].id);
+          (yyval.classinfo) = (classinfo_t*)c;
+    PASS2
+    slotinfo_t*s = registry_find((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
+    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;
+}
+    }
+    break;
+
+
+  
+    case 216:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2889 "parser.y"
+    {PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}
+    }
+    break;
+
+
+  
+    case 217:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2890 "parser.y"
+    {PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}
+    }
+    break;
+
+
+  
+    case 218:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2892 "parser.y"
+    {PASS12 (yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
+    }
+    break;
+
+
+  
+    case 219:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2893 "parser.y"
+    {PASS12 (yyval.classinfo)=TYPE_ANY;}
+    }
+    break;
+
+
+  
+    case 220:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2894 "parser.y"
+    {PASS12 (yyval.classinfo)=TYPE_VOID;}
+    }
+    break;
+
+
+  
+    case 221:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2903 "parser.y"
+    {PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
+    }
+    break;
+
+
+  
+    case 222:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2904 "parser.y"
+    {PASS12 (yyval.classinfo)=0;}
+    }
+    break;
+
+
+  
+    case 223:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2908 "parser.y"
+    {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
+    }
+    break;
+
+
+  
+    case 224:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2909 "parser.y"
+    {(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
+    }
+    break;
+
+
+  
+    case 225:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2911 "parser.y"
+    {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
+    }
+    break;
+
+
+  
+    case 228:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2915 "parser.y"
+    {(yyval.value_list).number=1;
+                                                  (yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
+                                                 }
+    }
+    break;
+
+
+  
+    case 229:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2919 "parser.y"
+    {(yyval.value_list) = (yyvsp[(1) - (2)].value_list);}
+    }
+    break;
+
+
+  
+    case 230:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2920 "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);
+                                                  }
+    }
+    break;
+
+
+  
+    case 232:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2926 "parser.y"
+    {
+    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;
+    if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
+        multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
+        (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);
+        multiname_destroy(name);
+    } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
+        int slot = (int)(ptroff_t)(yyval.value).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);
+    } 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(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;
+    }
+}
+    }
+    break;
+
+
+  
+    case 233:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2963 "parser.y"
+    {
+   
+    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);
+    }
+    code_t*paramcode = (yyvsp[(3) - (4)].value_list).cc;
+
+    (yyval.value).t = TYPE_ANY;
+    if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
+        multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
+        (yyval.value).c = code_cutlast((yyval.value).c);
+        (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];
+        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 = 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);
+    } 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);
+        (yyval.value).c = code_append((yyval.value).c, paramcode);
+        (yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);
+        multiname_destroy(name);
+    } else {
+        (yyval.value).c = abc_getglobalscope((yyval.value).c);
+        (yyval.value).c = code_append((yyval.value).c, paramcode);
+        (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
+    }
+   
+    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;
+    }
+}
+    }
+    break;
+
+
+  
+    case 234:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3013 "parser.y"
+    {
+    if(!state->cls) syntaxerror("super() not allowed outside of a class");
+    if(!state->method) syntaxerror("super() not allowed outside of a function");
+    if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
+
+    (yyval.value).c = code_new();
+    (yyval.value).c = abc_getlocal_0((yyval.value).c);
+
+    (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value_list).cc);
+    /*
+    this is dependent on the control path, check this somewhere else
+    if(state->method->has_super)
+        syntaxerror("constructor may call super() only once");
+    */
+    state->method->has_super = 1;
+
+    (yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);
+    (yyval.value).c = abc_pushundefined((yyval.value).c);
+    (yyval.value).t = TYPE_ANY;
+}
+    }
+    break;
+
+
+  
+    case 235:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3034 "parser.y"
+    {
+    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);
+    }
+    multiname_t*name = 0;
+    if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
+        (yyval.value).c->opcode = OPCODE_DELETEPROPERTY;
+    } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
+        int slot = (int)(ptroff_t)(yyval.value).c->data[0];
+        multiname_t*name = traits_find_slotid(state->cls->abc->traits,slot)->name;
+        (yyval.value).c = code_cutlast((yyval.value).c);
+        (yyval.value).c = abc_deleteproperty2((yyval.value).c, name);
+    } else {
+        (yyval.value).c = abc_getlocal_0((yyval.value).c);
+        MULTINAME_LATE(m, v.t?v.t->access:ACCESS_PACKAGE, "");
+        (yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
+    }
+    (yyval.value).t = TYPE_BOOLEAN;
+}
+    }
+    break;
+
+
+  
+    case 236:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3056 "parser.y"
+    {
+    (yyval.code) = abc_returnvoid(0);
+}
+    }
+    break;
+
+
+  
+    case 237:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3059 "parser.y"
+    {
+    (yyval.code) = (yyvsp[(2) - (2)].value).c;
+    (yyval.code) = abc_returnvalue((yyval.code));
+}
+    }
+    break;
+
+
+  
+    case 238:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3066 "parser.y"
+    {
+    (yyval.value) = node_read((yyvsp[(1) - (1)].node));
+}
+    }
+    break;
+
+
+  
+    case 239:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3069 "parser.y"
+    {
+    (yyval.value) = node_read((yyvsp[(1) - (1)].node));
+}
+    }
+    break;
+
+
+  
+    case 240:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3072 "parser.y"
+    {
+    (yyval.node) = mkmultinode(&node_comma, (yyvsp[(1) - (1)].node));
+}
+    }
+    break;
+
+
+  
+    case 241:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3075 "parser.y"
     {
-     (yyval.param) = malloc(sizeof(param_t));
-     (yyval.param)->name=(yyvsp[(1) - (2)].id);
-     (yyval.param)->type = TYPE_ANY;
-     (yyval.param)->value = (yyvsp[(2) - (2)].constant);
-;}
+    (yyval.node) = multinode_extend((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
+}
+    }
     break;
 
-  case 173:
 
-/* Line 1455 of yacc.c  */
-#line 2144 "parser.y"
-    {(yyval.token)=(yyvsp[(1) - (1)].token);;}
+  
+    case 242:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3078 "parser.y"
+    { 
+    (yyval.code) = node_exec((yyvsp[(1) - (1)].node)); 
+}
+    }
     break;
 
-  case 174:
 
-/* Line 1455 of yacc.c  */
-#line 2145 "parser.y"
-    {(yyval.token)=(yyvsp[(1) - (1)].token);;}
+  
+    case 243:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3081 "parser.y"
+    { 
+    (yyval.code) = (yyvsp[(1) - (3)].code);
+    (yyval.code) = code_append((yyval.code), node_exec((yyvsp[(3) - (3)].node))); 
+}
+    }
     break;
 
-  case 175:
 
-/* Line 1455 of yacc.c  */
-#line 2146 "parser.y"
-    {(yyval.token)=0;;}
+  
+    case 244:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3086 "parser.y"
+    {(yyval.value_list).cc=0;(yyval.value_list).number=0;}
+    }
     break;
 
-  case 176:
 
-/* Line 1455 of yacc.c  */
-#line 2149 "parser.y"
-    {startfunction(0,(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
+  
+    case 245:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3087 "parser.y"
+    {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
+    }
     break;
 
-  case 177:
 
-/* Line 1455 of yacc.c  */
-#line 2150 "parser.y"
-    {
-    code_t*c = 0;
-    if(state->method->late_binding) {
-        c = abc_getlocal_0(c);
-        c = abc_pushscope(c);
-    }
-    if(state->method->is_constructor && !state->method->has_super) {
-        // call default constructor
-        c = abc_getlocal_0(c);
-        c = abc_constructsuper(c, 0);
+  
+    case 246:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3089 "parser.y"
+    {(yyval.code)=abc_pushstring(0,(yyvsp[(1) - (1)].id));}
     }
-    c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));
-    endfunction(0,(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);
-    (yyval.code)=0;
-;}
     break;
 
-  case 179:
 
-/* Line 1455 of yacc.c  */
-#line 2167 "parser.y"
-    {(yyval.id)=0;;}
+  
+    case 247:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3090 "parser.y"
+    {(yyval.code)=abc_pushstring2(0,&(yyvsp[(1) - (1)].str));}
+    }
     break;
 
-  case 180:
 
-/* Line 1455 of yacc.c  */
-#line 2169 "parser.y"
+  
+    case 248:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3092 "parser.y"
     {
-    syntaxerror("nested functions not supported yet");
-;}
+    (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 181:
 
-/* Line 1455 of yacc.c  */
-#line 2176 "parser.y"
-    {
+  
+    case 249:
+    if(as3_pass==2) {
 
-    /* try current package */
-    (yyval.classinfo) = find_class((yyvsp[(1) - (1)].id));
-    if(!(yyval.classinfo)) syntaxerror("Could not find class %s\n", (yyvsp[(1) - (1)].id));
-;}
+/* Line 1464 of skeleton.m4  */
+#line 3098 "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 182:
 
-/* Line 1455 of yacc.c  */
-#line 2183 "parser.y"
-    {
-    (yyval.classinfo) = registry_findclass((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
-    if(!(yyval.classinfo)) syntaxerror("Couldn't find class %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
-    free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;
-;}
+  
+    case 250:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3107 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
     break;
 
-  case 185:
 
-/* Line 1455 of yacc.c  */
-#line 2192 "parser.y"
-    {(yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));;}
+  
+    case 251:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3108 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
     break;
 
-  case 186:
 
-/* Line 1455 of yacc.c  */
-#line 2193 "parser.y"
-    {(yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));;}
+  
+    case 252:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3109 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
     break;
 
-  case 187:
 
-/* Line 1455 of yacc.c  */
-#line 2195 "parser.y"
-    {(yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);;}
+  
+    case 253:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3110 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
     break;
 
-  case 188:
 
-/* Line 1455 of yacc.c  */
-#line 2196 "parser.y"
-    {(yyval.classinfo)=registry_getanytype();;}
+  
+    case 254:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3111 "parser.y"
+    {(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}
+    }
     break;
 
-  case 189:
 
-/* Line 1455 of yacc.c  */
-#line 2197 "parser.y"
-    {(yyval.classinfo)=registry_getanytype();;}
+  
+    case 255:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3112 "parser.y"
+    {(yyval.node) = (yyvsp[(1) - (1)].node);}
+    }
     break;
 
-  case 190:
 
-/* Line 1455 of yacc.c  */
-#line 2206 "parser.y"
-    {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);;}
+  
+    case 256:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3114 "parser.y"
+    { 
+    (yyval.node) = mkconstnode((yyvsp[(1) - (1)].constant));
+}
+    }
     break;
 
-  case 191:
 
-/* Line 1455 of yacc.c  */
-#line 2207 "parser.y"
-    {(yyval.classinfo)=0;;}
+  
+    case 257:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3118 "parser.y"
+    {
+    typedcode_t v;
+    v.c = 0;
+    namespace_t ns = {ACCESS_PACKAGE, ""};
+    multiname_t m = {QNAME, &ns, 0, "XML"};
+    v.c = abc_getlex2(v.c, &m);
+    v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].id));
+    v.c = abc_construct(v.c, 1);
+    v.t = TYPE_XML;
+    (yyval.node) = mkcodenode(v);
+}
+    }
     break;
 
-  case 192:
 
-/* Line 1455 of yacc.c  */
-#line 2211 "parser.y"
-    {(yyval.value_list).cc=0;(yyval.value_list).len=0;;}
+  
+    case 258:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3131 "parser.y"
+    {
+    typedcode_t v;
+    v.c = 0;
+    namespace_t ns = {ACCESS_PACKAGE, ""};
+    multiname_t m = {QNAME, &ns, 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 193:
 
-/* Line 1455 of yacc.c  */
-#line 2212 "parser.y"
-    {(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
+  
+    case 259:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3151 "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 194:
 
-/* Line 1455 of yacc.c  */
-#line 2214 "parser.y"
-    {(yyval.value_list).cc=0;(yyval.value_list).len=0;;}
+  
+    case 260:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3161 "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 196:
 
-/* Line 1455 of yacc.c  */
-#line 2216 "parser.y"
-    {(yyval.value_list).len=1;
-                                                  (yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
-                                                 ;}
+  
+    case 261:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3170 "parser.y"
+    {(yyval.node) = mknode2(&node_lt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 197:
 
-/* Line 1455 of yacc.c  */
-#line 2219 "parser.y"
-    {
-                                                  (yyval.value_list).len= (yyvsp[(1) - (3)].value_list).len+1;
-                                                  (yyval.value_list).cc = code_append((yyvsp[(1) - (3)].value_list).cc, (yyvsp[(3) - (3)].value).c);
-                                                  ;}
+  
+    case 262:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3171 "parser.y"
+    {(yyval.node) = mknode2(&node_gt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 198:
 
-/* Line 1455 of yacc.c  */
-#line 2224 "parser.y"
-    {
-    MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
-    (yyval.value).c = code_new();
+  
+    case 263:
+    if(as3_pass==2) {
 
-    if((yyvsp[(2) - (3)].classinfo)->slot) {
-        (yyval.value).c = abc_getglobalscope((yyval.value).c);
-        (yyval.value).c = abc_getslot((yyval.value).c, (yyvsp[(2) - (3)].classinfo)->slot);
-    } else {
-        (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
+/* Line 1464 of skeleton.m4  */
+#line 3172 "parser.y"
+    {(yyval.node) = mknode2(&node_le,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
+    break;
 
-    (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (3)].value_list).cc);
 
-    if((yyvsp[(2) - (3)].classinfo)->slot)
-        (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(3) - (3)].value_list).len);
-    else
-        (yyval.value).c = abc_constructprop2((yyval.value).c, &m, (yyvsp[(3) - (3)].value_list).len);
-    (yyval.value).t = (yyvsp[(2) - (3)].classinfo);
-;}
+  
+    case 264:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3173 "parser.y"
+    {(yyval.node) = mknode2(&node_ge,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 199:
 
-/* Line 1455 of yacc.c  */
-#line 2248 "parser.y"
-    {
-    
-    (yyval.value).c = (yyvsp[(1) - (4)].value).c;
-    if((yyval.value).c->opcode == OPCODE_COERCE_A) {
-        (yyval.value).c = code_cutlast((yyval.value).c);
-    }
-    code_t*paramcode = (yyvsp[(3) - (4)].value_list).cc;
+  
+    case 265:
+    if(as3_pass==2) {
 
-    (yyval.value).t = TYPE_ANY;
-    if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
-        multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;
-        (yyval.value).c = code_cutlast((yyval.value).c);
-        (yyval.value).c = code_append((yyval.value).c, paramcode);
-        (yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).len);
-        multiname_destroy(name);
-    } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
-        int slot = (int)(ptroff_t)(yyval.value).c->data[0];
-        trait_t*t = abc_class_find_slotid(state->cls->abc,slot);//FIXME
-        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 = 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).len);
-    } 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);
-        (yyval.value).c = code_append((yyval.value).c, paramcode);
-        (yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).len);
-        multiname_destroy(name);
-    } else {
-        (yyval.value).c = abc_getlocal_0((yyval.value).c);
-        (yyval.value).c = code_append((yyval.value).c, paramcode);
-        (yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).len);
-    }
-   
-    memberinfo_t*f = 0;
-   
-    if(TYPE_IS_FUNCTION((yyvsp[(1) - (4)].value).t) && (yyvsp[(1) - (4)].value).t->function) {
-        (yyval.value).t = (yyvsp[(1) - (4)].value).t->function->return_type;
-    } else {
-        (yyval.value).c = abc_coerce_a((yyval.value).c);
-        (yyval.value).t = TYPE_ANY;
+/* Line 1464 of skeleton.m4  */
+#line 3174 "parser.y"
+    {(yyval.node) = mknode2(&node_eqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
-
-;}
     break;
 
-  case 200:
 
-/* Line 1455 of yacc.c  */
-#line 2296 "parser.y"
-    {
-    if(!state->cls) syntaxerror("super() not allowed outside of a class");
-    if(!state->method) syntaxerror("super() not allowed outside of a function");
-    if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");
+  
+    case 266:
+    if(as3_pass==2) {
 
-    (yyval.value).c = code_new();
-    (yyval.value).c = abc_getlocal_0((yyval.value).c);
+/* Line 1464 of skeleton.m4  */
+#line 3175 "parser.y"
+    {(yyval.node) = mknode2(&node_eqeqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+    }
+    break;
 
-    (yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value_list).cc);
-    /*
-    this is dependent on the control path, check this somewhere else
-    if(state->method->has_super)
-        syntaxerror("constructor may call super() only once");
-    */
-    state->method->has_super = 1;
-    (yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).len);
-    (yyval.value).c = abc_pushundefined((yyval.value).c);
-    (yyval.value).t = TYPE_ANY;
-;}
+
+  
+    case 267:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3176 "parser.y"
+    {(yyval.node) = mknode2(&node_noteqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 201:
 
-/* Line 1455 of yacc.c  */
-#line 2316 "parser.y"
-    {
-    (yyval.value).c = (yyvsp[(2) - (2)].value).c;
-    if((yyval.value).c->opcode == OPCODE_COERCE_A) {
-        (yyval.value).c = code_cutlast((yyval.value).c);
+  
+    case 268:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3177 "parser.y"
+    {(yyval.node) = mknode2(&node_noteq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
-    multiname_t*name = 0;
-    if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {
-        (yyval.value).c->opcode = OPCODE_DELETEPROPERTY;
-    } else if((yyval.value).c->opcode == OPCODE_GETSLOT) {
-        int slot = (int)(ptroff_t)(yyval.value).c->data[0];
-        multiname_t*name = abc_class_find_slotid(state->cls->abc,slot)->name;
-        (yyval.value).c = code_cutlast((yyval.value).c);
-        (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, "");
-        (yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
+    break;
+
+
+  
+    case 269:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3178 "parser.y"
+    {(yyval.node) = mknode2(&node_oror,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
     }
-    (yyval.value).t = TYPE_BOOLEAN;
-;}
     break;
 
-  case 202:
 
-/* Line 1455 of yacc.c  */
-#line 2337 "parser.y"
-    {
-    (yyval.code) = abc_returnvoid(0);
-;}
+  
+    case 270:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3179 "parser.y"
+    {(yyval.node) = mknode2(&node_andand,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 203:
 
-/* Line 1455 of yacc.c  */
-#line 2340 "parser.y"
-    {
-    (yyval.code) = (yyvsp[(2) - (2)].value).c;
-    (yyval.code) = abc_returnvalue((yyval.code));
-;}
+  
+    case 271:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3180 "parser.y"
+    {(yyval.node) = mknode1(&node_not, (yyvsp[(2) - (2)].node));}
+    }
     break;
 
-  case 204:
 
-/* Line 1455 of yacc.c  */
-#line 2347 "parser.y"
-    {(yyval.value)=(yyvsp[(1) - (1)].value);;}
+  
+    case 272:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3181 "parser.y"
+    {(yyval.node) = mknode1(&node_bitnot, (yyvsp[(2) - (2)].node));}
+    }
     break;
 
-  case 205:
 
-/* Line 1455 of yacc.c  */
-#line 2348 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 273:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3182 "parser.y"
+    {(yyval.node) = mknode2(&node_bitand, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 206:
 
-/* Line 1455 of yacc.c  */
-#line 2349 "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;
-;}
+  
+    case 274:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3183 "parser.y"
+    {(yyval.node) = mknode2(&node_bitxor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 207:
 
-/* Line 1455 of yacc.c  */
-#line 2355 "parser.y"
-    {
-    (yyval.code)=cut_last_push((yyvsp[(1) - (1)].value).c);
-;}
+  
+    case 275:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3184 "parser.y"
+    {(yyval.node) = mknode2(&node_bitor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 208:
 
-/* Line 1455 of yacc.c  */
-#line 2361 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 276:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3185 "parser.y"
+    {(yyval.node) = mknode2(&node_shr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 210:
 
-/* Line 1455 of yacc.c  */
-#line 2365 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 277:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3186 "parser.y"
+    {(yyval.node) = mknode2(&node_ushr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 211:
 
-/* Line 1455 of yacc.c  */
-#line 2367 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 278:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3187 "parser.y"
+    {(yyval.node) = mknode2(&node_shl, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 212:
 
-/* Line 1455 of yacc.c  */
-#line 2369 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 279:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3188 "parser.y"
+    {(yyval.node) = mknode2(&node_div, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 213:
 
-/* Line 1455 of yacc.c  */
-#line 2371 "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);
+  
+    case 280:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3189 "parser.y"
+    {(yyval.node) = mknode2(&node_mod, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
     }
-    (yyval.value).t = TYPE_REGEXP;
-;}
     break;
 
-  case 214:
 
-/* Line 1455 of yacc.c  */
-#line 2388 "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;
-                  ;}
+  
+    case 281:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3190 "parser.y"
+    {(yyval.node) = mknode2(&node_plus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 215:
 
-/* Line 1455 of yacc.c  */
-#line 2393 "parser.y"
-    {(yyval.value).c = abc_pushshort(0, (yyvsp[(1) - (1)].number_uint));
-                    (yyval.value).t = TYPE_INT;
-                   ;}
+  
+    case 282:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3191 "parser.y"
+    {(yyval.node) = mknode2(&node_minus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 216:
 
-/* Line 1455 of yacc.c  */
-#line 2396 "parser.y"
-    {(yyval.value).c = abc_pushint(0, (yyvsp[(1) - (1)].number_int));
-                  (yyval.value).t = TYPE_INT;
-                 ;}
+  
+    case 283:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3192 "parser.y"
+    {(yyval.node) = mknode2(&node_multiply, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 217:
 
-/* Line 1455 of yacc.c  */
-#line 2399 "parser.y"
-    {(yyval.value).c = abc_pushuint(0, (yyvsp[(1) - (1)].number_uint));
-                   (yyval.value).t = TYPE_UINT;
-                  ;}
+  
+    case 284:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3193 "parser.y"
+    {(yyval.node) = mknode2(&node_in, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 218:
 
-/* Line 1455 of yacc.c  */
-#line 2402 "parser.y"
-    {(yyval.value).c = abc_pushdouble(0, (yyvsp[(1) - (1)].number_float));
-                    (yyval.value).t = TYPE_FLOAT;
-                   ;}
+  
+    case 285:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3194 "parser.y"
+    {(yyval.node) = mknode2(&node_as, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 219:
 
-/* Line 1455 of yacc.c  */
-#line 2405 "parser.y"
-    {(yyval.value).c = abc_pushstring2(0, &(yyvsp[(1) - (1)].str));
-                     (yyval.value).t = TYPE_STRING;
-                    ;}
+  
+    case 286:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3195 "parser.y"
+    {(yyval.node) = mknode2(&node_instanceof, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 220:
 
-/* Line 1455 of yacc.c  */
-#line 2408 "parser.y"
-    {(yyval.value).c = abc_pushundefined(0);
-                    (yyval.value).t = TYPE_ANY;
-                   ;}
+  
+    case 287:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3196 "parser.y"
+    {(yyval.node) = mknode2(&node_is, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 221:
 
-/* Line 1455 of yacc.c  */
-#line 2411 "parser.y"
-    {(yyval.value).c = abc_pushtrue(0);
-                    (yyval.value).t = TYPE_BOOLEAN;
-                   ;}
+  
+    case 288:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3197 "parser.y"
+    {(yyval.node) = mknode1(&node_typeof, (yyvsp[(3) - (4)].node));}
+    }
     break;
 
-  case 222:
 
-/* Line 1455 of yacc.c  */
-#line 2414 "parser.y"
-    {(yyval.value).c = abc_pushfalse(0);
-                     (yyval.value).t = TYPE_BOOLEAN;
-                    ;}
+  
+    case 289:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3198 "parser.y"
+    {(yyval.node) = mknode1(&node_void, (yyvsp[(2) - (2)].node));}
+    }
     break;
 
-  case 223:
 
-/* Line 1455 of yacc.c  */
-#line 2417 "parser.y"
-    {(yyval.value).c = abc_pushnull(0);
-                    (yyval.value).t = TYPE_NULL;
-                   ;}
+  
+    case 290:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3199 "parser.y"
+    { (yyval.node) = mkconstnode(constant_new_undefined());}
+    }
     break;
 
-  case 225:
 
-/* Line 1455 of yacc.c  */
-#line 2422 "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;
-            ;}
+  
+    case 291:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3200 "parser.y"
+    { (yyval.node)=(yyvsp[(2) - (3)].node);}
+    }
     break;
 
-  case 226:
 
-/* Line 1455 of yacc.c  */
-#line 2425 "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;
-            ;}
+  
+    case 292:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3201 "parser.y"
+    {(yyval.node) = mknode1(&node_neg, (yyvsp[(2) - (2)].node));}
+    }
     break;
 
-  case 227:
 
-/* Line 1455 of yacc.c  */
-#line 2428 "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;
-             ;}
+  
+    case 293:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3202 "parser.y"
+    {(yyval.node) = mknode2(&node_arraylookup, (yyvsp[(1) - (4)].node),(yyvsp[(3) - (4)].node));}
+    }
     break;
 
-  case 228:
 
-/* Line 1455 of yacc.c  */
-#line 2431 "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;
-             ;}
+  
+    case 294:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3203 "parser.y"
+    {(yyval.node) = mknode2(&node_muleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 229:
 
-/* Line 1455 of yacc.c  */
-#line 2434 "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;
-             ;}
+  
+    case 295:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3204 "parser.y"
+    {(yyval.node) = mknode2(&node_modeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 230:
 
-/* Line 1455 of yacc.c  */
-#line 2437 "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;
-              ;}
+  
+    case 296:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3205 "parser.y"
+    {(yyval.node) = mknode2(&node_shleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 231:
 
-/* Line 1455 of yacc.c  */
-#line 2440 "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;
-             ;}
+  
+    case 297:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3206 "parser.y"
+    {(yyval.node) = mknode2(&node_shreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 232:
 
-/* Line 1455 of yacc.c  */
-#line 2443 "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;
-             ;}
+  
+    case 298:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3207 "parser.y"
+    {(yyval.node) = mknode2(&node_ushreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 233:
 
-/* Line 1455 of yacc.c  */
-#line 2447 "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;
-             ;}
+  
+    case 299:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3208 "parser.y"
+    { (yyval.node) = mknode2(&node_diveq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 234:
 
-/* Line 1455 of yacc.c  */
-#line 2458 "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;              
-             ;}
-    break;
-
-  case 235:
-
-/* Line 1455 of yacc.c  */
-#line 2476 "parser.y"
-    {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
-              (yyval.value).c = abc_not((yyval.value).c);
-              (yyval.value).t = TYPE_BOOLEAN;
-             ;}
-    break;
-
-  case 236:
-
-/* Line 1455 of yacc.c  */
-#line 2481 "parser.y"
-    {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
-              (yyval.value).c = abc_bitnot((yyval.value).c);
-              (yyval.value).t = TYPE_INT;
-             ;}
+  
+    case 300:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3209 "parser.y"
+    { (yyval.node) = mknode2(&node_bitoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 237:
 
-/* Line 1455 of yacc.c  */
-#line 2486 "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;
-            ;}
+  
+    case 301:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3210 "parser.y"
+    { (yyval.node) = mknode2(&node_bitxoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 238:
 
-/* Line 1455 of yacc.c  */
-#line 2491 "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;
-            ;}
+  
+    case 302:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3211 "parser.y"
+    { (yyval.node) = mknode2(&node_bitandeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 239:
 
-/* Line 1455 of yacc.c  */
-#line 2496 "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;
-            ;}
+  
+    case 303:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3212 "parser.y"
+    { (yyval.node) = mknode2(&node_pluseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 240:
 
-/* Line 1455 of yacc.c  */
-#line 2501 "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;
-            ;}
+  
+    case 304:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3213 "parser.y"
+    { (yyval.node) = mknode2(&node_minuseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 241:
 
-/* Line 1455 of yacc.c  */
-#line 2505 "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;
-            ;}
+  
+    case 305:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3214 "parser.y"
+    { (yyval.node) = mknode2(&node_assign, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}
+    }
     break;
 
-  case 242:
 
-/* Line 1455 of yacc.c  */
-#line 2509 "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;
-            ;}
+  
+    case 306:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3215 "parser.y"
+    { (yyval.node) = mknode3(&node_tenary, (yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));}
+    }
     break;
 
-  case 243:
 
-/* Line 1455 of yacc.c  */
-#line 2514 "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;
-            ;}
+  
+    case 307:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3217 "parser.y"
+    { (yyval.node) = mknode1(&node_rplusplus, (yyvsp[(1) - (2)].node));}
+    }
     break;
 
-  case 244:
 
-/* Line 1455 of yacc.c  */
-#line 2518 "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;
-            ;}
-    break;
-
-  case 245:
-
-/* Line 1455 of yacc.c  */
-#line 2522 "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,'+');
-             }
-            ;}
-    break;
-
-  case 246:
-
-/* Line 1455 of yacc.c  */
-#line 2531 "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;
-             }
-            ;}
-    break;
-
-  case 247:
-
-/* Line 1455 of yacc.c  */
-#line 2540 "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;
-             }
-            ;}
-    break;
-
-  case 248:
-
-/* Line 1455 of yacc.c  */
-#line 2550 "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;
-             ;}
-    break;
-
-  case 249:
-
-/* Line 1455 of yacc.c  */
-#line 2555 "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)) {
-                MULTINAME(m,(yyvsp[(3) - (3)].value).t->cls);
-                (yyval.value).c = abc_astype2((yyvsp[(1) - (3)].value).c, &m);
-                (yyval.value).t = (yyvsp[(3) - (3)].value).t->cls;
-              } 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;
-              }
-             ;}
-    break;
-
-  case 250:
-
-/* Line 1455 of yacc.c  */
-#line 2568 "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;
-             ;}
-    break;
-
-  case 251:
-
-/* Line 1455 of yacc.c  */
-#line 2573 "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;
-             ;}
-    break;
-
-  case 252:
-
-/* Line 1455 of yacc.c  */
-#line 2578 "parser.y"
-    {
-              (yyval.value).c = (yyvsp[(3) - (4)].value).c;
-              (yyval.value).c = abc_typeof((yyval.value).c);
-              (yyval.value).t = TYPE_STRING;
-             ;}
+  
+    case 308:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3218 "parser.y"
+    { (yyval.node) = mknode1(&node_rminusminus, (yyvsp[(1) - (2)].node));}
+    }
     break;
 
-  case 253:
 
-/* Line 1455 of yacc.c  */
-#line 2584 "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;
-             ;}
+  
+    case 309:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3219 "parser.y"
+    {(yyval.node) = mknode1(&node_lplusplus, (yyvsp[(2) - (2)].node)); }
+    }
     break;
 
-  case 254:
 
-/* Line 1455 of yacc.c  */
-#line 2590 "parser.y"
-    { (yyval.value).c = abc_pushundefined(0);
-             (yyval.value).t = TYPE_ANY;
-           ;}
+  
+    case 310:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3220 "parser.y"
+    {(yyval.node) = mknode1(&node_lminusminus, (yyvsp[(2) - (2)].node)); }
+    }
     break;
 
-  case 255:
 
-/* Line 1455 of yacc.c  */
-#line 2594 "parser.y"
-    {(yyval.value)=(yyvsp[(2) - (3)].value);;}
+  
+    case 311:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3223 "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);
+              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 256:
 
-/* Line 1455 of yacc.c  */
-#line 2596 "parser.y"
+  
+    case 312:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3237 "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;
-  }
-;}
+    // attribute occuring in .() loops 
+    // TODO
+    (yyval.node) = mkdummynode();
+    as3_warning("ignored @ operator");
+}
+    }
     break;
 
-  case 257:
 
-/* Line 1455 of yacc.c  */
-#line 2607 "parser.y"
+  
+    case 313:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3244 "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
-;}
+    // filter 
+    // TODO: this needs to be implemented using a loop
+    (yyval.node) = mkdummynode();
+    as3_warning("ignored .() operator");
+}
+    }
     break;
 
-  case 258:
 
-/* Line 1455 of yacc.c  */
-#line 2616 "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).len);
-    (yyval.value).t = registry_getarrayclass();
-;}
+  
+    case 314:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3251 "parser.y"
+    {(yyval.id)=(yyvsp[(1) - (1)].id);}
+    }
     break;
 
-  case 259:
 
-/* Line 1455 of yacc.c  */
-#line 2623 "parser.y"
-    {(yyval.value_list).cc=0;(yyval.value_list).len=0;;}
+  
+    case 315:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3252 "parser.y"
+    {(yyval.id)=(char*)(yyvsp[(1) - (1)].id);}
+    }
     break;
 
-  case 260:
 
-/* Line 1455 of yacc.c  */
-#line 2624 "parser.y"
-    {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
+  
+    case 317:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3254 "parser.y"
+    {(yyval.id)="*";}
+    }
     break;
 
-  case 261:
 
-/* Line 1455 of yacc.c  */
-#line 2626 "parser.y"
+  
+    case 318:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3256 "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).len = 2;
-;}
+    typedcode_t v = node_read((yyvsp[(1) - (5)].node));
+    typedcode_t w = node_read(resolve_identifier((yyvsp[(3) - (5)].id)));
+    v.c = code_append(v.c, w.c);
+    if(!TYPE_IS_NAMESPACE(w.t)) {
+        as3_softwarning("%s might not be a namespace", (yyvsp[(3) - (5)].id));
+    }
+    v.c = converttype(v.c, w.t, TYPE_NAMESPACE);
+    multiname_t m = {RTQNAME, 0, 0, (yyvsp[(5) - (5)].id)};
+    v.c = abc_getproperty2(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;
+    }
+    (yyval.node) = mkcodenode(v);
+}
+    }
     break;
 
-  case 262:
 
-/* Line 1455 of yacc.c  */
-#line 2632 "parser.y"
+  
+    case 319:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3274 "parser.y"
     {
-    (yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;
-    (yyval.value_list).len = (yyvsp[(1) - (5)].value_list).len+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);
-;}
+    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 263:
 
-/* Line 1455 of yacc.c  */
-#line 2641 "parser.y"
+  
+    case 320:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3281 "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).len/2);
-    (yyval.value).t = registry_getobjectclass();
-;}
+    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 264:
-
-/* Line 1455 of yacc.c  */
-#line 2648 "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;
-              ;}
-    break;
-
-  case 265:
-
-/* Line 1455 of yacc.c  */
-#line 2660 "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;
-              ;}
-    break;
 
-  case 266:
+  
+    case 321:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 2666 "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 1464 of skeleton.m4  */
+#line 3292 "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 267:
 
-/* Line 1455 of yacc.c  */
-#line 2672 "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;
-              ;}
-    break;
-
-  case 268:
+  
+    case 322:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 2678 "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 1464 of skeleton.m4  */
+#line 3299 "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_getdescendants2(v.c, &m);
+    v.t = TYPE_STRING;
+    (yyval.node) = mkcodenode(v);
+}
+    }
     break;
 
-  case 269:
-
-/* Line 1455 of yacc.c  */
-#line 2684 "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;
-              ;}
-    break;
 
-  case 270:
+  
+    case 323:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 2690 "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 1464 of skeleton.m4  */
+#line 3306 "parser.y"
+    {
+    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 271:
 
-/* Line 1455 of yacc.c  */
-#line 2696 "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;
-              ;}
-    break;
-
-  case 272:
-
-/* Line 1455 of yacc.c  */
-#line 2709 "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;
-             ;}
-    break;
-
-  case 273:
-
-/* Line 1455 of yacc.c  */
-#line 2720 "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;
-            ;}
+  
+    case 324:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3316 "parser.y"
+    {
+    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 274:
 
-/* Line 1455 of yacc.c  */
-#line 2727 "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[(3) - (5)].value).t, (yyval.value).t);
-              (yyval.value).c = j2->branch = abc_label((yyval.value).c);
-            ;}
-    break;
-
-  case 275:
-
-/* Line 1455 of yacc.c  */
-#line 2740 "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;
-             }
-           ;}
-    break;
-
-  case 276:
-
-/* Line 1455 of yacc.c  */
-#line 2767 "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;
-            ;}
-    break;
-
-  case 277:
-
-/* Line 1455 of yacc.c  */
-#line 2781 "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;
-           ;}
-    break;
-
-  case 278:
-
-/* Line 1455 of yacc.c  */
-#line 2795 "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;
-           ;}
-    break;
-
-  case 279:
-
-/* Line 1455 of yacc.c  */
-#line 2810 "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;
+  
+    case 325:
+    if(as3_pass==2) {
 
-              memberinfo_t*f = registry_findmember(t, (yyvsp[(3) - (3)].id), 1);
-              namespace_t ns = flags2namespace(f->flags, "");
-              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 = memberinfo_gettype(f);
-           ;}
-    break;
-
-  case 280:
-
-/* Line 1455 of yacc.c  */
-#line 2825 "parser.y"
-    {(yyval.value).c = (yyvsp[(1) - (3)].value).c;
-             classinfo_t*t = (yyvsp[(1) - (3)].value).t;
-             char is_static = 0;
-             if(TYPE_IS_CLASS(t) && t->cls) {
-                 t = t->cls;
-                 is_static = 1;
-             }
-             if(t) {
-                 memberinfo_t*f = registry_findmember(t, (yyvsp[(3) - (3)].id), 1);
-                 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 {
-                     MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));
-                     (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
-                 }
-                 /* determine type */
-                 (yyval.value).t = memberinfo_gettype(f);
-                 if(!(yyval.value).t)
-                    (yyval.value).c = abc_coerce_a((yyval.value).c);
-             } 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 */
-                 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();
-             }
-            ;}
-    break;
-
-  case 281:
-
-/* Line 1455 of yacc.c  */
-#line 2858 "parser.y"
+/* Line 1464 of skeleton.m4  */
+#line 3327 "parser.y"
     {
-    (yyval.value).t = 0;
-    (yyval.value).c = 0;
-    classinfo_t*a = 0;
-    memberinfo_t*f = 0;
-
-    variable_t*v;
-    /* look at variables */
-    if((v = find_variable((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;
-    }
-
-    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(state->cls->info, (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 == MEMBER_METHOD) {
-            (yyval.value).t = TYPE_FUNCTION(f);
-        } else {
-            (yyval.value).t = f->type;
+    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(TYPE_IS_XML(t)) {
+        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);
         }
-        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 = {flags2access(f->flags), ""};
-            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);
+        memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1);
+        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);
-            break;
         } else {
-            namespace_t ns = {flags2access(f->flags), ""};
-            multiname_t m = {QNAME, &ns, 0, (yyvsp[(1) - (1)].id)};
-            (yyval.value).c = abc_getlocal_0((yyval.value).c);
+            if(!f) {
+                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);
-            break;
         }
-    } 
-    
-    /* look at actual classes, in the current package and imported */
-    if((a = find_class((yyvsp[(1) - (1)].id)))) {
-        if(a->flags & FLAG_METHOD) {
-            MULTINAME(m, a);
-            (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
-            (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
-            if(a->function->kind == MEMBER_METHOD) {
-                (yyval.value).t = TYPE_FUNCTION(a->function);
-            } else {
-                (yyval.value).t = a->function->type;
-            }
+        /* determine type */
+        (yyval.value).t = slotinfo_gettype((slotinfo_t*)f);
+        if(!(yyval.value).t)
+           (yyval.value).c = abc_coerce_a((yyval.value).c);
+        
+    } 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));
+
+        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 {
-            if(a->slot) {
-                (yyval.value).c = abc_getglobalscope((yyval.value).c);
-                (yyval.value).c = abc_getslot((yyval.value).c, a->slot);
-            } else {
-                MULTINAME(m, a);
-                (yyval.value).c = abc_getlex2((yyval.value).c, &m);
-            }
-            (yyval.value).t = TYPE_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_warning("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 = TYPE_ANY;
+    }
+}
+    }
+    break;
+
+
+  
+    case 326:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3497 "parser.y"
+    {
+    PASS1
+    /* Queue unresolved identifiers for checking against the parent
+       function's variables.
+       We consider everything which is not a local variable "unresolved".
+       This encompasses class names, members of the surrounding class
+       etc. which is *correct* because local variables of the parent function
+       would shadow those.
+       */
+    if(!find_variable(state, (yyvsp[(1) - (1)].id))) {
+        if(state->method->inner) {
+            unknown_variable((yyvsp[(1) - (1)].id));
         }
-        break;
+        /* 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));
     }
+   
+    (yyval.node) = 0;
+    PASS2
 
-    /* unknown object, let the avm2 resolve it */
-    if(1) {
-        if(strcmp((yyvsp[(1) - (1)].id),"trace"))
-            as3_softwarning("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.node) = resolve_identifier((yyvsp[(1) - (1)].id));
+}
+    }
+    break;
 
-        (yyval.value).t = 0;
-        (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
-        (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
+
+  
+    case 327:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3532 "parser.y"
+    {
+    PASS12
+    NEW(namespace_decl_t,n);
+    n->name = (yyvsp[(2) - (2)].id);
+    n->url = (yyvsp[(2) - (2)].id);
+    (yyval.namespace_decl)=n;
+}
     }
-;}
     break;
 
-  case 282:
 
-/* Line 1455 of yacc.c  */
-#line 2956 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 328:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3539 "parser.y"
+    {
+    PASS12
+    NEW(namespace_decl_t,n);
+    n->name = (yyvsp[(2) - (4)].id);
+    n->url = (yyvsp[(4) - (4)].id);
+    (yyval.namespace_decl)=n;
+}
+    }
     break;
 
-  case 283:
 
-/* Line 1455 of yacc.c  */
-#line 2957 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 329:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3546 "parser.y"
+    {
+    PASS12
+    NEW(namespace_decl_t,n);
+    n->name = (yyvsp[(2) - (4)].id);
+    n->url = (yyvsp[(4) - (4)].str).str;
+    (yyval.namespace_decl)=n;
+}
+    }
     break;
 
-  case 284:
 
-/* Line 1455 of yacc.c  */
-#line 2958 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 330:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3553 "parser.y"
+    {
+    PASS12
+    trie_put(active_namespaces, (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;
+}
+    }
     break;
 
-  case 285:
 
-/* Line 1455 of yacc.c  */
-#line 2960 "parser.y"
-    {(yyval.token)=0;;}
+  
+    case 331:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3575 "parser.y"
+    {
+    PASS12
+    const char*url = (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);
+    url = s->value->ns->name;
+
+    trie_put(active_namespaces, (yyvsp[(3) - (3)].classinfo)->name, (void*)url);
+    add_active_url(url);
+    (yyval.code)=0;
+}
+    }
     break;
 
 
 
-/* Line 1455 of yacc.c  */
-#line 6181 "parser.tab.c"
+
+/* Line 1464 of skeleton.m4  */
+#line 8357 "parser.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);