just made compileable- it'll be replaced soon
[swftools.git] / lib / as3 / parser.tab.c
index 6fe4636..72a4950 100644 (file)
@@ -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
 #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>
 #include "registry.h"
 #include "code.h"
 #include "opcodes.h"
+#include "compiler.h"
 
+extern int a3_lex();
 
 
-/* Line 189 of yacc.c  */
-#line 96 "parser.tab.c"
+
+/* Line 198 of skeleton.m4  */
+#line 99 "parser.tab.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
      minusminus_prefix = 355,
      plusplus_prefix = 356,
      below_curly = 357,
-     above_identifier = 358,
-     below_else = 359,
-     above_function = 360
+     new2 = 358,
+     above_identifier = 359,
+     below_else = 360,
+     above_function = 361
    };
 #endif
 
 
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 typedef union 
-/* Line 214 of yacc.c  */
-#line 41 "parser.y"
+/* Line 223 of skeleton.m4  */
+#line 44 "parser.y"
 tokenunion
 {
 
-/* Line 214 of yacc.c  */
-#line 41 "parser.y"
+/* Line 223 of skeleton.m4  */
+#line 44 "parser.y"
 
     enum yytokentype token;
     int flags;
@@ -263,8 +267,8 @@ tokenunion
 
 
 
-/* Line 214 of yacc.c  */
-#line 268 "parser.tab.c"
+/* Line 223 of skeleton.m4  */
+#line 272 "parser.tab.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -274,16 +278,17 @@ tokenunion
 
 /* Copy the second part of user declarations.  */
 
-/* Line 264 of yacc.c  */
-#line 251 "parser.y"
+/* Line 273 of skeleton.m4  */
+#line 257 "parser.y"
 
 
-static int yyerror(char*s)
+static int a3_error(char*s)
 {
    syntaxerror("%s", s); 
    return 0; //make gcc happy
 }
 
+
 static char* concat2(const char* t1, const char* t2)
 {
     int l1 = strlen(t1);
@@ -322,6 +327,8 @@ typedef struct _classstate {
     char has_constructor;
 } classstate_t;
 
+DECLARE_LIST(methodstate);
+
 typedef struct _methodstate {
     /* method data */
     memberinfo_t*info;
@@ -329,7 +336,15 @@ typedef struct _methodstate {
     char is_constructor;
     char has_super;
     char is_global;
+    int variable_count;
+
+    char inner;
+    abc_method_t*abc;
+    int var_index; // for inner methods
+
     abc_exception_list_t*exceptions;
+    
+    methodstate_list_t*innerfunctions;
 } methodstate_t;
 
 typedef struct _state {
@@ -340,6 +355,7 @@ typedef struct _state {
     import_list_t*wildcard_imports;
     dict_t*imports;
     char has_own_imports;
+    char new_vars; // e.g. transition between two functions
   
     classstate_t*cls;   
     methodstate_t*method;
@@ -352,8 +368,7 @@ typedef struct _state {
 typedef struct _global {
     abc_file_t*file;
     abc_script_t*init;
-
-    int variable_count;
+    dict_t*token2info;
 } global_t;
 
 static global_t*global = 0;
@@ -455,40 +470,57 @@ static void old_state()
     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(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;
-}
-
 void initialize_file(char*filename)
 {
+    if(state) {
+        syntaxerror("invalid call to initialize_file during parsing of another file");
+    }
     new_state();
-    state->package = filename;
-    // needed for state->method->late_binding:
+    state->package = strdup(filename);
+    
     state->method = rfx_calloc(sizeof(methodstate_t));
+    state->method->variable_count = 1;
 }
+
 void finish_file()
 {
     if(!state || state->level!=1) {
-        syntaxerror("unexpected end of file");
+        syntaxerror("unexpected end of file in pass %d", as3_pass);
     }
+    free(state->method);state->method=0;
+
+    //free(state->package);state->package=0; // used in registry
+
     state_destroy(state);state=0;
 }
 
+void initialize_parser()
+{
+    global = rfx_calloc(sizeof(global_t));
+    global->file = abc_file_new();
+    global->file->flags &= ~ABCFILE_LAZY;
+    global->token2info = dict_new2(&ptr_type);
+    
+    global->init = abc_initscript(global->file);
+    code_t*c = global->init->method->body->code;
+    c = abc_getlocal_0(c);
+    c = abc_pushscope(c);
+    global->init->method->body->code = c;
+}
+
 void* finish_parser()
 {
     code_t*c = global->init->method->body->code;
@@ -497,6 +529,7 @@ void* finish_parser()
       c = abc_callpropvoid(c, "[package]::trace", 1);*/
     c = abc_returnvoid(c);
     global->init->method->body->code = c;
+    dict_destroy(global->token2info);global->token2info=0;
     return global->file;
 }
 
@@ -547,6 +580,8 @@ static variable_t* find_variable(char*name)
         if(v) {
             return v;
         }
+        if(s->new_vars)
+            break;
         s = s->old;
     }
     return 0;
@@ -563,16 +598,16 @@ static char variable_exists(char*name)
     return dict_lookup(state->vars, name)!=0;
 }
 code_t*defaultvalue(code_t*c, classinfo_t*type);
-static int new_variable(char*name, classinfo_t*type, char init)
+static int new_variable(const char*name, classinfo_t*type, char init)
 {
     NEW(variable_t, v);
-    v->index = global->variable_count;
+    v->index = state->method->variable_count;
     v->type = type;
     v->init = init;
     
     dict_put(state->vars, name, v);
 
-    return global->variable_count++;
+    return state->method->variable_count++;
 }
 #define TEMPVARNAME "__as3_temp__"
 static int gettempvar()
@@ -627,6 +662,44 @@ code_t* var_block(code_t*body)
     return c;
 }
 
+#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}
+
+static void parsererror(const char*file, int line, const char*f)
+{
+    syntaxerror("internal error in %s, %s:%d", f, file, line);
+}
+
+   
+code_t* method_header()
+{
+    code_t*c = 0;
+    if(state->method->late_binding && !state->method->inner) {
+        c = abc_getlocal_0(c);
+        c = abc_pushscope(c);
+    }
+    /*if(state->method->innerfunctions) {
+        c = abc_newactivation(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);
+    }
+    methodstate_list_t*l = state->method->innerfunctions;
+    while(l) {
+        parserassert(l->methodstate->abc);
+        c = abc_newfunction(c, l->methodstate->abc);
+        c = abc_setlocal(c, l->methodstate->var_index);
+        free(l->methodstate);l->methodstate=0;
+        l = l->next;
+    }
+    list_free(state->method->innerfunctions);
+    state->method->innerfunctions = 0;
+    return c;
+}
+    
+
 static code_t* wrap_function(code_t*c,code_t*header, code_t*body)
 {
     c = code_append(c, header);
@@ -645,7 +718,6 @@ static void startpackage(char*name)
     new_state();
     /*printf("entering package \"%s\"\n", name);*/
     state->package = strdup(name);
-    global->variable_count = 1;
 }
 static void endpackage()
 {
@@ -657,6 +729,7 @@ static void endpackage()
     old_state();
 }
 
+
 char*as3_globalclass=0;
 static void startclass(int flags, char*classname, classinfo_t*extends, classinfo_list_t*implements, char interface)
 {
@@ -664,9 +737,7 @@ static void startclass(int flags, char*classname, classinfo_t*extends, classinfo
         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
 
     token_list_t*t=0;
     classinfo_list_t*mlist=0;
@@ -682,7 +753,7 @@ static void startclass(int flags, char*classname, classinfo_t*extends, classinfo
     char*package=0;
 
     if(!(flags&FLAG_PUBLIC) && !state->package) {
-        access = ACCESS_PRIVATE; package = current_filename;
+        access = ACCESS_PRIVATE; package = strdup(current_filename_short);
     } else if(!(flags&FLAG_PUBLIC) && state->package) {
         access = ACCESS_PACKAGEINTERNAL; package = state->package;
     } else if(state->package) {
@@ -691,131 +762,141 @@ static void startclass(int flags, char*classname, classinfo_t*extends, classinfo
         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->method = rfx_calloc(sizeof(methodstate_t)); // method state, for static constructor
+        state->method->variable_count = 1;
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
 
-    /* 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_findclass(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);
     }
     
-    multiname_t*extends2 = sig2mname(extends);
-
-    MULTINAME(classname2,state->cls->info);
+    if(as3_pass == 2) {
+        state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+
+        state->cls->info = registry_findclass(package, classname);
+        parserassert((int)state->cls->info);
+
+        /* fill out interfaces and extends (we couldn't resolve those during the first pass) */
+        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(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);
-    }
+        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);
+        }
 
-    abc_class_protectedNS(state->cls->abc, classname);
+        abc_class_protectedNS(state->cls->abc, classname);
 
-    for(mlist=implements;mlist;mlist=mlist->next) {
-        MULTINAME(m, mlist->classinfo);
-        abc_class_add_interface(state->cls->abc, &m);
-    }
+        for(mlist=implements;mlist;mlist=mlist->next) {
+            MULTINAME(m, mlist->classinfo);
+            abc_class_add_interface(state->cls->abc, &m);
+        }
 
-    /* now write the construction code for this class */
-    int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
+        /* write the construction code for this class to the global init
+           function */
+        int slotindex = abc_initscript_addClassTrait(global->init, &classname2, state->cls->abc);
 
-    abc_method_body_t*m = global->init->method->body;
-    __ getglobalscope(m);
-    classinfo_t*s = extends;
+        abc_method_body_t*m = global->init->method->body;
+        __ getglobalscope(m);
+        classinfo_t*s = extends;
 
-    int count=0;
-    
-    while(s) {
-        //TODO: take a look at the current scope stack, maybe 
-        //      we can re-use something
-        s = s->superclass;
-        if(!s) 
-        break;
-       
-        multiname_t*s2 = sig2mname(s);
-        __ getlex2(m, s2);
-        multiname_destroy(s2);
-
-        __ pushscope(m); count++;
-        m->code = m->code->prev->prev; // invert
-    }
-    /* continue appending after last op end */
-    while(m->code && m->code->next) m->code = m->code->next; 
-
-    /* TODO: if this is one of *our* classes, we can also 
-             do a getglobalscope/getslot <nr> (which references
-             the init function's slots) */
-    if(extends2) {
-        __ getlex2(m, extends2);
-        __ dup(m);
-        /* notice: we get a Verify Error #1107 if the top elemnt on the scope
-           stack is not the superclass */
-        __ pushscope(m);count++;
-    } else {
-        __ pushnull(m);
-        /* notice: we get a verify error #1107 if the top element on the scope 
-           stack is not the global object */
-        __ getlocal_0(m);
-        __ pushscope(m);count++;
-    }
-    __ newclass(m,state->cls->abc);
-    while(count--) {
-        __ popscope(m);
-    }
-    __ setslot(m, slotindex);
-
-    /* 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);
+        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 {
-            as3_globalclass = strdup(classname);
+            __ pushnull(m);
+            /* notice: we get a verify error #1107 if the top element on the scope 
+               stack is not the global object */
+            __ getlocal_0(m);
+            __ pushscope(m);count++;
+        }
+        __ newclass(m,state->cls->abc);
+        while(count--) {
+            __ popscope(m);
+        }
+        __ setslot(m, slotindex);
+        multiname_destroy(extends2);
+
+        /* 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);
+            }
         }
     }
-    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(as3_pass == 2) {
+        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(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);
+        }
     }
 
-    free(state->cls);state->cls=0;
-    free(state->method);state->method=0;
     old_state();
 }
 
@@ -906,7 +987,7 @@ static memberinfo_t*registerfunction(enum yytokentype getset, int flags, char*na
         classinfo_t*type=0;
         if(getset == KW_GET)
             type = return_type;
-        else if(params->list)
+        else if(params->list && params->list->param)
             type = params->list->param->type;
         // not sure wether to look into superclasses here, too
         if((minfo=registry_findmember(state->cls->info, name, 0))) {
@@ -937,6 +1018,67 @@ static memberinfo_t*registerfunction(enum yytokentype getset, int flags, char*na
     return minfo;
 }
 
+static void function_initvars(params_t*params, int flags)
+{
+    if(state->method->inner)
+        new_variable("this", 0, 0);
+    else if(!state->method->is_global)
+        new_variable((flags&FLAG_STATIC)?"class":"this", state->cls->info, 0);
+    else
+        new_variable("globalscope", 0, 0);
+
+    param_list_t*p=0;
+    for(p=params->list;p;p=p->next) {
+        new_variable(p->param->name, p->param->type, 0);
+    }
+    
+    methodstate_list_t*l = state->method->innerfunctions;
+    while(l) {
+        methodstate_t*m = l->methodstate;
+        m->var_index = new_variable(m->info->name, TYPE_FUNCTION(m->info), 0);
+        l = l->next;
+    }
+}
+
+static void innerfunction(char*name, params_t*params, classinfo_t*return_type)
+{
+    parserassert(state->method && state->method->info);
+
+    methodstate_t*parent_method = state->method;
+
+    if(as3_pass==1) {
+        // not valid yet
+        params = 0;
+        return_type = 0;
+    }
+
+    new_state();
+    state->new_vars = 1;
+   
+    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(memberinfo_t,minfo);
+        minfo->name = name;
+        state->method->info = minfo;
+
+        list_append(parent_method->innerfunctions, state->method);
+
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
+    }
+
+    if(as3_pass == 2) {
+        state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
+        parserassert(state->method);
+
+        state->method->info->return_type = return_type;
+        function_initvars(params, 0);
+    }
+}
+
 static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
                           params_t*params, classinfo_t*return_type)
 {
@@ -944,41 +1086,56 @@ static void startfunction(token_t*ns, int flags, enum yytokentype getset, char*n
         syntaxerror("not able to start another method scope");
     }
     new_state();
-    global->variable_count = 0;
-    state->method = rfx_calloc(sizeof(methodstate_t));
-    state->method->has_super = 0;
+    
+    if(as3_pass == 1) {
+        state->method = rfx_calloc(sizeof(methodstate_t));
+        state->method->has_super = 0;
+        state->method->variable_count = 0;
 
-    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(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__";
 
-        new_variable("globalscope", 0, 0);
+        return_type = 0;
+        state->method->info = registerfunction(getset, flags, name, params, return_type, 0);
+        
+        dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
     }
 
-    /* state->vars is initialized by state_new */
-
-    param_list_t*p=0;
-    for(p=params->list;p;p=p->next) {
-        new_variable(p->param->name, p->param->type, 0);
-    }
-    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);
+        parserassert(state->method);
+            
+        if(state->cls) { 
+            state->cls->has_constructor |= state->method->is_constructor;
+        }
+        
+        state->method->info->return_type = return_type;
+        function_initvars(params, flags);
+    } 
 }
 
-static void endfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
+static abc_method_t* endfunction(token_t*ns, int flags, enum yytokentype getset, char*name,
                           params_t*params, classinfo_t*return_type, code_t*body)
 {
+    if(as3_pass==1) {
+        old_state();
+        return 0;
+    }
+
     abc_method_t*f = 0;
 
     multiname_t*type2 = sig2mname(return_type);
     int slot = 0;
-    if(state->method->is_constructor) {
+    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 mname_ns = flags2namespace(flags, "");
@@ -1030,12 +1187,10 @@ static void endfunction(token_t*ns, int flags, enum yytokentype getset, char*nam
             syntaxerror("interface methods can't have a method body");
     }
        
-    free(state->method);state->method=0;
     old_state();
+    return f;
 }
 
-
-
 char is_subtype_of(classinfo_t*type, classinfo_t*supertype)
 {
     return 1; // FIXME
@@ -1162,11 +1317,6 @@ char is_pushundefined(code_t*c)
     return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);
 }
 
-void parserassert(int b)
-{
-    if(!b) syntaxerror("internal error: assertion failed");
-}
-
 static classinfo_t* find_class(char*name)
 {
     classinfo_t*c=0;
@@ -1197,9 +1347,9 @@ static classinfo_t* find_class(char*name)
     /* try global package */
     c = registry_findclass("", name);
     if(c) return c;
-   
+  
     /* try local "filename" package */
-    c = registry_findclass(current_filename, name);
+    c = registry_findclass(current_filename_short, name);
     if(c) return c;
 
     return 0;
@@ -1236,7 +1386,6 @@ static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char r
 
        [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
     */
-    
     if(in && in->opcode == OPCODE_COERCE_A) {
         in = code_cutlast(in);
     }
@@ -1356,6 +1505,7 @@ static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char r
             c = code_append(c, write);
             c = code_append(c, r);
         } else {
+            code_free(r);r=0;
             temp = gettempvar();
             if(prefix) {
                 c = code_append(c, prefix);
@@ -1502,10 +1652,16 @@ code_t* insert_finally(code_t*c, code_t*finally, int tempvar)
     }
 }
 
+#define PASS1 }} if(as3_pass == 1) {{
+#define PASS1END }} if(as3_pass == 2) {{
+#define PASS2 }} if(as3_pass == 2) {{
+#define PASS12 }} {{
+#define PASS12END }} if(as3_pass == 2) {{
+
 
 
-/* Line 264 of yacc.c  */
-#line 1509 "parser.tab.c"
+/* Line 273 of skeleton.m4  */
+#line 1665 "parser.tab.c"
 
 #ifdef short
 # undef short
@@ -1718,22 +1874,22 @@ union yyalloc
 #endif
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  119
+#define YYFINAL  117
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   2463
+#define YYLAST   3011
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  130
+#define YYNTOKENS  131
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  105
+#define YYNNTS  107
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  285
+#define YYNRULES  289
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  478
+#define YYNSTATES  491
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   360
+#define YYMAXUTOK   361
 
 #define YYTRANSLATE(YYX)                                               \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -1745,15 +1901,15 @@ static const yytype_uint8 yytranslate[] =
        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,
+     120,   130,   113,   111,    97,   110,   125,   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,     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,   122,     2,   123,   105,     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,   124,   104,   129,   115,     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 +1932,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,    98,   100,   101,   109,   117,   118,   119,   121,   126,
+     127,   128
 };
 
 #if YYDEBUG
@@ -1786,158 +1942,159 @@ 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,    32,    34,    35,    37,    39,    42,
+      44,    46,    48,    50,    52,    59,    61,    63,    64,    67,
+      69,    71,    73,    75,    77,    79,    81,    83,    85,    87,
+      89,    91,    93,    95,    97,    99,   101,   103,   105,   107,
+     111,   114,   117,   119,   121,   124,   125,   128,   131,   133,
+     137,   141,   142,   145,   146,   154,   155,   157,   159,   163,
+     165,   168,   172,   181,   188,   189,   196,   197,   205,   207,
+     210,   212,   215,   216,   218,   220,   223,   225,   228,   233,
+     237,   238,   247,   248,   258,   259,   265,   267,   270,   272,
+     275,   277,   278,   285,   288,   290,   296,   298,   300,   304,
+     306,   307,   314,   315,   321,   324,   329,   330,   332,   334,
+     337,   339,   341,   343,   345,   347,   349,   351,   353,   355,
+     356,   359,   360,   363,   364,   367,   368,   378,   379,   388,
+     389,   391,   393,   396,   398,   400,   402,   404,   405,   407,
+     409,   412,   414,   417,   426,   428,   430,   436,   437,   440,
+     442,   444,   446,   448,   450,   452,   454,   456,   457,   459,
+     462,   467,   471,   473,   478,   481,   483,   485,   486,   487,
+     500,   502,   503,   504,   515,   517,   521,   523,   525,   527,
+     531,   533,   535,   537,   540,   541,   542,   546,   547,   549,
+     551,   555,   556,   561,   566,   571,   574,   576,   579,   581,
+     583,   587,   589,   591,   593,   595,   597,   599,   601,   603,
+     605,   607,   609,   611,   613,   615,   617,   619,   621,   623,
+     627,   631,   635,   639,   643,   647,   651,   655,   659,   663,
+     666,   669,   673,   677,   681,   685,   689,   693,   697,   701,
+     705,   709,   713,   717,   721,   725,   729,   734,   737,   739,
+     743,   746,   751,   755,   756,   758,   762,   768,   772,   776,
+     780,   784,   788,   792,   796,   800,   804,   808,   812,   818,
+     821,   824,   827,   830,   834,   838,   840,   844,   850,   856
 };
 
 /* 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,
+     132,     0,    -1,   133,    -1,    -1,   134,    -1,   135,    -1,
+     134,   135,    -1,   181,    -1,   193,    -1,   191,    -1,   209,
+      -1,   202,    -1,   144,    -1,     3,    86,     3,   124,   134,
+     129,    -1,    96,    -1,    -1,   137,    -1,   138,    -1,   137,
+     138,    -1,   193,    -1,   191,    -1,   209,    -1,   202,    -1,
+     144,    -1,     3,    86,     3,   124,   137,   129,    -1,    96,
+      -1,   140,    -1,    -1,   140,   142,    -1,   142,    -1,   184,
+      -1,   155,    -1,   156,    -1,   157,    -1,   159,    -1,   167,
+      -1,   150,    -1,   178,    -1,   175,    -1,   230,    -1,    96,
+      -1,   141,    -1,   146,    -1,   161,    -1,   162,    -1,   227,
+      -1,   177,    -1,   236,    -1,   237,    -1,   124,   140,   129,
+      -1,   124,   129,    -1,   142,    96,    -1,   142,    -1,   141,
+      -1,    99,   228,    -1,    -1,    45,   147,    -1,    31,   147,
+      -1,   148,    -1,   147,    97,   148,    -1,     3,   219,   145,
+      -1,    -1,    64,   143,    -1,    -1,    63,   120,   151,   229,
+     130,   143,   149,    -1,    -1,   146,    -1,   230,    -1,    45,
+       3,   219,    -1,     3,    -1,    12,   120,    -1,    12,    49,
+     120,    -1,   154,   152,    96,   229,    96,   230,   130,   143,
+      -1,   154,   153,    67,   229,   130,   143,    -1,    -1,    13,
+     120,   158,   229,   130,   143,    -1,    -1,    14,   160,   143,
+      13,   120,   229,   130,    -1,    65,    -1,    65,     3,    -1,
+      29,    -1,    29,     3,    -1,    -1,   164,    -1,   166,    -1,
+     164,   166,    -1,   165,    -1,   164,   165,    -1,    33,   231,
+     103,   139,    -1,    61,   103,   139,    -1,    -1,    15,   120,
+     168,   231,   130,   124,   163,   129,    -1,    -1,    32,   120,
+       3,   219,   130,   170,   124,   139,   129,    -1,    -1,    27,
+     124,   172,   139,   129,    -1,   169,    -1,   173,   169,    -1,
+     173,    -1,   173,   171,    -1,   171,    -1,    -1,    51,   124,
+     176,   139,   129,   174,    -1,    36,   229,    -1,    36,    -1,
+      38,   120,   229,   130,   143,    -1,     3,    -1,    18,    -1,
+     180,   125,   179,    -1,   179,    -1,    -1,    18,   180,   124,
+     182,   136,   129,    -1,    -1,    18,   124,   183,   136,   129,
+      -1,    40,   215,    -1,    40,   180,   125,   113,    -1,    -1,
+     186,    -1,   187,    -1,   186,   187,    -1,    20,    -1,    21,
+      -1,    19,    -1,    37,    -1,    46,    -1,    48,    -1,    47,
+      -1,    25,    -1,    23,    -1,    -1,    53,   216,    -1,    -1,
+      53,   217,    -1,    -1,    16,   217,    -1,    -1,   185,    30,
+       3,   188,   190,   124,   192,   195,   129,    -1,    -1,   185,
+      43,     3,   189,   124,   194,   198,   129,    -1,    -1,   196,
+      -1,   197,    -1,   196,   197,    -1,    96,    -1,   202,    -1,
+     209,    -1,   141,    -1,    -1,   199,    -1,   200,    -1,   199,
+     200,    -1,    96,    -1,    45,     3,    -1,   185,    26,   208,
+       3,   120,   205,   130,   219,    -1,    45,    -1,    31,    -1,
+     185,   201,     3,   219,   145,    -1,    -1,    99,   204,    -1,
+       9,    -1,     7,    -1,     8,    -1,    11,    -1,     4,    -1,
+      55,    -1,    54,    -1,    44,    -1,    -1,   206,    -1,    90,
+     207,    -1,   206,    97,    90,   207,    -1,   206,    97,   207,
+      -1,   207,    -1,     3,   103,   218,   203,    -1,     3,   203,
+      -1,    50,    -1,    34,    -1,    -1,    -1,   185,    26,   208,
+       3,   120,   205,   130,   219,   124,   210,   139,   129,    -1,
+       3,    -1,    -1,    -1,    26,   211,   120,   205,   130,   219,
+     124,   213,   139,   129,    -1,     3,    -1,   180,   125,     3,
+      -1,   215,    -1,   214,    -1,   216,    -1,   217,    97,   216,
+      -1,   216,    -1,   113,    -1,    35,    -1,   103,   218,    -1,
+      -1,    -1,   120,   221,   130,    -1,    -1,   222,    -1,   228,
+      -1,   222,    97,   228,    -1,    -1,    24,   231,   223,   220,
+      -1,   231,   120,   221,   130,    -1,    52,   120,   221,   130,
+      -1,    62,   231,    -1,    41,    -1,    41,   229,    -1,   231,
+      -1,   231,    -1,   229,    97,   231,    -1,   229,    -1,   212,
+      -1,   232,    -1,   235,    -1,   224,    -1,   226,    -1,   225,
       -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
+      -1,    44,    -1,   231,   107,   231,    -1,   231,   108,   231,
+      -1,   231,    73,   231,    -1,   231,    74,   231,    -1,   231,
+      69,   231,    -1,   231,    70,   231,    -1,   231,    72,   231,
+      -1,   231,    71,   231,    -1,   231,    84,   231,    -1,   231,
+      85,   231,    -1,   116,   231,    -1,   115,   231,    -1,   231,
+     106,   231,    -1,   231,   105,   231,    -1,   231,   104,   231,
+      -1,   231,    93,   231,    -1,   231,    92,   231,    -1,   231,
+      91,   231,    -1,   231,   112,   231,    -1,   231,   114,   231,
+      -1,   231,   111,   231,    -1,   231,   110,   231,    -1,   231,
+     113,   231,    -1,   231,    67,   231,    -1,   231,    68,   231,
+      -1,   231,    39,   231,    -1,   231,    66,   231,    -1,    42,
+     120,   231,   130,    -1,    35,   231,    -1,    35,    -1,   120,
+     229,   130,    -1,   110,   231,    -1,   231,   122,   231,   123,
+      -1,   122,   221,   123,    -1,    -1,   234,    -1,   228,   103,
+     228,    -1,   234,    97,   228,   103,   228,    -1,   124,   233,
+     129,    -1,   231,    78,   231,    -1,   231,    77,   231,    -1,
+     231,    82,   231,    -1,   231,    81,   231,    -1,   231,    83,
+     231,    -1,   231,    76,   231,    -1,   231,    75,   231,    -1,
+     231,    79,   231,    -1,   231,    80,   231,    -1,   231,    99,
+     231,    -1,   231,   102,   231,   103,   231,    -1,   231,    88,
+      -1,   231,    87,    -1,    88,   231,    -1,    87,   231,    -1,
+      52,   125,     3,    -1,   231,   125,     3,    -1,     3,    -1,
+     185,    17,     3,    -1,   185,    17,     3,    99,     3,    -1,
+     185,    17,     3,    99,     4,    -1,    22,    17,     3,    -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,  1552,  1553,  1557,  1558,  1560,  1561,  1563,  1604,
-    1605,  1608,  1608,  1627,  1628,  1629,  1632,  1635,  1639,  1640,
-    1642,  1662,  1705,  1705,  1724,  1724,  1739,  1742,  1745,  1748,
-    1752,  1753,  1754,  1755,  1756,  1757,  1759,  1770,  1773,  1773,
-    1802,  1802,  1822,  1822,  1839,  1840,  1841,  1842,  1850,  1859,
-    1859,  1904,  1908,  1919,  1928,  1929,  1931,  1932,  1934,  1934,
-    1935,  1935,  1937,  1945,  1955,  1956,  1957,  1958,  1960,  1961,
-    1962,  1963,  1964,  1965,  1966,  1967,  1968,  1970,  1971,  1973,
-    1974,  1976,  1977,  1981,  1979,  1987,  1985,  1993,  1994,  1995,
-    1996,  1997,  1998,  1999,  2001,  2007,  2008,  2009,  2010,  2011,
-    2012,  2015,  2026,  2026,  2028,  2086,  2087,  2089,  2090,  2091,
-    2092,  2093,  2095,  2096,  2097,  2102,  2105,  2110,  2115,  2122,
-    2126,  2131,  2137,  2143,  2144,  2145,  2148,  2147,  2165,  2166,
-    2167,  2175,  2182,  2188,  2189,  2191,  2192,  2194,  2195,  2196,
-    2205,  2206,  2210,  2211,  2213,  2214,  2215,  2218,  2223,  2247,
-    2295,  2315,  2336,  2339,  2346,  2347,  2348,  2354,  2360,  2362,
-    2364,  2366,  2368,  2370,  2387,  2392,  2395,  2398,  2401,  2404,
-    2407,  2410,  2413,  2416,  2420,  2421,  2424,  2427,  2430,  2433,
-    2436,  2439,  2442,  2446,  2457,  2475,  2480,  2485,  2490,  2495,
-    2500,  2504,  2508,  2513,  2517,  2521,  2530,  2539,  2549,  2554,
-    2566,  2572,  2577,  2583,  2589,  2593,  2595,  2606,  2615,  2622,
-    2623,  2625,  2631,  2640,  2647,  2659,  2665,  2671,  2677,  2683,
-    2689,  2695,  2708,  2719,  2726,  2739,  2766,  2780,  2794,  2808,
-    2823,  2857,  2944,  2945,  2946,  2948
+       0,  1641,  1641,  1643,  1643,  1644,  1645,  1647,  1648,  1649,
+    1650,  1651,  1652,  1653,  1654,  1656,  1656,  1657,  1658,  1660,
+    1661,  1662,  1663,  1664,  1665,  1666,  1668,  1669,  1671,  1672,
+    1675,  1676,  1677,  1678,  1679,  1680,  1681,  1682,  1683,  1684,
+    1687,  1688,  1689,  1690,  1691,  1692,  1693,  1695,  1696,  1698,
+    1699,  1700,  1701,  1705,  1712,  1713,  1717,  1718,  1720,  1721,
+    1723,  1766,  1767,  1770,  1770,  1789,  1790,  1791,  1794,  1797,
+    1801,  1802,  1804,  1824,  1867,  1867,  1886,  1886,  1901,  1904,
+    1907,  1910,  1914,  1915,  1916,  1917,  1918,  1919,  1921,  1932,
+    1935,  1935,  1964,  1964,  1984,  1984,  2001,  2002,  2003,  2004,
+    2012,  2021,  2021,  2066,  2070,  2081,  2090,  2091,  2093,  2094,
+    2096,  2096,  2098,  2098,  2101,  2115,  2131,  2132,  2133,  2134,
+    2136,  2137,  2138,  2139,  2140,  2141,  2142,  2143,  2144,  2146,
+    2147,  2149,  2150,  2152,  2153,  2157,  2155,  2163,  2161,  2169,
+    2170,  2171,  2172,  2173,  2174,  2175,  2177,  2183,  2184,  2185,
+    2186,  2187,  2188,  2191,  2204,  2204,  2206,  2265,  2266,  2268,
+    2269,  2270,  2271,  2272,  2274,  2275,  2276,  2281,  2285,  2291,
+    2297,  2305,  2310,  2316,  2324,  2332,  2333,  2334,  2337,  2336,
+    2351,  2352,  2354,  2353,  2375,  2383,  2395,  2396,  2398,  2399,
+    2401,  2402,  2403,  2412,  2413,  2417,  2418,  2420,  2421,  2422,
+    2425,  2430,  2431,  2467,  2513,  2534,  2555,  2558,  2565,  2566,
+    2567,  2573,  2579,  2581,  2583,  2585,  2587,  2589,  2591,  2608,
+    2613,  2616,  2619,  2622,  2625,  2628,  2631,  2634,  2637,  2641,
+    2644,  2647,  2650,  2653,  2656,  2659,  2662,  2666,  2677,  2695,
+    2700,  2705,  2710,  2715,  2720,  2724,  2728,  2733,  2737,  2741,
+    2750,  2759,  2769,  2774,  2786,  2792,  2797,  2803,  2809,  2813,
+    2815,  2826,  2835,  2842,  2843,  2845,  2851,  2860,  2867,  2879,
+    2885,  2891,  2897,  2903,  2909,  2915,  2928,  2939,  2946,  2959,
+    2986,  3000,  3014,  3028,  3043,  3077,  3174,  3175,  3176,  3178
 };
 #endif
 
@@ -1966,8 +2123,8 @@ static const char *const yytname[] =
   "';'", "','", "below_assignment", "'='", "\"&=\"", "\"^=\"", "'?'",
   "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "below_minus", "'-'", "'+'",
   "'/'", "'*'", "'%'", "'~'", "'!'", "minusminus_prefix",
-  "plusplus_prefix", "below_curly", "'['", "']'", "'{'", "'.'",
-  "above_identifier", "below_else", "'('", "above_function", "'}'", "')'",
+  "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",
@@ -1986,11 +2143,12 @@ static const char *const yytname[] =
   "SLOT_DECLARATION", "MAYBESTATICCONSTANT", "STATICCONSTANT",
   "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",
-  "FUNCTIONCALL", "DELETE", "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION",
-  "VOIDEXPRESSION", "E", "CONSTANT", "MAYBE_EXPRPAIR_LIST",
-  "EXPRPAIR_LIST", "VAR_READ", "NAMESPACE_DECLARATION", "USE_NAMESPACE", 0
+  "$@13", "CLASS", "PACKAGEANDCLASS", "CLASS_SPEC", "CLASS_SPEC_LIST",
+  "TYPE", "MAYBETYPE", "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST",
+  "EXPRESSION_LIST", "XX", "NEW", "FUNCTIONCALL", "DELETE", "RETURN",
+  "NONCOMMAEXPRESSION", "EXPRESSION", "VOIDEXPRESSION", "E", "CONSTANT",
+  "MAYBE_EXPRPAIR_LIST", "EXPRPAIR_LIST", "VAR_READ",
+  "NAMESPACE_DECLARATION", "USE_NAMESPACE", 0
 };
 #endif
 
@@ -2011,76 +2169,77 @@ static const yytype_uint16 yytoknum[] =
      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
+      40,   358,    91,    93,   123,    46,   359,   360,   361,   125,
+      41
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 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,   131,   132,   133,   133,   134,   134,   135,   135,   135,
+     135,   135,   135,   135,   135,   136,   136,   137,   137,   138,
+     138,   138,   138,   138,   138,   138,   139,   139,   140,   140,
+     141,   141,   141,   141,   141,   141,   141,   141,   141,   141,
+     142,   142,   142,   142,   142,   142,   142,   142,   142,   143,
+     143,   143,   143,   144,   145,   145,   146,   146,   147,   147,
+     148,   149,   149,   151,   150,   152,   152,   152,   153,   153,
+     154,   154,   155,   156,   158,   157,   160,   159,   161,   161,
+     162,   162,   163,   163,   163,   163,   164,   164,   165,   166,
+     168,   167,   170,   169,   172,   171,   173,   173,   174,   174,
+     174,   176,   175,   177,   177,   178,   179,   179,   180,   180,
+     182,   181,   183,   181,   184,   184,   185,   185,   186,   186,
+     187,   187,   187,   187,   187,   187,   187,   187,   187,   188,
+     188,   189,   189,   190,   190,   192,   191,   194,   193,   195,
+     195,   196,   196,   197,   197,   197,   197,   198,   198,   199,
+     199,   200,   200,   200,   201,   201,   202,   203,   203,   204,
+     204,   204,   204,   204,   204,   204,   204,   205,   205,   205,
+     205,   206,   206,   207,   207,   208,   208,   208,   210,   209,
+     211,   211,   213,   212,   214,   215,   216,   216,   217,   217,
+     218,   218,   218,   219,   219,   220,   220,   221,   221,   222,
+     222,   223,   224,   225,   225,   226,   227,   227,   228,   229,
+     229,   230,   231,   231,   231,   231,   231,   231,   231,   232,
+     232,   232,   232,   232,   232,   232,   232,   232,   232,   231,
+     231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
+     231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
+     231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
+     231,   231,   231,   233,   233,   234,   234,   231,   231,   231,
+     231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
+     231,   231,   231,   231,   231,   235,   236,   236,   236,   237
 };
 
 /* 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,     6,     1,     0,     1,     1,     2,     1,
+       1,     1,     1,     1,     6,     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,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     3,     2,     2,     3,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     4,     2,     1,     3,     2,     4,     3,     0,
-       1,     3,     5,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     5,     2,     2,     2,     2,     3,
-       3,     1,     3,     5,     5,     3
+       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,     0,    10,     1,     3,     1,     1,     1,     3,
+       1,     1,     1,     2,     0,     0,     3,     0,     1,     1,
+       3,     0,     4,     4,     4,     2,     1,     2,     1,     1,
+       3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     2,
+       2,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     4,     2,     1,     3,
+       2,     4,     3,     0,     1,     3,     5,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     5,     2,
+       2,     2,     2,     3,     3,     1,     3,     5,     5,     3
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -2088,262 +2247,339 @@ 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,
+     116,   285,   224,   218,   221,   222,   219,   220,   223,     0,
+       0,    76,     0,     0,   122,   120,   121,   128,     0,   127,
+     181,   225,   258,   123,     0,     0,     0,   228,   124,   126,
+     125,     0,     0,   227,   226,     0,     0,     0,     0,    14,
+       0,     0,     0,     0,   197,   263,     0,     2,   116,     5,
+      53,    12,    36,    65,    31,    32,    33,    34,    35,    38,
+      37,     7,    30,     0,   117,   118,     9,     8,    11,    10,
+     212,   215,   217,   216,   211,    39,   209,   213,   214,     0,
+       0,    70,    74,   116,    90,   106,   107,   112,   109,     0,
+     285,   201,   180,     0,   257,     0,     0,   114,     0,   101,
+     197,     0,   205,    63,   282,   281,   260,   240,   239,     0,
+       0,   198,   199,   208,     0,     0,   264,     1,     6,   285,
+       0,     0,    66,     0,     0,    67,   177,     0,   155,     0,
+     154,     0,   119,     0,     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,   280,   279,     0,     0,     0,
        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,   197,     0,     0,     0,    71,     0,     0,    80,
+     104,   206,     0,    78,    40,   116,    41,    52,     0,    42,
+      43,    44,    46,     0,    45,    47,    48,     0,   116,   110,
+       0,   195,   167,     0,     0,     0,    27,     0,   283,     0,
+     259,   262,     0,     0,   267,     0,   194,    57,    58,   194,
+      56,     0,     0,   176,   175,     0,   129,   131,   194,   210,
+     254,   255,   252,   253,   233,   234,   236,   235,   231,   232,
+     274,   273,   269,   268,   275,   276,   271,   270,   272,   237,
+     238,   246,   245,   244,   277,     0,   243,   242,   241,   229,
+     230,   250,   249,   247,   251,   248,     0,     0,   284,   116,
+       0,     0,    81,   103,   207,    79,    50,   116,    29,   209,
+      51,     0,     0,     0,   285,    25,     0,   116,    17,    23,
+      20,    19,    22,    21,   116,   108,   197,   202,   157,     0,
+       0,   168,   172,   116,   185,   115,   256,     0,    26,   204,
+       0,   200,   265,     0,     0,    55,     0,    55,     0,     0,
+       0,     0,   133,     0,     0,    55,     0,   203,   261,   116,
+     116,   289,    49,    28,     0,   286,     0,     0,   113,    18,
+       0,     0,     0,     0,   174,   169,   194,     0,   105,     0,
+     116,     0,   184,   192,   191,     0,   187,   186,   190,   193,
+       0,    60,    59,     0,   116,   167,   130,     0,     0,   188,
+     132,   137,   156,   278,    13,    75,     0,     0,    82,     0,
+     111,   196,   163,   160,   161,   159,   162,   166,   165,   164,
+     158,   157,     0,     0,   171,     0,     0,    96,   100,    98,
+     102,    61,   266,     0,    54,     0,    73,     0,   134,   135,
+       0,   116,    77,   287,   288,     0,     0,     0,    83,    86,
+      84,   116,   173,   182,   170,    94,     0,    97,    99,   116,
+      64,   116,   194,   116,   189,     0,   151,     0,     0,   116,
+     149,     0,    27,    91,    87,    85,   116,    27,    27,   194,
+      62,    72,     0,   143,   146,     0,     0,   116,   141,   144,
+     145,   152,   177,   138,   150,    27,    89,    24,     0,     0,
+       0,   178,   136,   142,     0,    88,   183,    95,    92,    27,
+       0,     0,     0,   167,    27,   179,     0,     0,   194,    93,
+     153
 };
 
 /* 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,    46,    47,    48,    49,   286,   287,   288,   307,   308,
+     186,   278,   188,   289,   361,   189,   220,   218,   430,    52,
+     209,   123,   124,    53,    54,    55,    56,   177,    57,    83,
+     190,   191,   417,   418,   419,   420,    58,   197,   397,   481,
+     398,   448,   399,   400,    59,   206,   192,    60,    88,   355,
+      61,   294,   198,    62,   193,    64,    65,   322,   324,   368,
+     290,   433,   291,   411,   456,   457,   458,   438,   439,   440,
+     131,   292,   344,   390,   300,   301,   302,   225,   293,   479,
+      93,    70,   447,   356,   357,   358,   370,   359,   315,   297,
+     110,   111,   201,    71,    72,    73,   194,   112,    74,    75,
+      76,    77,   115,   116,    78,   195,   196
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -308
+#define YYPACT_NINF -370
 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
+    1338,    -3,  -370,  -370,  -370,  -370,  -370,  -370,  -370,   -28,
+     -29,  -370,    -1,    40,  -370,  -370,  -370,  -370,  2137,  -370,
+      94,  -370,  2210,  -370,    51,    24,    60,  -370,  -370,  -370,
+    -370,    58,   -86,  -370,  -370,  2137,    64,  2137,  2137,  -370,
+    2137,  2137,  2137,  2137,  2137,  2137,   188,  -370,  1461,  -370,
+    -370,  -370,  -370,  2044,  -370,  -370,  -370,  -370,  -370,  -370,
+    -370,  -370,  -370,    50,   158,  -370,  -370,  -370,  -370,  -370,
+    -370,  -370,  -370,  -370,    97,  -370,  2585,  -370,  -370,   204,
+      71,  -370,  -370,  1705,  -370,  -370,  -370,  -370,  -370,    -7,
+    -370,    47,  -370,    88,   -22,  2137,    85,  -370,  2137,  -370,
+    2137,   211,   -22,  -370,   -22,   -22,    99,   -22,   -22,   -66,
+     100,   129,  -370,  2585,   124,   101,   134,  -370,  -370,   165,
+     232,   233,  -370,   143,   173,  -370,    70,   238,  -370,   243,
+    -370,   244,  -370,  2137,  2137,  2137,  2137,  2137,  2137,  2137,
+    2137,  2137,  2137,  2137,  2137,  2137,  2137,  2137,  2137,  2137,
+    2137,  2137,  2137,  2137,  2137,  -370,  -370,  2137,  2137,  2137,
+    2137,  2137,  2137,  2137,  2137,  2137,  2137,  2137,  2137,  2137,
+    2137,  2137,  2137,  2137,   245,   126,  -370,  2137,   234,   249,
+    2137,  2137,   232,   250,  -370,   354,  -370,   169,   241,  -370,
+    -370,  -370,  -370,   251,  -370,  -370,  -370,  2137,   723,  -370,
+      24,   147,    15,   -62,    57,  2201,  1583,   149,  -370,  2137,
+    -370,  -370,  2137,  2137,  -370,  2137,   177,   189,  -370,   177,
+     189,  2137,  2137,  -370,  -370,   282,   237,   246,   177,  2585,
+     592,   715,   715,   715,  2886,  2886,  2886,  2886,   592,   592,
+    2585,  2585,  2585,  2585,  2585,  2585,  2585,  2585,  2585,  2646,
+    2706,   341,   341,   341,  2585,  2341,  2766,   190,  2826,   592,
+     592,    99,    99,   -22,   -22,   -22,   161,  2402,  -370,  1827,
+     -60,   303,  -370,    97,    97,  -370,  -370,   477,  -370,  2463,
+    -370,   187,   305,  2271,   223,  -370,   182,   846,  -370,  -370,
+    -370,  -370,  -370,  -370,   723,  -370,  2137,  -370,    13,   310,
+     186,   220,  -370,  1705,   193,  -370,  -370,   192,  1583,  -370,
+     -59,  -370,  -370,   219,    54,   236,   232,   -43,    79,   -56,
+     218,    43,   324,    43,   217,   236,  2137,  -370,  -370,   600,
+    1705,  -370,  -370,  -370,  2137,   247,   221,   339,  -370,  -370,
+     214,   222,   316,    54,  -370,  -370,   177,    17,  -370,    82,
+    1705,  2137,   193,  -370,  -370,   224,  -370,  -370,  -370,  -370,
+    2137,  -370,  -370,  2137,  1705,    15,  -370,    43,   227,  -370,
+     256,  -370,  -370,  2585,  -370,  -370,   -53,   140,    21,   231,
+    -370,  -370,  -370,  -370,  -370,  -370,  -370,  -370,  -370,  -370,
+    -370,   248,   257,   310,  -370,   260,   252,  -370,  -370,    82,
+    -370,   280,  -370,    66,  -370,   258,  -370,   263,   256,  -370,
+      43,   197,  -370,  -370,  -370,  2137,   283,   268,    21,  -370,
+    -370,  1949,  -370,  -370,  -370,  -370,   384,  -370,  -370,  1705,
+    -370,  1705,   177,   969,  -370,   401,  -370,   381,   281,   530,
+    -370,  2524,  1583,  -370,  -370,  -370,  1092,  1583,  1583,   177,
+    -370,  -370,   288,  -370,  -370,    68,   284,  1215,  -370,  -370,
+    -370,  -370,    70,  -370,  -370,  1583,  -370,  -370,   285,   286,
+     290,  -370,  -370,  -370,   415,  -370,  -370,  -370,  -370,  1583,
+     304,   299,   296,    15,  1583,  -370,   297,   301,   177,  -370,
+    -370
 };
 
 /* 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
+    -370,  -370,  -370,   157,   -37,   137,    11,  -272,  -369,   253,
+       1,   -75,  -263,     4,   112,   387,   323,   128,  -370,  -370,
+    -370,  -370,  -370,  -370,  -370,  -370,  -370,  -370,  -370,  -370,
+    -370,  -370,  -370,  -370,    27,    30,  -370,  -370,    63,  -370,
+      69,  -370,  -370,  -370,  -370,  -370,  -370,  -370,  -188,    77,
+    -370,  -370,  -370,  -370,     0,  -370,   385,  -370,  -370,  -370,
+       5,  -370,     7,  -370,  -370,  -370,     8,  -370,  -370,    28,
+    -370,     2,    65,  -370,  -318,  -370,  -285,     9,     3,  -370,
+    -370,  -370,  -370,  -370,   447,  -304,   106,   132,  -183,  -370,
+     -87,  -370,  -370,  -370,  -370,  -370,  -370,   -23,    16,   -44,
+     -12,  -370,  -370,  -370,  -370,  -370,  -370
 };
 
 /* 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 -209
 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,
+      63,    50,    68,    69,    51,    66,    91,    67,   187,   125,
+      94,   118,   295,   207,   345,   339,   295,   366,   298,   369,
+     298,    80,   114,   102,   -68,   104,   105,    85,   106,   107,
+     108,   133,   113,   113,   100,   133,   317,   133,   133,   101,
+     348,   133,    86,    85,   133,   325,   352,   407,    63,    50,
+      68,    69,    51,    66,   415,    67,   360,   352,    86,   109,
+     304,    86,   394,   369,   210,   155,   156,   375,   303,   304,
+     330,   350,    86,   466,   364,    86,   126,   412,   468,   469,
+     127,   128,   416,    79,    86,   266,   205,   401,   113,   353,
+      89,    82,    81,   129,   126,   130,   475,    92,   172,   128,
+     173,   406,    96,   174,   223,   299,   434,   393,   424,   395,
+     482,   203,   342,   130,   396,   487,   343,   199,   200,    84,
+     224,   229,   230,   231,   232,   233,   234,   235,   236,   237,
+     238,   239,   240,   241,   242,   243,   244,   245,   246,   247,
+     248,   249,   250,   413,   414,   251,   252,   253,   254,   255,
+     256,   257,   258,   259,   260,   261,   262,   263,   264,   265,
+     113,   267,   114,   392,    87,   486,   450,   354,   451,   173,
+     305,    95,   174,   279,   339,   363,   133,    14,    15,    16,
+      98,    17,    99,    19,   103,   283,   155,   156,   117,   311,
+     312,   176,   313,   270,   133,    23,   273,   274,    63,    50,
+     113,   113,   333,   113,    28,    29,    30,   175,   202,   341,
+     204,   169,   170,   171,   208,   295,    14,    15,    16,   172,
+      17,   173,    19,   211,   174,   310,   212,   213,   187,   134,
+     214,   215,   -69,   333,    23,   216,   219,   318,   319,   221,
+     222,   226,   435,    28,    29,    30,   227,   228,   268,   452,
+     269,   271,   272,   275,   281,   187,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   280,   470,   296,   282,    63,
+      50,    68,    69,    51,    66,   187,    67,   155,   156,   309,
+     314,   157,   158,   159,   113,   320,   316,    63,    50,   187,
+     321,   327,   118,   436,    63,    50,   164,   165,   166,   323,
+     167,   168,   169,   170,   171,   490,   331,   334,   335,   337,
+     172,   338,   173,   298,   373,   174,   346,   347,  -106,   405,
+     382,   349,   351,   383,   384,   385,  -147,   386,   402,    63,
+      50,    68,    69,    51,    66,   360,    67,   404,   365,   113,
+     367,   371,   379,   380,   429,   378,   377,   342,   113,   403,
+     376,   409,   381,   410,   187,   421,   187,    90,     2,     3,
+     387,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+     388,   389,   426,    14,    15,    16,   178,    17,    18,    19,
+      20,   423,    21,   179,   425,   120,   442,   449,   431,    22,
+     180,    23,    24,   432,    25,   181,    26,   443,    27,   182,
+      28,    29,    30,   441,   461,    31,    32,   462,    33,    34,
+     463,   437,   471,   472,   476,   477,    35,    36,   480,   183,
+     478,    63,    50,   484,   483,   485,   329,   488,   155,   156,
+     489,   340,   446,   455,   454,   459,   460,   372,   277,   437,
+     122,    37,    38,   217,   362,   444,    63,    50,   445,   132,
+     184,   167,   168,   169,   170,   171,   422,   455,   454,   459,
+     460,   172,   427,   173,    40,   473,   174,   464,   428,    41,
+      42,   474,    97,   408,    43,   391,    44,     0,    45,     0,
+      90,     2,     3,   276,     4,     5,     6,     7,     8,     9,
+      10,    11,    12,     0,     0,     0,    14,    15,    16,   178,
+      17,    18,    19,    20,     0,    21,   179,     0,   120,     0,
+       0,     0,    22,   180,    23,    24,     0,    25,   181,    26,
+       0,    27,   182,    28,    29,    30,     0,     0,    31,    32,
+       0,    33,    34,     0,     0,     0,     0,     0,     0,    35,
+      36,     0,   183,     0,     0,     0,     0,     0,     0,    14,
+      15,    16,     0,    17,     0,    19,     0,     0,     0,     0,
+       0,     0,     0,     0,    37,    38,     0,    23,     0,     0,
+       0,     0,     0,   184,     0,   435,    28,    29,    30,     0,
+       0,     0,     0,     0,     0,     0,     0,    40,     0,     0,
+       0,     0,    41,    42,     0,     0,     0,    43,     0,    44,
+       0,    45,     0,     1,     2,     3,   332,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,     0,     0,    13,    14,
+      15,    16,     0,    17,    18,    19,   436,     0,    21,     0,
+       0,  -209,     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,  -148,
+       0,     0,    35,    36,     0,  -209,  -209,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   155,
+     156,     0,     0,   157,   158,   159,     0,    37,    38,     0,
+       0,     0,     0,     0,     0,     0,    39,     0,     0,  -209,
+    -209,     0,   167,   168,   169,   170,   171,     0,     0,     0,
+      40,     0,   172,     0,   173,    41,    42,   174,     0,     0,
+      43,     0,    44,     0,    45,     0,   284,     2,     3,   374,
        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,
+       0,     0,    14,    15,    16,     0,    17,    18,    19,     0,
+       0,    21,     0,     0,   134,     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,
+       0,  -209,  -209,  -209,     0,    35,    36,     0,   142,   143,
        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,
+       0,     0,   155,   156,     0,     0,   157,   158,   159,     0,
+      37,    38,     0,     0,     0,     0,     0,     0,     0,   285,
+       0,     0,   165,   166,     0,   167,   168,   169,   170,   171,
+       0,     0,     0,    40,     0,   172,     0,   173,    41,    42,
+     174,     0,     0,    43,     0,    44,     0,    45,     0,   284,
+       2,     3,   -15,     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,     0,     0,     0,
+       0,     0,     0,    37,    38,     0,     0,     0,     0,     0,
+       0,     0,   285,     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,
+      45,     0,    90,     2,     3,   -16,     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,
+      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,   184,     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,
        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,   453,     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,
+       0,    44,     0,    45,     0,   284,     2,     3,  -139,     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,     0,     0,     0,     0,     0,     0,    37,
+      38,     0,     0,     0,     0,     0,     0,     0,   285,     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,    45,     0,    90,     2,
+       3,   467,     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,
+      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,  -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,
+      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,     0,     0,     0,     0,
        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,
+       0,   453,     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,    -3,    45,
+       0,     1,     2,     3,  -140,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,     0,     0,    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,     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,     0,
+       0,     0,     0,     0,     0,    37,    38,     0,     0,     0,
+       0,     0,     0,     0,    39,     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,    -4,    45,     0,     1,     2,     3,     0,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,     0,     0,    13,
       14,    15,    16,     0,    17,    18,    19,     0,     0,    21,
-       0,  -205,     0,     0,     0,     0,    22,     0,    23,    24,
+       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,  -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,
+       0,     0,     0,    35,    36,     0,     0,     0,     0,     0,
+       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,    39,     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,    45,    90,     2,     3,     0,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,     0,
+    -116,     0,    14,    15,    16,   178,    17,    18,    19,    20,
+       0,    21,   179,     0,   120,     0,     0,     0,    22,   180,
+      23,    24,     0,    25,   181,    26,     0,    27,   182,    28,
+      29,    30,     0,     0,    31,    32,     0,    33,    34,     0,
+       0,     0,     0,     0,     0,    35,    36,     0,   183,     0,
+       0,     0,     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,   184,
+       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,    45,    90,     2,
+       3,     0,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,     0,     0,     0,    14,    15,    16,   178,    17,    18,
+      19,    20,     0,    21,   179,     0,   120,     0,     0,     0,
+      22,   180,    23,    24,     0,    25,   181,    26,     0,    27,
+     182,    28,    29,    30,     0,     0,    31,    32,     0,    33,
+      34,     0,     0,     0,     0,     0,     0,    35,    36,     0,
+     183,     0,     0,     0,     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,   184,     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,   185,
        1,     2,     3,     0,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,     0,     0,     0,    14,    15,    16,     0,
+      10,    11,    12,     0,     0,    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,     0,     0,    31,    32,
@@ -2351,250 +2587,305 @@ static const yytype_int16 yytable[] =
       36,     0,     0,     0,     0,     0,     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,   442,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    39,     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,     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,  -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,     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,
+       0,    45,   284,     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,
+      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,   184,     0,     0,     0,     0,     0,
-       0,     1,     2,     3,     0,     4,     5,     6,     7,     8,
+       0,    35,    36,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        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,   285,     0,   119,     2,     3,
+       0,     4,     5,     6,     7,     8,     0,     0,     0,    40,
+       0,     0,     0,     0,    41,    42,     0,     0,    18,    43,
+      20,    44,    21,    45,     0,   120,     0,     0,     0,    22,
+       0,     0,     0,     0,     0,     0,    26,     0,    27,   121,
+       0,     0,     0,     0,     0,     0,    32,     0,    33,    34,
+       0,     0,     0,     0,     0,     0,    35,     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,     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,     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,    37,    38,     0,     0,     0,     0,     0,     0,     0,
+      90,     2,     3,     0,     4,     5,     6,     7,     8,     0,
+       0,     0,     0,     0,    40,     0,     0,     0,     0,    41,
+      42,    18,     0,    20,    43,    21,    44,     0,    45,     0,
+       0,     0,    22,     0,     0,     0,     0,     0,     0,    26,
+       0,    27,     0,     0,     0,     0,     0,     0,     0,    32,
+       0,    33,    34,     0,     0,     0,     0,     0,     0,    35,
        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,    90,     2,     3,     0,     4,     5,     6,
+       7,     8,     0,     0,    37,    38,     0,     0,     0,     0,
+       0,     0,     0,     0,    18,     0,    20,     0,    21,     0,
+     134,     0,     0,     0,     0,     0,     0,    40,     0,     0,
+       0,     0,    41,    42,    27,     0,     0,    43,     0,    44,
+       0,    45,    32,     0,    33,    34,     0,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,     0,   155,   156,
+       0,     0,   157,   158,   159,     0,     0,    37,    38,     0,
+     160,     0,     0,   161,     0,   162,   163,   164,   165,   166,
+     134,   167,   168,   169,   170,   171,     0,     0,     0,     0,
+       0,   172,     0,   173,     0,     0,   174,     0,     0,     0,
+      43,   306,    44,     0,    45,     0,     0,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,     0,   155,   156,
+       0,     0,   157,   158,   159,     0,     0,     0,     0,     0,
+     160,     0,     0,   161,     0,   162,   163,   164,   165,   166,
+     134,   167,   168,   169,   170,   171,     0,     0,     0,     0,
+       0,   172,     0,   173,     0,     0,   174,     0,     0,     0,
+       0,   336,     0,     0,     0,     0,     0,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,     0,   155,   156,
+       0,     0,   157,   158,   159,     0,     0,     0,     0,     0,
+     160,   134,     0,   161,   326,   162,   163,   164,   165,   166,
+       0,   167,   168,   169,   170,   171,     0,     0,     0,     0,
+       0,   172,     0,   173,     0,     0,   174,     0,   135,   136,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   150,   151,   152,   153,   154,     0,   155,
+     156,     0,     0,   157,   158,   159,     0,     0,     0,     0,
+       0,   160,   134,     0,   161,     0,   162,   163,   164,   165,
+     166,     0,   167,   168,   169,   170,   171,     0,     0,     0,
+       0,     0,   172,     0,   173,   328,     0,   174,     0,   135,
+     136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
+     146,   147,   148,   149,   150,   151,   152,   153,   154,     0,
+     155,   156,     0,     0,   157,   158,   159,     0,     0,     0,
+       0,     0,   160,   134,     0,   161,  -208,   162,   163,   164,
+     165,   166,     0,   167,   168,   169,   170,   171,     0,     0,
+       0,     0,     0,   172,     0,   173,     0,     0,   174,     0,
+     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
+     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
+       0,   155,   156,     0,     0,   157,   158,   159,     0,     0,
+       0,     0,     0,   160,   134,     0,   161,   465,   162,   163,
+     164,   165,   166,     0,   167,   168,   169,   170,   171,     0,
+       0,     0,     0,     0,   172,     0,   173,     0,     0,   174,
+       0,   135,   136,   137,   138,   139,   140,   141,   142,   143,
+     144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,     0,   155,   156,     0,     0,   157,   158,   159,     0,
+       0,     0,     0,     0,   160,   134,     0,   161,     0,   162,
+     163,   164,   165,   166,     0,   167,   168,   169,   170,   171,
+       0,     0,     0,     0,     0,   172,     0,   173,     0,     0,
+     174,     0,   135,   136,   137,   138,   139,   140,   141,   142,
+     143,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   154,     0,   155,   156,     0,     0,   157,   158,   159,
+       0,     0,     0,     0,     0,   134,     0,     0,     0,     0,
+     162,   163,   164,   165,   166,     0,   167,   168,   169,   170,
+     171,     0,     0,     0,     0,     0,   172,     0,   173,     0,
+       0,   174,   135,   136,   137,   138,   139,   140,   141,   142,
+     143,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   155,   156,     0,     0,   157,   158,   159,
+       0,     0,     0,     0,     0,   134,     0,     0,     0,     0,
+     162,   163,   164,   165,   166,     0,   167,   168,   169,   170,
+     171,     0,     0,     0,     0,     0,   172,     0,   173,     0,
+       0,   174,   135,   136,   137,   138,   139,   140,   141,   142,
+     143,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   155,   156,     0,     0,   157,   158,   159,
+       0,     0,     0,     0,     0,   134,     0,     0,     0,     0,
+       0,   163,   164,   165,   166,     0,   167,   168,   169,   170,
+     171,     0,     0,     0,     0,     0,   172,     0,   173,     0,
+       0,   174,   135,   136,   137,   138,   139,   140,   141,   142,
+     143,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   155,   156,     0,     0,   157,   158,   159,
+       0,     0,     0,     0,     0,   134,     0,     0,     0,     0,
+       0,     0,  -209,   165,   166,     0,   167,   168,   169,   170,
+     171,     0,     0,     0,     0,     0,   172,     0,   173,     0,
+       0,   174,   135,   136,   137,  -209,  -209,  -209,  -209,   142,
+     143,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   155,   156,     0,     0,   157,   158,   159,
        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,   165,   166,     0,   167,   168,   169,   170,
+     171,     0,     0,     0,     0,     0,   172,     0,   173,     0,
+       0,   174
 };
 
 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,
+       0,     0,     0,     0,     0,     0,    18,     0,    83,    53,
+      22,    48,   200,   100,   299,   287,   204,   321,     3,   323,
+       3,    49,    45,    35,    67,    37,    38,     3,    40,    41,
+      42,    97,    44,    45,   120,    97,   219,    97,    97,   125,
+     303,    97,    18,     3,    97,   228,     3,   365,    48,    48,
+      48,    48,    48,    48,    33,    48,    99,     3,    18,    43,
+       3,    18,   347,   367,   130,    87,    88,   330,   130,     3,
+     130,   130,    18,   442,   130,    18,    26,   130,   447,   448,
+      30,    31,    61,    86,    18,   172,    98,   350,   100,    35,
+      13,   120,   120,    43,    26,    45,   465,     3,   120,    31,
+     122,   364,    25,   125,    34,    90,   410,    90,   393,    27,
+     479,    95,    99,    45,    32,   484,   103,   124,   125,   120,
+      50,   133,   134,   135,   136,   137,   138,   139,   140,   141,
+     142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152,   153,   154,     3,     4,   157,   158,   159,   160,   161,
+     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+     172,   173,   185,   346,   124,   483,   429,   113,   431,   122,
+     113,   120,   125,   185,   446,    96,    97,    19,    20,    21,
+     120,    23,   124,    25,   120,   197,    87,    88,     0,   212,
+     213,   120,   215,   177,    97,    37,   180,   181,   198,   198,
+     212,   213,   277,   215,    46,    47,    48,     3,   120,   296,
+     125,   112,   113,   114,     3,   403,    19,    20,    21,   120,
+      23,   122,    25,   123,   125,   209,    97,   103,   303,    39,
+     129,    97,    67,   308,    37,     3,     3,   221,   222,    96,
+      67,     3,    45,    46,    47,    48,     3,     3,     3,   432,
+     124,    17,     3,     3,    13,   330,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    96,   449,   120,    17,   269,
+     269,   269,   269,   269,   269,   350,   269,    87,    88,   130,
+     103,    91,    92,    93,   296,     3,    97,   287,   287,   364,
+      53,   130,   329,    96,   294,   294,   106,   107,   108,    53,
+     110,   111,   112,   113,   114,   488,     3,   120,     3,    86,
+     120,   129,   122,     3,   326,   125,   130,    97,   125,   363,
+       4,   129,   103,     7,     8,     9,   129,    11,   351,   329,
+     329,   329,   329,   329,   329,    99,   329,   360,   120,   351,
+      16,   124,     3,   129,    64,   124,    99,    99,   360,   125,
+     334,   124,   130,    97,   429,   124,   431,     3,     4,     5,
+      44,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      54,    55,   120,    19,    20,    21,    22,    23,    24,    25,
+      26,   124,    28,    29,   124,    31,   103,     3,   130,    35,
+      36,    37,    38,   130,    40,    41,    42,   129,    44,    45,
+      46,    47,    48,   415,     3,    51,    52,    26,    54,    55,
+     129,   411,   124,   129,   129,   129,    62,    63,     3,    65,
+     130,   421,   421,   124,   120,   129,   269,   130,    87,    88,
+     129,   294,   421,   433,   433,   433,   433,   325,   185,   439,
+      53,    87,    88,   120,   316,   418,   446,   446,   418,    64,
+      96,   110,   111,   112,   113,   114,   391,   457,   457,   457,
+     457,   120,   399,   122,   110,   457,   125,   439,   399,   115,
+     116,   462,    25,   367,   120,   343,   122,    -1,   124,    -1,
+       3,     4,     5,   129,     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,    19,
+      20,    21,    -1,    23,    -1,    25,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    87,    88,    -1,    37,    -1,    -1,
+      -1,    -1,    -1,    96,    -1,    45,    46,    47,    48,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,
+      -1,    -1,   115,   116,    -1,    -1,    -1,   120,    -1,   122,
+      -1,   124,    -1,     3,     4,     5,   129,     7,     8,     9,
+      10,    11,    12,    13,    14,    15,    -1,    -1,    18,    19,
+      20,    21,    -1,    23,    24,    25,    96,    -1,    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,   129,
+      -1,    -1,    62,    63,    -1,    73,    74,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    87,
+      88,    -1,    -1,    91,    92,    93,    -1,    87,    88,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    96,    -1,    -1,   107,
+     108,    -1,   110,   111,   112,   113,   114,    -1,    -1,    -1,
+     110,    -1,   120,    -1,   122,   115,   116,   125,    -1,    -1,
+     120,    -1,   122,    -1,   124,    -1,     3,     4,     5,   129,
        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,
+      -1,    -1,    19,    20,    21,    -1,    23,    24,    25,    -1,
+      -1,    28,    -1,    -1,    39,    -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,
+      -1,    66,    67,    68,    -1,    62,    63,    -1,    73,    74,
       -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,
+      -1,    -1,    87,    88,    -1,    -1,    91,    92,    93,    -1,
+      87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    96,
+      -1,    -1,   107,   108,    -1,   110,   111,   112,   113,   114,
+      -1,    -1,    -1,   110,    -1,   120,    -1,   122,   115,   116,
+     125,    -1,    -1,   120,    -1,   122,    -1,   124,    -1,     3,
+       4,     5,   129,     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,    -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,
+     124,    -1,     3,     4,     5,   129,     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,
+      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,    65,    -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,
       -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,
+      -1,   122,    -1,   124,    -1,     3,     4,     5,   129,     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,    -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,   124,    -1,     3,     4,
+       5,   129,     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,
+      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,    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,
+      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,    -1,    -1,    -1,    -1,
       -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,
+      -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,     0,   124,
+      -1,     3,     4,     5,   129,     7,     8,     9,    10,    11,
+      12,    13,    14,    15,    -1,    -1,    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,    -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,    -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,     0,   124,    -1,     3,     4,     5,    -1,     7,     8,
+       9,    10,    11,    12,    13,    14,    15,    -1,    -1,    18,
       19,    20,    21,    -1,    23,    24,    25,    -1,    -1,    28,
-      -1,    39,    -1,    -1,    -1,    -1,    35,    -1,    37,    38,
+      -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,    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,
+      -1,    -1,    -1,    62,    63,    -1,    -1,    -1,    -1,    -1,
+      -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,   124,     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,    -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,   124,     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,    -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,   124,
        3,     4,     5,    -1,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    -1,    -1,    -1,    19,    20,    21,    -1,
+      13,    14,    15,    -1,    -1,    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,    -1,    -1,    51,    52,
@@ -2605,131 +2896,113 @@ static const yytype_int16 yycheck[] =
       -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,    -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,    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,    -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,
+      -1,   124,     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,
+      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,    65,    -1,    -1,    -1,    -1,    -1,
-      -1,     3,     4,     5,    -1,     7,     8,     9,    10,    11,
+      -1,    62,    63,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -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,    96,    -1,     3,     4,     5,
+      -1,     7,     8,     9,    10,    11,    -1,    -1,    -1,   110,
+      -1,    -1,    -1,    -1,   115,   116,    -1,    -1,    24,   120,
+      26,   122,    28,   124,    -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,    -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,
-      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,
-      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,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       3,     4,     5,    -1,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,    -1,   110,    -1,    -1,    -1,    -1,   115,
+     116,    24,    -1,    26,   120,    28,   122,    -1,   124,    -1,
+      -1,    -1,    35,    -1,    -1,    -1,    -1,    -1,    -1,    42,
+      -1,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,
+      -1,    54,    55,    -1,    -1,    -1,    -1,    -1,    -1,    62,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,     3,     4,     5,    -1,     7,     8,     9,
+      10,    11,    -1,    -1,    87,    88,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    24,    -1,    26,    -1,    28,    -1,
+      39,    -1,    -1,    -1,    -1,    -1,    -1,   110,    -1,    -1,
+      -1,    -1,   115,   116,    44,    -1,    -1,   120,    -1,   122,
+      -1,   124,    52,    -1,    54,    55,    -1,    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,    87,    88,    -1,
+      99,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
+      39,   110,   111,   112,   113,   114,    -1,    -1,    -1,    -1,
+      -1,   120,    -1,   122,    -1,    -1,   125,    -1,    -1,    -1,
+     120,   130,   122,    -1,   124,    -1,    -1,    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,    -1,   104,   105,   106,   107,   108,
+      39,   110,   111,   112,   113,   114,    -1,    -1,    -1,    -1,
+      -1,   120,    -1,   122,    -1,    -1,   125,    -1,    -1,    -1,
+      -1,   130,    -1,    -1,    -1,    -1,    -1,    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,
+      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,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    85,    -1,    87,
+      -1,   120,    -1,   122,    -1,    -1,   125,    -1,    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,    -1,    39,    -1,    -1,    -1,   104,   105,   106,   107,
+      -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,    -1,    -1,
+      -1,    -1,   120,    -1,   122,   123,    -1,   125,    -1,    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,    -1,    39,    -1,    -1,    -1,   104,   105,   106,
+      -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,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   120,    -1,   122,    -1,    -1,   125,    -1,
+      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,    -1,    39,    -1,    -1,    -1,    -1,   105,
+      -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,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    87,    88,    -1,    -1,    91,    92,    93,    -1,
+      -1,    -1,    -1,    -1,   120,    -1,   122,    -1,    -1,   125,
+      -1,    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,   122,    -1,    -1,
+     125,    -1,    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,    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,
+     104,   105,   106,   107,   108,    -1,   110,   111,   112,   113,
+     114,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,    -1,
+      -1,   125,    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,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,
+     104,   105,   106,   107,   108,    -1,   110,   111,   112,   113,
+     114,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,    -1,
+      -1,   125,    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,    39,    -1,    -1,    -1,    -1,
+      -1,   105,   106,   107,   108,    -1,   110,   111,   112,   113,
+     114,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,    -1,
+      -1,   125,    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,    39,    -1,    -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
+     114,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,    -1,
+      -1,   125,    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,   122,    -1,
+      -1,   125
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -2740,50 +3013,52 @@ static const yytype_uint8 yystos[] =
       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
+     110,   115,   116,   120,   122,   124,   132,   133,   134,   135,
+     141,   144,   150,   154,   155,   156,   157,   159,   167,   175,
+     178,   181,   184,   185,   186,   187,   191,   193,   202,   209,
+     212,   224,   225,   226,   229,   230,   231,   232,   235,    86,
+      49,   120,   120,   160,   120,     3,    18,   124,   179,   180,
+       3,   231,     3,   211,   231,   120,   180,   215,   120,   124,
+     120,   125,   231,   120,   231,   231,   231,   231,   231,   229,
+     221,   222,   228,   231,   228,   233,   234,     0,   135,     3,
+      31,    45,   146,   152,   153,   230,    26,    30,    31,    43,
+      45,   201,   187,    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,   122,   125,     3,   120,   158,    22,    29,
+      36,    41,    45,    65,    96,   124,   141,   142,   143,   146,
+     161,   162,   177,   185,   227,   236,   237,   168,   183,   124,
+     125,   223,   120,   229,   125,   231,   176,   221,     3,   151,
+     130,   123,    97,   103,   129,    97,     3,   147,   148,     3,
+     147,    96,    67,    34,    50,   208,     3,     3,     3,   231,
+     231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
+     231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
+     231,   231,   231,   231,   231,   231,   231,   231,   231,   231,
+     231,   231,   231,   231,   231,   231,   221,   231,     3,   124,
+     229,    17,     3,   229,   229,     3,   129,   140,   142,   231,
+      96,    13,    17,   231,     3,    96,   136,   137,   138,   144,
+     191,   193,   202,   209,   182,   179,   120,   220,     3,    90,
+     205,   206,   207,   130,     3,   113,   130,   139,   140,   130,
+     229,   228,   228,   228,   103,   219,    97,   219,   229,   229,
+       3,    53,   188,    53,   189,   219,   103,   130,   123,   134,
+     130,     3,   129,   142,   120,     3,   130,    86,   129,   138,
+     136,   221,    99,   103,   203,   207,   130,    97,   143,   129,
+     130,   103,     3,    35,   113,   180,   214,   215,   216,   218,
+      99,   145,   148,    96,   130,   120,   216,    16,   190,   216,
+     217,   124,   145,   231,   129,   143,   229,    99,   124,     3,
+     129,   130,     4,     7,     8,     9,    11,    44,    54,    55,
+     204,   218,   219,    90,   207,    27,    32,   169,   171,   173,
+     174,   143,   228,   125,   228,   230,   143,   205,   217,   124,
+      97,   194,   130,     3,     4,    33,    61,   163,   164,   165,
+     166,   124,   203,   124,   207,   124,   120,   169,   171,    64,
+     149,   130,   130,   192,   216,    45,    96,   185,   198,   199,
+     200,   231,   103,   129,   165,   166,   137,   213,   172,     3,
+     143,   143,   219,    96,   141,   185,   195,   196,   197,   202,
+     209,     3,    26,   129,   200,   103,   139,   129,   139,   139,
+     219,   124,   129,   197,   208,   139,   129,   129,   130,   210,
+       3,   170,   139,   120,   124,   129,   205,   139,   130,   129,
+     219
 };
 
 #define yyerrok                (yyerrstatus = 0)
@@ -3594,140 +3869,215 @@ yyreduce:
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-        case 24:
+        
+    case 26:
+    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 1668 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 25:
 
-/* Line 1455 of yacc.c  */
-#line 1510 "parser.y"
-    {(yyval.code)=code_new();;}
+  
+    case 27:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1669 "parser.y"
+    {(yyval.code)=code_new();}
+    }
     break;
 
-  case 26:
 
-/* Line 1455 of yacc.c  */
-#line 1512 "parser.y"
-    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));;}
+  
+    case 28:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1671 "parser.y"
+    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
+    }
     break;
 
-  case 27:
 
-/* Line 1455 of yacc.c  */
-#line 1513 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+  
+    case 29:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1672 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 38:
 
-/* Line 1455 of yacc.c  */
-#line 1528 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 40:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1687 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 45:
 
-/* Line 1455 of yacc.c  */
-#line 1536 "parser.y"
-    {/*TODO*/(yyval.code)=0;;}
+  
+    case 47:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1695 "parser.y"
+    {/*TODO*/(yyval.code)=0;}
+    }
     break;
 
-  case 46:
 
-/* Line 1455 of yacc.c  */
-#line 1537 "parser.y"
-    {/*TODO*/(yyval.code)=0;;}
+  
+    case 48:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1696 "parser.y"
+    {/*TODO*/(yyval.code)=0;}
+    }
     break;
 
-  case 47:
 
-/* Line 1455 of yacc.c  */
-#line 1539 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (3)].code);;}
+  
+    case 49:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1698 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (3)].code);}
+    }
     break;
 
-  case 48:
 
-/* Line 1455 of yacc.c  */
-#line 1540 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 50:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1699 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 49:
 
-/* Line 1455 of yacc.c  */
-#line 1541 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (2)].code);;}
+  
+    case 51:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1700 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (2)].code);}
+    }
     break;
 
-  case 50:
 
-/* Line 1455 of yacc.c  */
-#line 1542 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+  
+    case 52:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1701 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 51:
 
-/* Line 1455 of yacc.c  */
-#line 1546 "parser.y"
+  
+    case 53:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1705 "parser.y"
     {
-    if((yyvsp[(1) - (1)].code)) as3_warning("code ignored");
-;}
+    code_t**cc = &global->init->method->body->code;
+    *cc = code_append(*cc, (yyvsp[(1) - (1)].code));
+}
+    }
     break;
 
-  case 52:
 
-/* Line 1455 of yacc.c  */
-#line 1552 "parser.y"
-    {(yyval.value)=(yyvsp[(2) - (2)].value);;}
+  
+    case 54:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1712 "parser.y"
+    {(yyval.value)=(yyvsp[(2) - (2)].value);}
+    }
     break;
 
-  case 53:
 
-/* Line 1455 of yacc.c  */
-#line 1553 "parser.y"
+  
+    case 55:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1713 "parser.y"
     {(yyval.value).c=abc_pushundefined(0);
                                   (yyval.value).t=TYPE_ANY;
-                                 ;}
+                                 }
+    }
     break;
 
-  case 54:
 
-/* Line 1455 of yacc.c  */
-#line 1557 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);;}
+  
+    case 56:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1717 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+    }
     break;
 
-  case 55:
 
-/* Line 1455 of yacc.c  */
-#line 1558 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);;}
+  
+    case 57:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1718 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+    }
     break;
 
-  case 56:
 
-/* Line 1455 of yacc.c  */
-#line 1560 "parser.y"
-    {(yyval.code) = (yyvsp[(1) - (1)].code);;}
+  
+    case 58:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1720 "parser.y"
+    {(yyval.code) = (yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 57:
 
-/* Line 1455 of yacc.c  */
-#line 1561 "parser.y"
-    {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));;}
+  
+    case 59:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1721 "parser.y"
+    {(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
+    }
     break;
 
-  case 58:
 
-/* Line 1455 of yacc.c  */
-#line 1564 "parser.y"
+  
+    case 60:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1724 "parser.y"
     {
     if(variable_exists((yyvsp[(1) - (3)].id)))
         syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));
@@ -3745,6 +4095,7 @@ yyreduce:
             (yyval.code) = converttype((yyval.code), (yyvsp[(3) - (3)].value).t, (yyvsp[(2) - (3)].classinfo));
             (yyval.code) = abc_setlocal((yyval.code), index);
         } else {
+            code_free((yyvsp[(3) - (3)].value).c);
             (yyval.code) = defaultvalue(0, (yyvsp[(2) - (3)].classinfo));
             (yyval.code) = abc_setlocal((yyval.code), index);
         }
@@ -3754,6 +4105,7 @@ yyreduce:
             (yyval.code) = abc_coerce_a((yyval.code));
             (yyval.code) = abc_setlocal((yyval.code), index);
         } else {
+            code_free((yyvsp[(3) - (3)].value).c);
             (yyval.code) = code_new();
         }
     }
@@ -3764,34 +4116,50 @@ yyreduce:
         state->method->initcode = abc_setlocal(state->method->initcode, index);
     }*/
     //printf("variable %s -> %d (%s)\n", $2->text, index, $4.t?$4.t->name:"");
-;}
+}
+    }
     break;
 
-  case 59:
 
-/* Line 1455 of yacc.c  */
-#line 1604 "parser.y"
-    {(yyval.code) = code_new();;}
+  
+    case 61:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1766 "parser.y"
+    {(yyval.code) = code_new();}
+    }
     break;
 
-  case 60:
 
-/* Line 1455 of yacc.c  */
-#line 1605 "parser.y"
-    {(yyval.code)=(yyvsp[(2) - (2)].code);;}
+  
+    case 62:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1767 "parser.y"
+    {(yyval.code)=(yyvsp[(2) - (2)].code);}
+    }
     break;
 
-  case 61:
 
-/* Line 1455 of yacc.c  */
-#line 1608 "parser.y"
-    {new_state();;}
+  
+    case 63:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1770 "parser.y"
+    {new_state();}
+    }
     break;
 
-  case 62:
 
-/* Line 1455 of yacc.c  */
-#line 1608 "parser.y"
+  
+    case 64:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1770 "parser.y"
     {
      
     (yyval.code) = code_new();
@@ -3809,52 +4177,76 @@ yyreduce:
     }
     (yyval.code) = var_block((yyval.code));
     old_state();
-;}
+}
+    }
     break;
 
-  case 63:
 
-/* Line 1455 of yacc.c  */
-#line 1627 "parser.y"
-    {(yyval.code)=code_new();;}
+  
+    case 65:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1789 "parser.y"
+    {(yyval.code)=code_new();}
+    }
     break;
 
-  case 66:
 
-/* Line 1455 of yacc.c  */
-#line 1632 "parser.y"
+  
+    case 68:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1794 "parser.y"
     {
     (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1);
-;}
+}
+    }
     break;
 
-  case 67:
 
-/* Line 1455 of yacc.c  */
-#line 1635 "parser.y"
+  
+    case 69:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1797 "parser.y"
     {
     (yyval.id)=(yyvsp[(1) - (1)].id);
-;}
+}
+    }
     break;
 
-  case 68:
 
-/* Line 1455 of yacc.c  */
-#line 1639 "parser.y"
-    {new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;;}
+  
+    case 70:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1801 "parser.y"
+    {new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}
+    }
     break;
 
-  case 69:
 
-/* Line 1455 of yacc.c  */
-#line 1640 "parser.y"
-    {new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;;}
+  
+    case 71:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1802 "parser.y"
+    {new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}
+    }
     break;
 
-  case 70:
 
-/* Line 1455 of yacc.c  */
-#line 1642 "parser.y"
+  
+    case 72:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1804 "parser.y"
     {
     if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");
     (yyval.code) = code_new();
@@ -3873,13 +4265,17 @@ yyreduce:
 
     (yyval.code) = var_block((yyval.code));
     old_state();
-;}
+}
+    }
     break;
 
-  case 71:
 
-/* Line 1455 of yacc.c  */
-#line 1662 "parser.y"
+  
+    case 73:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1824 "parser.y"
     {
     variable_t*var = find_variable((yyvsp[(2) - (6)].id));
     char*tmp1name = concat2((yyvsp[(2) - (6)].id), "__tmp1__");
@@ -3921,20 +4317,28 @@ yyreduce:
 
     free(tmp1name);
     free(tmp2name);
-;}
+}
+    }
     break;
 
-  case 72:
 
-/* Line 1455 of yacc.c  */
-#line 1705 "parser.y"
-    {new_state();;}
+  
+    case 74:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1867 "parser.y"
+    {new_state();}
+    }
     break;
 
-  case 73:
 
-/* Line 1455 of yacc.c  */
-#line 1705 "parser.y"
+  
+    case 75:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1867 "parser.y"
     {
 
     (yyval.code) = code_new();
@@ -3952,20 +4356,28 @@ yyreduce:
 
     (yyval.code) = var_block((yyval.code));
     old_state();
-;}
+}
+    }
     break;
 
-  case 74:
 
-/* Line 1455 of yacc.c  */
-#line 1724 "parser.y"
-    {new_state();;}
+  
+    case 76:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1886 "parser.y"
+    {new_state();}
+    }
     break;
 
-  case 75:
 
-/* Line 1455 of yacc.c  */
-#line 1724 "parser.y"
+  
+    case 77:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1886 "parser.y"
     {
     (yyval.code) = code_new();
     code_t*loopstart = (yyval.code) = abc_label((yyval.code));
@@ -3979,91 +4391,135 @@ yyreduce:
     
     (yyval.code) = var_block((yyval.code));
     old_state();
-;}
+}
+    }
     break;
 
-  case 76:
 
-/* Line 1455 of yacc.c  */
-#line 1739 "parser.y"
+  
+    case 78:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1901 "parser.y"
     {
     (yyval.code) = abc___break__(0, "");
-;}
+}
+    }
     break;
 
-  case 77:
 
-/* Line 1455 of yacc.c  */
-#line 1742 "parser.y"
+  
+    case 79:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1904 "parser.y"
     {
     (yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));
-;}
+}
+    }
     break;
 
-  case 78:
 
-/* Line 1455 of yacc.c  */
-#line 1745 "parser.y"
+  
+    case 80:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1907 "parser.y"
     {
     (yyval.code) = abc___continue__(0, "");
-;}
+}
+    }
     break;
 
-  case 79:
 
-/* Line 1455 of yacc.c  */
-#line 1748 "parser.y"
+  
+    case 81:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1910 "parser.y"
     {
     (yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));
-;}
+}
+    }
     break;
 
-  case 80:
 
-/* Line 1455 of yacc.c  */
-#line 1752 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 82:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1914 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 81:
 
-/* Line 1455 of yacc.c  */
-#line 1753 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+  
+    case 83:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1915 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 82:
 
-/* Line 1455 of yacc.c  */
-#line 1754 "parser.y"
-    {(yyval.code)=(yyvsp[(1) - (1)].code);;}
+  
+    case 84:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1916 "parser.y"
+    {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 83:
 
-/* Line 1455 of yacc.c  */
-#line 1755 "parser.y"
-    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));;}
+  
+    case 85:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1917 "parser.y"
+    {(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}
+    }
     break;
 
-  case 84:
 
-/* Line 1455 of yacc.c  */
-#line 1756 "parser.y"
+  
+    case 86:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1918 "parser.y"
     {(yyval.code)=(yyvsp[(1) - (1)].code);}
+    }
     break;
 
-  case 85:
 
-/* Line 1455 of yacc.c  */
-#line 1757 "parser.y"
-    {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));;}
+  
+    case 87:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1919 "parser.y"
+    {(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}
+    }
     break;
 
-  case 86:
 
-/* Line 1455 of yacc.c  */
-#line 1759 "parser.y"
+  
+    case 88:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1921 "parser.y"
     {
     (yyval.code) = abc_dup(0);
     (yyval.code) = code_append((yyval.code), (yyvsp[(2) - (4)].value).c);
@@ -4074,29 +4530,41 @@ yyreduce:
     }
     code_t*e = (yyval.code) = abc_nop((yyval.code));
     j->branch = e;
-;}
+}
+    }
     break;
 
-  case 87:
 
-/* Line 1455 of yacc.c  */
-#line 1770 "parser.y"
+  
+    case 89:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1932 "parser.y"
     {
     (yyval.code) = (yyvsp[(3) - (3)].code);
-;}
+}
+    }
     break;
 
-  case 88:
 
-/* Line 1455 of yacc.c  */
-#line 1773 "parser.y"
-    {new_state();;}
+  
+    case 90:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1935 "parser.y"
+    {new_state();}
+    }
     break;
 
-  case 89:
 
-/* Line 1455 of yacc.c  */
-#line 1773 "parser.y"
+  
+    case 91:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1935 "parser.y"
     {
     (yyval.code)=(yyvsp[(4) - (8)].value).c;
     (yyval.code) = code_append((yyval.code), (yyvsp[(7) - (8)].code));
@@ -4122,20 +4590,28 @@ yyreduce:
    
     (yyval.code) = var_block((yyval.code));
     old_state();
-;}
+}
+    }
     break;
 
-  case 90:
 
-/* Line 1455 of yacc.c  */
-#line 1802 "parser.y"
-    {new_state();state->exception_name=(yyvsp[(3) - (5)].id);new_variable((yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0);;}
+  
+    case 92:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1964 "parser.y"
+    {new_state();state->exception_name=(yyvsp[(3) - (5)].id);new_variable((yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0);}
+    }
     break;
 
-  case 91:
 
-/* Line 1455 of yacc.c  */
-#line 1803 "parser.y"
+  
+    case 93:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1965 "parser.y"
     {
     namespace_t name_ns = {ACCESS_PACKAGE, ""};
     multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};
@@ -4154,20 +4630,28 @@ yyreduce:
 
     c = var_block(c);
     old_state();
-;}
-    break;
+}
+    }
+    break;
+
 
-  case 92:
+  
+    case 94:
+    if(as3_pass==2) {
 
-/* Line 1455 of yacc.c  */
-#line 1822 "parser.y"
-    {new_state();state->exception_name=0;;}
+/* Line 1464 of skeleton.m4  */
+#line 1984 "parser.y"
+    {new_state();state->exception_name=0;}
+    }
     break;
 
-  case 93:
 
-/* Line 1455 of yacc.c  */
-#line 1822 "parser.y"
+  
+    case 95:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 1984 "parser.y"
     {
     (yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code));
     if(!(yyvsp[(4) - (5)].code)) {
@@ -4183,34 +4667,50 @@ yyreduce:
         old_state();
         (yyval.exception) = e;
     }
-;}
+}
+    }
     break;
 
-  case 94:
 
-/* Line 1455 of yacc.c  */
-#line 1839 "parser.y"
-    {(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));;}
+  
+    case 96:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2001 "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 1840 "parser.y"
-    {(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));;}
+  
+    case 97:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2002 "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 1841 "parser.y"
+  
+    case 98:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2003 "parser.y"
     {(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}
+    }
     break;
 
-  case 97:
 
-/* Line 1455 of yacc.c  */
-#line 1842 "parser.y"
+  
+    case 99:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2004 "parser.y"
     {
     (yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);
     (yyval.catch_list).finally = 0;
@@ -4218,13 +4718,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 1850 "parser.y"
+  
+    case 100:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2012 "parser.y"
     {
     (yyval.catch_list).l=list_new();
     (yyval.catch_list).finally = 0;
@@ -4232,20 +4736,28 @@ 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 1859 "parser.y"
-    {new_state();;}
+  
+    case 101:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2021 "parser.y"
+    {new_state();}
+    }
     break;
 
-  case 100:
 
-/* Line 1455 of yacc.c  */
-#line 1859 "parser.y"
+  
+    case 102:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2021 "parser.y"
     {
     code_t*out = abc_nop(0);
 
@@ -4287,23 +4799,31 @@ yyreduce:
    
     (yyval.code) = var_block((yyval.code));
     old_state();
-;}
+}
+    }
     break;
 
-  case 101:
 
-/* Line 1455 of yacc.c  */
-#line 1904 "parser.y"
+  
+    case 103:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2066 "parser.y"
     {
     (yyval.code)=(yyvsp[(2) - (2)].value).c;
     (yyval.code)=abc_throw((yyval.code));
-;}
+}
+    }
     break;
 
-  case 102:
 
-/* Line 1455 of yacc.c  */
-#line 1908 "parser.y"
+  
+    case 104:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2070 "parser.y"
     {
     if(!state->exception_name)
         syntaxerror("re-throw only possible within a catch block");
@@ -4311,296 +4831,458 @@ yyreduce:
     (yyval.code)=code_new();
     (yyval.code)=abc_getlocal((yyval.code), v->index);
     (yyval.code)=abc_throw((yyval.code));
-;}
+}
+    }
     break;
 
-  case 103:
 
-/* Line 1455 of yacc.c  */
-#line 1919 "parser.y"
+  
+    case 105:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2081 "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));
      (yyval.code) = abc_popscope((yyval.code));
-;}
+}
+    }
     break;
 
-  case 105:
 
-/* Line 1455 of yacc.c  */
-#line 1929 "parser.y"
-    {(yyval.id)="package";;}
+  
+    case 107:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2091 "parser.y"
+    {PASS12 (yyval.id)="package";}
+    }
     break;
 
-  case 106:
 
-/* Line 1455 of yacc.c  */
-#line 1931 "parser.y"
-    {(yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;;}
+  
+    case 108:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2093 "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 107:
 
-/* Line 1455 of yacc.c  */
-#line 1932 "parser.y"
-    {(yyval.id)=strdup((yyvsp[(1) - (1)].id));;}
+  
+    case 109:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2094 "parser.y"
+    {PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}
+    }
     break;
 
-  case 108:
 
-/* Line 1455 of yacc.c  */
-#line 1934 "parser.y"
-    {startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;;}
+  
+    case 110:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2096 "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 1934 "parser.y"
-    {endpackage();(yyval.code)=0;;}
+  
+    case 111:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2097 "parser.y"
+    {PASS12 endpackage();(yyval.code)=0;}
+    }
     break;
 
-  case 110:
 
-/* Line 1455 of yacc.c  */
-#line 1935 "parser.y"
-    {startpackage("");}
+  
+    case 112:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2098 "parser.y"
+    {PASS12 startpackage("");}
+    }
     break;
 
-  case 111:
 
-/* Line 1455 of yacc.c  */
-#line 1935 "parser.y"
-    {endpackage();(yyval.code)=0;;}
+  
+    case 113:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2099 "parser.y"
+    {PASS12 endpackage();(yyval.code)=0;}
+    }
     break;
 
-  case 112:
 
-/* Line 1455 of yacc.c  */
-#line 1937 "parser.y"
+  
+    case 114:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2101 "parser.y"
     {
+       PASS1 
+       if(!registry_findclass((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name)) {
+           as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);
+       }
+
+       PASS2
        classinfo_t*c = (yyvsp[(2) - (2)].classinfo);
        if(!c) 
             syntaxerror("Couldn't import class\n");
        state_has_imports();
        dict_put(state->imports, c->name, c);
        (yyval.code)=0;
-;}
+}
+    }
     break;
 
-  case 113:
 
-/* Line 1455 of yacc.c  */
-#line 1945 "parser.y"
+  
+    case 115:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2115 "parser.y"
     {
+       PASS1 
+       if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6)) {
+           as3_schedule_package((yyvsp[(2) - (4)].id));
+       }
+
+       PASS2
        NEW(import_t,i);
        i->package = (yyvsp[(2) - (4)].id);
        state_has_imports();
        list_append(state->wildcard_imports, i);
        (yyval.code)=0;
-;}
+}
+    }
     break;
 
-  case 114:
 
-/* Line 1455 of yacc.c  */
-#line 1955 "parser.y"
-    {(yyval.flags)=0;;}
+  
+    case 116:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2131 "parser.y"
+    {PASS12 (yyval.flags)=0;}
+    }
     break;
 
-  case 115:
 
-/* Line 1455 of yacc.c  */
-#line 1956 "parser.y"
-    {(yyval.flags)=(yyvsp[(1) - (1)].flags);}
+  
+    case 117:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2132 "parser.y"
+    {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}
+    }
     break;
 
-  case 116:
 
-/* Line 1455 of yacc.c  */
-#line 1957 "parser.y"
-    {(yyval.flags)=(yyvsp[(1) - (1)].token);;}
+  
+    case 118:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2133 "parser.y"
+    {PASS12 (yyval.flags)=(yyvsp[(1) - (1)].token);}
+    }
     break;
 
-  case 117:
 
-/* Line 1455 of yacc.c  */
-#line 1958 "parser.y"
-    {(yyval.flags)=(yyvsp[(1) - (2)].flags)|(yyvsp[(2) - (2)].token);;}
+  
+    case 119:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2134 "parser.y"
+    {PASS12 (yyval.flags)=(yyvsp[(1) - (2)].flags)|(yyvsp[(2) - (2)].token);}
+    }
     break;
 
-  case 118:
 
-/* Line 1455 of yacc.c  */
-#line 1960 "parser.y"
-    {(yyval.token)=FLAG_PUBLIC;;}
+  
+    case 120:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2136 "parser.y"
+    {PASS12 (yyval.token)=FLAG_PUBLIC;}
+    }
     break;
 
-  case 119:
 
-/* Line 1455 of yacc.c  */
-#line 1961 "parser.y"
-    {(yyval.token)=FLAG_PRIVATE;;}
+  
+    case 121:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2137 "parser.y"
+    {PASS12 (yyval.token)=FLAG_PRIVATE;}
+    }
     break;
 
-  case 120:
 
-/* Line 1455 of yacc.c  */
-#line 1962 "parser.y"
-    {(yyval.token)=FLAG_PROTECTED;;}
+  
+    case 122:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2138 "parser.y"
+    {PASS12 (yyval.token)=FLAG_PROTECTED;}
+    }
     break;
 
-  case 121:
 
-/* Line 1455 of yacc.c  */
-#line 1963 "parser.y"
-    {(yyval.token)=FLAG_STATIC;;}
+  
+    case 123:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2139 "parser.y"
+    {PASS12 (yyval.token)=FLAG_STATIC;}
+    }
     break;
 
-  case 122:
 
-/* Line 1455 of yacc.c  */
-#line 1964 "parser.y"
-    {(yyval.token)=FLAG_DYNAMIC;;}
+  
+    case 124:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2140 "parser.y"
+    {PASS12 (yyval.token)=FLAG_DYNAMIC;}
+    }
     break;
 
-  case 123:
 
-/* Line 1455 of yacc.c  */
-#line 1965 "parser.y"
-    {(yyval.token)=FLAG_FINAL;;}
+  
+    case 125:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2141 "parser.y"
+    {PASS12 (yyval.token)=FLAG_FINAL;}
+    }
     break;
 
-  case 124:
 
-/* Line 1455 of yacc.c  */
-#line 1966 "parser.y"
-    {(yyval.token)=FLAG_OVERRIDE;;}
+  
+    case 126:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2142 "parser.y"
+    {PASS12 (yyval.token)=FLAG_OVERRIDE;}
+    }
     break;
 
-  case 125:
 
-/* Line 1455 of yacc.c  */
-#line 1967 "parser.y"
-    {(yyval.token)=FLAG_NATIVE;;}
+  
+    case 127:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2143 "parser.y"
+    {PASS12 (yyval.token)=FLAG_NATIVE;}
+    }
     break;
 
-  case 126:
 
-/* Line 1455 of yacc.c  */
-#line 1968 "parser.y"
-    {(yyval.token)=FLAG_PACKAGEINTERNAL;;}
+  
+    case 128:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2144 "parser.y"
+    {PASS12 (yyval.token)=FLAG_PACKAGEINTERNAL;}
+    }
     break;
 
-  case 127:
 
-/* Line 1455 of yacc.c  */
-#line 1970 "parser.y"
-    {(yyval.classinfo)=registry_getobjectclass();;}
+  
+    case 129:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2146 "parser.y"
+    {(yyval.classinfo)=registry_getobjectclass();}
+    }
     break;
 
-  case 128:
 
-/* Line 1455 of yacc.c  */
-#line 1971 "parser.y"
-    {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);;}
+  
+    case 130:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2147 "parser.y"
+    {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
+    }
     break;
 
-  case 129:
 
-/* Line 1455 of yacc.c  */
-#line 1973 "parser.y"
-    {(yyval.classinfo_list)=list_new();;}
+  
+    case 131:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2149 "parser.y"
+    {PASS12 (yyval.classinfo_list)=list_new();}
+    }
     break;
 
-  case 130:
 
-/* Line 1455 of yacc.c  */
-#line 1974 "parser.y"
-    {(yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);;}
+  
+    case 132:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2150 "parser.y"
+    {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
+    }
     break;
 
-  case 131:
 
-/* Line 1455 of yacc.c  */
-#line 1976 "parser.y"
-    {(yyval.classinfo_list)=list_new();;}
+  
+    case 133:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2152 "parser.y"
+    {PASS12 (yyval.classinfo_list)=list_new();}
+    }
     break;
 
-  case 132:
 
-/* Line 1455 of yacc.c  */
-#line 1977 "parser.y"
-    {(yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);;}
+  
+    case 134:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2153 "parser.y"
+    {PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}
+    }
     break;
 
-  case 133:
 
-/* Line 1455 of yacc.c  */
-#line 1981 "parser.y"
-    {startclass((yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list), 0);;}
+  
+    case 135:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2157 "parser.y"
+    {PASS12 startclass((yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list), 0);}
+    }
     break;
 
-  case 134:
 
-/* Line 1455 of yacc.c  */
-#line 1983 "parser.y"
-    {endclass();(yyval.code)=0;;}
+  
+    case 136:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2159 "parser.y"
+    {PASS12 endclass();(yyval.code)=0;}
+    }
     break;
 
-  case 135:
 
-/* Line 1455 of yacc.c  */
-#line 1987 "parser.y"
-    {startclass((yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list),1);;}
+  
+    case 137:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2163 "parser.y"
+    {PASS12 startclass((yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list),1);}
+    }
     break;
 
-  case 136:
 
-/* Line 1455 of yacc.c  */
-#line 1989 "parser.y"
-    {endclass();(yyval.code)=0;;}
+  
+    case 138:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2165 "parser.y"
+    {PASS12 endclass();(yyval.code)=0;}
+    }
     break;
 
-  case 144:
 
-/* Line 1455 of yacc.c  */
-#line 2001 "parser.y"
+  
+    case 146:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2177 "parser.y"
     {
     code_t*c = state->cls->static_init;
     c = code_append(c, (yyvsp[(1) - (1)].code));  
     state->cls->static_init = c;
-;}
+}
+    }
     break;
 
-  case 150:
 
-/* Line 1455 of yacc.c  */
-#line 2012 "parser.y"
+  
+    case 152:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2188 "parser.y"
     {
     syntaxerror("variable declarations not allowed in interfaces");
-;}
+}
+    }
     break;
 
-  case 151:
 
-/* Line 1455 of yacc.c  */
-#line 2015 "parser.y"
+  
+    case 153:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2191 "parser.y"
     {
+    PASS12
     (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");
     }
     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);
-;}
+    list_deep_free((yyvsp[(6) - (8)].params).list);
+}
+    }
     break;
 
-  case 154:
 
-/* Line 1455 of yacc.c  */
-#line 2028 "parser.y"
+  
+    case 156:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2206 "parser.y"
     {
     int flags = (yyvsp[(1) - (5)].flags);
     memberinfo_t* info = state->cls?
@@ -4618,6 +5300,7 @@ yyreduce:
     code_t**code;
     if(!state->cls) {
         // global variable
+        mname_ns.name = state->package;
         traits = &global->init->traits;
         code = &global->init->method->body->code;
     } else if(flags&FLAG_STATIC) {
@@ -4655,369 +5338,583 @@ yyreduce:
     }
 
     (yyval.code)=0;
-;}
+}
+    }
     break;
 
-  case 155:
 
-/* Line 1455 of yacc.c  */
-#line 2086 "parser.y"
-    {(yyval.constant)=0;;}
+  
+    case 157:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2265 "parser.y"
+    {(yyval.constant)=0;}
+    }
     break;
 
-  case 156:
 
-/* Line 1455 of yacc.c  */
-#line 2087 "parser.y"
-    {(yyval.constant)=(yyvsp[(2) - (2)].constant);;}
+  
+    case 158:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2266 "parser.y"
+    {(yyval.constant)=(yyvsp[(2) - (2)].constant);}
+    }
     break;
 
-  case 157:
 
-/* Line 1455 of yacc.c  */
-#line 2089 "parser.y"
-    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_uint));;}
+  
+    case 159:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2268 "parser.y"
+    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_uint));}
+    }
     break;
 
-  case 158:
 
-/* Line 1455 of yacc.c  */
-#line 2090 "parser.y"
-    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));;}
+  
+    case 160:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2269 "parser.y"
+    {(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}
+    }
     break;
 
-  case 159:
 
-/* Line 1455 of yacc.c  */
-#line 2091 "parser.y"
-    {(yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));;}
+  
+    case 161:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2270 "parser.y"
+    {(yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));}
+    }
     break;
 
-  case 160:
 
-/* Line 1455 of yacc.c  */
-#line 2092 "parser.y"
-    {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));;}
+  
+    case 162:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2271 "parser.y"
+    {(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}
+    }
     break;
 
-  case 161:
 
-/* Line 1455 of yacc.c  */
-#line 2093 "parser.y"
-    {(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);;}
+  
+    case 163:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2272 "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 162:
 
-/* Line 1455 of yacc.c  */
-#line 2095 "parser.y"
-    {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));;}
+  
+    case 164:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2274 "parser.y"
+    {(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}
+    }
     break;
 
-  case 163:
 
-/* Line 1455 of yacc.c  */
-#line 2096 "parser.y"
-    {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));;}
+  
+    case 165:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2275 "parser.y"
+    {(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}
+    }
     break;
 
-  case 164:
 
-/* Line 1455 of yacc.c  */
-#line 2097 "parser.y"
-    {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));;}
+  
+    case 166:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2276 "parser.y"
+    {(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}
+    }
     break;
 
-  case 165:
 
-/* Line 1455 of yacc.c  */
-#line 2102 "parser.y"
+  
+    case 167:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2281 "parser.y"
     {
+    PASS12
     memset(&(yyval.params),0,sizeof((yyval.params)));
-;}
+}
+    }
     break;
 
-  case 166:
 
-/* Line 1455 of yacc.c  */
-#line 2105 "parser.y"
+  
+    case 168:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2285 "parser.y"
     {
+    PASS12
     (yyval.params)=(yyvsp[(1) - (1)].params);
-;}
+}
+    }
     break;
 
-  case 167:
 
-/* Line 1455 of yacc.c  */
-#line 2110 "parser.y"
+  
+    case 169:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2291 "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 168:
 
-/* Line 1455 of yacc.c  */
-#line 2115 "parser.y"
+  
+    case 170:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2297 "parser.y"
     {
+    PASS12
     (yyval.params) =(yyvsp[(1) - (4)].params);
     (yyval.params).varargs=1;
     list_append((yyval.params).list, (yyvsp[(4) - (4)].param));
-;}
+}
+    }
     break;
 
-  case 169:
 
-/* Line 1455 of yacc.c  */
-#line 2122 "parser.y"
+  
+    case 171:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2305 "parser.y"
     {
+    PASS12
     (yyval.params) = (yyvsp[(1) - (3)].params);
     list_append((yyval.params).list, (yyvsp[(3) - (3)].param));
-;}
+}
+    }
     break;
 
-  case 170:
 
-/* Line 1455 of yacc.c  */
-#line 2126 "parser.y"
+  
+    case 172:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2310 "parser.y"
     {
+    PASS12
     memset(&(yyval.params),0,sizeof((yyval.params)));
     list_append((yyval.params).list, (yyvsp[(1) - (1)].param));
-;}
+}
+    }
     break;
 
-  case 171:
 
-/* Line 1455 of yacc.c  */
-#line 2131 "parser.y"
+  
+    case 173:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2316 "parser.y"
     {
+     PASS1 (yyval.param)=0;
+     PASS2
      (yyval.param) = malloc(sizeof(param_t));
      (yyval.param)->name=(yyvsp[(1) - (4)].id);
      (yyval.param)->type = (yyvsp[(3) - (4)].classinfo);
      (yyval.param)->value = (yyvsp[(4) - (4)].constant);
-;}
+}
+    }
     break;
 
-  case 172:
 
-/* Line 1455 of yacc.c  */
-#line 2137 "parser.y"
+  
+    case 174:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2324 "parser.y"
     {
+     PASS1 (yyval.param)=0;
+     PASS2
      (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);
-;}
+}
+    }
     break;
 
-  case 173:
 
-/* Line 1455 of yacc.c  */
-#line 2143 "parser.y"
-    {(yyval.token)=(yyvsp[(1) - (1)].token);;}
+  
+    case 175:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2332 "parser.y"
+    {(yyval.token)=(yyvsp[(1) - (1)].token);}
+    }
     break;
 
-  case 174:
 
-/* Line 1455 of yacc.c  */
-#line 2144 "parser.y"
-    {(yyval.token)=(yyvsp[(1) - (1)].token);;}
+  
+    case 176:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2333 "parser.y"
+    {(yyval.token)=(yyvsp[(1) - (1)].token);}
+    }
     break;
 
-  case 175:
 
-/* Line 1455 of yacc.c  */
-#line 2145 "parser.y"
-    {(yyval.token)=0;;}
+  
+    case 177:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2334 "parser.y"
+    {(yyval.token)=0;}
+    }
     break;
 
-  case 176:
 
-/* Line 1455 of yacc.c  */
-#line 2148 "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 178:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2337 "parser.y"
+    {PASS12 startfunction(0,(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}
+    }
     break;
 
-  case 177:
 
-/* Line 1455 of yacc.c  */
-#line 2149 "parser.y"
+  
+    case 179:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2338 "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);
-    }
+    PASS1 old_state();list_deep_free((yyvsp[(6) - (12)].params).list);
+    PASS2
+    if(!state->method->info) syntaxerror("internal error");
+    
+    code_t*c = method_header();
     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);
+    list_deep_free((yyvsp[(6) - (12)].params).list);
     (yyval.code)=0;
-;}
+}
+    }
     break;
 
-  case 179:
 
-/* Line 1455 of yacc.c  */
-#line 2166 "parser.y"
-    {(yyval.id)=0;;}
+  
+    case 181:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2352 "parser.y"
+    {PASS12 (yyval.id)=0;}
+    }
     break;
 
-  case 180:
 
-/* Line 1455 of yacc.c  */
-#line 2168 "parser.y"
-    {
-    syntaxerror("nested functions not supported yet");
-;}
+  
+    case 182:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2354 "parser.y"
+    {PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}
+    }
     break;
 
-  case 181:
 
-/* Line 1455 of yacc.c  */
-#line 2175 "parser.y"
+  
+    case 183:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2355 "parser.y"
     {
+    PASS1 old_state();list_deep_free((yyvsp[(4) - (10)].params).list);
+    PASS2
+    memberinfo_t*f = state->method->info;
+    if(!f) syntaxerror("internal error");
+    
+    code_t*c = method_header();
+    c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));
 
+    int index = state->method->var_index;
+    endfunction(0,0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);
+    list_deep_free((yyvsp[(4) - (10)].params).list);
+    
+    (yyval.value).c = abc_getlocal(0, index);
+    (yyval.value).t = TYPE_FUNCTION(f);
+}
+    }
+    break;
+
+
+  
+    case 184:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2375 "parser.y"
+    {
+    PASS1 (yyval.classinfo)=0;
+    PASS2
     /* 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));
-;}
+}
+    }
     break;
 
-  case 182:
 
-/* Line 1455 of yacc.c  */
-#line 2182 "parser.y"
+  
+    case 185:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2383 "parser.y"
     {
+    PASS1 static classinfo_t c;
+          memset(&c, 0, sizeof(c));
+          c.package = (yyvsp[(1) - (3)].id);
+          c.name = (yyvsp[(3) - (3)].id);
+          (yyval.classinfo)=&c;
+    PASS2
     (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;
-;}
+}
+    }
     break;
 
-  case 185:
 
-/* Line 1455 of yacc.c  */
-#line 2191 "parser.y"
-    {(yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));;}
+  
+    case 188:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2398 "parser.y"
+    {PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}
+    }
     break;
 
-  case 186:
 
-/* Line 1455 of yacc.c  */
-#line 2192 "parser.y"
-    {(yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));;}
+  
+    case 189:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2399 "parser.y"
+    {PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}
+    }
     break;
 
-  case 187:
 
-/* Line 1455 of yacc.c  */
-#line 2194 "parser.y"
-    {(yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);;}
+  
+    case 190:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2401 "parser.y"
+    {(yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}
+    }
     break;
 
-  case 188:
 
-/* Line 1455 of yacc.c  */
-#line 2195 "parser.y"
-    {(yyval.classinfo)=registry_getanytype();;}
+  
+    case 191:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2402 "parser.y"
+    {(yyval.classinfo)=registry_getanytype();}
+    }
     break;
 
-  case 189:
 
-/* Line 1455 of yacc.c  */
-#line 2196 "parser.y"
-    {(yyval.classinfo)=registry_getanytype();;}
+  
+    case 192:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2403 "parser.y"
+    {(yyval.classinfo)=registry_getanytype();}
+    }
     break;
 
-  case 190:
 
-/* Line 1455 of yacc.c  */
-#line 2205 "parser.y"
-    {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);;}
+  
+    case 193:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2412 "parser.y"
+    {(yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}
+    }
     break;
 
-  case 191:
 
-/* Line 1455 of yacc.c  */
-#line 2206 "parser.y"
-    {(yyval.classinfo)=0;;}
+  
+    case 194:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2413 "parser.y"
+    {(yyval.classinfo)=0;}
+    }
     break;
 
-  case 192:
 
-/* Line 1455 of yacc.c  */
-#line 2210 "parser.y"
-    {(yyval.value_list).cc=0;(yyval.value_list).len=0;;}
+  
+    case 195:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2417 "parser.y"
+    {(yyval.value_list).cc=0;(yyval.value_list).len=0;}
+    }
     break;
 
-  case 193:
 
-/* Line 1455 of yacc.c  */
-#line 2211 "parser.y"
+  
+    case 196:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2418 "parser.y"
     {(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}
+    }
     break;
 
-  case 194:
 
-/* Line 1455 of yacc.c  */
-#line 2213 "parser.y"
-    {(yyval.value_list).cc=0;(yyval.value_list).len=0;;}
+  
+    case 197:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2420 "parser.y"
+    {(yyval.value_list).cc=0;(yyval.value_list).len=0;}
+    }
     break;
 
-  case 196:
 
-/* Line 1455 of yacc.c  */
-#line 2215 "parser.y"
+  
+    case 199:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2422 "parser.y"
     {(yyval.value_list).len=1;
                                                   (yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;
-                                                 ;}
+                                                 }
+    }
     break;
 
-  case 197:
 
-/* Line 1455 of yacc.c  */
-#line 2218 "parser.y"
+  
+    case 200:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2425 "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);
-                                                  ;}
+                                                  }
+    }
     break;
 
-  case 198:
 
-/* Line 1455 of yacc.c  */
-#line 2223 "parser.y"
-    {
-    MULTINAME(m, (yyvsp[(2) - (3)].classinfo));
-    (yyval.value).c = code_new();
+  
+    case 202:
+    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);
+/* Line 1464 of skeleton.m4  */
+#line 2431 "parser.y"
+    {
+    (yyval.value).c = (yyvsp[(2) - (4)].value).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).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
+        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).len);
     } else {
-        (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
+        (yyval.value).c = code_append((yyval.value).c, paramcode);
+        (yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).len);
+    }
+   
+    (yyval.value).t = TYPE_ANY;
+    if(TYPE_IS_CLASS((yyvsp[(2) - (4)].value).t) && (yyvsp[(2) - (4)].value).t->cls) {
+        (yyval.value).t = (yyvsp[(2) - (4)].value).t->cls;
+    } else {
+        (yyval.value).c = abc_coerce_a((yyval.value).c);
+        (yyval.value).t = TYPE_ANY;
+    }
+}
     }
-
-    (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);
-;}
     break;
 
-  case 199:
 
-/* Line 1455 of yacc.c  */
-#line 2247 "parser.y"
+  
+    case 203:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2467 "parser.y"
     {
     
     (yyval.value).c = (yyvsp[(1) - (4)].value).c;
@@ -5051,27 +5948,28 @@ yyreduce:
         (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 = 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).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;
     }
-
-;}
+}
+    }
     break;
 
-  case 200:
 
-/* Line 1455 of yacc.c  */
-#line 2295 "parser.y"
+  
+    case 204:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2513 "parser.y"
     {
     if(!state->cls) syntaxerror("super() not allowed outside of a class");
     if(!state->method) syntaxerror("super() not allowed outside of a function");
@@ -5087,16 +5985,21 @@ yyreduce:
         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;
-;}
+}
+    }
     break;
 
-  case 201:
 
-/* Line 1455 of yacc.c  */
-#line 2315 "parser.y"
+  
+    case 205:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2534 "parser.y"
     {
     (yyval.value).c = (yyvsp[(2) - (2)].value).c;
     if((yyval.value).c->opcode == OPCODE_COERCE_A) {
@@ -5116,95 +6019,139 @@ yyreduce:
         (yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);
     }
     (yyval.value).t = TYPE_BOOLEAN;
-;}
+}
+    }
     break;
 
-  case 202:
 
-/* Line 1455 of yacc.c  */
-#line 2336 "parser.y"
+  
+    case 206:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2555 "parser.y"
     {
     (yyval.code) = abc_returnvoid(0);
-;}
+}
+    }
     break;
 
-  case 203:
 
-/* Line 1455 of yacc.c  */
-#line 2339 "parser.y"
+  
+    case 207:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2558 "parser.y"
     {
     (yyval.code) = (yyvsp[(2) - (2)].value).c;
     (yyval.code) = abc_returnvalue((yyval.code));
-;}
+}
+    }
     break;
 
-  case 204:
 
-/* Line 1455 of yacc.c  */
-#line 2346 "parser.y"
-    {(yyval.value)=(yyvsp[(1) - (1)].value);;}
+  
+    case 208:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2565 "parser.y"
+    {(yyval.value)=(yyvsp[(1) - (1)].value);}
+    }
     break;
 
-  case 205:
 
-/* Line 1455 of yacc.c  */
-#line 2347 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 209:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2566 "parser.y"
+    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+    }
     break;
 
-  case 206:
 
-/* Line 1455 of yacc.c  */
-#line 2348 "parser.y"
+  
+    case 210:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2567 "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;
-;}
+}
+    }
     break;
 
-  case 207:
 
-/* Line 1455 of yacc.c  */
-#line 2354 "parser.y"
+  
+    case 211:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2573 "parser.y"
     {
     (yyval.code)=cut_last_push((yyvsp[(1) - (1)].value).c);
-;}
+}
+    }
     break;
 
-  case 208:
 
-/* Line 1455 of yacc.c  */
-#line 2360 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 212:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2579 "parser.y"
+    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+    }
     break;
 
-  case 210:
 
-/* Line 1455 of yacc.c  */
-#line 2364 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 214:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2583 "parser.y"
+    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+    }
     break;
 
-  case 211:
 
-/* Line 1455 of yacc.c  */
-#line 2366 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 215:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2585 "parser.y"
+    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+    }
     break;
 
-  case 212:
 
-/* Line 1455 of yacc.c  */
-#line 2368 "parser.y"
-    {(yyval.value) = (yyvsp[(1) - (1)].value);;}
+  
+    case 216:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2587 "parser.y"
+    {(yyval.value) = (yyvsp[(1) - (1)].value);}
+    }
     break;
 
-  case 213:
 
-/* Line 1455 of yacc.c  */
-#line 2370 "parser.y"
+  
+    case 218:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2591 "parser.y"
     {
     (yyval.value).c = 0;
     namespace_t ns = {ACCESS_PACKAGE, ""};
@@ -5220,177 +6167,253 @@ yyreduce:
         (yyval.value).c = abc_construct((yyval.value).c, 2);
     }
     (yyval.value).t = TYPE_REGEXP;
-;}
+}
+    }
     break;
 
-  case 214:
 
-/* Line 1455 of yacc.c  */
-#line 2387 "parser.y"
+  
+    case 219:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2608 "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;
-                  ;}
+                  }
+    }
     break;
 
-  case 215:
 
-/* Line 1455 of yacc.c  */
-#line 2392 "parser.y"
+  
+    case 220:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2613 "parser.y"
     {(yyval.value).c = abc_pushshort(0, (yyvsp[(1) - (1)].number_uint));
                     (yyval.value).t = TYPE_INT;
-                   ;}
+                   }
+    }
     break;
 
-  case 216:
 
-/* Line 1455 of yacc.c  */
-#line 2395 "parser.y"
+  
+    case 221:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2616 "parser.y"
     {(yyval.value).c = abc_pushint(0, (yyvsp[(1) - (1)].number_int));
                   (yyval.value).t = TYPE_INT;
-                 ;}
+                 }
+    }
     break;
 
-  case 217:
 
-/* Line 1455 of yacc.c  */
-#line 2398 "parser.y"
+  
+    case 222:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2619 "parser.y"
     {(yyval.value).c = abc_pushuint(0, (yyvsp[(1) - (1)].number_uint));
                    (yyval.value).t = TYPE_UINT;
-                  ;}
+                  }
+    }
     break;
 
-  case 218:
 
-/* Line 1455 of yacc.c  */
-#line 2401 "parser.y"
+  
+    case 223:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2622 "parser.y"
     {(yyval.value).c = abc_pushdouble(0, (yyvsp[(1) - (1)].number_float));
                     (yyval.value).t = TYPE_FLOAT;
-                   ;}
+                   }
+    }
     break;
 
-  case 219:
 
-/* Line 1455 of yacc.c  */
-#line 2404 "parser.y"
-    {(yyval.value).c = abc_pushstring2(0, &(yyvsp[(1) - (1)].str));
+  
+    case 224:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2625 "parser.y"
+    {(yyval.value).c = abc_pushstring2(0, &(yyvsp[(1) - (1)].str));free((char*)(yyvsp[(1) - (1)].str).str);
                      (yyval.value).t = TYPE_STRING;
-                    ;}
+                    }
+    }
     break;
 
-  case 220:
 
-/* Line 1455 of yacc.c  */
-#line 2407 "parser.y"
+  
+    case 225:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2628 "parser.y"
     {(yyval.value).c = abc_pushundefined(0);
                     (yyval.value).t = TYPE_ANY;
-                   ;}
+                   }
+    }
     break;
 
-  case 221:
 
-/* Line 1455 of yacc.c  */
-#line 2410 "parser.y"
+  
+    case 226:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2631 "parser.y"
     {(yyval.value).c = abc_pushtrue(0);
                     (yyval.value).t = TYPE_BOOLEAN;
-                   ;}
+                   }
+    }
     break;
 
-  case 222:
 
-/* Line 1455 of yacc.c  */
-#line 2413 "parser.y"
+  
+    case 227:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2634 "parser.y"
     {(yyval.value).c = abc_pushfalse(0);
                      (yyval.value).t = TYPE_BOOLEAN;
-                    ;}
+                    }
+    }
     break;
 
-  case 223:
 
-/* Line 1455 of yacc.c  */
-#line 2416 "parser.y"
+  
+    case 228:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2637 "parser.y"
     {(yyval.value).c = abc_pushnull(0);
                     (yyval.value).t = TYPE_NULL;
-                   ;}
+                   }
+    }
     break;
 
-  case 225:
 
-/* Line 1455 of yacc.c  */
-#line 2421 "parser.y"
+  
+    case 229:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2641 "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;
-            ;}
+            }
+    }
     break;
 
-  case 226:
 
-/* Line 1455 of yacc.c  */
-#line 2424 "parser.y"
+  
+    case 230:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2644 "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;
-            ;}
+            }
+    }
     break;
 
-  case 227:
 
-/* Line 1455 of yacc.c  */
-#line 2427 "parser.y"
+  
+    case 231:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2647 "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;
-             ;}
+             }
+    }
     break;
 
-  case 228:
 
-/* Line 1455 of yacc.c  */
-#line 2430 "parser.y"
+  
+    case 232:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2650 "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;
-             ;}
+             }
+    }
     break;
 
-  case 229:
 
-/* Line 1455 of yacc.c  */
-#line 2433 "parser.y"
+  
+    case 233:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2653 "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;
-             ;}
+             }
+    }
     break;
 
-  case 230:
 
-/* Line 1455 of yacc.c  */
-#line 2436 "parser.y"
+  
+    case 234:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2656 "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;
-              ;}
+              }
+    }
     break;
 
-  case 231:
 
-/* Line 1455 of yacc.c  */
-#line 2439 "parser.y"
+  
+    case 235:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2659 "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;
-             ;}
+             }
+    }
     break;
 
-  case 232:
 
-/* Line 1455 of yacc.c  */
-#line 2442 "parser.y"
+  
+    case 236:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2662 "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;
-             ;}
+             }
+    }
     break;
 
-  case 233:
 
-/* Line 1455 of yacc.c  */
-#line 2446 "parser.y"
+  
+    case 237:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2666 "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);
@@ -5401,13 +6424,17 @@ yyreduce:
               (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 234:
 
-/* Line 1455 of yacc.c  */
-#line 2457 "parser.y"
+  
+    case 238:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2677 "parser.y"
     {
               (yyval.value).t = join_types((yyvsp[(1) - (3)].value).t, (yyvsp[(3) - (3)].value).t, 'A');
               /*printf("%08x:\n",$1.t);
@@ -5424,113 +6451,157 @@ yyreduce:
               (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 2475 "parser.y"
+  
+    case 239:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2695 "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 2480 "parser.y"
+  
+    case 240:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2700 "parser.y"
     {(yyval.value).c=(yyvsp[(2) - (2)].value).c;
               (yyval.value).c = abc_bitnot((yyval.value).c);
               (yyval.value).t = TYPE_INT;
-             ;}
+             }
+    }
     break;
 
-  case 237:
 
-/* Line 1455 of yacc.c  */
-#line 2485 "parser.y"
+  
+    case 241:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2705 "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;
-            ;}
+            }
+    }
     break;
 
-  case 238:
 
-/* Line 1455 of yacc.c  */
-#line 2490 "parser.y"
+  
+    case 242:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2710 "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;
-            ;}
+            }
+    }
     break;
 
-  case 239:
 
-/* Line 1455 of yacc.c  */
-#line 2495 "parser.y"
+  
+    case 243:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2715 "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;
-            ;}
+            }
+    }
     break;
 
-  case 240:
 
-/* Line 1455 of yacc.c  */
-#line 2500 "parser.y"
+  
+    case 244:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2720 "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;
-            ;}
+            }
+    }
     break;
 
-  case 241:
 
-/* Line 1455 of yacc.c  */
-#line 2504 "parser.y"
+  
+    case 245:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2724 "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;
-            ;}
+            }
+    }
     break;
 
-  case 242:
 
-/* Line 1455 of yacc.c  */
-#line 2508 "parser.y"
+  
+    case 246:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2728 "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;
-            ;}
+            }
+    }
     break;
 
-  case 243:
 
-/* Line 1455 of yacc.c  */
-#line 2513 "parser.y"
+  
+    case 247:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2733 "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;
-            ;}
+            }
+    }
     break;
 
-  case 244:
 
-/* Line 1455 of yacc.c  */
-#line 2517 "parser.y"
+  
+    case 248:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2737 "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 2521 "parser.y"
+  
+    case 249:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2741 "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);
@@ -5539,13 +6610,17 @@ yyreduce:
                 (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 2530 "parser.y"
+  
+    case 250:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2750 "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);
@@ -5554,13 +6629,17 @@ yyreduce:
                 (yyval.value).c = abc_subtract((yyval.value).c);
                 (yyval.value).t = TYPE_NUMBER;
              }
-            ;}
+            }
+    }
     break;
 
-  case 247:
 
-/* Line 1455 of yacc.c  */
-#line 2539 "parser.y"
+  
+    case 251:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2759 "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);
@@ -5569,23 +6648,31 @@ yyreduce:
                 (yyval.value).c = abc_multiply((yyval.value).c);
                 (yyval.value).t = TYPE_NUMBER;
              }
-            ;}
+            }
+    }
     break;
 
-  case 248:
 
-/* Line 1455 of yacc.c  */
-#line 2549 "parser.y"
+  
+    case 252:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2769 "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 2554 "parser.y"
+  
+    case 253:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2774 "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);
@@ -5596,71 +6683,99 @@ yyreduce:
                 (yyval.value).c = abc_astypelate((yyval.value).c);
                 (yyval.value).t = TYPE_ANY;
               }
-             ;}
+             }
+    }
     break;
 
-  case 250:
 
-/* Line 1455 of yacc.c  */
-#line 2567 "parser.y"
+  
+    case 254:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2787 "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 2572 "parser.y"
+  
+    case 255:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2792 "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 2577 "parser.y"
+  
+    case 256:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2797 "parser.y"
     {
               (yyval.value).c = (yyvsp[(3) - (4)].value).c;
               (yyval.value).c = abc_typeof((yyval.value).c);
               (yyval.value).t = TYPE_STRING;
-             ;}
+             }
+    }
     break;
 
-  case 253:
 
-/* Line 1455 of yacc.c  */
-#line 2583 "parser.y"
+  
+    case 257:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2803 "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;
-             ;}
+             }
+    }
     break;
 
-  case 254:
 
-/* Line 1455 of yacc.c  */
-#line 2589 "parser.y"
+  
+    case 258:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2809 "parser.y"
     { (yyval.value).c = abc_pushundefined(0);
              (yyval.value).t = TYPE_ANY;
-           ;}
+           }
+    }
     break;
 
-  case 255:
 
-/* Line 1455 of yacc.c  */
-#line 2593 "parser.y"
-    {(yyval.value)=(yyvsp[(2) - (3)].value);;}
+  
+    case 259:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2813 "parser.y"
+    {(yyval.value)=(yyvsp[(2) - (3)].value);}
+    }
     break;
 
-  case 256:
 
-/* Line 1455 of yacc.c  */
-#line 2595 "parser.y"
+  
+    case 260:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2815 "parser.y"
     {
   (yyval.value)=(yyvsp[(2) - (2)].value);
   if(IS_INT((yyvsp[(2) - (2)].value).t)) {
@@ -5670,89 +6785,121 @@ yyreduce:
    (yyval.value).c=abc_negate((yyval.value).c);
    (yyval.value).t = TYPE_NUMBER;
   }
-;}
+}
+    }
     break;
 
-  case 257:
 
-/* Line 1455 of yacc.c  */
-#line 2606 "parser.y"
+  
+    case 261:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2826 "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
-;}
+}
+    }
     break;
 
-  case 258:
 
-/* Line 1455 of yacc.c  */
-#line 2615 "parser.y"
+  
+    case 262:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2835 "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();
-;}
+}
+    }
     break;
 
-  case 259:
 
-/* Line 1455 of yacc.c  */
-#line 2622 "parser.y"
-    {(yyval.value_list).cc=0;(yyval.value_list).len=0;;}
+  
+    case 263:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2842 "parser.y"
+    {(yyval.value_list).cc=0;(yyval.value_list).len=0;}
+    }
     break;
 
-  case 260:
 
-/* Line 1455 of yacc.c  */
-#line 2623 "parser.y"
+  
+    case 264:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2843 "parser.y"
     {(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}
+    }
     break;
 
-  case 261:
 
-/* Line 1455 of yacc.c  */
-#line 2625 "parser.y"
+  
+    case 265:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2845 "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;
-;}
+}
+    }
     break;
 
-  case 262:
 
-/* Line 1455 of yacc.c  */
-#line 2631 "parser.y"
+  
+    case 266:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2851 "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);
-;}
+}
+    }
     break;
 
-  case 263:
 
-/* Line 1455 of yacc.c  */
-#line 2640 "parser.y"
+  
+    case 267:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2860 "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();
-;}
+}
+    }
     break;
 
-  case 264:
 
-/* Line 1455 of yacc.c  */
-#line 2647 "parser.y"
+  
+    case 268:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2867 "parser.y"
     { 
                code_t*c = (yyvsp[(3) - (3)].value).c;
                if(BOTH_INT((yyvsp[(1) - (3)].value).t,(yyvsp[(3) - (3)].value).t)) {
@@ -5763,85 +6910,113 @@ yyreduce:
                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 2659 "parser.y"
+  
+    case 269:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2879 "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:
 
-/* Line 1455 of yacc.c  */
-#line 2665 "parser.y"
+  
+    case 270:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2885 "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;
-              ;}
+              }
+    }
     break;
 
-  case 267:
 
-/* Line 1455 of yacc.c  */
-#line 2671 "parser.y"
+  
+    case 271:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2891 "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:
 
-/* Line 1455 of yacc.c  */
-#line 2677 "parser.y"
+  
+    case 272:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2897 "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;
-              ;}
+              }
+    }
     break;
 
-  case 269:
 
-/* Line 1455 of yacc.c  */
-#line 2683 "parser.y"
+  
+    case 273:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2903 "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:
 
-/* Line 1455 of yacc.c  */
-#line 2689 "parser.y"
+  
+    case 274:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2909 "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;
-              ;}
+              }
+    }
     break;
 
-  case 271:
 
-/* Line 1455 of yacc.c  */
-#line 2695 "parser.y"
+  
+    case 275:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2915 "parser.y"
     { 
                code_t*c = (yyvsp[(3) - (3)].value).c;
 
@@ -5854,13 +7029,17 @@ yyreduce:
                
                (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 2708 "parser.y"
+  
+    case 276:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2928 "parser.y"
     { code_t*c = (yyvsp[(3) - (3)].value).c; 
                if(TYPE_IS_INT((yyvsp[(1) - (3)].value).t)) {
                 c=abc_subtract_i(c);
@@ -5871,25 +7050,33 @@ yyreduce:
                
                (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 2719 "parser.y"
+  
+    case 277:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2939 "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;
-            ;}
+            }
+    }
     break;
 
-  case 274:
 
-/* Line 1455 of yacc.c  */
-#line 2726 "parser.y"
+  
+    case 278:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2946 "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;
@@ -5901,13 +7088,17 @@ yyreduce:
               (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 2739 "parser.y"
+  
+    case 279:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2959 "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)) {
@@ -5932,13 +7123,17 @@ yyreduce:
                  (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 2766 "parser.y"
+  
+    case 280:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 2986 "parser.y"
     { code_t*c = 0;
              classinfo_t*type = (yyvsp[(1) - (2)].value).t;
              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
@@ -5951,13 +7146,17 @@ yyreduce:
              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 2780 "parser.y"
+  
+    case 281:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3000 "parser.y"
     { code_t*c = 0;
              classinfo_t*type = (yyvsp[(2) - (2)].value).t;
              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
@@ -5970,13 +7169,17 @@ yyreduce:
              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 2794 "parser.y"
+  
+    case 282:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3014 "parser.y"
     { code_t*c = 0;
              classinfo_t*type = (yyvsp[(2) - (2)].value).t;
              if(TYPE_IS_INT(type) || TYPE_IS_UINT(type)) {
@@ -5989,13 +7192,17 @@ yyreduce:
              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 2809 "parser.y"
+  
+    case 283:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3029 "parser.y"
     { if(!state->cls->info)
                   syntaxerror("super keyword not allowed outside a class");
               classinfo_t*t = state->cls->info->superclass;
@@ -6008,13 +7215,17 @@ yyreduce:
               (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 2824 "parser.y"
+  
+    case 284:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3044 "parser.y"
     {(yyval.value).c = (yyvsp[(1) - (3)].value).c;
              classinfo_t*t = (yyvsp[(1) - (3)].value).t;
              char is_static = 0;
@@ -6046,13 +7257,17 @@ yyreduce:
                  (yyval.value).c = abc_coerce_a((yyval.value).c);
                  (yyval.value).t = registry_getanytype();
              }
-            ;}
+            }
+    }
     break;
 
-  case 281:
 
-/* Line 1455 of yacc.c  */
-#line 2857 "parser.y"
+  
+    case 285:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3077 "parser.y"
     {
     (yyval.value).t = 0;
     (yyval.value).c = 0;
@@ -6065,40 +7280,49 @@ yyreduce:
         // $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 */
-    } else if(state->cls && (f = registry_findmember(state->cls->info, (yyvsp[(1) - (1)].id), 1))) {
+    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);
-        int i_am_static = ((state->method && state->method->info)?(state->method->info->flags&FLAG_STATIC):FLAG_STATIC);
-        if(var_is_static != i_am_static) {
-            /* there doesn't seem to be any "static" way to access
-               static properties of a class */
+
+        if(f->kind == MEMBER_METHOD) {
+            (yyval.value).t = TYPE_FUNCTION(f);
+        } else {
+            (yyval.value).t = f->type;
+        }
+        if(var_is_static && !i_am_static) {
+        /* access to a static member from a non-static location.
+           do this via findpropstrict:
+           there doesn't seem to be any non-lookup way to access
+           static properties of a class */
             state->method->late_binding = 1;
             (yyval.value).t = f->type;
             namespace_t ns = {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);
+            (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
+            break;
         } else {
-            if(f->slot>0) {
-                (yyval.value).c = abc_getlocal_0((yyval.value).c);
-                (yyval.value).c = abc_getslot((yyval.value).c, f->slot);
-            } 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);
-                (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
-            }
-        }
-        if(f->kind == MEMBER_METHOD) {
-            (yyval.value).t = TYPE_FUNCTION(f);
-        } else {
-            (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_getlocal_0((yyval.value).c);
+            (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
+            break;
         }
+    } 
     
     /* look at actual classes, in the current package and imported */
-    } else if((a = find_class((yyvsp[(1) - (1)].id)))) {
+    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);
@@ -6118,11 +7342,12 @@ yyreduce:
             }
             (yyval.value).t = TYPE_CLASS(a);
         }
+        break;
+    }
 
     /* unknown object, let the avm2 resolve it */
-    } else {
-        if(strcmp((yyvsp[(1) - (1)].id),"trace"))
-            as3_softwarning("Couldn't resolve '%s', doing late binding", (yyvsp[(1) - (1)].id));
+    if(1) {
+        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)};
@@ -6131,41 +7356,59 @@ yyreduce:
         (yyval.value).c = abc_findpropstrict2((yyval.value).c, &m);
         (yyval.value).c = abc_getproperty2((yyval.value).c, &m);
     }
-;}
+}
+    }
     break;
 
-  case 282:
 
-/* Line 1455 of yacc.c  */
-#line 2944 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 286:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3174 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 283:
 
-/* Line 1455 of yacc.c  */
-#line 2945 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 287:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3175 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 284:
 
-/* Line 1455 of yacc.c  */
-#line 2946 "parser.y"
-    {(yyval.code)=0;;}
+  
+    case 288:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3176 "parser.y"
+    {(yyval.code)=0;}
+    }
     break;
 
-  case 285:
 
-/* Line 1455 of yacc.c  */
-#line 2948 "parser.y"
-    {(yyval.token)=0;;}
+  
+    case 289:
+    if(as3_pass==2) {
+
+/* Line 1464 of skeleton.m4  */
+#line 3178 "parser.y"
+    {(yyval.token)=0;}
+    }
     break;
 
 
 
-/* Line 1455 of yacc.c  */
-#line 6169 "parser.tab.c"
+
+/* Line 1464 of skeleton.m4  */
+#line 7412 "parser.tab.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);