jerlang.tar

jerlang/0000755000175000017500000000000011263343027012045 5ustar  huberthubertjerlang/ebin/0000755000175000017500000000000011263342626012766 5ustar  huberthubertjerlang/include/0000755000175000017500000000000011264172142013467 5ustar  huberthubertjerlang/src/0000755000175000017500000000000011264172142012633 5ustar  huberthubertjerlang/README0000644000175000017500000000453011263342612012726 0ustar  huberthubertRequirements:
- just JErlang library implementation - Erlang at least R12B-3
- patched version of the VM and compiler (see instructions at the bottom)

In order to compile JErlang simply run 'make'.
The Makefile contains many targets that were helpful in running tests, for their usage please refer to specific module definitions.

The makefile automatically detects whether the version of the Erlang runtime is actually the one that supports joins. You can additionally specify 'use_ordering_opt' macro in order to turn-on the joins ordering optimisations (see report). By default the optimisation is off.

The core modules that perform necessary matching and transformations include:
-jerlang_core
-jerlang_parse
-jerlang_vm_core
-jerlang_vm_parse
-jerlang_vm_gen_joins
-jerlang_gen_joins
-jerlang_gen_joins_parse

And related test-suite for standard constructs and vm changes:
jerlang_tests and jerlang_tests_vm

All the other modules are either used in implementating the main JErlang libraries (i.e. a kind of utility modules) or are small examples that present the capabilities of the extension.

The user should be carefull when mixing different JErlang approaches (i.e. sometimes compiling just the library and sometimes compiling version with VM support). Therefore it is recommended to keep to one version, and when switching, run 'make clean' in order to remove wrong bytecode, then again 'make'. This ensures that all the files are consistent.

**** JErlang with modified VM/compiler
Requiremenets: Erlang R12B-5 *only*. Untar the archive to a desired directory that we call SOURCEDIR.
Copy the patch file 'patch_jerlang.diff' into SOURCEDIR, 'cd' to it and run command:
patch -p1 < patch_jerlang.diff
Assuming that you want to install JErlang into directory DIR, you run following commands from SOURCEDIR:
./configure --prefix=DIR --disable-hipe
make
make install

You also need to change the environmental variables in order to catch the new version. You can typically do it by:

export PATH=DIR/bin:$PATH
export OTP_HOME=DIR

where DIR is assumed as before.
Finally you need to compile JErlang with the vm support. Makefile will automatically discover the new version and use 'use_joins_vm' macro that says that we should compile with the modified compiler.
Finally, you can run 'make test_runtime' and test-suite should successfully finish the runtime tests.

Happy coding!


jerlang/patch_jerlang.diff0000644000175000017500000603165711220224120015503 0ustar  huberthubertdiff -urNp otp_src_R12B-5/erts/emulator/beam/atom.names minimal_otp_src_R12B-5/erts/emulator/beam/atom.names
--- otp_src_R12B-5/erts/emulator/beam/atom.names	2008-11-04 10:51:08.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/atom.names	2009-06-23 20:40:30.000000000 +0100
@@ -511,3 +511,7 @@ atom wordsize
 atom xor
 atom yes
 atom yield
+
+#used in turning on/off debugging
+atom on
+atom off
diff -urNp otp_src_R12B-5/erts/emulator/beam/beam_emu.c minimal_otp_src_R12B-5/erts/emulator/beam/beam_emu.c
--- otp_src_R12B-5/erts/emulator/beam/beam_emu.c	2008-11-04 10:51:08.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/beam_emu.c	2009-06-23 20:40:30.000000000 +0100
@@ -20,6 +20,9 @@
 #  include "config.h"
 #endif
 
+// SEARCH HEADERS
+#include "erl_printf.h"
+
 #include <stddef.h> /* offsetof() */
 #include "sys.h"
 #include "erl_vm.h"
@@ -619,14 +622,22 @@ extern int count_instructions;
 #define DeallocateReturn(Deallocate)       \
   do {                                     \
     int words_to_pop = (Deallocate);       \
+    if (c_p->debug)			   \
+      erts_printf("[%d]: DEALLOCATE_RETURN1\n", c_p->id); \
     SET_I(cp_val(*E));                     \
+    if (c_p->debug) {						\
+      erts_printf("DEALLOCATE_RETURN2 %d\n", (cp_val(*E)));	\
+      erts_printf("VALUE E %T\n", *E);				\
+    }								\
     E = ADD_BYTE_OFFSET(E, words_to_pop);  \
+    if (c_p->debug)					\
+      erts_printf("DEALLOCATE_RETURN3 %T\n", *E);	\
     CHECK_TERM(r(0));                      \
     Goto(*I);                              \
   } while (0)
 
 #define MoveDeallocateReturn(Src, Dest, Deallocate)  \
-    (Dest) = (Src);                                  \
+    (Dest) = (Src);				     \
     DeallocateReturn(Deallocate)
 
 #define MoveCall(Src, Dest, CallDest, Size)	\
@@ -1526,7 +1537,6 @@ void process_main(void)
      PROCESS_MAIN_CHK_LOCKS(c_p);
 
      msgp = PEEK_MESSAGE(c_p);
-
      if (!msgp) {
 #ifdef ERTS_SMP
 	 erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_MSG_RECEIVE);
@@ -1548,18 +1558,77 @@ void process_main(void)
 	 }
 #endif
      }
+     
      MV_MSG_MBUF_INTO_PROC(msgp);
      PreFetch(1, next);
+
      r(0) = ERL_MESSAGE_TERM(msgp);
      NextPF(1, next);
  }
 
+ OpCase(i_loop_search_fr):
+ {
+     Eterm* next;
+     ErlMessage* msgp;
+     ErlMessage** msgpp;
+
+ loop_search__:
+     if (c_p->debug)
+       erts_printf("[%d]:Attempting to access last message\n", c_p->id);
+     PROCESS_MAIN_CHK_LOCKS(c_p);
+     msgpp = SEARCH_MESSAGE(c_p);
+     if (c_p->debug)
+       erts_printf("After attempt\n");
+
+     if (*msgpp == NULL) {
+       if (c_p->debug)
+	 erts_printf("[%d]:Search not succesful, following other path\n", c_p->id);
+#ifdef ERTS_SMP
+	 erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_MSG_RECEIVE);
+	 /* Make sure messages wont pass exit signals... */
+	 if (ERTS_PROC_PENDING_EXIT(c_p)) {
+	     erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_MSG_RECEIVE);
+	     SWAPOUT;
+	     goto do_schedule; /* Will be rescheduled for exit */
+	 }
+	 ERTS_SMP_MSGQ_MV_INQ2PRIVQ(c_p);
+	 msgpp = SEARCH_MESSAGE(c_p);
+	 if (*msgpp != NULL)
+	     erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_MSG_RECEIVE);
+	 else {
+#endif
+	     if (c_p->debug)
+	       erts_printf("[%d]:Search not succesful: non-smp E[%T]\n", c_p->id, *E);
+	     SET_I((Eterm *) Arg(0));
+	     Goto(*I);		/* Jump to a wait or wait_timeout instruction */
+#ifdef ERTS_SMP
+	 }
+#endif
+     }
+     msgp = *msgpp;
+     if (c_p->debug)
+       erts_printf("[%d]:Search found message: %T\n", c_p->id, ERL_MESSAGE_TERM(msgp));
+
+     MV_MSG_MBUF_INTO_PROC(msgp);
+     PreFetch(1, next);
+
+     if (c_p->debug) {
+       erts_printf("Erlang message index: %d\n", msgp->index);
+       erts_printf("Value E in loop_search: %T\n", *E);
+     }
+
+     r(0) = ERL_MESSAGE_TERM(msgp);
+
+     NextPF(1, next);
+ }
+
  /*
   * Remove a (matched) message from the message queue.
   */
  OpCase(remove_message): {
      Eterm* next;
      ErlMessage* msgp;
+     ErlMessage** tmp;
 
      PROCESS_MAIN_CHK_LOCKS(c_p);
 
@@ -1588,16 +1657,120 @@ void process_main(void)
 	 seq_trace_output(SEQ_TRACE_TOKEN(c_p), msg, SEQ_TRACE_RECEIVE, 
 			  c_p->id, c_p);
      }
-     UNLINK_MESSAGE(c_p, msgp);
+
+          if (c_p->debug >= 1) {
+       erts_printf("------\n");
+       if (msgp != NULL)
+	 erts_printf("REMOVE MESSAGE IS: %T\n", ERL_MESSAGE_TERM(msgp));
+       else
+	 erts_printf("REMOVE MESSAGE IS NULL\n");
+       
+       tmp = SEARCH_MESSAGE(c_p);
+       if (*tmp != NULL)
+	 erts_printf("SEARCH MESSAGE IS: %T\n", ERL_MESSAGE_TERM(*tmp));
+       else
+	 erts_printf("SEARCH MESSAGE IS NULL\n");
+	 erts_printf("R(0) %T\n", r(0));
+     }
+
+     int index = msgp->index;
+
+     HashtableEntry *entry;
+     HASH_FIND_INT(c_p->hashtable, &index, entry);
+     UNLINK_MESSAGE(c_p, msgp, entry);
      JOIN_MESSAGE(c_p);
      CANCEL_TIMER(c_p);
+          if (c_p->debug >= 1) {
+       tmp = SEARCH_MESSAGE(c_p);
+       if (*tmp == NULL)
+	 erts_printf("SEARCH AFTER IS NULL\n");
+       else {
+	 erts_printf("SEARCH AFTER IS: %T\n", ERL_MESSAGE_TERM(*tmp));
+       }
+       if (msgp->next == NULL)
+	 erts_printf("MESSAGE AFTER is NULL\n");
+       else
+	 erts_printf("MESSAGE AFTER is %T\n", ERL_MESSAGE_TERM(msgp->next));
+       erts_printf("---------\n");
+	  }
      free_message(msgp);
 
+
      PROCESS_MAIN_CHK_LOCKS(c_p);
 
      NextPF(0, next);
  }
 
+
+ /*
+  *  Same as remove_message but leave it in the place
+  *  End search.
+  */
+ OpCase(found_message) : {
+     Eterm* next;
+     ErlMessage** tmp;
+     ErlMessage* tmp2;
+
+     PROCESS_MAIN_CHK_LOCKS(c_p);
+     PreFetch(0, next);
+     //msgp = PEEK_MESSAGE(c_p);
+     //     if (IS_TRACED_FL(c_p, F_TRACE_RECEIVE)) {
+     //	 trace_receive(c_p, am_timeout);
+     //}
+     if (c_p->ct != NULL) {
+	 save_calls(c_p, &exp_receive);
+     }
+     /*
+     if (ERL_MESSAGE_TOKEN(msgp) == NIL) {
+	 SEQ_TRACE_TOKEN(c_p) = NIL;
+     } else if (ERL_MESSAGE_TOKEN(msgp) != am_undefined) {
+	 Eterm msg;
+	 SEQ_TRACE_TOKEN(c_p) = ERL_MESSAGE_TOKEN(msgp);
+	 ASSERT(is_tuple(SEQ_TRACE_TOKEN(c_p)));
+	 ASSERT(SEQ_TRACE_TOKEN_ARITY(c_p) == 5);
+	 ASSERT(is_small(SEQ_TRACE_TOKEN_SERIAL(c_p)));
+	 ASSERT(is_small(SEQ_TRACE_TOKEN_LASTCNT(c_p)));
+	 ASSERT(is_small(SEQ_TRACE_TOKEN_FLAGS(c_p)));
+	 ASSERT(is_pid(SEQ_TRACE_TOKEN_SENDER(c_p)));
+	 c_p->seq_trace_lastcnt = unsigned_val(SEQ_TRACE_TOKEN_SERIAL(c_p));
+	 if (c_p->seq_trace_clock < unsigned_val(SEQ_TRACE_TOKEN_SERIAL(c_p))) {
+	     c_p->seq_trace_clock = unsigned_val(SEQ_TRACE_TOKEN_SERIAL(c_p));
+	 }
+	 msg = ERL_MESSAGE_TERM(msgp);
+	 seq_trace_output(SEQ_TRACE_TOKEN(c_p), msg, SEQ_TRACE_RECEIVE, 
+			  c_p->id, c_p);
+			  }*/
+     //UNLINK_MESSAGE(c_p, msgp);
+     //JOIN_MESSAGE(c_p);
+
+     //     erl_exit(1, "Saving message in message found");
+     SET_FOUND_INDEX(c_p);
+     UPDATE_SEARCH(c_p);
+     if (c_p->debug) {
+       erts_printf("[%d]: Found message\n", c_p->id);
+       tmp = SEARCH_MESSAGE(c_p);
+
+       if (tmp != NULL && *tmp != NULL) {
+	 erts_printf("FOUND, REPLACED WITH: %T\n", ERL_MESSAGE_TERM(*tmp));
+	 tmp2 = (*tmp)->next;
+	 if (tmp2 == NULL)
+	   erts_printf("Next is NULL\n");
+	 else
+	   erts_printf("Next is Not NULL: %T\n", ERL_MESSAGE_TERM((*tmp)->next));
+       } else
+	 erts_printf("FOUND, REPLACED with NULL\n");
+     }
+     CANCEL_TIMER(c_p);
+
+     PROCESS_MAIN_CHK_LOCKS(c_p);
+     if (c_p->debug) {
+       erts_printf("[%d]: NEEXT: %T\n",c_p->id, *next);
+       erts_printf("VAL:E %T\n", *E);
+     }
+     //Next(0);
+     NextPF(0, next);
+ }
+
     /*
      * Advance the save pointer to the next message (the current
      * message didn't match), then jump to the loop_rec instruction.
@@ -1607,6 +1780,14 @@ void process_main(void)
      SAVE_MESSAGE(c_p);
      goto loop_rec__;
  }
+
+ OpCase(loop_search_end_f): {
+     SET_I((Eterm *) Arg(0));
+     UPDATE_SEARCH(c_p);
+     if (c_p->debug)
+       erts_printf("[%d]: UPDATE SEARCH POINTER E[%T]\n", c_p->id, *E);
+     goto loop_search__;
+ }
     /*
      * Prepare to wait for a message or a timeout, whichever occurs first.
      *
@@ -1685,6 +1866,7 @@ void process_main(void)
 
 	 wait2: {
 	     ASSERT(!ERTS_PROC_IS_EXITING(c_p));
+	     /* FIXME: does this work correct for search? */
 	     c_p->i = (Eterm *) Arg(0); /* L1 */
 	     SWAPOUT;
 	     c_p->arity = 0;
@@ -1737,6 +1919,7 @@ void process_main(void)
      if (c_p->ct != NULL) {
 	 save_calls(c_p, &exp_timeout);
      }
+
      c_p->flags &= ~F_TIMO;
      JOIN_MESSAGE(c_p);
      NextPF(0, next);
@@ -2028,9 +2211,13 @@ void process_main(void)
 	PRE_BIF_SWAPOUT(c_p);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p));
 	result = (*bf)(c_p, r(0), I);
+	if (c_p->debug)
+	  erts_printf("[%d]: After BIF call\n", c_p->id);
 	ASSERT(!ERTS_PROC_IS_EXITING(c_p) || is_non_value(result));
 	ERTS_HOLE_CHECK(c_p);
 	POST_BIF_GC_SWAPIN(c_p, result, reg, 1);
+	if (c_p->debug)
+	  erts_printf("[%d]: BIF: [%T]\n", c_p->id, *E);
 	FCALLS = c_p->fcalls;
         if (is_value(result)) {
 	    r(0) = result;
diff -urNp otp_src_R12B-5/erts/emulator/beam/bif.c minimal_otp_src_R12B-5/erts/emulator/beam/bif.c
--- otp_src_R12B-5/erts/emulator/beam/bif.c	2008-11-04 10:51:08.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/bif.c	2009-06-23 20:40:30.000000000 +0100
@@ -36,6 +36,8 @@
 #include "erl_db_util.h"
 #include "register.h"
 
+#include "erl_printf.h"
+
 #define DECL_AM(S) Eterm AM_ ## S = am_atom_put(#S, sizeof(#S) - 1)
 
 /*
@@ -1911,6 +1913,119 @@ send_3(Process *p, Eterm to, Eterm msg, 
 }
 
 Eterm
+ebif_search_reset_0(Process *p) {
+    ErlMessage** tmp;
+
+    if (p->debug) {
+      erts_printf("[%d]: BIF: Reset search\n", p->id);
+      tmp = SEARCH_MESSAGE(p);
+      if ((tmp != NULL) && (*tmp != NULL)) {
+	erts_printf("Search was pointing at: %T\n", ERL_MESSAGE_TERM(*tmp));
+      } else {
+	erts_printf("Search was pointing at NULL\n");
+      }
+
+    }
+    BIF_PROCESS_MAIN_CHK_LOCKS(p);
+    RESET_SEARCH(p);
+    //    BUMP_REDS(p, 0);
+    BIF_RET(am_ok);
+}
+
+Eterm
+ebif_search_debug_1(Process *p, Eterm state) {
+    if (state == am_on)
+      p->debug = 1;
+    else if (state == am_off)
+      p->debug = 0;
+}
+
+Eterm
+ebif_last_search_index_0(Process *p) {
+  if (p->debug)
+    erts_printf("[%d]: ebif_last_search_index_0\n", p->id);
+
+  Eterm* hp = HAlloc(p, 3);
+  Eterm result;
+  result = TUPLE2(hp, am_ok, make_small(p->msg.foundIndex));
+  BIF_RET(result);
+}
+
+Eterm
+ebif_search_index_1(Process *p, Eterm value) {
+  int index;
+  if (p->debug)
+    erts_printf("[%d]: Starting ebif_search_index_1\n", p->id);
+
+  BIF_PROCESS_MAIN_CHK_LOCKS(p);
+  index = (int)signed_val(value);
+
+  if (p->debug)
+    erts_printf("Searching for the index %d\n", index);
+
+  HashtableEntry *entry;
+  HASH_FIND_INT(p->hashtable, &index, entry);
+
+  if (entry == NULL) {
+    BIF_RET(am_undefined);
+  } else {
+    BIF_RET(ERL_MESSAGE_TERM(entry->msg));
+  }
+}
+
+Eterm
+ebif_receive_index_1(Process *p, Eterm e_index) {
+  ErlMessage* msgp;
+  Eterm result;
+  int index = (int)signed_val(e_index);
+
+  BIF_PROCESS_MAIN_CHK_LOCKS(p);
+  JOIN_MESSAGE(p);
+
+  HashtableEntry *entry;
+  HASH_FIND_INT(p->hashtable, &index, entry);
+  
+  if (entry == NULL) {
+    BIF_RET(am_undefined);
+  } else {
+    Eterm* hp = HAlloc(p, 3);
+    if (p->debug)
+      erts_printf("[%d]: Returning message with id %d\n", p->id, index);
+
+    msgp = entry->msg;
+
+    Eterm result;
+    result = TUPLE2(hp, am_ok, ERL_MESSAGE_TERM(msgp));
+    
+    // This could be possibly simplified
+
+    msgp = PEEK_MESSAGE(p);
+    while (msgp != NULL) {
+      if (msgp->index != index) {
+	SAVE_MESSAGE(p);
+	msgp = PEEK_MESSAGE(p);
+      } else {
+	if (p->debug)
+	  erts_printf("Returning the required index\n");
+	break;
+      }
+    }
+
+    if (msgp == NULL) {
+      // Should never happen
+      BIF_RET(am_undefined);
+    }
+
+    UNLINK_MESSAGE(p, msgp, entry);
+    JOIN_MESSAGE(p);
+    if (p->debug)
+      erts_printf("Freeing message\n");
+    free_message(msgp);
+    BIF_RET(result);
+  }
+}
+
+Eterm
 send_2(Process *p, Eterm to, Eterm msg) {
     Sint result = do_send(p, to, msg, !0);
     
diff -urNp otp_src_R12B-5/erts/emulator/beam/bif.h minimal_otp_src_R12B-5/erts/emulator/beam/bif.h
--- otp_src_R12B-5/erts/emulator/beam/bif.h	2008-10-15 13:30:33.000000000 +0100
+++ minimal_otp_src_R12B-5/erts/emulator/beam/bif.h	2009-06-23 20:40:30.000000000 +0100
@@ -233,5 +233,24 @@ do {									\
 #endif
 
 #include "erl_bif_table.h"
+#include "erl_process_lock.h"
+#include "erl_lock_check.h"
+
+#ifdef ERTS_ENABLE_LOCK_CHECK
+#  ifdef ERTS_SMP
+#    define BIF_PROCESS_MAIN_CHK_LOCKS(P)				\
+do {									\
+    if ((P))								\
+	erts_proc_lc_chk_only_proc_main((P));				\
+    else								\
+	erts_lc_check_exact(NULL, 0);					\
+    ERTS_SMP_LC_ASSERT(!ERTS_LC_IS_BLOCKING);				\
+} while (0)
+#  else
+#    define BIF_PROCESS_MAIN_CHK_LOCKS(P) erts_lc_check_exact(NULL, 0)
+#  endif
+#else
+#  define BIF_PROCESS_MAIN_CHK_LOCKS(P)
+#endif
 
 #endif
diff -urNp otp_src_R12B-5/erts/emulator/beam/bif.tab minimal_otp_src_R12B-5/erts/emulator/beam/bif.tab
--- otp_src_R12B-5/erts/emulator/beam/bif.tab	2008-11-04 10:51:09.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/bif.tab	2009-06-23 20:40:30.000000000 +0100
@@ -726,6 +726,16 @@ bif unicode:characters_to_binary/2
 bif unicode:characters_to_list/2
 
 #
+# Joins in R12B-5
+#
+
+bif erlang:search_reset/0	ebif_search_reset_0
+bif erlang:last_search_index/0	ebif_last_search_index_0
+bif erlang:search_debug/1	ebif_search_debug_1
+bif erlang:search_index/1	ebif_search_index_1
+bif erlang:receive_index/1	ebif_receive_index_1
+
+#
 # Obsolete
 #
 
diff -urNp otp_src_R12B-5/erts/emulator/beam/break.c minimal_otp_src_R12B-5/erts/emulator/beam/break.c
--- otp_src_R12B-5/erts/emulator/beam/break.c	2008-04-07 14:57:51.000000000 +0100
+++ minimal_otp_src_R12B-5/erts/emulator/beam/break.c	2009-06-23 20:40:30.000000000 +0100
@@ -283,6 +283,8 @@ print_process_info(int to, void *to_arg,
 		erts_print(to, to_arg, "send");
 	     else if (p->ct->ct[j] == &exp_receive)
 		erts_print(to, to_arg, "'receive'");
+	     else if (p->ct->ct[j] == &exp_search)
+		erts_print(to, to_arg, "'search'");	    
 	     else if (p->ct->ct[j] == &exp_timeout)
 		   erts_print(to, to_arg, "timeout");
 	     else
diff -urNp otp_src_R12B-5/erts/emulator/beam/erl_bif_info.c minimal_otp_src_R12B-5/erts/emulator/beam/erl_bif_info.c
--- otp_src_R12B-5/erts/emulator/beam/erl_bif_info.c	2008-11-04 10:51:34.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/erl_bif_info.c	2009-06-23 20:40:30.000000000 +0100
@@ -1410,6 +1410,8 @@ process_info_aux(Process *BIF_P,
 		    term = am_send;
 		else if (rp->ct->ct[j] == &exp_receive)
 		    term = am_receive;
+		else if (rp->ct->ct[j] == &exp_search)
+		    term = am_search;
 		else if (rp->ct->ct[j] == &exp_timeout)
 		    term = am_timeout;
 		else {
diff -urNp otp_src_R12B-5/erts/emulator/beam/erl_bif_trace.c minimal_otp_src_R12B-5/erts/emulator/beam/erl_bif_trace.c
--- otp_src_R12B-5/erts/emulator/beam/erl_bif_trace.c	2008-09-01 13:51:21.000000000 +0100
+++ minimal_otp_src_R12B-5/erts/emulator/beam/erl_bif_trace.c	2009-06-23 20:40:30.000000000 +0100
@@ -357,6 +357,7 @@ erts_trace_flag2bit(Eterm flag) 
     case am_all: return TRACEE_FLAGS;
     case am_send: return F_TRACE_SEND;
     case am_receive: return F_TRACE_RECEIVE;
+    case am_search: return F_TRACE_SEARCH;
     case am_set_on_spawn: return F_TRACE_SOS;
     case am_procs: return F_TRACE_PROCS;
     case am_set_on_first_spawn: return F_TRACE_SOS1;
@@ -893,6 +894,7 @@ trace_info_pid(Process* p, Eterm pid_spe
 	limit = hp+needed;
 	FLAG(F_TRACE_SEND, am_send);
 	FLAG(F_TRACE_RECEIVE, am_receive);
+	FLAG(F_TRACE_SEARCH, am_search);
 	FLAG(F_TRACE_SOS, am_set_on_spawn);
 	FLAG(F_TRACE_CALLS, am_call);
 	FLAG(F_TRACE_PROCS, am_procs);
@@ -1587,6 +1589,8 @@ Eterm erts_seq_trace(Process *p, Eterm a
 	current_flag = SEQ_TRACE_SEND;
     } else if (arg1 == am_receive) {
 	current_flag = SEQ_TRACE_RECEIVE; 
+    } else if (arg1 == am_search) {
+	current_flag = SEQ_TRACE_SEARCH; 
     } else if (arg1 == am_print) {
 	current_flag = SEQ_TRACE_PRINT; 
     } else if (arg1 == am_timestamp) {
@@ -1687,7 +1691,8 @@ BIF_RETTYPE seq_trace_info_1(BIF_ALIST_1
     item = BIF_ARG_1;
 
     if (SEQ_TRACE_TOKEN(BIF_P) == NIL) {
-	if ((item == am_send) || (item == am_receive) || 
+	if ((item == am_send) || (item == am_receive) ||
+	    (item == am_search) ||
 	    (item == am_print) || (item == am_timestamp)) {
 	    hp = HAlloc(BIF_P,3);
 	    res = TUPLE2(hp, item, am_false);
@@ -1703,6 +1708,8 @@ BIF_RETTYPE seq_trace_info_1(BIF_ALIST_1
 	current_flag = SEQ_TRACE_SEND;
     } else if (BIF_ARG_1 == am_receive) {
 	current_flag = SEQ_TRACE_RECEIVE; 
+    } else if (BIF_ARG_1 == am_search) {
+	current_flag = SEQ_TRACE_SEARCH; 
     } else if (BIF_ARG_1 == am_print) {
 	current_flag = SEQ_TRACE_PRINT; 
     } else if (BIF_ARG_1 == am_timestamp) {
diff -urNp otp_src_R12B-5/erts/emulator/beam/erl_message.c minimal_otp_src_R12B-5/erts/emulator/beam/erl_message.c
--- otp_src_R12B-5/erts/emulator/beam/erl_message.c	2008-09-01 13:51:20.000000000 +0100
+++ minimal_otp_src_R12B-5/erts/emulator/beam/erl_message.c	2009-06-23 20:40:30.000000000 +0100
@@ -268,6 +268,7 @@ erts_queue_message(Process* receiver,
     ERL_MESSAGE_TERM(mp) = message;
     ERL_MESSAGE_TOKEN(mp) = seq_trace_token;
     mp->next = NULL;
+    //    mp->index = 0;
 
 #ifdef ERTS_SMP
     if (receiver_locks & ERTS_PROC_LOCK_MAIN) {
@@ -712,6 +713,7 @@ erts_send_message(Process* sender,
 	    ERL_MESSAGE_TERM(mp) = message;
 	    ERL_MESSAGE_TOKEN(mp) = NIL;
 	    mp->next = NULL;
+	    //	    mp->index = 0;
 	    /*
 	     * We move 'in queue' to 'private queue' and place
 	     * message at the end of 'private queue' in order
diff -urNp otp_src_R12B-5/erts/emulator/beam/erl_message.h minimal_otp_src_R12B-5/erts/emulator/beam/erl_message.h
--- otp_src_R12B-5/erts/emulator/beam/erl_message.h	2008-09-01 13:51:20.000000000 +0100
+++ minimal_otp_src_R12B-5/erts/emulator/beam/erl_message.h	2009-06-23 20:40:30.000000000 +0100
@@ -64,6 +64,7 @@ do {									\
 typedef struct erl_mesg {
     struct erl_mesg* next;	/* Next message */
     ErlHeapFragment *bp;
+    int index;
     Eterm m[2];			/* m[0] = message, m[1] = seq trace token */
 } ErlMessage;
 
@@ -77,7 +78,10 @@ typedef struct {
     ErlMessage* first;
     ErlMessage** last;  /* point to the last next pointer */
     ErlMessage** save;
+    ErlMessage** search;
     int len;            /* queue length */
+    int index;
+    int foundIndex;
 } ErlMessageQueue;
 
 #ifdef ERTS_SMP
@@ -93,12 +97,23 @@ typedef struct {
 /* Get "current" message */
 #define PEEK_MESSAGE(p)  (*(p)->msg.save)
 
-
 /* Add message last in private message queue */
 #define LINK_MESSAGE_PRIVQ(p, mp) do { \
-    *(p)->msg.last = (mp); \
-    (p)->msg.last = &(mp)->next; \
-    (p)->msg.len++; \
+    (mp)->index = (p)->msg.index;		\
+    HashtableEntry *tmp = (HashtableEntry*)(malloc(sizeof(HashtableEntry))); \
+    tmp->index = (mp)->index;						\
+    tmp->msg = (mp);							\
+    HASH_ADD_INT((p)->hashtable, index, tmp);				\
+    *(p)->msg.last = (mp);			\
+    if ((p)->debug) {							\
+      erts_printf("[%d]: Linking message: %T\n", (p)->id, ERL_MESSAGE_TERM(mp)); \
+      if (*(p)->msg.search == NULL)					\
+	erts_printf("Search is NULL\n");				\
+      else								\
+	erts_printf("Search is %T\n", ERL_MESSAGE_TERM(*(p)->msg.search));}\
+    (p)->msg.last = &(mp)->next;		\
+    (p)->msg.index++;				\
+    (p)->msg.len++;				\
 } while(0)
 
 
@@ -109,6 +124,17 @@ typedef struct {
 do {							\
     if ((P)->msg_inq.first) {				\
 	*(P)->msg.last = (P)->msg_inq.first;		\
+	ErlMessage* tmpMessage = (P)->msg_inq.first;	\
+	HashtableEntry *tmp;					\
+        while (tmpMessage != NULL) {				\
+	  tmpMessage->index = (P)->msg.index++;		\
+	  tmp = (HashtableEntry*)(malloc(sizeof(HashtableEntry)));	\
+	  if (tmp == NULL) erts_printf("MALLOC RETURNED NULL\n");	\
+	  tmp->index = tmpMessage->index;		\
+	  tmp->msg = tmpMessage;			\
+	  HASH_ADD_INT((P)->hashtable, index, tmp);	\
+	  tmpMessage = tmpMessage->next;		\
+	}						\
 	(P)->msg.last = (P)->msg_inq.last;		\
 	(P)->msg.len += (P)->msg_inq.len;		\
 	(P)->msg_inq.first = NULL;			\
@@ -133,10 +159,17 @@ do {							\
 
 #endif
 
+
 /* Unlink current message */
-#define UNLINK_MESSAGE(p,msgp) do { \
-     ErlMessage* __mp = (msgp)->next; \
-     *(p)->msg.save = __mp; \
+#define UNLINK_MESSAGE(p,msgp, hash) do {  \
+     ErlMessage* __mp = (msgp)->next;	   \
+     *(p)->msg.save = __mp; 		   \
+     HASH_DEL(p->hashtable, hash);	   \
+     free(hash);							\
+     if ( (*(p)->msg.search != NULL) && (*(p)->msg.search == msgp)) {	\
+       (p)->msg.search = (p)->msg.save;	}				\
+     else if ((*(p)->msg.search == __mp)) {				\
+       (p)->msg.search = (p)->msg.save; }				\
      (p)->msg.len--; \
      if (__mp == NULL) \
          (p)->msg.last = (p)->msg.save; \
@@ -150,6 +183,17 @@ do {							\
 #define SAVE_MESSAGE(p) \
      (p)->msg.save = &(*(p)->msg.save)->next
 
+
+// FIXME: this doesn't work in case of search
+#define UPDATE_SEARCH(p) do {			\
+  (p)->msg.search = &(*(p)->msg.search)->next;	\
+} while (0)
+
+#define SEARCH_MESSAGE(p) ((p)->msg.search)
+#define SET_FOUND_INDEX(p) (p)->msg.foundIndex = (*(p)->msg.search)->index
+
+#define RESET_SEARCH(p) (p)->msg.search = &(p)->msg.first
+
 #define ERTS_SND_FLG_NO_SEQ_TRACE		(((unsigned) 1) << 0)
 
 void init_message(void);
diff -urNp otp_src_R12B-5/erts/emulator/beam/erl_process.c minimal_otp_src_R12B-5/erts/emulator/beam/erl_process.c
--- otp_src_R12B-5/erts/emulator/beam/erl_process.c	2008-11-04 10:51:10.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/erl_process.c	2009-06-23 20:40:30.000000000 +0100
@@ -2746,6 +2746,8 @@ erl_create_process(Process* parent, /* P
     p->msg.first = NULL;
     p->msg.last = &p->msg.first;
     p->msg.save = &p->msg.first;
+    p->msg.search = &p->msg.first;
+    p->msg.index = 0;
     p->msg.len = 0;
 #ifdef ERTS_SMP
     p->msg_inq.first = NULL;
@@ -2772,6 +2774,8 @@ erl_create_process(Process* parent, /* P
 #ifdef DEBUG
     p->last_old_htop = NULL;
 #endif
+    p->debug = 0;
+    p->hashtable = NULL;
 
     if (IS_TRACED(parent)) {
 	if (parent->trace_flags & F_TRACE_SOS) {
@@ -2970,7 +2974,9 @@ void erts_init_empty_process(Process *p)
     p->msg.first = NULL;
     p->msg.last = &p->msg.first;
     p->msg.save = &p->msg.first;
+    p->msg.search = &p->msg.first;
     p->msg.len = 0;
+    p->msg.index = 0;
     p->bif_timers = NULL;
     p->dictionary = NULL;
     p->ct = NULL;
@@ -3021,6 +3027,8 @@ void erts_init_empty_process(Process *p)
 #ifdef DEBUG
     p->last_old_htop = NULL;
 #endif
+    p->debug = 0;
+    p->hashtable = NULL;
 
 
 #ifdef ERTS_SMP
diff -urNp otp_src_R12B-5/erts/emulator/beam/erl_process.h minimal_otp_src_R12B-5/erts/emulator/beam/erl_process.h
--- otp_src_R12B-5/erts/emulator/beam/erl_process.h	2008-11-04 10:51:11.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/erl_process.h	2009-06-23 20:40:30.000000000 +0100
@@ -45,6 +45,8 @@ typedef struct process Process;
 #include "erl_bif_timer.h"
 #include "erl_time.h"
 
+#include "uthash.h"
+
 #ifdef HIPE
 #include "hipe_process.h"
 #endif
@@ -78,7 +80,15 @@ struct saved_calls {
    Export *ct[1];
 };
 
-extern Export exp_send, exp_receive, exp_timeout;
+/* Define hash map for each element in the message queue
+   This is for faster matching using indexes. */
+typedef struct HashtableEntry {
+  int index;
+  ErlMessage* msg;
+  UT_hash_handle hh;
+} HashtableEntry;
+
+extern Export exp_send, exp_receive, exp_timeout, exp_search;
 extern Uint erts_no_schedulers;
 
 #ifdef ERTS_SMP
@@ -330,8 +340,11 @@ struct process {
 				 * heap fragments.
 				 */
 #endif
+    int debug; /*Used for turning on/off debugging on runtime */
+    HashtableEntry *hashtable;
 };
 
+
 #ifdef CHECK_FOR_HOLES
 # define INIT_HOLE_CHECK(p)			\
 do {						\
@@ -524,8 +537,9 @@ extern struct erts_system_profile_flags_
 #define F_TRACE_PORTS	     (1 << 20) /* Ports equivalent to F_TRACE_PROCS */
 #define F_TRACE_SCHED_NO     (1 << 21) /* Trace with scheduler id */
 #define F_TRACE_SCHED_EXIT   (1 << 22)
+#define F_TRACE_SEARCH       (1 << 23)
 
-#define F_NUM_FLAGS          23
+#define F_NUM_FLAGS          24
 #ifdef DEBUG
 #  define F_INITIAL_TRACE_FLAGS (5 << F_NUM_FLAGS)
 #else
@@ -536,6 +550,7 @@ extern struct erts_system_profile_flags_
 
 #define TRACEE_FLAGS ( F_TRACE_PROCS | F_TRACE_CALLS \
 		     | F_TRACE_SOS |  F_TRACE_SOS1| F_TRACE_RECEIVE  \
+		     | F_TRACE_SEARCH \
 		     | F_TRACE_SOL | F_TRACE_SOL1 | F_TRACE_SEND \
 		     | F_TRACE_SCHED | F_TIMESTAMP | F_TRACE_GC \
 		     | F_TRACE_ARITY_ONLY | F_TRACE_RETURN_TO \
@@ -555,6 +570,7 @@ extern struct erts_system_profile_flags_
 #define SEQ_TRACE_RECEIVE  (1 << 1)
 #define SEQ_TRACE_PRINT    (1 << 2)
 #define SEQ_TRACE_TIMESTAMP (1 << 3)
+#define SEQ_TRACE_SEARCH (1 << 4)
 
 #ifdef ERTS_SMP
 /* Status flags ... */
diff -urNp otp_src_R12B-5/erts/emulator/beam/erl_trace.c minimal_otp_src_R12B-5/erts/emulator/beam/erl_trace.c
--- otp_src_R12B-5/erts/emulator/beam/erl_trace.c	2008-11-04 10:51:32.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/erl_trace.c	2009-06-23 20:40:30.000000000 +0100
@@ -46,7 +46,7 @@ extern Eterm beam_return_trace[1];    /*
 
 /* Pseudo export entries. Never filled in with data, only used to
    yield unique pointers of the correct type. */
-Export exp_send, exp_receive, exp_timeout;
+Export exp_send, exp_receive, exp_timeout, exp_search;
 
 static Eterm system_seq_tracer;
 static Uint default_trace_flags;
@@ -887,6 +887,7 @@ trace_send(Process *p, Eterm to, Eterm m
     }
 }
 
+// FIXME: add trace for search
 /* Send {trace_ts, Pid, receive, Msg, Timestamp}
  * or   {trace, Pid, receive, Msg}
  */
@@ -993,6 +994,7 @@ seq_trace_output_generic(Eterm token, Et
     case SEQ_TRACE_SEND:    type_atom = am_send; break;
     case SEQ_TRACE_PRINT:   type_atom = am_print; break;
     case SEQ_TRACE_RECEIVE: type_atom = am_receive; break;
+    case SEQ_TRACE_SEARCH:  type_atom = am_search; break;
     default:
 	erl_exit(1, "invalid type in seq_trace_output_generic: %d:\n", type);
 	return;			/* To avoid warning */
diff -urNp otp_src_R12B-5/erts/emulator/beam/global.h minimal_otp_src_R12B-5/erts/emulator/beam/global.h
--- otp_src_R12B-5/erts/emulator/beam/global.h	2008-11-04 10:51:10.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/global.h	2009-06-23 20:40:30.000000000 +0100
@@ -1400,6 +1400,7 @@ void erts_queue_error_logger_message(Ete
 void erts_send_sys_msg_proc(Eterm, Eterm, Eterm, ErlHeapFragment *);
 void trace_send(Process*, Eterm, Eterm);
 void trace_receive(Process*, Eterm);
+void trace_search(Process*, Eterm);
 Uint32 erts_call_trace(Process *p, Eterm mfa[], Binary *match_spec, Eterm* args,
 		       int local, Eterm *tracer_pid);
 void erts_trace_return(Process* p, Eterm* fi, Eterm retval, Eterm *tracer_pid);
diff -urNp otp_src_R12B-5/erts/emulator/beam/ops.tab minimal_otp_src_R12B-5/erts/emulator/beam/ops.tab
--- otp_src_R12B-5/erts/emulator/beam/ops.tab	2008-11-04 10:51:27.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/emulator/beam/ops.tab	2009-06-23 20:40:30.000000000 +0100
@@ -70,6 +70,8 @@ i_debug_breakpoint
 i_count_breakpoint
 i_return_to_trace
 i_yield
+#i_search_index
+#i_receive_index
 i_global_cons
 i_global_tuple
 i_global_copy
@@ -275,6 +277,7 @@ move s d
 # Receive operations.
 
 loop_rec Fail Src | smp_mark_target_label(Fail) => i_loop_rec Fail Src
+loop_search Fail Src | smp_mark_target_label(Fail) => i_loop_search Fail Src
 
 label L | wait_timeout Fail Src | smp_already_locked(L) => label L | i_wait_timeout_locked Fail Src
 wait_timeout Fail Src => i_wait_timeout Fail Src
@@ -287,10 +290,13 @@ wait Fail | smp() => wait_unlocked Fail
 label L | timeout | smp_already_locked(L) => label L | timeout_locked
 
 remove_message
+found_message
 timeout
 timeout_locked
 i_loop_rec f r
+i_loop_search f r
 loop_rec_end f
+loop_search_end f
 wait f
 wait_locked f
 wait_unlocked f
@@ -799,6 +805,20 @@ call_ext_last u==0 u$func:erlang:yield/0
 call_ext_only u==0 u$func:erlang:yield/0 => i_yield | return
 
 #
+# The functions for manipulation of mailbox
+# search_index/1, receive_index/1 is an instruction
+#
+
+#call_ext u==1 u$func:erlang:search_index/1 => i_search_index
+#call_ext_last u==1 u$func:erlang:search_index/1 D => i_search_index | deallocate_return D
+#call_ext_only Ar=u==1 u$func:erlang:search_index/1 => i_search_index | return
+
+#call_ext Ar=u==1 u$func:erlang:receive_index/1 => i_receive_index
+#call_ext_last Ar=u==1 u$func:erlang:receive_index/1 D => i_receive_index | deallocate_return u
+#call_ext_only Ar=u==1 u$func:erlang:receive_index/1 => allocate u Ar | i_receive_index | deallocate_return u
+
+
+#
 # The hibernate/3 BIF is an instruction.
 #
 call_ext u==3 u$func:erlang:hibernate/3 => i_hibernate
diff -urNp otp_src_R12B-5/erts/emulator/beam/uthash.h minimal_otp_src_R12B-5/erts/emulator/beam/uthash.h
--- otp_src_R12B-5/erts/emulator/beam/uthash.h	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/erts/emulator/beam/uthash.h	2009-06-23 20:40:30.000000000 +0100
@@ -0,0 +1,612 @@
+/*
+Copyright (c) 2003-2009, Troy D. Hanson     http://uthash.sourceforge.net
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <string.h> /* memcmp,strlen */
+#include <stddef.h> /* ptrdiff_t */
+
+#ifndef UTHASH_H
+#define UTHASH_H 
+
+#define UTHASH_VERSION 1.5
+
+/* C++ requires extra stringent casting */
+#if defined __cplusplus
+#define TYPEOF(x) (typeof(x))
+#else
+#define TYPEOF(x)
+#endif
+
+
+#define uthash_fatal(msg) exit(-1)        /* fatal error (out of memory,etc) */
+#define uthash_bkt_malloc(sz) malloc(sz)  /* malloc fcn for UT_hash_bucket's */
+#define uthash_bkt_free(ptr) free(ptr)    /* free fcn for UT_hash_bucket's   */
+#define uthash_tbl_malloc(sz) malloc(sz)  /* malloc fcn for UT_hash_table    */
+#define uthash_tbl_free(ptr) free(ptr)    /* free fcn for UT_hash_table      */
+
+#define uthash_noexpand_fyi(tbl)          /* can be defined to log noexpand  */
+#define uthash_expand_fyi(tbl)            /* can be defined to log expands   */
+
+/* initial number of buckets */
+#define HASH_INITIAL_NUM_BUCKETS 32      /* initial number of buckets        */
+#define HASH_INITIAL_NUM_BUCKETS_LOG2 5  /* lg2 of initial number of buckets */
+#define HASH_BKT_CAPACITY_THRESH 10      /* expand when bucket count reaches */
+
+/* calculate the element whose hash handle address is hhe */
+#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)hhp) - (tbl)->hho))
+
+#define HASH_FIND(hh,head,keyptr,keylen,out)                                   \
+do {                                                                           \
+  unsigned _hf_bkt,_hf_hashv;                                                  \
+  out=TYPEOF(out)head;                                                         \
+  if (head) {                                                                  \
+     HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt); \
+     HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ],  \
+                      keyptr,keylen,out);                                      \
+  }                                                                            \
+} while (0)
+
+#define HASH_ADD(hh,head,fieldname,keylen_in,add)                              \
+        HASH_ADD_KEYPTR(hh,head,&add->fieldname,keylen_in,add)
+ 
+#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add)                          \
+do {                                                                           \
+ unsigned _ha_bkt;                                                             \
+ add->hh.next = NULL;                                                          \
+ add->hh.key = (char*)keyptr;                                                  \
+ add->hh.keylen = keylen_in;                                                   \
+ if (!(head)) {                                                                \
+    head = add;                                                                \
+    (head)->hh.prev = NULL;                                                    \
+    (head)->hh.tbl = (UT_hash_table*)uthash_tbl_malloc(                        \
+                    sizeof(UT_hash_table));                                    \
+    if (!((head)->hh.tbl))  { uthash_fatal( "out of memory"); }                \
+    memset((head)->hh.tbl, 0, sizeof(UT_hash_table));                          \
+    (head)->hh.tbl->tail = &(add->hh);                                         \
+    (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;                    \
+    (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;          \
+    (head)->hh.tbl->hho = (char*)(&add->hh) - (char*)(add);                    \
+    (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_bkt_malloc(              \
+            HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));           \
+    if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); }         \
+    memset((head)->hh.tbl->buckets, 0,                                         \
+            HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));           \
+ } else {                                                                      \
+    (head)->hh.tbl->tail->next = add;                                          \
+    add->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail);         \
+    (head)->hh.tbl->tail = &(add->hh);                                         \
+ }                                                                             \
+ (head)->hh.tbl->num_items++;                                                  \
+ add->hh.tbl = (head)->hh.tbl;                                                 \
+ HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets,                       \
+         (add)->hh.hashv, _ha_bkt);                                            \
+ HASH_ADD_TO_BKT(hh,(head)->hh.tbl->buckets[_ha_bkt],add);                     \
+ HASH_EMIT_KEY(hh,head,keyptr,keylen_in);                                      \
+ HASH_FSCK(hh,head);                                                           \
+} while(0)
+
+#define HASH_TO_BKT( hashv, num_bkts, bkt ) bkt = ((hashv) & ((num_bkts) - 1))
+
+/* delete "delptr" from the hash table.
+ * "the usual" patch-up process for the app-order doubly-linked-list.
+ * The use of _hd_hh_del below deserves special explanation.
+ * These used to be expressed using (delptr) but that led to a bug
+ * if someone used the same symbol for the head and deletee, like
+ *  HASH_DELETE(hh,users,users);
+ * We want that to work, but by changing the head (users) below
+ * we were forfeiting our ability to further refer to the deletee (users)
+ * in the patch-up process. Solution: use scratch space in the table to
+ * copy the deletee pointer, then the latter references are via that
+ * scratch pointer rather than through the repointed (users) symbol.
+ */
+#define HASH_DELETE(hh,head,delptr)                                            \
+do {                                                                           \
+    unsigned _hd_bkt;                                                          \
+    struct UT_hash_handle *_hd_hh_del;                                         \
+    if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) )  {       \
+        uthash_bkt_free((head)->hh.tbl->buckets );                             \
+        uthash_tbl_free((head)->hh.tbl);                                       \
+        head = NULL;                                                           \
+    } else {                                                                   \
+        _hd_hh_del = &((delptr)->hh);                                          \
+        if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) {   \
+            (head)->hh.tbl->tail =                                             \
+                (UT_hash_handle*)((char*)((delptr)->hh.prev) +                 \
+                (head)->hh.tbl->hho);                                          \
+        }                                                                      \
+        if ((delptr)->hh.prev) {                                               \
+            ((UT_hash_handle*)((char*)((delptr)->hh.prev) +                    \
+                    (head)->hh.tbl->hho))->next = (delptr)->hh.next;           \
+        } else {                                                               \
+            head = TYPEOF(head)((delptr)->hh.next);                            \
+        }                                                                      \
+        if (_hd_hh_del->next) {                                                \
+            ((UT_hash_handle*)((char*)_hd_hh_del->next +                       \
+                    (head)->hh.tbl->hho))->prev =                              \
+                    _hd_hh_del->prev;                                          \
+        }                                                                      \
+        HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \
+        HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del);      \
+        (head)->hh.tbl->num_items--;                                           \
+    }                                                                          \
+    HASH_FSCK(hh,head);                                                        \
+} while (0)
+
+
+/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
+#define HASH_FIND_STR(head,findstr,out)                                        \
+    HASH_FIND(hh,head,findstr,strlen(findstr),out)
+#define HASH_ADD_STR(head,strfield,add)                                        \
+    HASH_ADD(hh,head,strfield,strlen(add->strfield),add)
+#define HASH_FIND_INT(head,findint,out)                                        \
+    HASH_FIND(hh,head,findint,sizeof(int),out)
+#define HASH_ADD_INT(head,intfield,add)                                        \
+    HASH_ADD(hh,head,intfield,sizeof(int),add)
+#define HASH_DEL(head,delptr)                                                  \
+    HASH_DELETE(hh,head,delptr)
+
+/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
+ * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
+ */
+#ifdef HASH_DEBUG
+#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
+#define HASH_FSCK(hh,head)                                                     \
+do {                                                                           \
+    unsigned _bkt_i;                                                           \
+    unsigned _count, _bkt_count;                                               \
+    char *_prev;                                                               \
+    struct UT_hash_handle *_thh;                                               \
+    if (head) {                                                                \
+        _count = 0;                                                            \
+        for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) {     \
+            _bkt_count = 0;                                                    \
+            _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head;                    \
+            _prev = NULL;                                                      \
+            while (_thh) {                                                     \
+               if (_prev != (char*)(_thh->hh_prev)) {                          \
+                   HASH_OOPS("invalid hh_prev %p, actual %p\n",                \
+                    _thh->hh_prev, _prev );                                    \
+               }                                                               \
+               _bkt_count++;                                                   \
+               _prev = (char*)(_thh);                                          \
+               _thh = _thh->hh_next;                                           \
+            }                                                                  \
+            _count += _bkt_count;                                              \
+            if ((head)->hh.tbl->buckets[_bkt_i].count !=  _bkt_count) {        \
+               HASH_OOPS("invalid bucket count %d, actual %d\n",               \
+                (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count);            \
+            }                                                                  \
+        }                                                                      \
+        if (_count != (head)->hh.tbl->num_items) {                             \
+            HASH_OOPS("invalid hh item count %d, actual %d\n",                 \
+                (head)->hh.tbl->num_items, _count );                           \
+        }                                                                      \
+        /* traverse hh in app order; check next/prev integrity, count */       \
+        _count = 0;                                                            \
+        _prev = NULL;                                                          \
+        _thh =  &(head)->hh;                                                   \
+        while (_thh) {                                                         \
+           _count++;                                                           \
+           if (_prev !=(char*)(_thh->prev)) {                                  \
+              HASH_OOPS("invalid prev %p, actual %p\n",                        \
+                    _thh->prev, _prev );                                       \
+           }                                                                   \
+           _prev = ELMT_FROM_HH((head)->hh.tbl, _thh);                         \
+           _thh = ( _thh->next ?  (UT_hash_handle*)((char*)(_thh->next) +      \
+                                  (head)->hh.tbl->hho) : NULL );               \
+        }                                                                      \
+        if (_count != (head)->hh.tbl->num_items) {                             \
+            HASH_OOPS("invalid app item count %d, actual %d\n",                \
+                (head)->hh.tbl->num_items, _count );                           \
+        }                                                                      \
+    }                                                                          \
+} while (0)
+#else
+#define HASH_FSCK(hh,head) 
+#endif
+
+/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to 
+ * the descriptor to which this macro is defined for tuning the hash function.
+ * The app can #include <unistd.h> to get the prototype for write(2). */
+#ifdef HASH_EMIT_KEYS
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)                                 \
+do {                                                                           \
+    unsigned _klen = fieldlen;                                                 \
+    write(HASH_EMIT_KEYS, &_klen, sizeof(_klen));                              \
+    write(HASH_EMIT_KEYS, keyptr, fieldlen);                                   \
+} while (0)
+#else 
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)                    
+#endif
+
+/* default to Jenkins unless specified e.g. DHASH_FUNCTION=HASH_SAX */
+#ifdef HASH_FUNCTION 
+#define HASH_FCN HASH_FUNCTION
+#else
+#define HASH_FCN HASH_JEN
+#endif
+
+/* The Bernstein hash function, used in Perl prior to v5.6 */
+#define HASH_BER(key,keylen,num_bkts,hashv,bkt)                                \
+do {                                                                           \
+  unsigned _hb_keylen=keylen;                                                  \
+  char *_hb_key=(char*)key;                                                    \
+  (hashv) = 0;                                                                 \
+  while (_hb_keylen--)  { (hashv) = ((hashv) * 33) + *_hb_key++; }             \
+  bkt = (hashv) & (num_bkts-1);                                                \
+} while (0)
+
+
+/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at 
+ * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */
+#define HASH_SAX(key,keylen,num_bkts,hashv,bkt)                                \
+do {                                                                           \
+  unsigned _sx_i;                                                              \
+  hashv = 0;                                                                   \
+  for(_sx_i=0; _sx_i < keylen; _sx_i++)                                        \
+      hashv ^= (hashv << 5) + (hashv >> 2) + key[_sx_i];                       \
+  bkt = hashv & (num_bkts-1);                                                  \
+} while (0)
+
+#define HASH_FNV(key,keylen,num_bkts,hashv,bkt)                                \
+do {                                                                           \
+  unsigned _fn_i;                                                              \
+  hashv = 2166136261UL;                                                        \
+  for(_fn_i=0; _fn_i < keylen; _fn_i++)                                        \
+      hashv = (hashv * 16777619) ^ key[_fn_i];                                 \
+  bkt = hashv & (num_bkts-1);                                                  \
+} while(0);
+ 
+#define HASH_OAT(key,keylen,num_bkts,hashv,bkt)                                \
+do {                                                                           \
+  unsigned _ho_i;                                                              \
+  hashv = 0;                                                                   \
+  for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                      \
+      hashv += key[_ho_i];                                                     \
+      hashv += (hashv << 10);                                                  \
+      hashv ^= (hashv >> 6);                                                   \
+  }                                                                            \
+  hashv += (hashv << 3);                                                       \
+  hashv ^= (hashv >> 11);                                                      \
+  hashv += (hashv << 15);                                                      \
+  bkt = hashv & (num_bkts-1);                                                  \
+} while(0)
+
+#define HASH_JEN_MIX(a,b,c)                                                    \
+do {                                                                           \
+  a -= b; a -= c; a ^= ( c >> 13 );                                            \
+  b -= c; b -= a; b ^= ( a << 8 );                                             \
+  c -= a; c -= b; c ^= ( b >> 13 );                                            \
+  a -= b; a -= c; a ^= ( c >> 12 );                                            \
+  b -= c; b -= a; b ^= ( a << 16 );                                            \
+  c -= a; c -= b; c ^= ( b >> 5 );                                             \
+  a -= b; a -= c; a ^= ( c >> 3 );                                             \
+  b -= c; b -= a; b ^= ( a << 10 );                                            \
+  c -= a; c -= b; c ^= ( b >> 15 );                                            \
+} while (0)
+
+#define HASH_JEN(key,keylen,num_bkts,hashv,bkt)                                \
+do {                                                                           \
+  unsigned _hj_i,_hj_j,_hj_k;                                                  \
+  char *_hj_key=(char*)key;                                                    \
+  hashv = 0xfeedbeef;                                                          \
+  _hj_i = _hj_j = 0x9e3779b9;                                                  \
+  _hj_k = keylen;                                                              \
+  while (_hj_k >= 12) {                                                        \
+    _hj_i +=    (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 )                    \
+        + ( (unsigned)_hj_key[2] << 16 )                                       \
+        + ( (unsigned)_hj_key[3] << 24 ) );                                    \
+    _hj_j +=    (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 )                    \
+        + ( (unsigned)_hj_key[6] << 16 )                                       \
+        + ( (unsigned)_hj_key[7] << 24 ) );                                    \
+    hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 )                       \
+        + ( (unsigned)_hj_key[10] << 16 )                                      \
+        + ( (unsigned)_hj_key[11] << 24 ) );                                   \
+                                                                               \
+     HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                        \
+                                                                               \
+     _hj_key += 12;                                                            \
+     _hj_k -= 12;                                                              \
+  }                                                                            \
+  hashv += keylen;                                                             \
+  switch ( _hj_k ) {                                                           \
+     case 11: hashv += ( (unsigned)_hj_key[10] << 24 );                        \
+     case 10: hashv += ( (unsigned)_hj_key[9] << 16 );                         \
+     case 9:  hashv += ( (unsigned)_hj_key[8] << 8 );                          \
+     case 8:  _hj_j += ( (unsigned)_hj_key[7] << 24 );                         \
+     case 7:  _hj_j += ( (unsigned)_hj_key[6] << 16 );                         \
+     case 6:  _hj_j += ( (unsigned)_hj_key[5] << 8 );                          \
+     case 5:  _hj_j += _hj_key[4];                                             \
+     case 4:  _hj_i += ( (unsigned)_hj_key[3] << 24 );                         \
+     case 3:  _hj_i += ( (unsigned)_hj_key[2] << 16 );                         \
+     case 2:  _hj_i += ( (unsigned)_hj_key[1] << 8 );                          \
+     case 1:  _hj_i += _hj_key[0];                                             \
+  }                                                                            \
+  HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                           \
+  bkt = hashv & (num_bkts-1);                                                  \
+} while(0)
+
+
+/* key comparison function; return 0 if keys equal */
+#define HASH_KEYCMP(a,b,len) memcmp(a,b,len) 
+
+/* iterate over items in a known bucket to find desired item */
+#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out)                     \
+out = TYPEOF(out)((head.hh_head) ? ELMT_FROM_HH(tbl,head.hh_head) : NULL);     \
+while (out) {                                                                  \
+    if (out->hh.keylen == keylen_in) {                                         \
+        if ((HASH_KEYCMP(out->hh.key,keyptr,keylen_in)) == 0) break;           \
+    }                                                                          \
+    out= TYPEOF(out)((out->hh.hh_next) ?                                       \
+                     ELMT_FROM_HH(tbl,out->hh.hh_next) : NULL);                \
+}
+
+/* add an item to a bucket  */
+#define HASH_ADD_TO_BKT(hh,head,add)                                           \
+ head.count++;                                                                 \
+ add->hh.hh_next = head.hh_head;                                               \
+ add->hh.hh_prev = NULL;                                                       \
+ if (head.hh_head) head.hh_head->hh_prev = &add->hh;                           \
+ head.hh_head=&add->hh;                                                        \
+ if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH)           \
+     && add->hh.tbl->noexpand != 1) {                                          \
+       HASH_EXPAND_BUCKETS(add->hh.tbl);                                       \
+ }
+
+/* remove an item from a given bucket */
+#define HASH_DEL_IN_BKT(hh,head,hh_del)                                        \
+    (head).count--;                                                            \
+    if ((head).hh_head == hh_del) {                                            \
+      (head).hh_head = hh_del->hh_next;                                        \
+    }                                                                          \
+    if (hh_del->hh_prev) {                                                     \
+        hh_del->hh_prev->hh_next = hh_del->hh_next;                            \
+    }                                                                          \
+    if (hh_del->hh_next) {                                                     \
+        hh_del->hh_next->hh_prev = hh_del->hh_prev;                            \
+    }                                                                
+
+/* Bucket expansion has the effect of doubling the number of buckets
+ * and redistributing the items into the new buckets. Ideally the
+ * items will distribute more or less evenly into the new buckets
+ * (the extent to which this is true is a measure of the quality of
+ * the hash function as it applies to the key domain). 
+ * 
+ * With the items distributed into more buckets, the chain length
+ * (item count) in each bucket is reduced. Thus by expanding buckets
+ * the hash keeps a bound on the chain length. This bounded chain 
+ * length is the essence of how a hash provides constant time lookup.
+ * 
+ * The calculation of tbl->ideal_chain_maxlen below deserves some
+ * explanation. First, keep in mind that we're calculating the ideal
+ * maximum chain length based on the *new* (doubled) bucket count.
+ * In fractions this is just n/b (n=number of items,b=new num buckets).
+ * Since the ideal chain length is an integer, we want to calculate 
+ * ceil(n/b). We don't depend on floating point arithmetic in this
+ * hash, so to calculate ceil(n/b) with integers we could write
+ * 
+ *      ceil(n/b) = (n/b) + ((n%b)?1:0)
+ * 
+ * and in fact a previous version of this hash did just that.
+ * But now we have improved things a bit by recognizing that b is
+ * always a power of two. We keep its base 2 log handy (call it lb),
+ * so now we can write this with a bit shift and logical AND:
+ * 
+ *      ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
+ * 
+ */
+#define HASH_EXPAND_BUCKETS(tbl)                                               \
+do {                                                                           \
+    unsigned _he_bkt;                                                          \
+    unsigned _he_bkt_i;                                                        \
+    struct UT_hash_handle *_he_thh, *_he_hh_nxt;                               \
+    UT_hash_bucket *_he_new_buckets, *_he_newbkt;                              \
+    _he_new_buckets = (UT_hash_bucket*)uthash_bkt_malloc(                      \
+             2 * tbl->num_buckets * sizeof(struct UT_hash_bucket));            \
+    if (!_he_new_buckets) { uthash_fatal( "out of memory"); }                  \
+    memset(_he_new_buckets, 0,                                                 \
+            2 * tbl->num_buckets * sizeof(struct UT_hash_bucket));             \
+    tbl->ideal_chain_maxlen =                                                  \
+       (tbl->num_items >> (tbl->log2_num_buckets+1)) +                         \
+       ((tbl->num_items & ((tbl->num_buckets*2)-1)) ? 1 : 0);                  \
+    tbl->nonideal_items = 0;                                                   \
+    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)              \
+    {                                                                          \
+        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;                           \
+        while (_he_thh) {                                                      \
+           _he_hh_nxt = _he_thh->hh_next;                                      \
+           HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2, _he_bkt);          \
+           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);                         \
+           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {              \
+             tbl->nonideal_items++;                                            \
+             _he_newbkt->expand_mult = _he_newbkt->count /                     \
+                                        tbl->ideal_chain_maxlen;               \
+           }                                                                   \
+           _he_thh->hh_prev = NULL;                                            \
+           _he_thh->hh_next = _he_newbkt->hh_head;                             \
+           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =             \
+                _he_thh;                                                       \
+           _he_newbkt->hh_head = _he_thh;                                      \
+           _he_thh = _he_hh_nxt;                                               \
+        }                                                                      \
+    }                                                                          \
+    tbl->num_buckets *= 2;                                                     \
+    tbl->log2_num_buckets++;                                                   \
+    uthash_bkt_free( tbl->buckets );                                           \
+    tbl->buckets = _he_new_buckets;                                            \
+    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?       \
+        (tbl->ineff_expands+1) : 0;                                            \
+    if (tbl->ineff_expands > 1) {                                              \
+        tbl->noexpand=1;                                                       \
+        uthash_noexpand_fyi(tbl);                                              \
+    }                                                                          \
+    uthash_expand_fyi(tbl);                                                    \
+} while(0)
+
+
+/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
+/* Note that HASH_SORT assumes the hash handle name to be hh. 
+ * HASH_SRT was added to allow the hash handle name to be passed in. */
+#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
+#define HASH_SRT(hh,head,cmpfcn)                                               \
+do {                                                                           \
+  unsigned _hs_i;                                                              \
+  unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize;             \
+  struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail;          \
+  if (head) {                                                                  \
+      _hs_insize = 1;                                                          \
+      _hs_looping = 1;                                                         \
+      _hs_list = &((head)->hh);                                                \
+      while (_hs_looping) {                                                    \
+          _hs_p = _hs_list;                                                    \
+          _hs_list = NULL;                                                     \
+          _hs_tail = NULL;                                                     \
+          _hs_nmerges = 0;                                                     \
+          while (_hs_p) {                                                      \
+              _hs_nmerges++;                                                   \
+              _hs_q = _hs_p;                                                   \
+              _hs_psize = 0;                                                   \
+              for ( _hs_i = 0; _hs_i  < _hs_insize; _hs_i++ ) {                \
+                  _hs_psize++;                                                 \
+                  _hs_q = (UT_hash_handle*)((_hs_q->next) ?                    \
+                          ((void*)((char*)(_hs_q->next) +                      \
+                          (head)->hh.tbl->hho)) : NULL);                       \
+                  if (! (_hs_q) ) break;                                       \
+              }                                                                \
+              _hs_qsize = _hs_insize;                                          \
+              while ((_hs_psize > 0) || ((_hs_qsize > 0) && _hs_q )) {         \
+                  if (_hs_psize == 0) {                                        \
+                      _hs_e = _hs_q;                                           \
+                      _hs_q = (UT_hash_handle*)((_hs_q->next) ?                \
+                              ((void*)((char*)(_hs_q->next) +                  \
+                              (head)->hh.tbl->hho)) : NULL);                   \
+                      _hs_qsize--;                                             \
+                  } else if ( (_hs_qsize == 0) || !(_hs_q) ) {                 \
+                      _hs_e = _hs_p;                                           \
+                      _hs_p = (UT_hash_handle*)((_hs_p->next) ?                \
+                              ((void*)((char*)(_hs_p->next) +                  \
+                              (head)->hh.tbl->hho)) : NULL);                   \
+                      _hs_psize--;                                             \
+                  } else if ((                                                 \
+                      cmpfcn(TYPEOF(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
+                            TYPEOF(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q)))  \
+                             ) <= 0) {                                         \
+                      _hs_e = _hs_p;                                           \
+                      _hs_p = (UT_hash_handle*)((_hs_p->next) ?                \
+                              ((void*)((char*)(_hs_p->next) +                  \
+                              (head)->hh.tbl->hho)) : NULL);                   \
+                      _hs_psize--;                                             \
+                  } else {                                                     \
+                      _hs_e = _hs_q;                                           \
+                      _hs_q = (UT_hash_handle*)((_hs_q->next) ?                \
+                              ((void*)((char*)(_hs_q->next) +                  \
+                              (head)->hh.tbl->hho)) : NULL);                   \
+                      _hs_qsize--;                                             \
+                  }                                                            \
+                  if ( _hs_tail ) {                                            \
+                      _hs_tail->next = ((_hs_e) ?                              \
+                            ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL);        \
+                  } else {                                                     \
+                      _hs_list = _hs_e;                                        \
+                  }                                                            \
+                  _hs_e->prev = ((_hs_tail) ?                                  \
+                     ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL);            \
+                  _hs_tail = _hs_e;                                            \
+              }                                                                \
+              _hs_p = _hs_q;                                                   \
+          }                                                                    \
+          _hs_tail->next = NULL;                                               \
+          if ( _hs_nmerges <= 1 ) {                                            \
+              _hs_looping=0;                                                   \
+              (head)->hh.tbl->tail = _hs_tail;                                 \
+              (head) = TYPEOF(head)ELMT_FROM_HH((head)->hh.tbl, _hs_list);     \
+          }                                                                    \
+          _hs_insize *= 2;                                                     \
+      }                                                                        \
+      HASH_FSCK(hh,head);                                                      \
+ }                                                                             \
+} while (0)
+
+/* obtain a count of items in the hash */
+#define HASH_COUNT(head) HASH_CNT(hh,head) 
+#define HASH_CNT(hh,head) (head?(head->hh.tbl->num_items):0)
+
+typedef struct UT_hash_bucket {
+   struct UT_hash_handle *hh_head;
+   unsigned count;
+
+   /* expand_mult is normally set to 0. In this situation, the max chain length
+    * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
+    * the bucket's chain exceeds this length, bucket expansion is triggered). 
+    * However, setting expand_mult to a non-zero value delays bucket expansion
+    * (that would be triggered by additions to this particular bucket)
+    * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
+    * (The multiplier is simply expand_mult+1). The whole idea of this
+    * multiplier is to reduce bucket expansions, since they are expensive, in
+    * situations where we know that a particular bucket tends to be overused.
+    * It is better to let its chain length grow to a longer yet-still-bounded
+    * value, than to do an O(n) bucket expansion too often. 
+    */
+   unsigned expand_mult;
+
+} UT_hash_bucket;
+
+typedef struct UT_hash_table {
+   UT_hash_bucket *buckets;
+   unsigned num_buckets, log2_num_buckets;
+   unsigned num_items;
+   struct UT_hash_handle *tail; /* tail hh in app order, for fast append    */
+   ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
+
+   /* in an ideal situation (all buckets used equally), no bucket would have
+    * more than ceil(#items/#buckets) items. that's the ideal chain length. */
+   unsigned ideal_chain_maxlen;
+
+   /* nonideal_items is the number of items in the hash whose chain position
+    * exceeds the ideal chain maxlen. these items pay the penalty for an uneven
+    * hash distribution; reaching them in a chain traversal takes >ideal steps */
+   unsigned nonideal_items;
+
+   /* ineffective expands occur when a bucket doubling was performed, but 
+    * afterward, more than half the items in the hash had nonideal chain
+    * positions. If this happens on two consecutive expansions we inhibit any
+    * further expansion, as it's not helping; this happens when the hash
+    * function isn't a good fit for the key domain. When expansion is inhibited
+    * the hash will still work, albeit no longer in constant time. */
+   unsigned ineff_expands, noexpand;
+
+
+} UT_hash_table;
+
+
+typedef struct UT_hash_handle {
+   struct UT_hash_table *tbl;
+   void *prev;                       /* prev element in app order      */
+   void *next;                       /* next element in app order      */
+   struct UT_hash_handle *hh_prev;   /* previous hh in bucket order    */
+   struct UT_hash_handle *hh_next;   /* next hh in bucket order        */
+   void *key;                        /* ptr to enclosing struct's key  */
+   unsigned keylen;                  /* enclosing struct's key len     */
+   unsigned hashv;                   /* result of hash-fcn(key)        */
+} UT_hash_handle;
+
+#endif /* UTHASH_H */
diff -urNp otp_src_R12B-5/erts/vsn.mk minimal_otp_src_R12B-5/erts/vsn.mk
--- otp_src_R12B-5/erts/vsn.mk	2008-11-04 10:51:24.000000000 +0000
+++ minimal_otp_src_R12B-5/erts/vsn.mk	2009-06-23 20:40:30.000000000 +0100
@@ -1,5 +1,5 @@
-VSN = 5.6.5
-SYSTEM_VSN = R12B
+VSN = 5.6.5-joins
+SYSTEM_VSN = R12B-joins
 
 # Port number 4365 in 4.2
 # Port number 4366 in 4.3
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_block.erl minimal_otp_src_R12B-5/lib/compiler/src/beam_block.erl
--- otp_src_R12B-5/lib/compiler/src/beam_block.erl	2008-11-04 10:51:32.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_block.erl	2009-06-23 20:40:10.000000000 +0100
@@ -168,6 +168,7 @@ collect({get_tuple_element,S,I,D}) -> {s
 collect({set_tuple_element,S,D,I}) -> {set,[],[S,D],{set_tuple_element,I}};
 collect({get_list,S,D1,D2})  -> {set,[D1,D2],[S],get_list};
 collect(remove_message)      -> {set,[],[],remove_message};
+collect(found_message)       -> {set,[],[],found_message};
 collect({'catch',R,L})       -> {set,[R],[],{'catch',L}};
 collect({'%live',_}=Live)    -> Live;
 collect(_)                   -> error.
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_clean.erl minimal_otp_src_R12B-5/lib/compiler/src/beam_clean.erl
--- otp_src_R12B-5/lib/compiler/src/beam_clean.erl	2008-11-04 10:51:36.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_clean.erl	2009-06-23 20:40:10.000000000 +0100
@@ -220,6 +220,11 @@ replace([{loop_rec,{f,Lbl},R}|Is], Acc, 
     replace(Is, [{loop_rec,{f,label(Lbl, D)},R}|Acc], D);
 replace([{loop_rec_end,{f,Lbl}}|Is], Acc, D) ->
     replace(Is, [{loop_rec_end,{f,label(Lbl, D)}}|Acc], D);
+%% Added search loop
+replace([{loop_search,{f,Lbl},R}|Is], Acc, D) ->
+    replace(Is, [{loop_search,{f,label(Lbl, D)},R}|Acc], D);
+replace([{loop_search_end,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{loop_search_end,{f,label(Lbl, D)}}|Acc], D);
 replace([{wait,{f,Lbl}}|Is], Acc, D) ->
     replace(Is, [{wait,{f,label(Lbl, D)}}|Acc], D);
 replace([{wait_timeout,{f,Lbl},To}|Is], Acc, D) ->
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_clean.erl~ minimal_otp_src_R12B-5/lib/compiler/src/beam_clean.erl~
--- otp_src_R12B-5/lib/compiler/src/beam_clean.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_clean.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,364 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Clean up, such as removing unused labels and unused functions.
+
+-module(beam_clean).
+
+-export([module/2]).
+-export([bs_clean_saves/1]).
+-export([clean_labels/1]).
+-import(lists, [map/2,foldl/3,reverse/1]).
+
+module({Mod,Exp,Attr,Fs0,_}, _Opt) ->
+    Order = [Lbl || {function,_,_,Lbl,_} <- Fs0],
+    All = foldl(fun({function,_,_,Lbl,_}=Func,D) -> dict:store(Lbl, Func, D) end,
+		dict:new(), Fs0),
+    {WorkList,Used0} = exp_to_labels(Fs0, gb_sets:from_list(Exp)),
+    Used = find_all_used(WorkList, All, Used0),
+    Fs1 = remove_unused(Order, Used, All),
+    {Fs2,Lc} = clean_labels(Fs1),
+    Fs = bs_fix(Fs2),
+    {ok,{Mod,Exp,Attr,Fs,Lc}}.
+
+%% Remove all bs_save2/2 instructions not referenced by a bs_restore2/2.
+bs_clean_saves(Is) ->
+    Needed = bs_restores(Is, []),
+    bs_clean_saves_1(Is, gb_sets:from_list(Needed), []).
+
+%% Convert the export list ({Name,Arity} pairs) to a list of entry labels.
+
+exp_to_labels(Fs, Exp) -> exp_to_labels(Fs, Exp, [], sets:new()).
+    
+exp_to_labels([{function,Name,Arity,Lbl,_}|Fs], Exp, Acc, Used) ->
+    case gb_sets:is_member({Name,Arity}, Exp) of
+	true -> exp_to_labels(Fs, Exp, [Lbl|Acc], sets:add_element(Lbl, Used));
+	false -> exp_to_labels(Fs, Exp, Acc, Used)
+    end;
+exp_to_labels([], _, Acc, Used) -> {Acc,Used}.
+
+%% Remove the unused functions.
+
+remove_unused([F|Fs], Used, All) ->
+    case sets:is_element(F, Used) of
+	false -> remove_unused(Fs, Used, All);
+	true -> [dict:fetch(F, All)|remove_unused(Fs, Used, All)]
+    end;
+remove_unused([], _, _) -> [].
+	    
+%% Find all used functions.
+
+find_all_used([F|Fs0], All, Used0) ->
+    {function,_,_,_,Code} = dict:fetch(F, All),
+    {Fs,Used} = update_work_list(Code, {Fs0,Used0}),
+    find_all_used(Fs, All, Used);
+find_all_used([], _All, Used) -> Used.
+
+update_work_list([{call,_,{f,L}}|Is], Sets) ->
+    update_work_list(Is, add_to_work_list(L, Sets));
+update_work_list([{call_last,_,{f,L},_}|Is], Sets) ->
+    update_work_list(Is, add_to_work_list(L, Sets));
+update_work_list([{call_only,_,{f,L}}|Is], Sets) ->
+    update_work_list(Is, add_to_work_list(L, Sets));
+update_work_list([{make_fun2,{f,L},_,_,_}|Is], Sets) ->
+    update_work_list(Is, add_to_work_list(L, Sets));
+update_work_list([_|Is], Sets) ->
+    update_work_list(Is, Sets);
+update_work_list([], Sets) -> Sets.
+
+add_to_work_list(F, {Fs,Used}=Sets) ->
+    case sets:is_element(F, Used) of
+	true -> Sets;
+	false -> {[F|Fs],sets:add_element(F, Used)}
+    end.
+
+
+%%%
+%%% Coalesce adjacent labels. Renumber all labels to eliminate gaps.
+%%% This cleanup will slightly reduce file size and slightly speed up loading.
+%%%
+%%% We also expand is_record/3 to a sequence of instructions. It is done
+%%% here merely because this module will always be called even if optimization
+%%% is turned off. We don't want to do the expansion in beam_asm because we
+%%% want to see the expanded code in a .S file.
+%%%
+
+-record(st, {lmap,				%Translation tables for labels.
+	     entry,				%Number of entry label.
+	     lc					%Label counter
+	     }).
+
+clean_labels(Fs0) ->
+    St0 = #st{lmap=[],lc=1},
+    {Fs1,#st{lmap=Lmap0,lc=Lc}} = function_renumber(Fs0, St0, []),
+    Lmap = gb_trees:from_orddict(ordsets:from_list(Lmap0)),
+    Fs = function_replace(Fs1, Lmap, []),
+    {Fs,Lc}.
+
+function_renumber([{function,Name,Arity,_Entry,Asm0}|Fs], St0, Acc) ->
+    {Asm,St} = renumber_labels(Asm0, [], St0),
+    function_renumber(Fs, St, [{function,Name,Arity,St#st.entry,Asm}|Acc]);
+function_renumber([], St, Acc) -> {Acc,St}.
+
+renumber_labels([{bif,is_record,{f,_},
+		  [Term,{atom,Tag}=TagAtom,{integer,Arity}],Dst}|Is0], Acc, St) ->
+    ContLabel = 900000000+2*St#st.lc,
+    FailLabel = ContLabel+1,
+    Fail = {f,FailLabel},
+    Tmp = Dst,
+    Is = case is_record_tuple(Term, Tag, Arity) of
+	     yes ->
+		 [{move,{atom,true},Dst}|Is0];
+	     no ->
+		 [{move,{atom,false},Dst}|Is0];
+	     maybe ->
+		 [{test,is_tuple,Fail,[Term]},
+		  {test,test_arity,Fail,[Term,Arity]},
+		  {get_tuple_element,Term,0,Tmp},
+		  {test,is_eq_exact,Fail,[Tmp,TagAtom]},
+		  {move,{atom,true},Dst},
+		  {jump,{f,ContLabel}},
+		  {label,FailLabel},
+		  {move,{atom,false},Dst},
+		  {jump,{f,ContLabel}},	%Improves optimization by beam_dead.
+		  {label,ContLabel}|Is0]
+	 end,
+    renumber_labels(Is, Acc, St);
+renumber_labels([{test,is_record,{f,_}=Fail,
+		  [Term,{atom,Tag}=TagAtom,{integer,Arity}]}|Is0], Acc, St) ->
+    Tmp = {x,1023},
+    Is = case is_record_tuple(Term, Tag, Arity) of
+	     yes ->
+		 Is0;
+	     no ->
+		 [{jump,Fail}|Is0];
+	     maybe ->
+		 [{test,is_tuple,Fail,[Term]},
+		  {test,test_arity,Fail,[Term,Arity]},
+		  {get_tuple_element,Term,0,Tmp},
+		  {test,is_eq_exact,Fail,[Tmp,TagAtom]}|Is0]
+	 end,
+    renumber_labels(Is, Acc, St);
+renumber_labels([{label,Old}|Is], [{label,New}|_]=Acc, #st{lmap=D0}=St) ->
+    D = [{Old,New}|D0],
+    renumber_labels(Is, Acc, St#st{lmap=D});
+renumber_labels([{label,Old}|Is], Acc, St0) ->
+    New = St0#st.lc,
+    D = [{Old,New}|St0#st.lmap],
+    renumber_labels(Is, [{label,New}|Acc], St0#st{lmap=D,lc=New+1});
+renumber_labels([{func_info,_,_,_}=Fi|Is], Acc, St0) ->
+    renumber_labels(Is, [Fi|Acc], St0#st{entry=St0#st.lc});
+renumber_labels([I|Is], Acc, St0) ->
+    renumber_labels(Is, [I|Acc], St0);
+renumber_labels([], Acc, St) -> {Acc,St}.
+
+is_record_tuple({x,_}, _, _) -> maybe;
+is_record_tuple({y,_}, _, _) -> maybe;
+is_record_tuple({literal,Tuple}, Tag, Arity)
+  when element(1, Tuple) =:= Tag, tuple_size(Tuple) =:= Arity -> yes;
+is_record_tuple(_, _, _) -> no.
+
+function_replace([{function,Name,Arity,Entry,Asm0}|Fs], Dict, Acc) ->
+    Asm = try
+	      replace(Asm0, [], Dict)
+	  catch
+	      throw:{error,{undefined_label,Lbl}=Reason} ->
+		  io:format("Function ~s/~w refers to undefined label ~w\n",
+			    [Name,Arity,Lbl]),
+		  exit(Reason)
+	  end,
+    function_replace(Fs, Dict, [{function,Name,Arity,Entry,Asm}|Acc]);
+function_replace([], _, Acc) -> Acc.
+
+replace([{test,bs_match_string=Op,{f,Lbl},[Ctx,Bin0]}|Is], Acc, D) ->
+    Bits = bit_size(Bin0),
+    Bin = case Bits rem 8 of
+	      0 -> Bin0;
+	      Rem -> <<Bin0/bitstring,0:(8-Rem)>>
+	  end,
+    I = {test,Op,{f,label(Lbl, D)},[Ctx,Bits,{string,binary_to_list(Bin)}]},
+    replace(Is, [I|Acc], D);
+replace([{test,Test,{f,Lbl},Ops}|Is], Acc, D) ->
+    replace(Is, [{test,Test,{f,label(Lbl, D)},Ops}|Acc], D);
+replace([{select_val,R,{f,Fail0},{list,Vls0}}|Is], Acc, D) ->
+    Vls1 = map(fun ({f,L}) -> {f,label(L, D)};
+		   (Other) -> Other end, Vls0),
+    Fail = label(Fail0, D),
+    case redundant_values(Vls1, Fail, []) of
+	[] ->
+	    %% Oops, no choices left. The loader will not accept that.
+	    %% Convert to a plain jump.
+	    replace(Is, [{jump,{f,Fail}}|Acc], D);
+	Vls ->
+	    replace(Is, [{select_val,R,{f,Fail},{list,Vls}}|Acc], D)
+    end;
+replace([{select_tuple_arity,R,{f,Fail},{list,Vls0}}|Is], Acc, D) ->
+    Vls = map(fun ({f,L}) -> {f,label(L, D)};
+		  (Other) -> Other end, Vls0),
+    replace(Is, [{select_tuple_arity,R,{f,label(Fail, D)},{list,Vls}}|Acc], D);
+replace([{'try',R,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{'try',R,{f,label(Lbl, D)}}|Acc], D);
+replace([{'catch',R,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{'catch',R,{f,label(Lbl, D)}}|Acc], D);
+replace([{jump,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{jump,{f,label(Lbl, D)}}|Acc], D);
+replace([{loop_rec,{f,Lbl},R}|Is], Acc, D) ->
+    replace(Is, [{loop_rec,{f,label(Lbl, D)},R}|Acc], D);
+replace([{loop_rec_end,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{loop_rec_end,{f,label(Lbl, D)}}|Acc], D);
+replace([{wait,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{wait,{f,label(Lbl, D)}}|Acc], D);
+replace([{wait_timeout,{f,Lbl},To}|Is], Acc, D) ->
+    replace(Is, [{wait_timeout,{f,label(Lbl, D)},To}|Acc], D);
+replace([{bif,Name,{f,Lbl},As,R}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{bif,Name,{f,label(Lbl, D)},As,R}|Acc], D);
+replace([{gc_bif,Name,{f,Lbl},Live,As,R}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{gc_bif,Name,{f,label(Lbl, D)},Live,As,R}|Acc], D);
+replace([{call,Ar,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{call,Ar,{f,label(Lbl,D)}}|Acc], D);
+replace([{call_last,Ar,{f,Lbl},N}|Is], Acc, D) ->
+    replace(Is, [{call_last,Ar,{f,label(Lbl,D)},N}|Acc], D);
+replace([{call_only,Ar,{f,Lbl}}|Is], Acc, D) ->
+    replace(Is, [{call_only,Ar,{f,label(Lbl, D)}}|Acc], D);
+replace([{make_fun2,{f,Lbl},U1,U2,U3}|Is], Acc, D) ->
+    replace(Is, [{make_fun2,{f,label(Lbl, D)},U1,U2,U3}|Acc], D);
+replace([{bs_init2,{f,Lbl},Sz,Words,R,F,Dst}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{bs_init2,{f,label(Lbl, D)},Sz,Words,R,F,Dst}|Acc], D);
+replace([{bs_init_bits,{f,Lbl},Sz,Words,R,F,Dst}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{bs_init_bits,{f,label(Lbl, D)},Sz,Words,R,F,Dst}|Acc], D);
+replace([{bs_put_integer,{f,Lbl},Bits,Unit,Fl,Val}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{bs_put_integer,{f,label(Lbl, D)},Bits,Unit,Fl,Val}|Acc], D);
+replace([{bs_put_utf8=I,{f,Lbl},Fl,Val}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{I,{f,label(Lbl, D)},Fl,Val}|Acc], D);
+replace([{bs_put_utf16=I,{f,Lbl},Fl,Val}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{I,{f,label(Lbl, D)},Fl,Val}|Acc], D);
+replace([{bs_put_utf32=I,{f,Lbl},Fl,Val}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{I,{f,label(Lbl, D)},Fl,Val}|Acc], D);
+replace([{bs_put_binary,{f,Lbl},Bits,Unit,Fl,Val}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{bs_put_binary,{f,label(Lbl, D)},Bits,Unit,Fl,Val}|Acc], D);
+replace([{bs_put_float,{f,Lbl},Bits,Unit,Fl,Val}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{bs_put_float,{f,label(Lbl, D)},Bits,Unit,Fl,Val}|Acc], D);
+replace([{bs_add,{f,Lbl},Src,Dst}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{bs_add,{f,label(Lbl, D)},Src,Dst}|Acc], D);
+replace([{bs_append,{f,Lbl},_,_,_,_,_,_,_}=I0|Is], Acc, D) when Lbl =/= 0 ->
+    I = setelement(2, I0, {f,label(Lbl, D)}),
+    replace(Is, [I|Acc], D);
+replace([{bs_utf8_size=I,{f,Lbl},Src,Dst}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{I,{f,label(Lbl, D)},Src,Dst}|Acc], D);
+replace([{bs_utf16_size=I,{f,Lbl},Src,Dst}|Is], Acc, D) when Lbl =/= 0 ->
+    replace(Is, [{I,{f,label(Lbl, D)},Src,Dst}|Acc], D);
+replace([I|Is], Acc, D) ->
+    replace(Is, [I|Acc], D);
+replace([], Acc, _) -> Acc.
+
+label(Old, D) ->
+    case gb_trees:lookup(Old, D) of
+	{value,Val} -> Val;
+	none -> throw({error,{undefined_label,Old}})
+    end.
+	    
+redundant_values([_,{f,Fail}|Vls], Fail, Acc) ->
+    redundant_values(Vls, Fail, Acc);
+redundant_values([Val,Lbl|Vls], Fail, Acc) ->
+    redundant_values(Vls, Fail, [Lbl,Val|Acc]);
+redundant_values([], _, Acc) -> reverse(Acc).
+
+%%%
+%%% Final fixup of bs_start_match2/5,bs_save2/bs_restore2 instructions for
+%%% new bit syntax matching (introduced in R11B).
+%%%
+%%% Pass 1: Scan the code, looking for bs_restore2/2 instructions.
+%%%
+%%% Pass 2: Update bs_save2/2 and bs_restore/2 instructions. Remove
+%%% any bs_save2/2 instruction whose save position are never referenced
+%%% by any bs_restore2/2 instruction.
+%%%
+%%% Note this module can be invoked several times, so we must be careful
+%%% not to touch instructions that have already been fixed up.
+%%%
+
+bs_fix(Fs) ->
+    bs_fix(Fs, []).
+
+bs_fix([{function,Name,Arity,Entry,Asm0}|Fs], Acc) ->
+    Asm = bs_function(Asm0),
+    bs_fix(Fs, [{function,Name,Arity,Entry,Asm}|Acc]);
+bs_fix([], Acc) -> reverse(Acc).
+
+bs_function(Is) ->
+    Dict0 = bs_restores(Is, []),
+    S0 = sofs:relation(Dict0, [{context,save_point}]),
+    S1 = sofs:relation_to_family(S0),
+    S = sofs:to_external(S1),
+    Dict = make_save_point_dict(S, []),
+    bs_replace(Is, Dict, []).
+
+make_save_point_dict([{Ctx,Pts}|T], Acc0) ->
+    Acc = make_save_point_dict_1(Pts, Ctx, 0, Acc0),
+    make_save_point_dict(T, Acc);
+make_save_point_dict([], Acc) ->
+    gb_trees:from_orddict(ordsets:from_list(Acc)).
+
+make_save_point_dict_1([H|T], Ctx, I, Acc) ->
+    make_save_point_dict_1(T, Ctx, I+1, [{{Ctx,H},I}|Acc]);
+make_save_point_dict_1([], Ctx, I, Acc) ->
+    [{Ctx,I}|Acc].
+
+%% Pass 1.
+bs_restores([{bs_restore2,_,{Same,Same}}|Is], Dict) ->
+    %% This save point is special. No explicit save is needed.
+    bs_restores(Is, Dict);
+bs_restores([{bs_restore2,_,{_,_}=SavePoint}|Is], Dict) ->
+    bs_restores(Is, [SavePoint|Dict]);
+bs_restores([_|Is], Dict) ->
+    bs_restores(Is, Dict);
+bs_restores([], Dict) -> Dict.
+    
+%% Pass 2.
+bs_replace([{test,bs_start_match2,F,[Src,Live,Ctx,CtxR]}|T], Dict, Acc) when is_atom(Ctx) ->
+    Slots = case gb_trees:lookup(Ctx, Dict) of
+		{value,Slots0} -> Slots0;
+		none -> 0
+	    end,
+    I = {test,bs_start_match2,F,[Src,Live,Slots,CtxR]},
+    bs_replace(T, Dict, [I|Acc]);
+bs_replace([{bs_save2,CtxR,{_,_}=SavePoint}|T], Dict, Acc) ->
+    case gb_trees:lookup(SavePoint, Dict) of
+	{value,N} ->
+	    bs_replace(T, Dict, [{bs_save2,CtxR,N}|Acc]);
+	none ->
+	    bs_replace(T, Dict, Acc)
+    end;
+bs_replace([{bs_restore2,CtxR,{Same,Same}}|T], Dict, Acc) ->
+    %% This save refers to the point in the binary where the match
+    %% started. It has a special name.
+    bs_replace(T, Dict, [{bs_restore2,CtxR,{atom,start}}|Acc]);
+bs_replace([{bs_restore2,CtxR,{_,_}=SavePoint}|T], Dict, Acc) ->
+    N = gb_trees:get(SavePoint, Dict),
+    bs_replace(T, Dict, [{bs_restore2,CtxR,N}|Acc]);
+bs_replace([I|Is], Dict, Acc) ->
+    bs_replace(Is, Dict, [I|Acc]);
+bs_replace([], _, Acc) -> reverse(Acc).
+
+bs_clean_saves_1([{bs_save2,_,{_,_}=SavePoint}=I|Is], Needed, Acc) ->
+    case gb_sets:is_member(SavePoint, Needed) of
+	false -> bs_clean_saves_1(Is, Needed, Acc);
+	true -> bs_clean_saves_1(Is, Needed, [I|Acc])
+    end;
+bs_clean_saves_1([I|Is], Needed, Acc) ->
+    bs_clean_saves_1(Is, Needed, [I|Acc]);
+bs_clean_saves_1([], _, Acc) -> reverse(Acc).
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_disasm.erl minimal_otp_src_R12B-5/lib/compiler/src/beam_disasm.erl
--- otp_src_R12B-5/lib/compiler/src/beam_disasm.erl	2008-11-04 10:51:36.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_disasm.erl	2009-06-23 20:40:10.000000000 +0100
@@ -665,12 +665,18 @@ resolve_inst({send,[]},_,_,_) ->
     send;
 resolve_inst({remove_message,[]},_,_,_) ->
     remove_message;
+resolve_inst({found_message,[]},_,_,_) ->
+    found_message;
 resolve_inst({timeout,[]},_,_,_) ->
     timeout;
 resolve_inst({loop_rec,[Lbl,Dst]},_,_,_) ->
     {loop_rec,Lbl,Dst};
 resolve_inst({loop_rec_end,[Lbl]},_,_,_) ->
     {loop_rec_end,Lbl};
+resolve_inst({loop_search,[Lbl,Dst]},_,_,_) ->
+    {loop_search,Lbl,Dst};
+resolve_inst({loop_search_end,[Lbl]},_,_,_) ->
+    {loop_search_end,Lbl};
 resolve_inst({wait,[Lbl]},_,_,_) ->
     {wait,Lbl};
 resolve_inst({wait_timeout,[Lbl,Int]},_,_,_) ->
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_disasm.erl~ minimal_otp_src_R12B-5/lib/compiler/src/beam_disasm.erl~
--- otp_src_R12B-5/lib/compiler/src/beam_disasm.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_disasm.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,1136 @@
+%% -*- erlang-indent-level: 4 -*-
+%%=======================================================================
+%% File        : beam_disasm.erl
+%% Author      : Kostis Sagonas
+%% Description : Disassembles an R5-R12 .beam file into symbolic BEAM code
+%%=======================================================================
+%% $Id$
+%%=======================================================================
+%% Notes:
+%%   1. It does NOT work for .beam files of previous BEAM versions.
+%%   2. If handling of new BEAM instructions is needed, this should be 
+%%      inserted at the end of function resolve_inst().
+%%=======================================================================
+
+-module(beam_disasm).
+
+-export([file/1]). %% the main function and some utilities below
+-export([dfs/1, df/1, files/1, pp/1, pp/2, format_error/1]).
+-export([function__code/1]).
+
+-author("Kostis Sagonas").
+
+-include("beam_opcodes.hrl").
+-include("beam_disasm.hrl").
+
+%%-----------------------------------------------------------------------
+
+%% -type gb_tree()      :: tuple().  % XXX: temporarily
+
+%% -type literals()     :: 'none' | gb_tree().
+-type symbolic_tag() :: 'a' | 'f' | 'h' | 'i' | 'u' | 'x' | 'y' | 'z'.
+%% -type disasm_tag() :: symbolic_tag() | 'fr' | 'atom' | 'float' | 'literal'.
+%% -type disasm_term()  :: 'nil' | {disasm_tag(), _}.
+
+%%-----------------------------------------------------------------------
+
+-define(NO_DEBUG(Str,Xs), ok).
+-define(DEBUG(Str,Xs), io:format(Str,Xs)).
+-define(exit(Reason), exit({?MODULE,?LINE,Reason})).
+
+%%-----------------------------------------------------------------------
+%% Utility functions to get/set their fields. (Uncomment and export
+%% them when/if they get used in other files.)
+%%-----------------------------------------------------------------------
+
+%% -spec function__name(#function{}) -> atom().
+%% function__name(#function{name=N}) -> N.
+%% -spec function__arity(#function{}) -> byte().
+%% function__arity(#function{arity=A}) -> A.
+%% function__entry(#function{entry=E}) -> E.
+
+-spec function__code(#function{}) -> [beam_instr()].
+function__code(#function{code=Code}) -> Code.
+
+-spec function__code_update(#function{}, [beam_instr()]) -> #function{}.
+function__code_update(Function, NewCode) ->
+  Function#function{code = NewCode}.
+
+%%-----------------------------------------------------------------------
+%% Error information
+
+-spec format_error({'internal',_} | {'error',atom(),_}) -> string().
+
+format_error({internal,Error}) ->
+    io_lib:format("~p: disassembly failed with reason ~P.",
+		  [?MODULE, Error, 25]);
+format_error({error,Module,Error}) ->
+    lists:flatten(Module:format_error(Error)).
+
+%%-----------------------------------------------------------------------
+%% User comfort functions to directly disassemble to file or to
+%% stream, pretty-printed, and to just pretty-print, also commented.
+%%-----------------------------------------------------------------------
+
+dfs(Files) when is_list(Files) ->
+    lists:foreach(fun df/1, Files).
+
+df(Module) when is_atom(Module) ->
+    case code:which(Module) of
+	File when is_list(File) ->
+	    df(File);
+	Reason when is_atom(Reason) ->
+	    {error,?MODULE,Reason}
+    end;
+df(File) when is_list(File) ->
+    file(File, filename:rootname(File, ".beam")++".dis").
+
+files(Files) when is_list(Files) ->
+    lists:foreach(fun (File) -> file(File, group_leader()) end, Files).
+
+file(File, Dest) ->
+    case file(File) of
+	#beam_file{code=DisasmCode} ->
+	    pp(Dest, [{file,File},{code,DisasmCode}]);
+	Error -> Error
+    end.
+
+-spec pp([_]) -> 'ok' | {'error','file',atom()}.
+
+pp(Disasm) ->
+    pp(group_leader(), Disasm).
+
+-spec pp(pid() | string(), [_]) -> 'ok' | {'error','file',atom()}.
+
+pp(Stream, Disasm) when is_pid(Stream), is_list(Disasm) ->
+    NL = io_lib:nl(),
+    lists:foreach(
+      fun ({code,Code}) ->
+	      lists:foreach(
+		fun (#function{name=F,arity=A,entry=E,code=C}) ->
+			io:format(Stream, "~p.~n", [{function,F,A,E}]),
+			lists:foreach(
+			  fun (I) -> 
+				  io:put_chars(Stream, [pp_instr(I)|NL])
+			  end, C),
+			io:nl(Stream)
+		end, Code);
+	  (Item) ->
+	      io:format(Stream, "~p.~n~n", [Item])
+      end, Disasm),
+    ok;
+pp(File, Disasm) when is_list(Disasm) ->
+    case file:open(File, [write]) of
+	{ok,F} ->
+	    Result = pp(F, Disasm),
+	    ok = file:close(F),
+	    Result;
+	{error,Reason} -> {error,file,Reason}
+    end.
+
+pp_instr({comment,I,Comment}) ->
+    [pp_instr(I)|" % "++Comment];
+pp_instr({comment,Comment}) ->
+    ["%% "++Comment];
+pp_instr({label,_}=I) ->
+    io_lib:format("  ~p.", [I]);
+pp_instr(I) ->
+    io_lib:format("    ~p.", [I]).
+
+%%-----------------------------------------------------------------------
+%% The main exported function
+%%   File is either a file name or a binary containing the code.
+%%   Call `format_error({error, Module, Reason})' for an error string.
+%%-----------------------------------------------------------------------
+
+-spec file(string() | binary()) -> #beam_file{} | {'error',atom(),_}.
+
+file(File) ->
+    try process_chunks(File)
+    catch error:Reason ->
+	    {error,?MODULE,{internal,{Reason,erlang:get_stacktrace()}}}
+    end.
+
+%%-----------------------------------------------------------------------
+%% Interface might need to be revised -- do not depend on it.
+%%-----------------------------------------------------------------------
+
+process_chunks(F) ->
+    case beam_lib:chunks(F, [atoms,"Code","StrT",
+			     indexed_imports,labeled_exports]) of
+	{ok,{Module,
+	     [{atoms,AtomsList},{"Code",CodeBin},{"StrT",StrBin},
+	      {indexed_imports,ImportsList},{labeled_exports,Exports}]}} ->
+	    Atoms = mk_atoms(AtomsList),
+	    LambdaBin = optional_chunk(F, "FunT"),
+	    Lambdas = beam_disasm_lambdas(LambdaBin, Atoms),
+	    LiteralBin = optional_chunk(F, "LitT"),
+	    Literals = beam_disasm_literals(LiteralBin),
+	    Code = beam_disasm_code(CodeBin, Atoms, mk_imports(ImportsList),
+				    StrBin, Lambdas, Literals, Module),
+	    Attributes = optional_chunk(F, attributes),
+	    CompInfo = 
+		case optional_chunk(F, "CInf") of
+		    none -> none;
+		    CompInfoBin when is_binary(CompInfoBin) ->
+			binary_to_term(CompInfoBin)
+		end,
+	    #beam_file{module=Module,
+		       exports=Exports,
+		       attributes=Attributes,
+		       comp_info=CompInfo,
+		       code=Code};
+	Error -> Error
+    end.
+
+%%-----------------------------------------------------------------------
+%% Retrieve an optional chunk or none if the chunk doesn't exist.
+%%-----------------------------------------------------------------------
+
+optional_chunk(F, ChunkTag) ->
+    case beam_lib:chunks(F, [ChunkTag]) of
+	{ok,{_Module,[{ChunkTag,Chunk}]}} -> Chunk;
+	{error,beam_lib,{missing_chunk,_,ChunkTag}} -> none
+    end.
+
+%%-----------------------------------------------------------------------
+%% Disassembles the lambda (fun) table of a BEAM file.
+%%-----------------------------------------------------------------------
+
+%% -type lambda_info() :: {non_neg_integer(), tuple()}.
+%% -spec beam_disasm_lambdas('none' | binary(), gb_tree()) -> 'none' | [lambda_info()].
+beam_disasm_lambdas(none, _) -> none;
+beam_disasm_lambdas(<<_:32,Tab/binary>>, Atoms) ->
+    disasm_lambdas(Tab, Atoms, 0).
+
+disasm_lambdas(<<F:32,A:32,Lbl:32,Index:32,NumFree:32,OldUniq:32,More/binary>>,
+	       Atoms, OldIndex) ->
+    Info = {lookup(F, Atoms),A,Lbl,Index,NumFree,OldUniq},
+    [{OldIndex,Info}|disasm_lambdas(More, Atoms, OldIndex+1)];
+disasm_lambdas(<<>>, _, _) -> [].
+
+%%-----------------------------------------------------------------------
+%% Disassembles the literal table (constant pool) of a BEAM file.
+%%-----------------------------------------------------------------------
+
+%% -spec beam_disasm_literals('none' | binary()) -> literals().
+beam_disasm_literals(none) -> none;
+beam_disasm_literals(<<_:32,Compressed/binary>>) ->
+    <<_:32,Tab/binary>> = zlib:uncompress(Compressed),
+    gb_trees:from_orddict(disasm_literals(Tab, 0)).
+
+disasm_literals(<<Sz:32,Ext:Sz/binary,T/binary>>, Index) ->
+    [{Index,binary_to_term(Ext)}|disasm_literals(T, Index+1)];
+disasm_literals(<<>>, _) -> [].
+
+%%-----------------------------------------------------------------------
+%% Disassembles the code chunk of a BEAM file:
+%%   - The code is first disassembled into a long list of instructions.
+%%   - This list is then split into functions and all names are resolved.
+%%-----------------------------------------------------------------------
+
+beam_disasm_code(<<_SS:32, % Sub-Size (length of information before code)
+		  _IS:32,  % Instruction Set Identifier (always 0)
+		  _OM:32,  % Opcode Max
+		  _L:32,_F:32,
+		  CodeBin/binary>>, Atoms, Imports,
+		 Str, Lambdas, Literals, M) ->
+    Code = binary_to_list(CodeBin),
+    try disasm_code(Code, Atoms, Literals) of
+	DisasmCode ->
+	    Functions = get_function_chunks(DisasmCode),
+	    Labels = mk_labels(local_labels(Functions)),
+	    [function__code_update(Function,
+				   resolve_names(Is, Imports, Str,
+						 Labels, Lambdas, Literals, M))
+	     || Function = #function{code=Is} <- Functions]
+    catch
+	error:Rsn ->
+	    ?NO_DEBUG('code disassembling failed: ~p~n',[Rsn]),
+	    ?exit(Rsn)
+    end.
+
+%%-----------------------------------------------------------------------
+
+disasm_code([B|Bs], Atoms, Literals) ->
+    {Instr,RestBs} = disasm_instr(B, Bs, Atoms, Literals),
+    [Instr|disasm_code(RestBs, Atoms, Literals)];
+disasm_code([], _, _) -> [].
+
+%%-----------------------------------------------------------------------
+%% Splits the code stream into chunks representing the code of functions.
+%%
+%% NOTE: code actually looks like
+%%   label L1: ... label Ln:
+%%     func_info ...
+%%   label entry:
+%%     ...
+%%     <on failure, use label Li to show where things died>
+%%     ...
+%% So the labels before each func_info should be included as well.
+%% Ideally, only one such label is needed, but the BEAM compiler
+%% before R8 didn't care to remove the redundant ones.
+%%-----------------------------------------------------------------------
+
+get_function_chunks([]) ->
+    ?exit(empty_code_segment);
+get_function_chunks(Code) ->
+    get_funs(labels_r(Code, [])).
+
+labels_r([], R) -> {R, []};
+labels_r([{label,_}=I|Is], R) ->
+    labels_r(Is, [I|R]);
+labels_r(Is, R) -> {R, Is}.
+
+get_funs({[],[]}) -> [];
+get_funs({_,[]}) ->
+    ?exit(no_func_info_in_code_segment);
+get_funs({LsR0,[{func_info,[{atom,M}=AtomM,{atom,F}=AtomF,ArityArg]}|Code0]})
+  when is_atom(M), is_atom(F) ->
+    Arity = resolve_arg_unsigned(ArityArg),
+    {LsR,Code,RestCode} = get_fun(Code0, []),
+    Entry = case Code of
+		[{label,[{u,E}]}|_] -> E;
+		_ -> undefined
+	    end,
+    [#function{name=F,
+	       arity=Arity,
+	       entry=Entry,
+	       code=lists:reverse(LsR0, [{func_info,AtomM,AtomF,Arity}|Code])}
+     |get_funs({LsR,RestCode})].
+
+get_fun([{func_info,_}|_]=Is, R0) ->
+    {LsR,R} = labels_r(R0, []),
+    {LsR,lists:reverse(R),Is};
+get_fun([{int_code_end,[]}], R) ->
+    {[],lists:reverse(R),[]};
+get_fun([I|Is], R) ->
+    get_fun(Is, [I|R]);
+get_fun([], R) ->
+    ?DEBUG('warning: code segment did not end with int_code_end~n',[]),
+    {[],lists:reverse(R),[]}.
+
+%%-----------------------------------------------------------------------
+%% Collects local labels -- I am not sure this is 100% what is needed.
+%%-----------------------------------------------------------------------
+
+local_labels(Funs) ->
+    lists:sort(lists:foldl(fun (F, R) ->
+				   local_labels_1(function__code(F), R)
+			   end, [], Funs)).
+
+%% The first clause below attempts to provide some (limited form of)
+%% backwards compatibility; it is not needed for .beam files generated
+%% by the R8 compiler.  The clause should one fine day be taken out.
+local_labels_1([{label,_}|[{label,_}|_]=Code], R) ->
+    local_labels_1(Code, R);
+local_labels_1([{label,_},{func_info,{atom,M},{atom,F},A}|Code], R)
+  when is_atom(M), is_atom(F) ->
+    local_labels_2(Code, R, M, F, A);
+local_labels_1(Code, _) ->
+    ?exit({'local_labels: no label in code',Code}).
+
+local_labels_2([{label,[{u,L}]}|Code], R, M, F, A) ->
+    local_labels_2(Code, [{L,{M,F,A}}|R], M, F, A);
+local_labels_2(_, R, _, _, _) -> R.
+
+%%-----------------------------------------------------------------------
+%% Disassembles a single BEAM instruction; most instructions are handled
+%% in a generic way; indexing instructions are handled separately.
+%%-----------------------------------------------------------------------
+
+disasm_instr(B, Bs, Atoms, Literals) ->
+    {SymOp, Arity} = beam_opcodes:opname(B),
+    case SymOp of
+	select_val ->
+	    disasm_select_inst(select_val, Bs, Atoms, Literals);
+	select_tuple_arity ->
+	    disasm_select_inst(select_tuple_arity, Bs, Atoms, Literals);
+	_ ->
+	    try decode_n_args(Arity, Bs, Atoms, Literals) of
+		{Args, RestBs} ->
+		    ?NO_DEBUG("instr ~p~n", [{SymOp, Args}]),
+		    {{SymOp, Args}, RestBs}
+	    catch
+		error:Rsn ->
+		    ?NO_DEBUG("decode_n_args(~p,~p) failed~n", [Arity, Bs]),
+		    ?exit({cannot_disasm_instr, {SymOp, Arity, Rsn}})
+	    end
+    end.
+
+%%-----------------------------------------------------------------------
+%% Disassembles a BEAM select_* instruction used for indexing.
+%%   Currently handles {select_val,3} and {select_tuple_arity,3} insts.
+%%
+%%   The arguments of a "select"-type instruction look as follows:
+%%       <reg>, {f,FailLabel}, {list, <num cases>, [<case1> ... <caseN>]}
+%%   where each case is of the form [symbol,{f,Label}].
+%%-----------------------------------------------------------------------
+
+disasm_select_inst(Inst, Bs, Atoms, Literals) ->
+    {X, Bs1} = decode_arg(Bs, Atoms, Literals),
+    {F, Bs2} = decode_arg(Bs1, Atoms, Literals),
+    {Z, Bs3} = decode_arg(Bs2, Atoms, Literals),
+    {U, Bs4} = decode_arg(Bs3, Atoms, Literals),
+    {u,Len} = U,
+    {List, RestBs} = decode_n_args(Len, Bs4, Atoms, Literals),
+    {{Inst,[X,F,{Z,U,List}]},RestBs}.
+
+%%-----------------------------------------------------------------------
+%% decode_arg([Byte]) -> {Arg, [Byte]}
+%%
+%% - an arg can have variable length, so we must return arg + remaining bytes
+%% - decodes an argument into its 'raw' form: { Tag, Value }
+%%   several types map to a single tag, so the byte code instr must then
+%%   assign a type to it
+%%-----------------------------------------------------------------------
+
+%% -spec decode_arg([byte(),...]) -> {{disasm_tag(),_}, [byte()]}.
+decode_arg([B|Bs]) ->
+    Tag = decode_tag(B band 2#111),
+    ?NO_DEBUG('Tag = ~p, B = ~p, Bs = ~p~n',[Tag,B,Bs]),
+    case Tag of
+	z ->
+	    decode_z_tagged(Tag, B, Bs, no_literals);
+	_ ->
+	    %% all other cases are handled as if they were integers
+	    decode_int(Tag, B, Bs)
+    end.
+
+%% -spec decode_arg([byte(),...], gb_tree(), literals()) ->
+%%		{disasm_term(), [byte()]}).
+decode_arg([B|Bs0], Atoms, Literals) ->
+    Tag = decode_tag(B band 2#111),
+    ?NO_DEBUG('Tag = ~p, B = ~p, Bs = ~p~n',[Tag,B,Bs]),
+    case Tag of
+	z ->
+	    decode_z_tagged(Tag, B, Bs0, Literals);
+	a ->
+	    %% atom or nil
+	    case decode_int(Tag, B, Bs0) of
+		{{a,0},Bs} -> {nil,Bs};
+		{{a,I},Bs} -> {{atom,lookup(I, Atoms)},Bs}
+	    end;
+	_ ->
+	    %% all other cases are handled as if they were integers
+	    decode_int(Tag, B, Bs0)
+    end.
+
+%%-----------------------------------------------------------------------
+%% Decodes an integer value.  Handles positives, negatives, and bignums.
+%%
+%% Tries to do the opposite of:
+%%   beam_asm:encode(1, 5) =            [81]
+%%   beam_asm:encode(1, 1000) =         [105,232]
+%%   beam_asm:encode(1, 2047) =         [233,255]
+%%   beam_asm:encode(1, 2048) =         [25,8,0]
+%%   beam_asm:encode(1,-1) =            [25,255,255]
+%%   beam_asm:encode(1,-4294967295) =   [121,255,0,0,0,1]
+%%   beam_asm:encode(1, 4294967295) =   [121,0,255,255,255,255]
+%%   beam_asm:encode(1, 429496729501) = [121,99,255,255,255,157]
+%%-----------------------------------------------------------------------
+
+decode_int(Tag,B,Bs) when (B band 16#08) =:= 0 ->
+    %% N < 16 = 4 bits, NNNN:0:TTT
+    N = B bsr 4,
+    {{Tag,N},Bs};
+decode_int(Tag,B,Bs) when (B band 16#10) =:= 0 ->
+    %% N < 2048 = 11 bits = 3:8 bits, NNN:01:TTT, NNNNNNNN
+    [B1|Bs1] = Bs,
+    Val0 = B band 2#11100000,
+    N = (Val0 bsl 3) bor B1,
+    ?NO_DEBUG('NNN:01:TTT, NNNNNNNN = ~n~p:01:~p, ~p = ~p~n', [Val0,Tag,B,N]),
+    {{Tag,N},Bs1};
+decode_int(Tag,B,Bs) ->
+    {Len,Bs1} = decode_int_length(B,Bs),
+    {IntBs,RemBs} = take_bytes(Len,Bs1),
+    N = build_arg(IntBs),
+    [F|_] = IntBs,
+    Num = if F > 127, Tag =:= i -> decode_negative(N,Len);
+	     true -> N
+	  end,
+    ?NO_DEBUG('Len = ~p, IntBs = ~p, Num = ~p~n', [Len,IntBs,Num]),
+    {{Tag,Num},RemBs}.
+
+-spec decode_int_length(integer(), [byte()]) -> {integer(), [byte()]}.
+decode_int_length(B, Bs) ->
+    %% The following imitates get_erlang_integer() in beam_load.c
+    %% Len is the size of the integer value in bytes
+    case B bsr 5 of
+	7 ->
+	    {Arg,ArgBs} = decode_arg(Bs),
+	    case Arg of
+		{u,L} ->
+		    {L+9,ArgBs};  % 9 stands for 7+2
+		_ -> 
+		    ?exit({decode_int,weird_bignum_sublength,Arg})
+	    end;
+	L ->
+	    {L+2,Bs}
+    end.
+    
+-spec decode_negative(non_neg_integer(), non_neg_integer()) -> neg_integer().
+decode_negative(N, Len) ->
+    N - (1 bsl (Len*8)). % 8 is number of bits in a byte
+
+%%-----------------------------------------------------------------------
+%% Decodes lists and floating point numbers.
+%%-----------------------------------------------------------------------
+
+decode_z_tagged(Tag,B,Bs,Literals) when (B band 16#08) =:= 0 ->
+    N = B bsr 4,
+    case N of
+	0 -> % float
+	    decode_float(Bs);
+	1 -> % list
+	    {{Tag,N},Bs};
+	2 -> % fr
+	    decode_fr(Bs);
+	3 -> % allocation list
+	    decode_alloc_list(Bs, Literals);
+	4 -> % literal
+	    {{u,LitIndex},RestBs} = decode_arg(Bs),
+	    {{literal,gb_trees:get(LitIndex, Literals)},RestBs};
+	_ ->
+	    ?exit({decode_z_tagged,{invalid_extended_tag,N}})
+    end;
+decode_z_tagged(_,B,_,_) ->
+    ?exit({decode_z_tagged,{weird_value,B}}).
+
+-spec decode_float([byte(),...]) -> {{'float',float()}, [byte()]}.
+decode_float(Bs) ->
+    {FL,RestBs} = take_bytes(8,Bs),
+    <<Float:64/float>> = list_to_binary(FL),
+    {{float,Float},RestBs}.
+
+-spec decode_fr([byte(),...]) -> {{'fr',non_neg_integer()}, [byte()]}.
+decode_fr(Bs) ->
+    {{u,Fr},RestBs} = decode_arg(Bs),
+    {{fr,Fr},RestBs}.
+
+decode_alloc_list(Bs, Literals) ->
+    {{u,N},RestBs} = decode_arg(Bs),
+    decode_alloc_list_1(N, Literals, RestBs, []).
+
+decode_alloc_list_1(0, _Literals, RestBs, Acc) ->
+    {{u,{alloc,lists:reverse(Acc)}},RestBs};
+decode_alloc_list_1(N, Literals, Bs0, Acc) ->
+    {{u,Type},Bs1} = decode_arg(Bs0),
+    {{u,Val},Bs} = decode_arg(Bs1),
+    Res = case Type of
+	      0 -> {words,Val};
+	      1 -> {floats,Val};
+	      2 -> {literal,gb_trees:get(Val, Literals)}
+	  end,
+    decode_alloc_list_1(N-1, Literals, Bs, [Res|Acc]).
+
+%%-----------------------------------------------------------------------
+%% take N bytes from a stream, return {Taken_bytes, Remaining_bytes}
+%%-----------------------------------------------------------------------
+
+-spec take_bytes(non_neg_integer(), [byte()]) -> {[byte()],[byte()]}.
+take_bytes(N, Bs) ->
+    take_bytes(N, Bs, []).
+
+take_bytes(N, [B|Bs], Acc) when N > 0 ->
+    take_bytes(N-1, Bs, [B|Acc]);
+take_bytes(0, Bs, Acc) ->
+    {lists:reverse(Acc), Bs}.
+
+%%-----------------------------------------------------------------------
+%% from a list of bytes Bn,Bn-1,...,B1,B0
+%% build  (Bn << 8*n) bor ... bor (B1 << 8) bor (B0 << 0)
+%%-----------------------------------------------------------------------
+
+build_arg(Bs) ->
+    build_arg(Bs, 0).
+
+build_arg([B|Bs], N) ->
+    build_arg(Bs, (N bsl 8) bor B);
+build_arg([], N) ->
+    N.
+
+%%-----------------------------------------------------------------------
+%% Decodes a bunch of arguments and returns them in a list
+%%-----------------------------------------------------------------------
+
+decode_n_args(N, Bs, Atoms, Literals) when N >= 0 ->
+    decode_n_args(N, [], Bs, Atoms, Literals).
+
+decode_n_args(N, Acc, Bs0, Atoms, Literals) when N > 0 ->
+    {A1,Bs} = decode_arg(Bs0, Atoms, Literals),
+    decode_n_args(N-1, [A1|Acc], Bs, Atoms, Literals);
+decode_n_args(0, Acc, Bs, _, _) ->
+    {lists:reverse(Acc),Bs}.
+
+%%-----------------------------------------------------------------------
+%% Convert a numeric tag value into a symbolic one
+%%-----------------------------------------------------------------------
+
+-spec decode_tag(0..7) -> symbolic_tag().
+decode_tag(?tag_u) -> u;
+decode_tag(?tag_i) -> i;
+decode_tag(?tag_a) -> a;
+decode_tag(?tag_x) -> x;
+decode_tag(?tag_y) -> y;
+decode_tag(?tag_f) -> f;
+decode_tag(?tag_h) -> h;
+decode_tag(?tag_z) -> z.
+
+%%-----------------------------------------------------------------------
+%% - replace all references {a,I} with the atom with index I (or {atom,A})
+%% - replace all references to {i,K} in an external call position with
+%%    the proper MFA (position in list, first elt = 0, yields MFA to use)
+%% - resolve strings, represented as <offset, length>, into their
+%%   actual values by using string table
+%%    (note: string table should be passed as a BINARY so that we can
+%%    use binary_to_list/3!)
+%% - convert instruction to its readable form ...
+%% 
+%% Currently, only the first three are done (systematically, at least).
+%%
+%% Note: It MAY be premature to remove the lists of args, since that
+%%  representation means it is simpler to iterate over all args, etc.
+%%-----------------------------------------------------------------------
+
+resolve_names(Fun, Imports, Str, Lbls, Lambdas, Literals, M) ->
+    [resolve_inst(Instr, Imports, Str, Lbls, Lambdas, Literals, M) || Instr <- Fun].
+
+%%
+%% New make_fun2/4 instruction added in August 2001 (R8).
+%% New put_literal/2 instruction added in Feb 2006 R11B-4.
+%% We handle them specially here to avoid adding an argument to
+%% the clause for every instruction.
+%%
+
+resolve_inst({make_fun2,Args}, _, _, _, Lambdas, _, M) ->
+    [OldIndex] = resolve_args(Args),
+    {value,{OldIndex,{F,A,_Lbl,_Index,NumFree,OldUniq}}} =
+	lists:keysearch(OldIndex, 1, Lambdas),
+    {make_fun2,{M,F,A},OldIndex,OldUniq,NumFree};
+resolve_inst({put_literal,[{u,Index},Dst]},_,_,_,_,Literals,_) ->
+    {put_literal,{literal,gb_trees:get(Index, Literals)},Dst};
+resolve_inst(Instr, Imports, Str, Lbls, _Lambdas, _Literals, _M) ->
+    %% io:format(?MODULE_STRING":resolve_inst ~p.~n", [Instr]),
+    resolve_inst(Instr, Imports, Str, Lbls).
+
+resolve_inst({label,[{u,L}]},_,_,_) ->
+    {label,L};
+resolve_inst(FuncInfo,_,_,_) when element(1, FuncInfo) =:= func_info -> 
+    FuncInfo; % already resolved
+%% resolve_inst(int_code_end,_,_,_,_) ->  % instruction already handled
+%%    int_code_end;                       % should not really be handled here
+resolve_inst({call,[{u,N},{f,L}]},_,_,Lbls) ->
+    {call,N,lookup(L,Lbls)};
+resolve_inst({call_last,[{u,N},{f,L},{u,U}]},_,_,Lbls) ->
+    {call_last,N,lookup(L,Lbls),U};
+resolve_inst({call_only,[{u,N},{f,L}]},_,_,Lbls) ->
+    {call_only,N,lookup(L,Lbls)};
+resolve_inst({call_ext,[{u,N},{u,MFAix}]},Imports,_,_) ->
+    {call_ext,N,lookup(MFAix+1,Imports)};
+resolve_inst({call_ext_last,[{u,N},{u,MFAix},{u,X}]},Imports,_,_) ->
+    {call_ext_last,N,lookup(MFAix+1,Imports),X};
+resolve_inst({bif0,Args},Imports,_,_) ->
+    [Bif,Reg] = resolve_args(Args),
+    {extfunc,_Mod,BifName,_Arity} = lookup(Bif+1,Imports),
+    %% ?NO_DEBUG('bif0(~p, ~p)~n',[BifName,Reg]),
+    {bif,BifName,nofail,[],Reg};
+resolve_inst({bif1,Args},Imports,_,_) ->
+    [F,Bif,A1,Reg] = resolve_args(Args),
+    {extfunc,_Mod,BifName,_Arity} = lookup(Bif+1,Imports),
+    %% ?NO_DEBUG('bif1(~p, ~p, ~p, ~p, ~p)~n',[Bif,BifName,F,[A1],Reg]),
+    {bif,BifName,F,[A1],Reg};
+resolve_inst({bif2,Args},Imports,_,_) ->
+    [F,Bif,A1,A2,Reg] = resolve_args(Args),
+    {extfunc,_Mod,BifName,_Arity} = lookup(Bif+1,Imports),
+    %% ?NO_DEBUG('bif2(~p, ~p, ~p, ~p, ~p)~n',[Bif,BifName,F,[A1,A2],Reg]),
+    {bif,BifName,F,[A1,A2],Reg};
+resolve_inst({allocate,[{u,X0},{u,X1}]},_,_,_) ->
+    {allocate,X0,X1};
+resolve_inst({allocate_heap,[{u,X0},{u,X1},{u,X2}]},_,_,_) ->
+    {allocate_heap,X0,X1,X2};
+resolve_inst({allocate_zero,[{u,X0},{u,X1}]},_,_,_) ->
+    {allocate_zero,X0,X1};
+resolve_inst({allocate_heap_zero,[{u,X0},{u,X1},{u,X2}]},_,_,_) ->
+    {allocate_heap_zero,X0,X1,X2};
+resolve_inst({test_heap,[{u,X0},{u,X1}]},_,_,_) ->
+    {test_heap,X0,X1};
+resolve_inst({init,[Dst]},_,_,_) ->
+    {init,Dst};
+resolve_inst({deallocate,[{u,L}]},_,_,_) ->
+    {deallocate,L};
+resolve_inst({return,[]},_,_,_) ->
+    return;
+resolve_inst({send,[]},_,_,_) ->
+    send;
+resolve_inst({remove_message,[]},_,_,_) ->
+    remove_message;
+resolve_inst({found_message,[]},_,_,_) ->
+    found_message;
+resolve_inst({timeout,[]},_,_,_) ->
+    timeout;
+resolve_inst({loop_rec,[Lbl,Dst]},_,_,_) ->
+    {loop_rec,Lbl,Dst};
+resolve_inst({loop_rec_end,[Lbl]},_,_,_) ->
+    {loop_rec_end,Lbl};
+resolve_inst({wait,[Lbl]},_,_,_) ->
+    {wait,Lbl};
+resolve_inst({wait_timeout,[Lbl,Int]},_,_,_) ->
+    {wait_timeout,Lbl,resolve_arg(Int)};
+resolve_inst({m_plus,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'+',W,[SrcR1,SrcR2],DstR};
+resolve_inst({m_minus,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'-',W,[SrcR1,SrcR2],DstR};
+resolve_inst({m_times,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'*',W,[SrcR1,SrcR2],DstR};
+resolve_inst({m_div,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'/',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_div,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'div',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_rem,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'rem',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_band,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'band',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_bor,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'bor',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_bxor,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'bxor',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_bsl,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'bsl',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_bsr,Args},_,_,_) ->
+    [W,SrcR1,SrcR2,DstR] = resolve_args(Args),
+    {arithbif,'bsr',W,[SrcR1,SrcR2],DstR};
+resolve_inst({int_bnot,Args},_,_,_) ->
+    [W,SrcR,DstR] = resolve_args(Args),
+    {arithbif,'bnot',W,[SrcR],DstR};
+resolve_inst({is_lt=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_ge=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_eq=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_ne=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_eq_exact=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_ne_exact=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_integer=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_float=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_number=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_atom=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_pid=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_reference=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_port=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_nil=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_binary=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_constant=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_list=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_nonempty_list=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({is_tuple=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({test_arity=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({select_val,Args},_,_,_) ->
+    [Reg,FLbl,{{z,1},{u,_Len},List0}] = Args,
+    List = resolve_args(List0),
+    {select_val,Reg,FLbl,{list,List}};
+resolve_inst({select_tuple_arity,Args},_,_,_) ->
+    [Reg,FLbl,{{z,1},{u,_Len},List0}] = Args,
+    List = resolve_args(List0),
+    {select_tuple_arity,Reg,FLbl,{list,List}};
+resolve_inst({jump,[Lbl]},_,_,_) ->
+    {jump,Lbl};
+resolve_inst({'catch',[Dst,Lbl]},_,_,_) ->
+    {'catch',Dst,Lbl};
+resolve_inst({catch_end,[Dst]},_,_,_) ->
+    {catch_end,Dst};
+resolve_inst({move,[Src,Dst]},_,_,_) ->
+    {move,resolve_arg(Src),Dst};
+resolve_inst({get_list,[Src,Dst1,Dst2]},_,_,_) ->
+    {get_list,Src,Dst1,Dst2};
+resolve_inst({get_tuple_element,[Src,{u,Off},Dst]},_,_,_) ->
+    {get_tuple_element,resolve_arg(Src),Off,resolve_arg(Dst)};
+resolve_inst({set_tuple_element,[Src,Dst,{u,Off}]},_,_,_) ->
+    {set_tuple_element,resolve_arg(Src),resolve_arg(Dst),Off};
+resolve_inst({put_string,[{u,Len},{u,Off},Dst]},_,Strings,_) ->
+    String = if Len > 0 -> binary_to_list(Strings, Off+1, Off+Len);
+		true -> ""
+	     end,
+    %% ?NO_DEBUG('put_string(~p, {string,~p}, ~p)~n',[Len,String,Dst]),
+    {put_string,Len,{string,String},Dst};
+resolve_inst({put_list,[Src1,Src2,Dst]},_,_,_) ->
+    {put_list,resolve_arg(Src1),resolve_arg(Src2),Dst};
+resolve_inst({put_tuple,[{u,Arity},Dst]},_,_,_) ->
+    {put_tuple,Arity,Dst};
+resolve_inst({put,[Src]},_,_,_) ->
+    {put,resolve_arg(Src)};
+resolve_inst({badmatch,[X]},_,_,_) ->
+    {badmatch,resolve_arg(X)};
+resolve_inst({if_end,[]},_,_,_) ->
+    if_end;
+resolve_inst({case_end,[X]},_,_,_) ->
+    {case_end,resolve_arg(X)};
+resolve_inst({call_fun,[{u,N}]},_,_,_) ->
+    {call_fun,N};
+resolve_inst({make_fun,Args},_,_,Lbls) ->
+    [{f,L},Magic,FreeVars] = resolve_args(Args),
+    {make_fun,lookup(L,Lbls),Magic,FreeVars};
+resolve_inst({is_function=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+resolve_inst({call_ext_only,[{u,N},{u,MFAix}]},Imports,_,_) ->
+    {call_ext_only,N,lookup(MFAix+1,Imports)};
+%%
+%% Instructions for handling binaries added in R7A & R7B
+%%
+resolve_inst({bs_start_match,[F,Reg]},_,_,_) ->
+    {bs_start_match,F,Reg};
+resolve_inst({bs_get_integer=I,[Lbl,Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    {test,I,Lbl,[A2,N,decode_field_flags(U),A5]};
+resolve_inst({bs_get_float=I,[Lbl,Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    {test,I,Lbl,[A2,N,decode_field_flags(U),A5]};
+resolve_inst({bs_get_binary=I,[Lbl,Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    {test,I,Lbl,[A2,N,decode_field_flags(U),A5]};
+resolve_inst({bs_skip_bits,[Lbl,Arg2,{u,N},{u,U}]},_,_,_) ->
+    [A2] = resolve_args([Arg2]),
+    {test,bs_skip_bits,Lbl,[A2,N,decode_field_flags(U)]};
+resolve_inst({bs_test_tail,[F,{u,N}]},_,_,_) ->
+    {test,bs_test_tail,F,[N]};
+resolve_inst({bs_save,[{u,N}]},_,_,_) ->
+    {bs_save,N};
+resolve_inst({bs_restore,[{u,N}]},_,_,_) ->
+    {bs_restore,N};
+resolve_inst({bs_init,[{u,N},{u,U}]},_,_,_) ->
+    {bs_init,N,decode_field_flags(U)};
+resolve_inst({bs_final,[F,X]},_,_,_) ->
+    {bs_final,F,X};
+resolve_inst({bs_put_integer,[Lbl,Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    {bs_put_integer,Lbl,A2,N,decode_field_flags(U),A5};
+resolve_inst({bs_put_binary,[Lbl,Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    ?NO_DEBUG('bs_put_binary(~p,~p,~p,~p,~p})~n',[Lbl,A2,N,U,A5]),
+    {bs_put_binary,Lbl,A2,N,decode_field_flags(U),A5};
+resolve_inst({bs_put_float,[Lbl,Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    ?NO_DEBUG('bs_put_float(~p,~p,~p,~p,~p})~n',[Lbl,A2,N,U,A5]),
+    {bs_put_float,Lbl,A2,N,decode_field_flags(U),A5};
+resolve_inst({bs_put_string,[{u,Len},{u,Off}]},_,Strings,_) ->
+    String = if Len > 0 -> binary_to_list(Strings, Off+1, Off+Len);
+		true -> ""
+	     end,
+    ?NO_DEBUG('bs_put_string(~p, {string,~p})~n',[Len,String]),
+    {bs_put_string,Len,{string,String}};
+resolve_inst({bs_need_buf,[{u,N}]},_,_,_) ->
+    {bs_need_buf,N};
+
+%%
+%% Instructions for handling floating point numbers added in June 2001 (R8).
+%%
+resolve_inst({fclearerror,[]},_,_,_) ->
+    fclearerror;
+resolve_inst({fcheckerror,Args},_,_,_) ->
+    [Fail] = resolve_args(Args),
+    {fcheckerror,Fail};
+resolve_inst({fmove,Args},_,_,_) ->
+    [FR,Reg] = resolve_args(Args),
+    {fmove,FR,Reg};
+resolve_inst({fconv,Args},_,_,_) ->
+    [Reg,FR] = resolve_args(Args),
+    {fconv,Reg,FR};
+resolve_inst({fadd=I,Args},_,_,_) ->
+    [F,A1,A2,Reg] = resolve_args(Args),
+    {arithfbif,I,F,[A1,A2],Reg};
+resolve_inst({fsub=I,Args},_,_,_) ->
+    [F,A1,A2,Reg] = resolve_args(Args),
+    {arithfbif,I,F,[A1,A2],Reg};
+resolve_inst({fmul=I,Args},_,_,_) ->
+    [F,A1,A2,Reg] = resolve_args(Args),
+    {arithfbif,I,F,[A1,A2],Reg};
+resolve_inst({fdiv=I,Args},_,_,_) ->
+    [F,A1,A2,Reg] = resolve_args(Args),
+    {arithfbif,I,F,[A1,A2],Reg};
+resolve_inst({fnegate,Args},_,_,_) ->
+    [F,Arg,Reg] = resolve_args(Args),
+    {arithfbif,fnegate,F,[Arg],Reg};
+
+%%
+%% Instructions for try expressions added in January 2003 (R10).
+%%
+resolve_inst({'try',[Reg,Lbl]},_,_,_) -> % analogous to 'catch'
+    {'try',Reg,Lbl};
+resolve_inst({try_end,[Reg]},_,_,_) ->   % analogous to 'catch_end'
+    {try_end,Reg};
+resolve_inst({try_case,[Reg]},_,_,_) ->  % analogous to 'catch_end'
+    {try_case,Reg};
+resolve_inst({try_case_end,[Arg]},_,_,_) ->
+    {try_case_end,resolve_arg(Arg)};
+resolve_inst({raise,[Reg1,Reg2]},_,_,_) ->
+    {raise,{f,0},[Reg1,Reg2],{x,0}};	 % do NOT wrap this as a 'bif'
+					 % as there is no raise/2 bif!
+
+%%
+%% New bit syntax instructions added in February 2004 (R10B).
+%%
+resolve_inst({bs_init2,[Lbl,Arg2,{u,W},{u,R},{u,F},Arg6]},_,_,_) ->
+    [A2,A6] = resolve_args([Arg2,Arg6]),
+    {bs_init2,Lbl,A2,W,R,decode_field_flags(F),A6};
+resolve_inst({bs_bits_to_bytes,[Lbl,Arg2,Arg3]},_,_,_) ->
+    [A2,A3] = resolve_args([Arg2,Arg3]),
+    {bs_bits_to_bytes,Lbl,A2,A3};
+resolve_inst({bs_add=I,[Lbl,Arg2,Arg3,Arg4,Arg5]},_,_,_) ->
+    [A2,A3,A4,A5] = resolve_args([Arg2,Arg3,Arg4,Arg5]),
+    {I,Lbl,[A2,A3,A4],A5};
+
+%%
+%% New apply instructions added in April 2004 (R10B).
+%%
+resolve_inst({apply,[{u,Arity}]},_,_,_) ->
+    {apply,Arity};
+resolve_inst({apply_last,[{u,Arity},{u,D}]},_,_,_) ->
+    {apply_last,Arity,D};
+
+%%
+%% New test instruction added in April 2004 (R10B).
+%%
+resolve_inst({is_boolean=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+
+%%
+%% New instruction added in June 2005.
+%%
+resolve_inst({is_function2=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+
+%%
+%% New bit syntax matching added in Dec 2005 (R11B).
+%%
+resolve_inst({bs_start_match2=I,[F,Reg,{u,Live},{u,Max},Ms]},_,_,_) ->
+    {test,I,F,[Reg,Live,Max,Ms]};
+resolve_inst({bs_get_integer2=I,[Lbl,Ms,{u,Live},Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    {test,I,Lbl,[Ms, Live,A2,N,decode_field_flags(U),A5]};
+resolve_inst({bs_get_binary2=I,[Lbl,Ms,{u,Live},Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    {test,I,Lbl,[Ms, Live,A2,N,decode_field_flags(U),A5]};
+resolve_inst({bs_get_float2=I,[Lbl,Ms,{u,Live},Arg2,{u,N},{u,U},Arg5]},_,_,_) ->
+    [A2,A5] = resolve_args([Arg2,Arg5]),
+    {test,I,Lbl,[Ms, Live,A2,N,decode_field_flags(U),A5]};
+resolve_inst({bs_skip_bits2=I,[Lbl,Ms,Arg2,{u,N},{u,U}]},_,_,_) ->
+    [A2] = resolve_args([Arg2]),
+    {test,I,Lbl,[Ms,A2,N,decode_field_flags(U)]};
+resolve_inst({bs_test_tail2=I,[F,Ms,{u,N}]},_,_,_) ->
+    {test,I,F,[Ms,N]};
+resolve_inst({bs_save2=I,[Ms,{u,N}]},_,_,_) ->
+    {I,Ms,N};
+resolve_inst({bs_restore2=I,[Ms,{u,N}]},_,_,_) ->
+    {I,Ms,N};
+resolve_inst({bs_save2=I,[Ms,{atom,_}=Atom]},_,_,_) ->
+    %% New operand type in R12B.
+    {I,Ms,Atom};
+resolve_inst({bs_restore2=I,[Ms,{atom,_}=Atom]},_,_,_) ->
+    %% New operand type in R12B.
+    {I,Ms,Atom};
+
+%%
+%% New instructions for guard BIFs that may GC. Added in Jan 2006 (R11B).
+%%
+resolve_inst({gc_bif0,Args},Imports,_,_) ->
+    [F,Live,Bif,Reg] = resolve_args(Args),
+    {extfunc,_Mod,BifName,_Arity} = lookup(Bif+1,Imports),
+    %% ?NO_DEBUG('gc_bif0(~p, ~p)~n',[BifName,Reg]),
+    {gc_bif,BifName,F,Live,[],Reg};
+resolve_inst({gc_bif1,Args},Imports,_,_) ->
+    [F,Live,Bif,A1,Reg] = resolve_args(Args),
+    {extfunc,_Mod,BifName,_Arity} = lookup(Bif+1,Imports),
+    %% ?NO_DEBUG('gc_bif1(~p, ~p, ~p, ~p, ~p)~n',[Bif,BifName,F,[A1],Reg]),
+    {gc_bif,BifName,F,Live,[A1],Reg};
+resolve_inst({gc_bif2,Args},Imports,_,_) ->
+    [F,Live,Bif,A1,A2,Reg] = resolve_args(Args),
+    {extfunc,_Mod,BifName,_Arity} = lookup(Bif+1,Imports),
+    %% ?NO_DEBUG('gc_bif2(~p, ~p, ~p, ~p, ~p)~n',[Bif,BifName,F,[A1,A2],Reg]),
+    {gc_bif,BifName,F,Live,[A1,A2],Reg};
+
+%%
+%% New instructions for creating non-byte aligned binaries.
+%%
+resolve_inst({bs_bits_to_bytes2,[Arg2,Arg3]},_,_,_) ->
+    [A2,A3] = resolve_args([Arg2,Arg3]),
+    {bs_bits_to_bytes2,A2,A3};
+resolve_inst({bs_final2,[X,Y]},_,_,_) ->
+    {bs_final2,X,Y};
+
+%%
+%% R11B-5.
+%% 
+resolve_inst({is_bitstr=I,Args0},_,_,_) ->
+    [L|Args] = resolve_args(Args0),
+    {test,I,L,Args};
+
+%%
+%% R12B.
+%%
+resolve_inst({bs_context_to_binary=I,[Reg0]},_,_,_) ->
+    Reg = resolve_arg(Reg0),
+    {I,Reg};
+resolve_inst({bs_test_unit=I,[F,Ms,{u,N}]},_,_,_) ->
+    {test,I,F,[Ms,N]};
+resolve_inst({bs_match_string=I,[F,Ms,{u,Bits},{u,Off}]},_,Strings,_) ->
+    Len = (Bits+7) div 8,
+    String = if
+		 Len > 0 -> 
+		     <<_:Off/binary,Bin:Len/binary,_/binary>> = Strings,
+		     Bin;
+		 true -> <<>>
+	     end,
+    {test,I,F,[Ms,Bits,String]};
+resolve_inst({bs_init_writable=I,[]},_,_,_) ->
+    I;
+resolve_inst({bs_append=I,[Lbl,Arg2,{u,W},{u,R},{u,U},Arg6,{u,F},Arg8]},_,_,_) ->
+    [A2,A6,A8] = resolve_args([Arg2,Arg6,Arg8]),
+    {I,Lbl,A2,W,R,U,A6,decode_field_flags(F),A8};
+resolve_inst({bs_private_append=I,[Lbl,Arg2,{u,U},Arg4,{u,F},Arg6]},_,_,_) ->
+    [A2,A4,A6] = resolve_args([Arg2,Arg4,Arg6]),
+    {I,Lbl,A2,U,A4,decode_field_flags(F),A6};
+resolve_inst({trim=I,[{u,N},{u,Remaining}]},_,_,_) ->
+    {I,N,Remaining};
+resolve_inst({bs_init_bits,[Lbl,Arg2,{u,W},{u,R},{u,F},Arg6]},_,_,_) ->
+    [A2,A6] = resolve_args([Arg2,Arg6]),
+    {bs_init_bits,Lbl,A2,W,R,decode_field_flags(F),A6};
+
+%%
+%% R12B-5.
+%%
+resolve_inst({bs_get_utf8=I,[Lbl,Arg2,Arg3,{u,U},Arg4]},_,_,_) ->
+    [A2,A3,A4] = resolve_args([Arg2,Arg3,Arg4]),
+    {test,I,Lbl,[A2,A3,decode_field_flags(U),A4]};
+resolve_inst({bs_skip_utf8=I,[Lbl,Arg2,Arg3,{u,U}]},_,_,_) ->
+    [A2,A3] = resolve_args([Arg2,Arg3]),
+    {test,I,Lbl,[A2,A3,decode_field_flags(U)]};
+resolve_inst({bs_get_utf16=I,[Lbl,Arg2,Arg3,{u,U},Arg4]},_,_,_) ->
+    [A2,A3,A4] = resolve_args([Arg2,Arg3,Arg4]),
+    {test,I,Lbl,[A2,A3,decode_field_flags(U),A4]};
+resolve_inst({bs_skip_utf16=I,[Lbl,Arg2,Arg3,{u,U}]},_,_,_) ->
+    [A2,A3] = resolve_args([Arg2,Arg3]),
+    {test,I,Lbl,[A2,A3,decode_field_flags(U)]};
+resolve_inst({bs_get_utf32=I,[Lbl,Arg2,Arg3,{u,U},Arg4]},_,_,_) ->
+    [A2,A3,A4] = resolve_args([Arg2,Arg3,Arg4]),
+    {test,I,Lbl,[A2,A3,decode_field_flags(U),A4]};
+resolve_inst({bs_skip_utf32=I,[Lbl,Arg2,Arg3,{u,U}]},_,_,_) ->
+    [A2,A3] = resolve_args([Arg2,Arg3]),
+    {test,I,Lbl,[A2,A3,decode_field_flags(U)]};
+resolve_inst({bs_utf8_size=I,[Lbl,Arg2,Arg3]},_,_,_) ->
+    [A2,A3] = resolve_args([Arg2,Arg3]),
+    {I,Lbl,A2,A3};
+resolve_inst({bs_put_utf8=I,[Lbl,{u,U},Arg3]},_,_,_) ->
+    [A3] = resolve_args([Arg3]),
+    {I,Lbl,decode_field_flags(U),A3};
+resolve_inst({bs_utf16_size=I,[Lbl,Arg2,Arg3]},_,_,_) ->
+    [A2,A3] = resolve_args([Arg2,Arg3]),
+    {I,Lbl,A2,A3};
+resolve_inst({bs_put_utf16=I,[Lbl,{u,U},Arg3]},_,_,_) ->
+    [A3] = resolve_args([Arg3]),
+    {I,Lbl,decode_field_flags(U),A3};
+resolve_inst({bs_put_utf32=I,[Lbl,{u,U},Arg3]},_,_,_) ->
+    [A3] = resolve_args([Arg3]),
+    {I,Lbl,decode_field_flags(U),A3};
+
+%%
+%% Catches instructions that are not yet handled.
+%%
+resolve_inst(X,_,_,_) -> ?exit({resolve_inst,X}).
+
+%%-----------------------------------------------------------------------
+%% Resolves arguments in a generic way.
+%%-----------------------------------------------------------------------
+
+resolve_args(Args) -> [resolve_arg(A) || A <- Args].
+
+resolve_arg({x,N} = Arg) when is_integer(N), N >= 0 -> Arg;
+resolve_arg({y,N} = Arg) when is_integer(N), N >= 0 -> Arg;
+resolve_arg({fr,N} = Arg) when is_integer(N), N >= 0 -> Arg;
+resolve_arg({f,N} = Arg) when is_integer(N), N >= 0 -> Arg;
+resolve_arg({u,_} = Arg) -> resolve_arg_unsigned(Arg);
+resolve_arg({i,_} = Arg) -> resolve_arg_integer(Arg);
+resolve_arg({atom,Atom} = Arg) when is_atom(Atom) -> Arg;
+resolve_arg({float,F} = Arg) when is_float(F) -> Arg;
+resolve_arg({literal,_} = Arg) -> Arg;
+resolve_arg(nil) -> nil.
+
+resolve_arg_unsigned({u,N}) when is_integer(N), N >= 0 -> N.
+
+resolve_arg_integer({i,N}) when is_integer(N) -> {integer,N}.
+
+%%-----------------------------------------------------------------------
+%% The purpose of the following is just to add a hook for future changes.
+%% Currently, field flags are numbers 1-2-4-8 and only two of these
+%% numbers (BSF_LITTLE 2 -- BSF_SIGNED 4) have a semantic significance;
+%% others are just hints for speeding up the execution; see "erl_bits.h".
+%%-----------------------------------------------------------------------
+
+decode_field_flags(FF) ->
+    {field_flags,FF}.
+
+%%-----------------------------------------------------------------------
+%% Private Utilities
+%%-----------------------------------------------------------------------
+
+mk_imports(ImportList) ->
+    gb_trees:from_orddict([{I,{extfunc,M,F,A}} || {I,M,F,A} <- ImportList]).
+
+mk_atoms(AtomList) ->
+    gb_trees:from_orddict(AtomList).
+
+mk_labels(LabelList) ->
+    gb_trees:from_orddict(LabelList).
+
+lookup(I, Imports) ->
+    gb_trees:get(I, Imports).
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_disasm.hrl minimal_otp_src_R12B-5/lib/compiler/src/beam_disasm.hrl
--- otp_src_R12B-5/lib/compiler/src/beam_disasm.hrl	2008-11-04 10:52:03.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_disasm.hrl	2009-06-23 20:40:10.000000000 +0100
@@ -11,7 +11,7 @@
 %%
 -type beam_instr() :: 'bs_init_writable' | 'fclearerror' | 'if_end'
                     | 'remove_message' | 'return' | 'send' | 'timeout'
-                    | tuple().  %% XXX: Very underspecified - FIX THIS
+                    | 'found_message' | tuple().  %% XXX: Very underspecified - FIX THIS
 
 %%
 %% This is a labeled_export tuple returned by beam_lib:chunks/2.
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_flatten.erl minimal_otp_src_R12B-5/lib/compiler/src/beam_flatten.erl
--- otp_src_R12B-5/lib/compiler/src/beam_flatten.erl	2008-11-04 10:51:32.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_flatten.erl	2009-06-23 20:40:10.000000000 +0100
@@ -63,6 +63,7 @@ norm({set,[D],[S],{get_tuple_element,I}}
 norm({set,[],[S,D],{set_tuple_element,I}}) -> {set_tuple_element,S,D,I};
 norm({set,[D1,D2],[S],get_list})          -> {get_list,S,D1,D2};
 norm({set,[],[],remove_message})   -> remove_message;
+norm({set,[],[],found_message}) -> found_message;
 norm({set,[],[],fclearerror}) -> fclearerror;
 norm({set,[],[],fcheckerror}) -> {fcheckerror,{f,0}};
 norm({'%',_}=Comment)   -> Comment;
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_jump.erl minimal_otp_src_R12B-5/lib/compiler/src/beam_jump.erl
--- otp_src_R12B-5/lib/compiler/src/beam_jump.erl	2008-11-04 10:51:32.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_jump.erl	2009-06-23 20:40:10.000000000 +0100
@@ -340,6 +340,7 @@ is_unreachable_after({jump,_Lbl}) -> tru
 is_unreachable_after({select_val,_R,_Lbl,_Cases}) -> true;
 is_unreachable_after({select_tuple_arity,_R,_Lbl,_Cases}) -> true;
 is_unreachable_after({loop_rec_end,_}) -> true;
+is_unreachable_after({loop_search_end,_}) -> true;
 is_unreachable_after({wait,_}) -> true;
 is_unreachable_after(I) -> is_exit_instruction(I).
 
@@ -418,6 +419,12 @@ ulbl({loop_rec,Lbl,_}, Used) ->
     mark_used(Lbl, Used);
 ulbl({loop_rec_end,Lbl}, Used) ->
     mark_used(Lbl, Used);
+%% Search
+ulbl({loop_search,Lbl,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({loop_search_end,Lbl}, Used) ->
+    mark_used(Lbl, Used);
+
 ulbl({wait,Lbl}, Used) ->
     mark_used(Lbl, Used);
 ulbl({wait_timeout,Lbl,_To}, Used) ->
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_jump.erl~ minimal_otp_src_R12B-5/lib/compiler/src/beam_jump.erl~
--- otp_src_R12B-5/lib/compiler/src/beam_jump.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_jump.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,461 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%%% Purpose : Optimise jumps and remove unreachable code.
+
+-module(beam_jump).
+
+-export([module/2,module_labels/1,
+	 is_unreachable_after/1,is_exit_instruction/1,
+	 remove_unused_labels/1,is_label_used_in/2]).
+
+%%% The following optimisations are done:
+%%%
+%%% (1) This code with two identical instruction sequences
+%%% 
+%%%     L1: <Instruction sequence>
+%%%     L2:
+%%%          . . .
+%%%     L3: <Instruction sequence>
+%%%     L4:
+%%%
+%%%     can be replaced with
+%%% 
+%%%     L1: jump L3
+%%%     L2:
+%%%          . . .
+%%%     L3: <Instruction sequence>
+%%%     L4
+%%%     
+%%%     Note: The instruction sequence must end with an instruction
+%%%     such as a jump that never transfers control to the instruction
+%%%     following it.
+%%%
+%%% (2) case_end, if_end, and badmatch, and function calls that cause an
+%%%     exit (such as calls to exit/1) are moved to the end of the function.
+%%%     The purpose is to allow further optimizations at the place from
+%%%     which the code was moved.
+%%%
+%%% (3) Any unreachable code is removed.  Unreachable code is code after
+%%%     jump, call_last and other instructions which never transfer control
+%%%     to the following instruction.  Code is unreachable up to the next
+%%%     *referenced* label.  Note that the optimisations below might
+%%%     generate more possibilities for removing unreachable code.
+%%%
+%%% (4) This code:
+%%%	L1:	jump L2
+%%%          . . .
+%%%     L2: ...
+%%%
+%%%    will be changed to
+%%%
+%%%    jump L2
+%%%          . . .
+%%%    L1:
+%%%    L2: ...
+%%%
+%%%    If the jump is unreachable, it will be removed according to (1).
+%%%
+%%% (5) In
+%%%
+%%%	 jump L1
+%%%      L1:
+%%%
+%%%	 the jump will be removed.
+%%%
+%%% (6) If test instructions are used to skip a single jump instruction,
+%%%      the test is inverted and the jump is eliminated (provided that
+%%%      the test can be inverted).  Example:
+%%%
+%%%      is_eq L1 {x,1} {x,2}
+%%%      jump L2
+%%%      L1:
+%%%
+%%%      will be changed to
+%%%
+%%%      is_ne L2 {x,1} {x,2}
+%%%
+%%%      (The label L1 will be retained if there were previous references to it.)
+%%%
+%%% Terminology note: The optimisation done here is called unreachable-code
+%%% elimination, NOT dead-code elimination.  Dead code elimination
+%%% means the removal of instructions that are executed, but have no visible
+%%% effect on the program state.
+%%% 
+
+-import(lists, [reverse/1,reverse/2,foldl/3,last/1]).
+
+module({Mod,Exp,Attr,Fs0,Lc}, _Opt) ->
+    Fs = [function(F) || F <- Fs0],
+    {ok,{Mod,Exp,Attr,Fs,Lc}}.
+
+module_labels({Mod,Exp,Attr,Fs,Lc}) ->
+    {Mod,Exp,Attr,[function_labels(F) || F <- Fs],Lc}.
+
+function_labels({function,Name,Arity,CLabel,Asm0}) ->
+    Asm = remove_unused_labels(Asm0),
+    {function,Name,Arity,CLabel,Asm}.    
+
+function({function,Name,Arity,CLabel,Asm0}) ->
+    Asm1 = share(Asm0),
+    Asm2 = move(Asm1),
+    Asm3 = opt(Asm2, CLabel),
+    Asm = remove_unused_labels(Asm3),
+    {function,Name,Arity,CLabel,Asm}.
+
+%%%
+%%% (1) We try to share the code for identical code segments by replacing all
+%%% occurrences except the last with jumps to the last occurrence.
+%%%
+
+share(Is) ->
+    share_1(reverse(Is), dict:new(), [], []).
+
+share_1([{label,_}=Lbl|Is], Dict, [], Acc) ->
+    share_1(Is, Dict, [], [Lbl|Acc]);
+share_1([{label,L}=Lbl|Is], Dict0, Seq, Acc) ->
+    case is_unreachable_after(last(Seq)) of
+	false ->
+	    share_1(Is, Dict0, [], [Lbl|Seq ++ Acc]);
+	true ->
+	    case dict:find(Seq, Dict0) of
+		error ->
+		    Dict = dict:store(Seq, L, Dict0),
+		    share_1(Is, Dict, [], [Lbl|Seq ++ Acc]);
+		{ok,Label} ->
+		    share_1(Is, Dict0, [], [Lbl,{jump,{f,Label}}|Acc])
+	    end
+    end;
+share_1([{func_info,_,_,_}=I|Is], _, [], Acc) ->
+    Is++[I|Acc];
+share_1([I|Is], Dict, Seq, Acc) ->
+    case is_unreachable_after(I) of
+	false ->
+	    share_1(Is, Dict, [I|Seq], Acc);
+	true ->
+	    share_1(Is, Dict, [I], Acc)
+    end.
+
+%%%
+%%% (2) Move short code sequences ending in an instruction that causes an exit
+%%% to the end of the function.
+%%%
+
+move(Is) ->
+    move_1(Is, [], []).
+
+move_1([I|Is], End, Acc) ->
+    case is_exit_instruction(I) of
+	false -> move_1(Is, End, [I|Acc]);
+	true -> move_2(I, Is, End, Acc)
+    end;
+move_1([], End, Acc) ->
+    reverse(Acc, reverse(End)).
+
+move_2(Exit, Is, End, [{block,_},{label,_},{func_info,_,_,_}|_]=Acc) ->
+    move_1(Is, End, [Exit|Acc]);
+move_2(Exit, Is, End, [{block,_}=Blk,{label,_}=Lbl,Dead|More]=Acc) ->
+    case is_unreachable_after(Dead) of
+	false ->
+	    move_1(Is, End, [Exit|Acc]);
+	true ->
+	    move_1([Dead|Is], [Exit,Blk,Lbl|End], More)
+    end;
+move_2(Exit, Is, End, [{label,_}=Lbl,Dead|More]=Acc) ->
+    case is_unreachable_after(Dead) of
+	false ->
+	    move_1(Is, End, [Exit|Acc]);
+	true ->
+	    move_1([Dead|Is], [Exit,Lbl|End], More)
+    end;
+move_2(Exit, Is, End, Acc) ->
+    move_1(Is, End, [Exit|Acc]).
+
+%%%
+%%% (3) (4) (5) (6) Jump and unreachable code optimizations.
+%%%
+
+-record(st, {fc,				%Label for function class errors.
+	     entry,				%Entry label (must not be moved).
+	     mlbl,				%Moved labels.
+	     labels				%Set of referenced labels.
+	    }).
+
+opt([{label,Fc}|_]=Is, CLabel) ->
+    Lbls = initial_labels(Is),
+    St = #st{fc=Fc,entry=CLabel,mlbl=dict:new(),labels=Lbls},
+    opt(Is, [], St).
+
+opt([{test,Test0,{f,Lnum}=Lbl,Ops}=I|Is0], Acc, St) ->
+    case Is0 of
+	[{jump,{f,Lnum}}|[{label,Lnum}|Is2]=Is1] ->
+	    %% The test and jump are redundant. Keep the label if it is used
+	    %% (from some other place).
+	    Is = case is_label_used(Lnum, St) of
+		     true -> Is1;
+		     false -> Is2
+		 end,
+	    opt(Is, Acc, St);
+	[{jump,To}|[{label,Lnum}|Is2]=Is1] ->
+	    case invert_test(Test0) of
+		not_possible ->
+		    opt(Is0, [I|Acc], label_used(Lbl, St));
+		Test ->
+		    Is = case is_label_used(Lnum, St) of
+			     true -> Is1;
+			     false -> Is2
+			 end,
+		    opt([{test,Test,To,Ops}|Is], Acc, label_used(To, St))
+	    end;
+	_Other ->
+	    opt(Is0, [I|Acc], label_used(Lbl, St))
+    end;
+opt([{select_val,_R,Fail,{list,Vls}}=I|Is], Acc, St) ->
+    skip_unreachable(Is, [I|Acc], label_used([Fail|Vls], St));
+opt([{select_tuple_arity,_R,Fail,{list,Vls}}=I|Is], Acc, St) ->
+    skip_unreachable(Is, [I|Acc], label_used([Fail|Vls], St));
+opt([{label,L}=I|Is], Acc, #st{entry=L}=St) ->
+    %% NEVER move the entry label.
+    opt(Is, [I|Acc], St);
+opt([{label,L1},{jump,{f,L2}}=I|Is], [Prev|Acc], St0) ->
+    St = St0#st{mlbl=dict:append(L2, L1, St0#st.mlbl)},
+    opt([Prev,I|Is], Acc, label_used({f,L2}, St));
+opt([{label,Lbl}=I|Is], Acc, #st{mlbl=Mlbl}=St0) ->
+    case dict:find(Lbl, Mlbl) of
+	{ok,Lbls} ->
+	    %% Essential to remove the list of labels from the dictionary,
+	    %% since we will rescan the inserted labels.  We MUST rescan.
+	    St = St0#st{mlbl=dict:erase(Lbl, Mlbl)},
+	    insert_labels([Lbl|Lbls], Is, Acc, St);
+	error -> opt(Is, [I|Acc], St0)
+    end;
+opt([{jump,{f,Lbl}},{label,Lbl}=I|Is], Acc, St) ->
+    opt([I|Is], Acc, St);
+opt([{jump,Lbl}=I|Is], Acc, St) ->
+    skip_unreachable(Is, [I|Acc], label_used(Lbl, St));
+%% Optimization: quickly handle some common instructions that don't
+%% have any failure labels and where is_unreachable_after(I) =:= false.
+opt([{block,_}=I|Is], Acc, St) ->
+    opt(Is, [I|Acc], St);
+opt([{kill,_}=I|Is], Acc, St) ->
+    opt(Is, [I|Acc], St);
+opt([{call,_,_}=I|Is], Acc, St) ->
+    opt(Is, [I|Acc], St);
+opt([{deallocate,_}=I|Is], Acc, St) ->
+    opt(Is, [I|Acc], St);
+%% All other instructions.
+opt([I|Is], Acc, #st{labels=Used0}=St0) ->
+    Used = ulbl(I, Used0),
+    St = St0#st{labels=Used},
+    case is_unreachable_after(I) of
+	true  -> skip_unreachable(Is, [I|Acc], St);
+	false -> opt(Is, [I|Acc], St)
+    end;
+opt([], Acc, #st{fc=Fc,mlbl=Mlbl}) ->
+    Code = reverse(Acc),
+    case dict:find(Fc, Mlbl) of
+ 	{ok,Lbls} -> insert_fc_labels(Lbls, Mlbl, Code);
+ 	error -> Code
+    end.
+
+insert_fc_labels([L|Ls], Mlbl, Acc0) ->
+    Acc = [{label,L}|Acc0],
+    case dict:find(L, Mlbl) of
+	error ->
+	    insert_fc_labels(Ls, Mlbl, Acc);
+	{ok,Lbls} ->
+	    insert_fc_labels(Lbls++Ls, Mlbl, Acc)
+    end;
+insert_fc_labels([], _, Acc) -> Acc.
+
+%% invert_test(Test0) -> not_possible | Test
+
+invert_test(is_ge) ->       is_lt;
+invert_test(is_lt) ->       is_ge;
+invert_test(is_eq) ->       is_ne;
+invert_test(is_ne) ->       is_eq;
+invert_test(is_eq_exact) -> is_ne_exact;
+invert_test(is_ne_exact) -> is_eq_exact;
+invert_test(_) ->           not_possible.
+
+insert_labels([L|Ls], Is, [{jump,{f,L}}|Acc], St) ->
+    insert_labels(Ls, [{label,L}|Is], Acc, St);
+insert_labels([L|Ls], Is, Acc, St) ->
+    insert_labels(Ls, [{label,L}|Is], Acc, St);
+insert_labels([], Is, Acc, St) ->
+    opt(Is, Acc, St).
+
+%% Skip unreachable code up to the next referenced label.
+
+skip_unreachable([{label,L}|Is], [{jump,{f,L}}|Acc], St) ->
+    opt([{label,L}|Is], Acc, St);
+skip_unreachable([{label,L}|Is], Acc, St) ->
+    case is_label_used(L, St) of
+	true  -> opt([{label,L}|Is], Acc, St);
+	false -> skip_unreachable(Is, Acc, St)
+    end;
+skip_unreachable([_|Is], Acc, St) ->
+    skip_unreachable(Is, Acc, St);
+skip_unreachable([], Acc, St) ->
+    opt([], Acc, St).
+
+%% Add one or more label to the set of used labels.
+
+label_used({f,0}, St) -> St;
+label_used({f,L}, St) -> St#st{labels=gb_sets:add(L, St#st.labels)};
+label_used([H|T], St0) -> label_used(T, label_used(H, St0));
+label_used([], St) -> St;
+label_used(_Other, St) -> St.
+
+%% Test if label is used.
+
+is_label_used(L, St) ->
+    gb_sets:is_member(L, St#st.labels).
+
+%% is_unreachable_after(Instruction) -> true|false
+%%  Test whether the code after Instruction is unreachable.
+
+is_unreachable_after({func_info,_M,_F,_A}) -> true;
+is_unreachable_after(return) -> true;
+is_unreachable_after({call_ext_last,_Ar,_ExtFunc,_D}) -> true;
+is_unreachable_after({call_ext_only,_Ar,_ExtFunc}) -> true;
+is_unreachable_after({call_last,_Ar,_Lbl,_D}) -> true;
+is_unreachable_after({call_only,_Ar,_Lbl}) -> true;
+is_unreachable_after({apply_last,_Ar,_N}) -> true;
+is_unreachable_after({jump,_Lbl}) -> true;
+is_unreachable_after({select_val,_R,_Lbl,_Cases}) -> true;
+is_unreachable_after({select_tuple_arity,_R,_Lbl,_Cases}) -> true;
+is_unreachable_after({loop_rec_end,_}) -> true;
+is_unreachable_after({wait,_}) -> true;
+is_unreachable_after(I) -> is_exit_instruction(I).
+
+%% is_exit_instruction(Instruction) -> true|false
+%%  Test whether the instruction Instruction always
+%%  causes an exit/failure.
+
+is_exit_instruction({call_ext,_,{extfunc,M,F,A}}) ->
+    erl_bifs:is_exit_bif(M, F, A);
+is_exit_instruction({call_ext_last,_,{extfunc,M,F,A},_}) ->
+    erl_bifs:is_exit_bif(M, F, A);
+is_exit_instruction({call_ext_only,_,{extfunc,M,F,A}}) ->
+    erl_bifs:is_exit_bif(M, F, A);
+is_exit_instruction(if_end) -> true;
+is_exit_instruction({case_end,_}) -> true;
+is_exit_instruction({try_case_end,_}) -> true;
+is_exit_instruction({badmatch,_}) -> true;
+is_exit_instruction(_) -> false.
+
+%% is_label_used_in(LabelNumber, [Instruction]) -> true|false
+%%  Check whether the labels is used in the instruction sequence.
+
+is_label_used_in(Lbl, Is) ->
+    is_label_used_in_1(Is, Lbl, gb_sets:empty()).
+
+is_label_used_in_1([I|Is], Lbl, Empty) ->
+    Used = ulbl(I, Empty),
+    case gb_sets:is_member(Lbl, Used) of
+	false ->
+	    is_label_used_in_1(Is, Lbl, Empty);
+	true ->
+	    true
+    end;
+is_label_used_in_1([], _, _) -> false.
+
+%% remove_unused_labels(Instructions0) -> Instructions
+%%  Remove all unused labels.
+
+remove_unused_labels(Is) ->
+    Used0 = initial_labels(Is),
+    Used = foldl(fun ulbl/2, Used0, Is),
+    rem_unused(Is, Used, []).
+
+rem_unused([{label,Lbl}=I|Is], Used, Acc) ->
+    case gb_sets:is_member(Lbl, Used) of
+	false -> rem_unused(Is, Used, Acc);
+	true -> rem_unused(Is, Used, [I|Acc])
+    end;
+rem_unused([I|Is], Used, Acc) ->
+    rem_unused(Is, Used, [I|Acc]);
+rem_unused([], _, Acc) -> reverse(Acc).
+
+initial_labels(Is) ->
+    initial_labels(Is, []).
+
+initial_labels([{label,Lbl}|Is], Acc) ->
+    initial_labels(Is, [Lbl|Acc]);
+initial_labels([{func_info,_,_,_},{label,Lbl}|_], Acc) ->
+    gb_sets:from_list([Lbl|Acc]).
+
+%% ulbl(Instruction, UsedGbSet) -> UsedGbSet'
+
+ulbl({test,_,Fail,_}, Used) ->
+    mark_used(Fail, Used);
+ulbl({select_val,_,Fail,{list,Vls}}, Used) ->
+    mark_used_list(Vls, mark_used(Fail, Used));
+ulbl({select_tuple_arity,_,Fail,{list,Vls}}, Used) ->
+    mark_used_list(Vls, mark_used(Fail, Used));
+ulbl({'try',_,Lbl}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({'catch',_,Lbl}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({jump,Lbl}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({loop_rec,Lbl,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({loop_rec_end,Lbl}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({wait,Lbl}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({wait_timeout,Lbl,_To}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bif,_Name,Lbl,_As,_R}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({gc_bif,_Name,Lbl,_Live,_As,_R}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_init2,Lbl,_,_,_,_,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_init_bits,Lbl,_,_,_,_,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_put_integer,Lbl,_Bits,_Unit,_Fl,_Val}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_put_float,Lbl,_Bits,_Unit,_Fl,_Val}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_put_binary,Lbl,_Bits,_Unit,_Fl,_Val}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_put_utf8,Lbl,_Fl,_Val}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_put_utf16,Lbl,_Fl,_Val}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_put_utf32,Lbl,_Fl,_Val}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_add,Lbl,_,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_append,Lbl,_,_,_,_,_,_,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_utf8_size,Lbl,_,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl({bs_utf16_size,Lbl,_,_}, Used) ->
+    mark_used(Lbl, Used);
+ulbl(_, Used) -> Used.
+
+mark_used({f,0}, Used) -> Used;
+mark_used({f,L}, Used) -> gb_sets:add(L, Used);
+mark_used(_, Used) -> Used.
+
+mark_used_list([H|T], Used) ->
+    mark_used_list(T, mark_used(H, Used));
+mark_used_list([], Used) -> Used.
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_opcodes.erl minimal_otp_src_R12B-5/lib/compiler/src/beam_opcodes.erl
--- otp_src_R12B-5/lib/compiler/src/beam_opcodes.erl	2008-11-05 11:42:25.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_opcodes.erl	2009-06-23 20:40:10.000000000 +0100
@@ -1,6 +1,6 @@
 -module(beam_opcodes).
 %%  Warning: Do not edit this file.  It was automatically
-%%  generated by 'beam_makeops' on Wed Nov  5 12:42:25 2008.
+%%  generated by 'beam_makeops' on Tue Jun 23 18:42:30 2009.
 
 -export([format_number/0]).
 -export([opcode/2,opname/1]).
@@ -8,7 +8,7 @@
 -spec format_number() -> 0.
 format_number() -> 0.
 
--spec opcode(atom(), 0..8) -> 1..148.
+-spec opcode(atom(), 0..8) -> 1..151.
 opcode(label, 1) -> 1;
 opcode(func_info, 3) -> 2;
 opcode(int_code_end, 0) -> 3;
@@ -157,9 +157,12 @@ opcode(bs_put_utf8, 3) -> 145;
 opcode(bs_utf16_size, 3) -> 146;
 opcode(bs_put_utf16, 3) -> 147;
 opcode(bs_put_utf32, 3) -> 148;
+opcode(found_message, 0) -> 149;
+opcode(loop_search, 2) -> 150;
+opcode(loop_search_end, 1) -> 151;
 opcode(Name, Arity) -> erlang:error(badarg, [Name,Arity]).
 
--spec opname(1..148) -> {atom(),0..8}.
+-spec opname(1..151) -> {atom(),0..8}.
 opname(1) -> {label,1};
 opname(2) -> {func_info,3};
 opname(3) -> {int_code_end,0};
@@ -308,4 +311,7 @@ opname(145) -> {bs_put_utf8,3};
 opname(146) -> {bs_utf16_size,3};
 opname(147) -> {bs_put_utf16,3};
 opname(148) -> {bs_put_utf32,3};
+opname(149) -> {found_message,0};
+opname(150) -> {loop_search,2};
+opname(151) -> {loop_search_end,1};
 opname(Number) -> erlang:error(badarg, [Number]).
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_opcodes.hrl minimal_otp_src_R12B-5/lib/compiler/src/beam_opcodes.hrl
--- otp_src_R12B-5/lib/compiler/src/beam_opcodes.hrl	2008-11-05 11:42:25.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_opcodes.hrl	2009-06-23 20:40:10.000000000 +0100
@@ -1,5 +1,5 @@
 %%  Warning: Do not edit this file.  It was automatically
-%%  generated by 'beam_makeops' on Wed Nov  5 12:42:25 2008.
+%%  generated by 'beam_makeops' on Tue Jun 23 18:42:30 2009.
 
 -define(tag_u, 0).
 -define(tag_i, 1).
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_validator.erl minimal_otp_src_R12B-5/lib/compiler/src/beam_validator.erl
--- otp_src_R12B-5/lib/compiler/src/beam_validator.erl	2008-11-04 10:51:53.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_validator.erl	2009-06-23 20:40:10.000000000 +0100
@@ -414,6 +414,8 @@ valfun_1({'%live',Live}, Vst) ->
     Vst;
 valfun_1(remove_message, Vst) ->
     Vst;
+valfun_1(found_message, Vst) ->
+    Vst;
 valfun_1({'%',_}, Vst) ->
     Vst;
 %% Exception generating calls
@@ -604,6 +606,11 @@ valfun_4({jump,{f,Lbl}}, Vst) ->
 valfun_4({loop_rec,{f,Fail},Dst}, Vst0) ->
     Vst = branch_state(Fail, Vst0),
     set_type_reg(term, Dst, Vst);
+
+valfun_4({loop_search,{f,Fail},Dst}, Vst0) ->
+    Vst = branch_state(Fail, Vst0),
+    set_type_reg(term, Dst, Vst);
+
 valfun_4({wait,_}, Vst) ->
     kill_state(Vst);
 valfun_4({wait_timeout,_,Src}, Vst) ->
@@ -611,6 +618,8 @@ valfun_4({wait_timeout,_,Src}, Vst) ->
     Vst;
 valfun_4({loop_rec_end,_}, Vst) ->
     kill_state(Vst);
+valfun_4({loop_search_end,_}, Vst) ->
+    kill_state(Vst);
 valfun_4(timeout, #vst{current=St}=Vst) ->
     Vst#vst{current=St#st{x=init_regs(0, term)}};
 valfun_4(send, Vst) ->
diff -urNp otp_src_R12B-5/lib/compiler/src/beam_validator.erl~ minimal_otp_src_R12B-5/lib/compiler/src/beam_validator.erl~
--- otp_src_R12B-5/lib/compiler/src/beam_validator.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/beam_validator.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,1734 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+
+-module(beam_validator).
+
+-export([file/1,files/1]).
+
+%% Interface for compiler.
+-export([module/2,format_error/1]).
+
+-include("beam_disasm.hrl").
+
+-import(lists, [reverse/1,foldl/3,foreach/2,member/2,dropwhile/2]).
+
+-define(MAXREG, 1024).
+
+%%-define(DEBUG, 1).
+-ifdef(DEBUG).
+-define(DBG_FORMAT(F, D), (io:format((F), (D)))).
+-else.
+-define(DBG_FORMAT(F, D), ok).
+-endif.
+
+%%%
+%%% API functions.
+%%%
+
+files([F|Fs]) ->
+    ?DBG_FORMAT("# Verifying: ~p~n", [F]),
+    case file(F) of
+	ok -> ok;
+	{error,Es} -> 
+	    io:format("~p:~n~s~n", [F,format_error(Es)])
+    end,
+    files(Fs);
+files([]) -> ok.
+
+file(Name) when is_list(Name) ->
+    case case filename:extension(Name) of
+	     ".S" -> s_file(Name);
+	     ".beam" -> beam_file(Name)
+	 end of
+	[] -> ok;
+	Es -> {error,Es}
+    end.
+
+%% To be called by the compiler.
+module({Mod,Exp,Attr,Fs,Lc}=Code, _Opts)
+  when is_atom(Mod), is_list(Exp), is_list(Attr), is_integer(Lc) ->
+    case validate(Mod, Fs) of
+	[] -> {ok,Code};
+	Es0 ->
+	    Es = [{?MODULE,E} || E <- Es0],
+	    {error,[{atom_to_list(Mod),Es}]}
+    end.
+
+format_error([]) -> [];
+format_error([{{M,F,A},{I,Off,Desc}}|Es]) ->
+    [io_lib:format("  ~p:~p/~p+~p:~n    ~p - ~p~n", 
+		   [M,F,A,Off,I,Desc])|format_error(Es)];
+format_error([Error|Es]) ->
+    [format_error(Error)|format_error(Es)];
+format_error({{_M,F,A},{I,Off,limit}}) ->
+    io_lib:format(
+      "function ~p/~p+~p:~n"
+      "  An implementation limit was reached.~n"
+      "  Try reducing the complexity of this function.~n~n"
+      "  Instruction: ~p~n", [F,A,Off,I]);
+format_error({{_M,F,A},{undef_labels,Lbls}}) ->
+    io_lib:format(
+      "function ~p/~p:~n"
+      "  Internal consistency check failed - please report this bug.~n"
+      "  The following label(s) were referenced but not defined:~n", [F,A]) ++
+	"  " ++ [[integer_to_list(L)," "] || L <- Lbls] ++ "\n";
+format_error({{_M,F,A},{I,Off,Desc}}) ->
+    io_lib:format(
+      "function ~p/~p+~p:~n"
+      "  Internal consistency check failed - please report this bug.~n"
+      "  Instruction: ~p~n"
+      "  Error:       ~p:~n", [F,A,Off,I,Desc]);
+format_error({Module,Error}) ->
+    [Module:format_error(Error)];
+format_error(Error) ->
+    io_lib:format("~p~n", [Error]).
+
+%%%
+%%% Local functions follow.
+%%% 
+
+s_file(Name) ->
+    {ok,Is} = file:consult(Name),
+    {value,{module,Module}} = lists:keysearch(module, 1, Is),
+    Fs = find_functions(Is),
+    validate(Module, Fs).
+
+find_functions(Fs) ->
+    find_functions_1(Fs, none, [], []).
+
+find_functions_1([{function,Name,Arity,Entry}|Is], Func, FuncAcc, Acc0) ->
+    Acc = add_func(Func, FuncAcc, Acc0),
+    find_functions_1(Is, {Name,Arity,Entry}, [], Acc);
+find_functions_1([I|Is], Func, FuncAcc, Acc) ->
+    find_functions_1(Is, Func, [I|FuncAcc], Acc);
+find_functions_1([], Func, FuncAcc, Acc) ->
+    reverse(add_func(Func, FuncAcc, Acc)).
+
+add_func(none, _, Acc) -> Acc;
+add_func({Name,Arity,Entry}, Is, Acc) ->
+    [{function,Name,Arity,Entry,reverse(Is)}|Acc].
+
+beam_file(Name) ->
+    try beam_disasm:file(Name) of
+	{error,beam_lib,Reason} -> [{beam_lib,Reason}];
+	#beam_file{module=Module, code=Code0} ->
+	    Code = normalize_disassembled_code(Code0),
+	    validate(Module, Code)
+    catch _:_ -> [disassembly_failed]
+    end.
+
+%%%
+%%% The validator follows.
+%%%
+%%% The purpose of the validator is find errors in the generated code
+%%% that may cause the emulator to crash or behave strangely.
+%%% We don't care about type errors in the user's code that will
+%%% cause a proper exception at run-time.
+%%%
+
+%%% Things currently not checked. XXX
+%%%
+%%% - Heap allocation for binaries.
+%%% - That put_tuple is followed by the correct number of
+%%%   put instructions.
+%%%
+
+%% validate(Module, [Function]) -> [] | [Error]
+%%  A list of functions with their code. The code is in the same
+%%  format as used in the compiler and in .S files.
+
+validate(Module, Fs) ->
+    Ft = index_bs_start_match(Fs, []),
+    validate_0(Module, Fs, Ft).
+
+index_bs_start_match([{function,_,_,Entry,Code}|Fs], Acc0) ->
+    case Code of
+	[_,_,{label,Entry}|Is] ->
+	    Acc = index_bs_start_match_1(Is, Entry, Acc0),
+	    index_bs_start_match(Fs, Acc);
+	_ ->
+	    index_bs_start_match(Fs, Acc0)
+    end;
+index_bs_start_match([], Acc) ->
+    gb_trees:from_orddict(lists:sort(Acc)).
+
+index_bs_start_match_1([{test,bs_start_match2,_,_}=I|_], Entry, Acc) ->
+    [{Entry,[I]}|Acc];
+index_bs_start_match_1([{test,_,{f,F},_},{bs_context_to_binary,_}|Is0], Entry, Acc) ->
+    [{label,F}|Is] = dropwhile(fun({label,L}) when L =:= F -> false;
+				  (_)  -> true
+			       end, Is0),
+    index_bs_start_match_1(Is, Entry, Acc);
+index_bs_start_match_1(_, _, Acc) -> Acc.
+
+validate_0(_Module, [], _) -> [];
+validate_0(Module, [{function,Name,Ar,Entry,Code}|Fs], Ft) ->
+    try validate_1(Code, Name, Ar, Entry, Ft) of
+	_ -> validate_0(Module, Fs, Ft)
+    catch
+	Error ->
+	    [Error|validate_0(Module, Fs, Ft)];
+	  error:Error ->
+	    [validate_error(Error, Module, Name, Ar)|validate_0(Module, Fs, Ft)]
+    end.
+
+-ifdef(DEBUG).
+validate_error(Error, Module, Name, Ar) ->
+    exit(validate_error_1(Error, Module, Name, Ar)).
+-else.
+validate_error(Error, Module, Name, Ar) ->
+    validate_error_1(Error, Module, Name, Ar).
+-endif.
+validate_error_1(Error, Module, Name, Ar) ->
+    {{Module,Name,Ar},
+     {internal_error,'_',{Error,erlang:get_stacktrace()}}}.
+
+-record(st,				%Emulation state
+	{x=init_regs(0, term),		%x register info.
+	 y=init_regs(0, initialized),	%y register info.
+	 f=init_fregs(),                %
+	 numy=none,			%Number of y registers.
+	 h=0,				%Available heap size.
+	 hf=0,				%Available heap size for floats.
+	 fls=undefined,			%Floating point state.
+	 ct=[],				%List of hot catch/try labels
+	 bsm=undefined,			%Bit syntax matching state.
+	 bits=undefined,	        %Number of bits in bit syntax binary.
+	 setelem=false			%Previous instruction was setelement/3.
+	}).
+
+-record(vst,				%Validator state
+	{current=none,			%Current state
+	 branched=gb_trees:empty(),	%States at jumps
+	 labels=gb_sets:empty(),	%All defined labels
+	 ft			        %Some other functions in the module
+	 				% (those that start with bs_start_match2).
+	}).
+
+-ifdef(DEBUG).
+print_st(#st{x=Xs,y=Ys,numy=NumY,h=H,ct=Ct}) ->
+    io:format("  #st{x=~p~n"
+	      "      y=~p~n"
+	      "      numy=~p,h=~p,ct=~w~n",
+	      [gb_trees:to_list(Xs),gb_trees:to_list(Ys),NumY,H,Ct]).
+-endif.
+
+validate_1(Is, Name, Arity, Entry, Ft) ->
+    validate_2(labels(Is), Name, Arity, Entry, Ft).
+
+validate_2({Ls1,[{func_info,{atom,Mod},{atom,Name},Arity}=_F|Is]},
+	   Name, Arity, Entry, Ft) ->
+    lists:foreach(fun (_L) -> ?DBG_FORMAT("  ~p.~n", [{label,_L}]) end, Ls1),
+    ?DBG_FORMAT("  ~p.~n", [_F]),
+    validate_3(labels(Is), Name, Arity, Entry, Mod, Ls1, Ft);
+validate_2({Ls1,Is}, Name, Arity, _Entry, _Ft) ->
+    error({{'_',Name,Arity},{first(Is),length(Ls1),illegal_instruction}}).
+
+validate_3({Ls2,Is}, Name, Arity, Entry, Mod, Ls1, Ft) ->
+    lists:foreach(fun (_L) -> ?DBG_FORMAT("  ~p.~n", [{label,_L}]) end, Ls2),
+    Offset = 1 + length(Ls1) + 1 + length(Ls2),
+    EntryOK = (Entry =:= undefined) orelse lists:member(Entry, Ls2),
+    if
+	EntryOK ->
+	    St = init_state(Arity),
+	    Vst0 = #vst{current=St,
+			branched=gb_trees_from_list([{L,St} || L <- Ls1]),
+			labels=gb_sets:from_list(Ls1++Ls2),
+			ft=Ft},
+	    MFA = {Mod,Name,Arity},
+	    Vst = valfun(Is, MFA, Offset, Vst0),
+	    validate_fun_info_branches(Ls1, MFA, Vst);
+	true ->
+	    error({{Mod,Name,Arity},{first(Is),Offset,no_entry_label}})
+    end.
+
+validate_fun_info_branches([L|Ls], MFA, #vst{branched=Branches}=Vst0) ->
+    Vst = Vst0#vst{current=gb_trees:get(L, Branches)},
+    validate_fun_info_branches_1(0, MFA, Vst),
+    validate_fun_info_branches(Ls, MFA, Vst);
+validate_fun_info_branches([], _, _) -> ok.
+
+validate_fun_info_branches_1(Arity, {_,_,Arity}, _) -> ok;
+validate_fun_info_branches_1(X, {Mod,Name,Arity}=MFA, Vst) ->
+    try
+	get_term_type({x,X}, Vst)
+    catch Error ->
+	    I = {func_info,{atom,Mod},{atom,Name},Arity},
+	    Offset = 2,
+	    error({MFA,{I,Offset,Error}})
+    end,
+    validate_fun_info_branches_1(X+1, MFA, Vst).
+
+first([X|_]) -> X;
+first([]) -> [].
+
+labels(Is) ->
+    labels_1(Is, []).
+
+labels_1([{label,L}|Is], R) ->
+    labels_1(Is, [L|R]);
+labels_1(Is, R) ->
+    {lists:reverse(R),Is}.
+
+init_state(Arity) ->
+    Xs = init_regs(Arity, term),
+    Ys = init_regs(0, initialized),
+    kill_heap_allocation(#st{x=Xs,y=Ys,numy=none,ct=[]}).
+
+kill_heap_allocation(St) ->
+    St#st{h=0,hf=0}.
+
+init_regs(0, _) ->
+    gb_trees:empty();
+init_regs(N, Type) ->
+    gb_trees_from_list([{R,Type} || R <- lists:seq(0, N-1)]).
+
+valfun([], MFA, _Offset, #vst{branched=Targets0,labels=Labels0}=Vst) ->
+    Targets = gb_trees:keys(Targets0),
+    Labels = gb_sets:to_list(Labels0),
+    case Targets -- Labels of
+	[] -> Vst;
+	Undef ->
+	    Error = {undef_labels,Undef},
+	    error({MFA,Error})
+    end;
+valfun([I|Is], MFA, Offset, Vst0) ->
+    ?DBG_FORMAT("    ~p.\n", [I]),
+    valfun(Is, MFA, Offset+1,
+	   try
+	       Vst = val_dsetel(I, Vst0),
+	       valfun_1(I, Vst)
+	   catch Error ->
+		   error({MFA,{I,Offset,Error}})
+	   end).
+
+%% Instructions that are allowed in dead code or when failing,
+%% that is while the state is undecided in some way.
+valfun_1({label,Lbl}, #vst{current=St0,branched=B,labels=Lbls}=Vst) ->
+    St = merge_states(Lbl, St0, B),
+    Vst#vst{current=St,branched=gb_trees:enter(Lbl, St, B),
+	    labels=gb_sets:add(Lbl, Lbls)};
+valfun_1(_I, #vst{current=none}=Vst) ->
+    %% Ignore instructions after erlang:error/1,2, which
+    %% the original R10B compiler thought would return.
+    ?DBG_FORMAT("Ignoring ~p\n", [_I]),
+    Vst;
+valfun_1({badmatch,Src}, Vst) ->
+    assert_term(Src, Vst),
+    kill_state(Vst);
+valfun_1({case_end,Src}, Vst) ->
+    assert_term(Src, Vst),
+    kill_state(Vst);
+valfun_1(if_end, Vst) ->
+    kill_state(Vst);
+valfun_1({try_case_end,Src}, Vst) ->
+    assert_term(Src, Vst),
+    kill_state(Vst);
+%% Instructions that can not cause exceptions
+valfun_1({bs_context_to_binary,Ctx}, #vst{current=#st{x=Xs}}=Vst) ->
+    case Ctx of
+	{Tag,X} when Tag =:= x; Tag =:= y ->
+	    Type = case gb_trees:lookup(X, Xs) of
+		       {value,{match_context,_,_}} -> term;
+		       _ -> get_term_type(Ctx, Vst)
+		   end,
+	    set_type_reg(Type, Ctx, Vst);
+	_ ->
+	    error({bad_source,Ctx})
+    end;
+valfun_1(bs_init_writable=I, Vst) ->
+    call(I, 1, Vst);
+valfun_1({move,{y,_}=Src,{y,_}=Dst}, Vst) ->
+    %% The stack trimming optimization may generate a move from an initialized
+    %% but unassigned Y register to another Y register.
+    case get_term_type_1(Src, Vst) of
+	{catchtag,_} -> error({catchtag,Src});
+	{trytag,_} -> error({trytag,Src});
+	Type -> set_type_reg(Type, Dst, Vst)
+    end;
+valfun_1({move,Src,Dst}, Vst) ->
+    Type = get_move_term_type(Src, Vst),
+    set_type_reg(Type, Dst, Vst);
+valfun_1({fmove,Src,{fr,_}=Dst}, Vst) ->
+    assert_type(float, Src, Vst),
+    set_freg(Dst, Vst);
+valfun_1({fmove,{fr,_}=Src,Dst}, Vst0) ->
+    assert_freg_set(Src, Vst0),
+    assert_fls(checked, Vst0),
+    Vst = eat_heap_float(Vst0),
+    set_type_reg({float,[]}, Dst, Vst);
+valfun_1({kill,{y,_}=Reg}, Vst) ->
+    set_type_y(initialized, Reg, Vst);
+valfun_1({init,{y,_}=Reg}, Vst) ->
+    set_type_y(initialized, Reg, Vst);
+valfun_1({test_heap,Heap,Live}, Vst) ->
+    test_heap(Heap, Live, Vst);
+valfun_1({bif,_Op,nofail,Src,Dst}, Vst) ->
+    validate_src(Src, Vst),
+    set_type_reg(term, Dst, Vst);
+valfun_1({bif,Op,{f,_},Src,Dst}=I, Vst) ->
+    case is_bif_safe(Op, length(Src)) of
+	false ->
+	    %% Since the BIF can fail, make sure that any catch state
+	    %% is updated.
+	    valfun_2(I, Vst);
+	true ->
+	    %% It can't fail, so we finish handling it here (not updating
+	    %% catch state).
+	    validate_src(Src, Vst),
+	    Type = bif_type(Op, Src, Vst),
+	    set_type_reg(Type, Dst, Vst)
+    end;
+%% Put instructions.
+valfun_1({put_list,A,B,Dst}, Vst0) ->
+    assert_term(A, Vst0),
+    assert_term(B, Vst0),
+    Vst = eat_heap(2, Vst0),
+    set_type_reg(cons, Dst, Vst);
+valfun_1({put_tuple,Sz,Dst}, Vst0) when is_integer(Sz) ->
+    Vst = eat_heap(1, Vst0),
+    set_type_reg({tuple,Sz}, Dst, Vst);
+valfun_1({put,Src}, Vst) ->
+    assert_term(Src, Vst),
+    eat_heap(1, Vst);
+valfun_1({put_string,Sz,_,Dst}, Vst0) when is_integer(Sz) ->
+    Vst = eat_heap(2*Sz, Vst0),
+    set_type_reg(cons, Dst, Vst);
+%% Misc.
+valfun_1({'%live',Live}, Vst) ->
+    verify_live(Live, Vst),
+    Vst;
+valfun_1(remove_message, Vst) ->
+    Vst;
+valfun_1(found_message, Vst) ->
+    Vst;
+valfun_1({'%',_}, Vst) ->
+    Vst;
+%% Exception generating calls
+valfun_1({call_ext,Live,Func}=I, Vst) ->
+    case return_type(Func, Vst) of
+	exception ->
+	    verify_live(Live, Vst),
+	    kill_state(Vst);
+	_ ->
+	    valfun_2(I, Vst)
+    end;
+valfun_1(_I, #vst{current=#st{ct=undecided}}) ->
+    error(unknown_catch_try_state);
+%%
+%% Allocate and deallocate, et.al
+valfun_1({allocate,Stk,Live}, Vst) ->
+    allocate(false, Stk, 0, Live, Vst);
+valfun_1({allocate_heap,Stk,Heap,Live}, Vst) ->
+    allocate(false, Stk, Heap, Live, Vst);
+valfun_1({allocate_zero,Stk,Live}, Vst) ->
+    allocate(true, Stk, 0, Live, Vst);
+valfun_1({allocate_heap_zero,Stk,Heap,Live}, Vst) ->
+    allocate(true, Stk, Heap, Live, Vst);
+valfun_1({deallocate,StkSize}, #vst{current=#st{numy=StkSize}}=Vst) ->
+    verify_no_ct(Vst),
+    deallocate(Vst);
+valfun_1({deallocate,_}, #vst{current=#st{numy=NumY}}) ->
+    error({allocated,NumY});
+valfun_1({trim,N,Remaining}, #vst{current=#st{y=Yregs0,numy=NumY}=St}=Vst) ->
+    if
+	N =< NumY, N+Remaining =:= NumY ->
+	    Yregs1 = [{Y-N,Type} || {Y,Type} <- gb_trees:to_list(Yregs0), Y >= N],
+	    Yregs = gb_trees_from_list(Yregs1),
+	    Vst#vst{current=St#st{y=Yregs,numy=NumY-N}};
+	true ->
+	    error({trim,N,Remaining,allocated,NumY})
+    end;
+%% Catch & try.
+valfun_1({'catch',Dst,{f,Fail}}, Vst0) when Fail /= none ->
+    Vst = #vst{current=#st{ct=Fails}=St} = 
+	set_type_y({catchtag,[Fail]}, Dst, Vst0),
+    Vst#vst{current=St#st{ct=[[Fail]|Fails]}};
+valfun_1({'try',Dst,{f,Fail}}, Vst0) ->
+    Vst = #vst{current=#st{ct=Fails}=St} = 
+	set_type_y({trytag,[Fail]}, Dst, Vst0),
+    Vst#vst{current=St#st{ct=[[Fail]|Fails]}};
+valfun_1({catch_end,Reg}, #vst{current=#st{ct=[Fail|Fails]}=St0}=Vst0) ->
+    case get_special_y_type(Reg, Vst0) of
+	{catchtag,Fail} ->
+	    Vst = #vst{current=St} = 
+		set_type_y(initialized_ct, Reg, 
+			   Vst0#vst{current=St0#st{ct=Fails}}),
+	    Xs = gb_trees_from_list([{0,term}]),
+	    Vst#vst{current=St#st{x=Xs,fls=undefined}};
+	Type ->
+	    error({bad_type,Type})
+    end;
+valfun_1({try_end,Reg}, #vst{current=#st{ct=[Fail|Fails]}=St}=Vst0) ->
+    case get_special_y_type(Reg, Vst0) of
+	{trytag,Fail} ->
+	    Vst = case Fail of
+		      [FailLabel] -> branch_state(FailLabel, Vst0);
+		      _ -> Vst0
+		  end,
+	    set_type_reg(initialized_ct, Reg, 
+			 Vst#vst{current=St#st{ct=Fails,fls=undefined}});
+	Type ->
+	    error({bad_type,Type})
+    end;
+valfun_1({try_case,Reg}, #vst{current=#st{ct=[Fail|Fails]}=St0}=Vst0) ->
+    case get_special_y_type(Reg, Vst0) of
+	{trytag,Fail} ->
+	    Vst = #vst{current=St} = 
+		set_type_y(initialized_ct, Reg, 
+			   Vst0#vst{current=St0#st{ct=Fails}}),
+	    Xs = gb_trees_from_list([{0,{atom,[]}},{1,term},{2,term}]), %XXX
+	    Vst#vst{current=St#st{x=Xs,fls=undefined}};
+	Type ->
+	    error({bad_type,Type})
+    end;
+valfun_1(I, Vst) ->
+    valfun_2(I, Vst).
+
+%% Update branched state if necessary and try next set of instructions.
+valfun_2(I, #vst{current=#st{ct=[]}}=Vst) ->
+    valfun_3(I, Vst);
+valfun_2(I, #vst{current=#st{ct=[[Fail]|_]}}=Vst) when is_integer(Fail) ->
+    %% Update branched state
+    valfun_3(I, branch_state(Fail, Vst));
+valfun_2(_, _) ->
+    error(ambigous_catch_try_state).
+
+%% Handle the remaining floating point instructions here.
+%% Floating point.
+valfun_3({fconv,Src,{fr,_}=Dst}, Vst) ->
+    assert_term(Src, Vst),
+    set_freg(Dst, Vst);
+valfun_3({bif,fadd,_,[_,_]=Src,Dst}, Vst) ->
+    float_op(Src, Dst, Vst);
+valfun_3({bif,fdiv,_,[_,_]=Src,Dst}, Vst) ->
+    float_op(Src, Dst, Vst);
+valfun_3({bif,fmul,_,[_,_]=Src,Dst}, Vst) ->
+    float_op(Src, Dst, Vst);
+valfun_3({bif,fnegate,_,[_]=Src,Dst}, Vst) ->
+    float_op(Src, Dst, Vst);
+valfun_3({bif,fsub,_,[_,_]=Src,Dst}, Vst) ->
+    float_op(Src, Dst, Vst);
+valfun_3(fclearerror, Vst) ->
+    case get_fls(Vst) of
+	undefined -> ok;
+	checked -> ok;
+	Fls -> error({bad_floating_point_state,Fls})
+    end,
+    set_fls(cleared, Vst);
+valfun_3({fcheckerror,_}, Vst) ->
+    assert_fls(cleared, Vst),
+    set_fls(checked, Vst);
+valfun_3(I, Vst) ->
+    %% The instruction is not a float instruction.
+    case get_fls(Vst) of
+	undefined ->
+	    valfun_4(I, Vst);
+	checked ->
+	    valfun_4(I, Vst);
+	Fls ->
+	    error({unsafe_instruction,{float_error_state,Fls}})
+    end.
+
+%% Instructions that can cause exceptions.
+valfun_4({apply,Live}, Vst) ->
+    call(apply, Live+2, Vst);
+valfun_4({apply_last,Live,_}, Vst) ->
+    tail_call(apply, Live+2, Vst);
+valfun_4({call_fun,Live}, Vst) ->
+    call('fun', Live+1, Vst);
+valfun_4({call,Live,Func}, Vst) ->
+    call(Func, Live, Vst);
+valfun_4({call_ext,Live,Func}, Vst) ->
+    %% Exception BIFs has already been taken care of above.
+    call(Func, Live, Vst);
+valfun_4({call_only,Live,Func}, Vst) ->
+    tail_call(Func, Live, Vst);
+valfun_4({call_ext_only,Live,Func}, Vst) ->
+    tail_call(Func, Live, Vst);
+valfun_4({call_last,Live,Func,StkSize}, #vst{current=#st{numy=StkSize}}=Vst) ->
+    tail_call(Func, Live, Vst);
+valfun_4({call_last,_,_,_}, #vst{current=#st{numy=NumY}}) ->
+    error({allocated,NumY});
+valfun_4({call_ext_last,Live,Func,StkSize}, 
+	 #vst{current=#st{numy=StkSize}}=Vst) ->
+    tail_call(Func, Live, Vst);
+valfun_4({call_ext_last,_,_,_}, #vst{current=#st{numy=NumY}}) ->
+    error({allocated,NumY});
+valfun_4({make_fun,_,_,Live}, Vst) ->
+    call('fun', Live, Vst);
+valfun_4({make_fun2,_,_,_,Live}, Vst) ->
+    call(make_fun, Live, Vst);
+%% Other BIFs
+valfun_4({bif,element,{f,Fail},[Pos,Tuple],Dst}, Vst0) ->
+    TupleType0 = get_term_type(Tuple, Vst0),
+    PosType = get_term_type(Pos, Vst0),
+    Vst1 = branch_state(Fail, Vst0),
+    TupleType = upgrade_tuple_type({tuple,[get_tuple_size(PosType)]}, TupleType0),
+    Vst = set_type(TupleType, Tuple, Vst1),
+    set_type_reg(term, Dst, Vst);
+valfun_4({raise,{f,_}=Fail,Src,Dst}, Vst) ->
+    valfun_4({bif,raise,Fail,Src,Dst}, Vst);
+valfun_4({bif,Op,{f,Fail},Src,Dst}, Vst0) ->
+    validate_src(Src, Vst0),
+    Vst = branch_state(Fail, Vst0),
+    Type = bif_type(Op, Src, Vst),
+    set_type_reg(Type, Dst, Vst);
+valfun_4({gc_bif,Op,{f,Fail},Live,Src,Dst}, #vst{current=St0}=Vst0) ->
+    St = kill_heap_allocation(St0),
+    Vst1 = Vst0#vst{current=St},
+    verify_live(Live, Vst1),
+    Vst2 = prune_x_regs(Live, Vst1),
+    validate_src(Src, Vst2),
+    Vst = branch_state(Fail, Vst2),
+    Type = bif_type(Op, Src, Vst),
+    set_type_reg(Type, Dst, Vst);
+valfun_4(return, #vst{current=#st{numy=none}}=Vst) ->
+    kill_state(Vst);
+valfun_4(return, #vst{current=#st{numy=NumY}}) ->
+    error({stack_frame,NumY});
+valfun_4({jump,{f,Lbl}}, Vst) ->
+    kill_state(branch_state(Lbl, Vst));
+valfun_4({loop_rec,{f,Fail},Dst}, Vst0) ->
+    Vst = branch_state(Fail, Vst0),
+    set_type_reg(term, Dst, Vst);
+valfun_4({wait,_}, Vst) ->
+    kill_state(Vst);
+valfun_4({wait_timeout,_,Src}, Vst) ->
+    assert_term(Src, Vst),
+    Vst;
+valfun_4({loop_rec_end,_}, Vst) ->
+    kill_state(Vst);
+valfun_4(timeout, #vst{current=St}=Vst) ->
+    Vst#vst{current=St#st{x=init_regs(0, term)}};
+valfun_4(send, Vst) ->
+    call(send, 2, Vst);
+valfun_4({set_tuple_element,Src,Tuple,I}, Vst) ->
+    assert_term(Src, Vst),
+    assert_type({tuple_element,I+1}, Tuple, Vst);
+%% Match instructions.
+valfun_4({select_val,Src,{f,Fail},{list,Choices}}, Vst) ->
+    assert_term(Src, Vst),
+    Lbls = [L || {f,L} <- Choices]++[Fail],
+    kill_state(foldl(fun(L, S) -> branch_state(L, S) end, Vst, Lbls));
+valfun_4({select_tuple_arity,Tuple,{f,Fail},{list,Choices}}, Vst) ->
+    assert_type(tuple, Tuple, Vst),
+    kill_state(branch_arities(Choices, Tuple, branch_state(Fail, Vst)));
+valfun_4({get_list,Src,D1,D2}, Vst0) ->
+    assert_type(cons, Src, Vst0),
+    Vst = set_type_reg(term, D1, Vst0),
+    set_type_reg(term, D2, Vst);
+valfun_4({get_tuple_element,Src,I,Dst}, Vst) ->
+    assert_type({tuple_element,I+1}, Src, Vst),
+    set_type_reg(term, Dst, Vst);
+
+%% New bit syntax matching instructions.
+valfun_4({test,bs_start_match2,{f,Fail},[Ctx,Live,NeedSlots,Ctx]}, Vst0) ->
+    %% If source and destination registers are the same, match state
+    %% is OK as input.
+    _ = get_move_term_type(Ctx, Vst0),
+    verify_live(Live, Vst0),
+    Vst1 = prune_x_regs(Live, Vst0),
+    Vst = branch_state(Fail, Vst1),
+    set_type_reg(bsm_match_state(NeedSlots), Ctx, Vst);
+valfun_4({test,bs_start_match2,{f,Fail},[Src,Live,Slots,Dst]}, Vst0) ->
+    assert_term(Src, Vst0),
+    verify_live(Live, Vst0),
+    Vst1 = prune_x_regs(Live, Vst0),
+    Vst = branch_state(Fail, Vst1),
+    set_type_reg(bsm_match_state(Slots), Dst, Vst);
+valfun_4({test,bs_match_string,{f,Fail},[Ctx,_,_]}, Vst) ->
+    bsm_validate_context(Ctx, Vst),
+    branch_state(Fail, Vst);
+valfun_4({test,bs_skip_bits2,{f,Fail},[Ctx,Src,_,_]}, Vst) ->
+    bsm_validate_context(Ctx, Vst),
+    assert_term(Src, Vst),
+    branch_state(Fail, Vst);
+valfun_4({test,bs_test_tail2,{f,Fail},[Ctx,_]}, Vst) ->
+    bsm_validate_context(Ctx, Vst),
+    branch_state(Fail, Vst);
+valfun_4({test,bs_test_unit,{f,Fail},[Ctx,_]}, Vst) ->
+    bsm_validate_context(Ctx, Vst),
+    branch_state(Fail, Vst);
+valfun_4({test,bs_skip_utf8,{f,Fail},[Ctx,Live,_]}, Vst) ->
+    validate_bs_skip_utf(Fail, Ctx, Live, Vst);
+valfun_4({test,bs_skip_utf16,{f,Fail},[Ctx,Live,_]}, Vst) ->
+    validate_bs_skip_utf(Fail, Ctx, Live, Vst);
+valfun_4({test,bs_skip_utf32,{f,Fail},[Ctx,Live,_]}, Vst) ->
+    validate_bs_skip_utf(Fail, Ctx, Live, Vst);
+valfun_4({test,bs_get_integer2,{f,Fail},[Ctx,Live,_,_,_,Dst]}, Vst) ->
+    validate_bs_get(Fail, Ctx, Live, Dst, Vst);
+valfun_4({test,bs_get_float2,{f,Fail},[Ctx,Live,_,_,_,Dst]}, Vst) ->
+    validate_bs_get(Fail, Ctx, Live, Dst, Vst);
+valfun_4({test,bs_get_binary2,{f,Fail},[Ctx,Live,_,_,_,Dst]}, Vst) ->
+    validate_bs_get(Fail, Ctx, Live, Dst, Vst);
+valfun_4({test,bs_get_utf8,{f,Fail},[Ctx,Live,_,Dst]}, Vst) ->
+    validate_bs_get(Fail, Ctx, Live, Dst, Vst);
+valfun_4({test,bs_get_utf16,{f,Fail},[Ctx,Live,_,Dst]}, Vst) ->
+    validate_bs_get(Fail, Ctx, Live, Dst, Vst);
+valfun_4({test,bs_get_utf32,{f,Fail},[Ctx,Live,_,Dst]}, Vst) ->
+    validate_bs_get(Fail, Ctx, Live, Dst, Vst);
+valfun_4({bs_save2,Ctx,SavePoint}, Vst) ->
+    bsm_save(Ctx, SavePoint, Vst);
+valfun_4({bs_restore2,Ctx,SavePoint}, Vst) ->
+    bsm_restore(Ctx, SavePoint, Vst);
+
+%% Bit syntax instructions.
+valfun_4({bs_start_match,{f,Fail},Src}, Vst) ->
+    valfun_4({test,bs_start_match,{f,Fail},[Src]}, Vst);
+valfun_4({test,bs_start_match,{f,Fail},[Src]}, Vst) ->
+    assert_term(Src, Vst),
+    bs_start_match(branch_state(Fail, Vst));
+
+valfun_4({bs_save,SavePoint}, Vst) ->
+    bs_assert_state(Vst),
+    bs_save(SavePoint, Vst);
+valfun_4({bs_restore,SavePoint}, Vst) ->
+    bs_assert_state(Vst),
+    bs_assert_savepoint(SavePoint, Vst),
+    Vst;
+valfun_4({test,bs_skip_bits,{f,Fail},[Src,_,_]}, Vst) ->
+    bs_assert_state(Vst),
+    assert_term(Src, Vst),
+    branch_state(Fail, Vst);
+valfun_4({test,bs_test_tail,{f,Fail},_}, Vst) ->
+    bs_assert_state(Vst),
+    branch_state(Fail, Vst);
+valfun_4({test,_,{f,Fail},[_,_,_,Dst]}, Vst0) ->
+    bs_assert_state(Vst0),
+    Vst = branch_state(Fail, Vst0),
+    set_type_reg({integer,[]}, Dst, Vst);
+
+%% Other test instructions.
+valfun_4({test,is_float,{f,Lbl},[Float]}, Vst) ->
+    assert_term(Float, Vst),
+    set_type({float,[]}, Float, branch_state(Lbl, Vst));
+valfun_4({test,is_tuple,{f,Lbl},[Tuple]}, Vst) ->
+    Type0 = get_term_type(Tuple, Vst),
+    Type = upgrade_tuple_type({tuple,[0]}, Type0),
+    set_type(Type, Tuple, branch_state(Lbl, Vst));
+valfun_4({test,is_nonempty_list,{f,Lbl},[Cons]}, Vst) ->
+    assert_term(Cons, Vst),
+    set_type(cons, Cons, branch_state(Lbl, Vst));
+valfun_4({test,test_arity,{f,Lbl},[Tuple,Sz]}, Vst) when is_integer(Sz) ->
+    assert_type(tuple, Tuple, Vst),
+    set_type_reg({tuple,Sz}, Tuple, branch_state(Lbl, Vst));
+valfun_4({test,_Op,{f,Lbl},Src}, Vst) ->
+    validate_src(Src, Vst),
+    branch_state(Lbl, Vst);
+valfun_4({bs_add,{f,Fail},[A,B,_],Dst}, Vst) ->
+    assert_term(A, Vst),
+    assert_term(B, Vst),
+    set_type_reg({integer,[]}, Dst, branch_state(Fail, Vst));
+valfun_4({bs_utf8_size,{f,Fail},A,Dst}, Vst) ->
+    assert_term(A, Vst),
+    set_type_reg({integer,[]}, Dst, branch_state(Fail, Vst));
+valfun_4({bs_utf16_size,{f,Fail},A,Dst}, Vst) ->
+    assert_term(A, Vst),
+    set_type_reg({integer,[]}, Dst, branch_state(Fail, Vst));
+valfun_4({bs_bits_to_bytes2,Src,Dst}, Vst) ->
+    assert_term(Src, Vst),
+    set_type_reg({integer,[]}, Dst, Vst);
+valfun_4({bs_bits_to_bytes,{f,Fail},Src,Dst}, Vst) ->
+    assert_term(Src, Vst),
+    set_type_reg({integer,[]}, Dst, branch_state(Fail, Vst));
+valfun_4({bs_init2,{f,Fail},_,Heap,Live,_,Dst}, Vst0) ->
+    verify_live(Live, Vst0),
+    Vst1 = heap_alloc(Heap, Vst0),
+    Vst2 = branch_state(Fail, Vst1),
+    Vst3 = prune_x_regs(Live, Vst2),
+    Vst = bs_zero_bits(Vst3),
+    set_type_reg(binary, Dst, Vst);
+valfun_4({bs_init_bits,{f,Fail},_,Heap,Live,_,Dst}, Vst0) ->
+    verify_live(Live, Vst0),
+    Vst1 = heap_alloc(Heap, Vst0),
+    Vst2 = branch_state(Fail, Vst1),
+    Vst3 = prune_x_regs(Live, Vst2),
+    Vst = bs_zero_bits(Vst3),
+    set_type_reg(binary, Dst, Vst);
+valfun_4({bs_append,{f,Fail},Bits,Heap,Live,_Unit,Bin,_Flags,Dst}, Vst0) ->
+    verify_live(Live, Vst0),
+    assert_term(Bits, Vst0),
+    assert_term(Bin, Vst0),
+    Vst1 = heap_alloc(Heap, Vst0),
+    Vst2 = branch_state(Fail, Vst1),
+    Vst3 = prune_x_regs(Live, Vst2),
+    Vst = bs_zero_bits(Vst3),
+    set_type_reg(binary, Dst, Vst);
+valfun_4({bs_private_append,{f,Fail},Bits,_Unit,Bin,_Flags,Dst}, Vst0) ->
+    assert_term(Bits, Vst0),
+    assert_term(Bin, Vst0),
+    Vst1 = branch_state(Fail, Vst0),
+    Vst = bs_zero_bits(Vst1),
+    set_type_reg(binary, Dst, Vst);
+valfun_4({bs_put_string,Sz,_}, Vst) when is_integer(Sz) ->
+    Vst;
+valfun_4({bs_put_binary,{f,Fail},_,_,_,Src}=I, Vst0) ->
+    assert_term(Src, Vst0),
+    Vst = bs_align_check(I, Vst0),
+    branch_state(Fail, Vst);
+valfun_4({bs_put_float,{f,Fail},_,_,_,Src}=I, Vst0) ->
+    assert_term(Src, Vst0),
+    Vst = bs_align_check(I, Vst0),
+    branch_state(Fail, Vst);
+valfun_4({bs_put_integer,{f,Fail},_,_,_,Src}=I, Vst0) ->
+    assert_term(Src, Vst0),
+    Vst = bs_align_check(I, Vst0),
+    branch_state(Fail, Vst);
+valfun_4({bs_put_utf8,{f,Fail},_,Src}=I, Vst0) ->
+    assert_term(Src, Vst0),
+    Vst = bs_align_check(I, Vst0),
+    branch_state(Fail, Vst);
+valfun_4({bs_put_utf16,{f,Fail},_,Src}=I, Vst0) ->
+    assert_term(Src, Vst0),
+    Vst = bs_align_check(I, Vst0),
+    branch_state(Fail, Vst);
+valfun_4({bs_put_utf32,{f,Fail},_,Src}=I, Vst0) ->
+    assert_term(Src, Vst0),
+    Vst = bs_align_check(I, Vst0),
+    branch_state(Fail, Vst);
+%% Old bit syntax construction (before R10B).
+valfun_4({bs_init,_,_}, Vst) ->
+    bs_zero_bits(Vst);
+valfun_4({bs_need_buf,_}, Vst) -> Vst;
+valfun_4({bs_final,{f,Fail},Dst}, Vst0) ->
+    Vst = branch_state(Fail, Vst0),
+    set_type_reg(binary, Dst, Vst);
+valfun_4({bs_final2,Src,Dst}, Vst0) ->
+    assert_term(Src, Vst0),
+    set_type_reg(binary, Dst, Vst0);
+valfun_4(_, _) ->
+    error(unknown_instruction).
+
+%%
+%% Common code for validating bs_get* instructions.
+%%
+validate_bs_get(Fail, Ctx, Live, Dst, Vst0) ->
+    bsm_validate_context(Ctx, Vst0),
+    verify_live(Live, Vst0),
+    Vst1 = prune_x_regs(Live, Vst0),
+    Vst = branch_state(Fail, Vst1),
+    set_type_reg(term, Dst, Vst).
+
+%%
+%% Common code for validating bs_skip_utf* instructions.
+%%
+validate_bs_skip_utf(Fail, Ctx, Live, Vst0) ->
+    bsm_validate_context(Ctx, Vst0),
+    verify_live(Live, Vst0),
+    Vst = prune_x_regs(Live, Vst0),
+    branch_state(Fail, Vst).
+
+%%
+%% Special state handling for setelement/3 and the set_tuple_element/3 instruction.
+%% A possibility for garbage collection must not occur between setelement/3 and
+%% set_tuple_element/3.
+%%
+val_dsetel({move,_,_}, Vst) ->
+    Vst;
+val_dsetel({put_string,0,{string,""},_}, Vst) ->
+    %% An empty string is OK since it doesn't build anything.
+    Vst;
+val_dsetel({call_ext,3,{extfunc,erlang,setelement,3}}, #vst{current=St}=Vst) ->
+    Vst#vst{current=St#st{setelem=true}};
+val_dsetel({set_tuple_element,_,_,_}, #vst{current=#st{setelem=false}}) ->
+    error(illegal_context_for_set_tuple_element);
+val_dsetel({set_tuple_element,_,_,_}, #vst{current=#st{setelem=true}}=Vst) ->
+    Vst;
+val_dsetel(_, #vst{current=#st{setelem=true}=St}=Vst) ->
+    Vst#vst{current=St#st{setelem=false}};
+val_dsetel(_, Vst) -> Vst.
+
+kill_state(#vst{current=#st{ct=[[Fail]|_]}}=Vst) when is_integer(Fail) ->
+    %% There is an active catch. Make sure that we merge the state into
+    %% the catch label before clearing it, so that that we can be sure
+    %% that the label gets a state.
+    kill_state_1(branch_state(Fail, Vst));
+kill_state(Vst) ->
+    kill_state_1(Vst).
+
+kill_state_1(Vst) ->
+    Vst#vst{current=none}.
+
+%% A "plain" call.
+%%  The stackframe must be initialized.
+%%  The instruction will return to the instruction following the call.
+call(Name, Live, #vst{current=St}=Vst) ->
+    verify_live(Live, Vst),
+    verify_y_init(Vst),
+    case return_type(Name, Vst) of
+	Type when Type =/= exception ->
+	    %% Type is never 'exception' because it has been handled earlier.
+	    Xs = gb_trees_from_list([{0,Type}]),
+	    Vst#vst{current=St#st{x=Xs,f=init_fregs(),bsm=undefined}}
+    end.
+
+%% Tail call.
+%%  The stackframe must have a known size and be initialized.
+%%  Does not return to the instruction following the call.
+tail_call(Name, Live, Vst) ->
+    verify_call_args(Name, Live, Vst),
+    verify_y_init(Vst),
+    verify_no_ct(Vst),
+    kill_state(Vst).
+
+verify_call_args(_, 0, #vst{}) ->
+    ok;
+verify_call_args({f,Lbl}, Live, Vst) when is_integer(Live)->
+    Verify = fun(R) ->
+		     case get_move_term_type(R, Vst) of
+			 {match_context,_,_} ->
+			     verify_call_match_context(Lbl, Vst);
+			 _ ->
+			     ok
+		     end
+	     end,
+    verify_call_args_1(Live, Verify, Vst);
+verify_call_args(_, Live, Vst) when is_integer(Live)->
+    Verify = fun(R) -> get_term_type(R, Vst) end,
+    verify_call_args_1(Live, Verify, Vst);
+verify_call_args(_, Live, _) ->
+    error({bad_number_of_live_regs,Live}).
+
+verify_call_args_1(0, _, _) -> ok;
+verify_call_args_1(N, Verify, Vst) ->
+    X = N - 1,
+    Verify({x,X}),
+    verify_call_args_1(X, Verify, Vst).
+
+verify_call_match_context(Lbl, #vst{ft=Ft}) ->
+    case gb_trees:lookup(Lbl, Ft) of
+	none ->
+	    error(no_bs_start_match2);
+	{value,[{test,bs_start_match2,_,[Ctx,_,_,Ctx]}|_]} ->
+	    ok;
+	{value,[{test,bs_start_match2,_,[Bin,_,_,Ctx]}|_]} ->
+	    error({binary_and_context_regs_different,Bin,Ctx})
+    end.
+
+allocate(Zero, Stk, Heap, Live, #vst{current=#st{numy=none}=St}=Vst0) ->
+    verify_live(Live, Vst0),
+    Vst = prune_x_regs(Live, Vst0),
+    Ys = init_regs(Stk, case Zero of 
+			    true -> initialized;
+			    false -> uninitialized
+			end),
+    heap_alloc(Heap, Vst#vst{current=St#st{y=Ys,numy=Stk}});
+allocate(_, _, _, _, #vst{current=#st{numy=Numy}}) ->
+    error({existing_stack_frame,{size,Numy}}).
+
+deallocate(#vst{current=St}=Vst) ->
+    Vst#vst{current=St#st{y=init_regs(0, initialized),numy=none,bsm=undefined}}.
+
+test_heap(Heap, Live, Vst0) ->
+    verify_live(Live, Vst0),
+    Vst = prune_x_regs(Live, Vst0),
+    heap_alloc(Heap, Vst).
+
+heap_alloc(Heap, #vst{current=St0}=Vst) ->
+    St1 = kill_heap_allocation(St0#st{bsm=undefined}),
+    St = heap_alloc_1(Heap, St1),
+    Vst#vst{current=St}.
+
+heap_alloc_1({alloc,Alloc}, St) ->
+    heap_alloc_2(Alloc, St);
+heap_alloc_1(HeapWords, St) when is_integer(HeapWords) ->
+    St#st{h=HeapWords}.
+
+heap_alloc_2([{words,HeapWords}|T], St0) ->
+    St = St0#st{h=HeapWords},
+    heap_alloc_2(T, St);
+heap_alloc_2([{floats,Floats}|T], St0) ->
+    St = St0#st{hf=Floats},
+    heap_alloc_2(T, St);
+heap_alloc_2([], St) -> St.
+    
+prune_x_regs(Live, #vst{current=#st{x=Xs0}=St0}=Vst) when is_integer(Live) ->
+    Xs1 = gb_trees:to_list(Xs0),
+    Xs = [P || {R,_}=P <- Xs1, R < Live],
+    St = St0#st{x=gb_trees:from_orddict(Xs)},
+    Vst#vst{current=St}.
+
+%%%
+%%% Floating point checking.
+%%%
+%%% Possible values for the fls field (=floating point error state).
+%%%
+%%% undefined 	- Undefined (initial state). No float operations allowed.
+%%%
+%%% cleared	- fclearerror/0 has been executed. Float operations
+%%%		  are allowed (such as fadd).
+%%%
+%%% checked	- fcheckerror/1 has been executed. It is allowed to
+%%%               move values out of floating point registers.
+%%%
+%%% The following instructions may be executed in any state:
+%%%
+%%%   fconv Src {fr,_}             
+%%%   fmove Src {fr,_}		%% Move INTO floating point register.
+%%%
+
+float_op(Src, Dst, Vst0) ->
+    foreach (fun(S) -> assert_freg_set(S, Vst0) end, Src),
+    assert_fls(cleared, Vst0),
+    Vst = set_fls(cleared, Vst0),
+    set_freg(Dst, Vst).
+
+assert_fls(Fls, Vst) ->
+    case get_fls(Vst) of
+	Fls -> Vst;
+	OtherFls -> error({bad_floating_point_state,OtherFls})
+    end.
+
+set_fls(Fls, #vst{current=#st{}=St}=Vst) when is_atom(Fls) ->
+    Vst#vst{current=St#st{fls=Fls}}.
+
+get_fls(#vst{current=#st{fls=Fls}}) when is_atom(Fls) -> Fls.
+
+init_fregs() -> 0.
+
+set_freg({fr,Fr}, #vst{current=#st{f=Fregs0}=St}=Vst)
+  when is_integer(Fr), 0 =< Fr ->
+    limit_check(Fr),
+    Bit = 1 bsl Fr,
+    if
+	Fregs0 band Bit =:= 0 ->
+	    Fregs = Fregs0 bor Bit,
+	    Vst#vst{current=St#st{f=Fregs}};
+	true -> Vst
+    end;
+set_freg(Fr, _) -> error({bad_target,Fr}).
+
+assert_freg_set({fr,Fr}=Freg, #vst{current=#st{f=Fregs}})
+  when is_integer(Fr), 0 =< Fr ->
+    if
+	Fregs band (1 bsl Fr) =/= 0 ->
+	    limit_check(Fr);
+	true -> error({uninitialized_reg,Freg})
+    end;
+assert_freg_set(Fr, _) -> error({bad_source,Fr}).
+
+%%%
+%%% Binary matching.
+%%%
+%%% Possible values for the bsm field (=bit syntax matching state).
+%%%
+%%% undefined 	- Undefined (initial state). No matching instructions allowed.
+%%%		 
+%%% (gb set)	- The gb set contains the defined save points.
+%%%
+%%% The bsm field is reset to 'undefined' by instructions that may cause a
+%%% a garbage collection (might move the binary) and/or context switch
+%%% (may invalidate the save points).
+
+bs_start_match(#vst{current=#st{bsm=undefined}=St}=Vst) ->
+    Vst#vst{current=St#st{bsm=gb_sets:empty()}};
+bs_start_match(Vst) ->
+    %% Must retain save points here - it is possible to restore back
+    %% to a previous binary.
+    Vst.
+
+bs_save(Reg, #vst{current=#st{bsm=Saved}=St}=Vst)
+  when is_integer(Reg), Reg < ?MAXREG  ->
+    Vst#vst{current=St#st{bsm=gb_sets:add(Reg, Saved)}};
+bs_save(_, _) -> error(limit).
+
+bs_assert_savepoint(Reg, #vst{current=#st{bsm=Saved}}) ->
+    case gb_sets:is_member(Reg, Saved) of
+	false -> error({no_save_point,Reg});
+	true -> ok
+    end.
+
+bs_assert_state(#vst{current=#st{bsm=undefined}}) ->
+    error(no_bs_match_state);
+bs_assert_state(_) -> ok.
+
+
+%%%
+%%% New binary matching instructions.
+%%%
+
+bsm_match_state(Slots) ->
+    {match_context,0,Slots}.
+
+bsm_validate_context(Reg, Vst) ->
+    bsm_get_context(Reg, Vst),
+    ok.
+
+bsm_get_context({x,X}=Reg, #vst{current=#st{x=Xs}}=_Vst) when is_integer(X) ->
+    case gb_trees:lookup(X, Xs) of
+	{value,{match_context,_,_}=Ctx} -> Ctx;
+	_ -> error({no_bsm_context,Reg})
+    end;
+bsm_get_context(Reg, _) -> error({bad_source,Reg}).
+    
+bsm_save(Reg, {atom,start}, Vst) ->
+    %% Save point refering to where the match started.
+    %% It is always valid. But don't forget to validate the context register.
+    bsm_get_context(Reg, Vst),
+    Vst;
+bsm_save(Reg, SavePoint, Vst) ->
+    case bsm_get_context(Reg, Vst) of
+	{match_context,Bits,Slots} when SavePoint < Slots ->
+	    Ctx = {match_context,Bits bor (1 bsl SavePoint),Slots},
+	    set_type_reg(Ctx, Reg, Vst);
+	_ -> error({illegal_save,SavePoint})
+    end.
+
+bsm_restore(Reg, {atom,start}, Vst) ->
+    %% (Mostly) automatic save point refering to where the match started.
+    %% It is always valid. But don't forget to validate the context register.
+    bsm_get_context(Reg, Vst),
+    Vst;
+bsm_restore(Reg, SavePoint, Vst) ->
+    case bsm_get_context(Reg, Vst) of
+	{match_context,Bits,Slots} when SavePoint < Slots ->
+	    case Bits band (1 bsl SavePoint) of
+		0 -> error({illegal_restore,SavePoint,not_set});
+		_ -> Vst
+	    end;
+	_ -> error({illegal_restore,SavePoint,range})
+    end.
+    
+
+%%%
+%%% Validation of alignment in the bit syntax. (Currently, construction only.)
+%%%
+%%% We make sure that the aligned flag is only set when we can be sure of the
+%%% aligment.
+%%%
+
+bs_zero_bits(#vst{current=St}=Vst) ->
+    Vst#vst{current=St#st{bits=0}}.
+
+bs_align_check({bs_put_utf8,_,Flags,_}, #vst{current=#st{}=St}=Vst) ->
+    bs_verify_flags(Flags, St),
+    Vst;
+bs_align_check({bs_put_utf16,_,Flags,_}, #vst{current=#st{}=St}=Vst) ->
+    bs_verify_flags(Flags, St),
+    Vst;
+bs_align_check({bs_put_utf32,_,Flags,_}, #vst{current=#st{}=St}=Vst) ->
+    bs_verify_flags(Flags, St),
+    Vst;
+bs_align_check({_,_,Sz,U,Flags,_}, #vst{current=#st{bits=Bits}=St}=Vst) ->
+    bs_verify_flags(Flags, St),
+    bs_update_bits(Bits, Sz, U, St, Vst).
+
+bs_update_bits(undefined, _, _, _, Vst) -> Vst;
+bs_update_bits(Bits0, {integer,Sz}, U, St, Vst) ->
+    Bits = Bits0 + U*Sz,
+    Vst#vst{current=St#st{bits=Bits}};
+bs_update_bits(_, {atom,all}, _, _, Vst) ->
+    %% A binary will not change the alignment.
+    Vst;
+bs_update_bits(_, _, U, _, Vst) when U rem 8 =:= 0 ->
+    %% Units of 8, 16, and so on will not change the aligment.
+    Vst;
+bs_update_bits(_, _, _, St, Vst) ->
+    %% We can no longer be sure about aligment.
+    Vst#vst{current=St#st{bits=undefined}}.
+
+bs_verify_flags({field_flags,Fl}, #st{bits=Bits}) ->
+    case bs_is_aligned(Fl) of
+	false -> ok;
+	true when is_integer(Bits), Bits rem 8 =:= 0 -> ok;
+	true -> error({aligned_flag_set,{bits,Bits}})
+    end.
+
+bs_is_aligned(Fl) when is_integer(Fl) -> Fl band 1 =:= 1;
+bs_is_aligned(Fl) when is_list(Fl) -> member(aligned, Fl).
+    
+%%%
+%%% Keeping track of types.
+%%%
+
+set_type(Type, {x,_}=Reg, Vst) -> set_type_reg(Type, Reg, Vst);
+set_type(Type, {y,_}=Reg, Vst) -> set_type_y(Type, Reg, Vst);
+set_type(_, _, #vst{}=Vst) -> Vst.
+
+set_type_reg(Type, {x,X}, #vst{current=#st{x=Xs}=St}=Vst) 
+  when is_integer(X), 0 =< X ->
+    limit_check(X),
+    Vst#vst{current=St#st{x=gb_trees:enter(X, Type, Xs)}};
+set_type_reg(Type, Reg, Vst) ->
+    set_type_y(Type, Reg, Vst).
+
+set_type_y(Type, {y,Y}=Reg, #vst{current=#st{y=Ys0,numy=NumY}=St}=Vst) 
+  when is_integer(Y), 0 =< Y ->
+    limit_check(Y),
+    case {Y,NumY} of
+	{_,none} ->
+	    error({no_stack_frame,Reg});
+	{_,_} when Y > NumY ->
+	    error({y_reg_out_of_range,Reg,NumY});
+	{_,_} ->
+	    Ys = if  Type =:= initialized_ct ->
+			 gb_trees:enter(Y, initialized, Ys0);
+		     true ->
+			 case gb_trees:lookup(Y, Ys0) of
+			     none -> 
+				 gb_trees:insert(Y, Type, Ys0);
+			     {value,uinitialized} ->
+				 gb_trees:insert(Y, Type, Ys0);
+			     {value,{catchtag,_}=Tag} ->
+				 error(Tag);
+			     {value,{trytag,_}=Tag} ->
+				 error(Tag);
+			     {value,_} ->
+				 gb_trees:update(Y, Type, Ys0)
+			 end
+		 end,
+	    Vst#vst{current=St#st{y=Ys}}
+    end;
+set_type_y(Type, Reg, #vst{}) -> error({invalid_store,Reg,Type}).
+
+assert_term(Src, Vst) ->
+    get_term_type(Src, Vst),
+    ok.
+
+%% The possible types.
+%%
+%% First non-term types:
+%%
+%% initialized		Only for Y registers. Means that the Y register
+%%			has been initialized with some valid term so that
+%%			it is safe to pass to the garbage collector.
+%%			NOT safe to use in any other way (will not crash the
+%%			emulator, but clearly points to a bug in the compiler).
+%%
+%% {catchtag,[Lbl]}	A special term used within a catch. Must only be used
+%%			by the catch instructions; NOT safe to use in other
+%%			instructions.
+%%
+%% {trytag,[Lbl]}	A special term used within a try block. Must only be
+%%			used by the catch instructions; NOT safe to use in other
+%%			instructions.
+%%
+%% exception		Can only be used as a type returned by return_type/2
+%%			(which gives the type of the value returned by a BIF).
+%%			Thus 'exception' is never stored as type descriptor
+%%			for a register.
+%%
+%% {match_context,_,_}	A matching context for bit syntax matching. We do allow
+%%			it to moved/to from stack, but otherwise it must only
+%%			be accessed by bit syntax matching instructions.
+%%
+%%
+%% Normal terms:
+%%
+%% term			Any valid Erlang (but not of the special types above).
+%%
+%% bool			The atom 'true' or the atom 'false'.
+%%
+%% cons         	Cons cell: [_|_]
+%%
+%% nil			Empty list: []
+%%
+%% {tuple,[Sz]}		Tuple. An element has been accessed using
+%%              	element/2 or setelement/3 so that it is known that
+%%              	the type is a tuple of size at least Sz.
+%%
+%% {tuple,Sz}		Tuple. A test_arity instruction has been seen
+%%           		so that it is known that the size is exactly Sz.
+%%
+%% {atom,[]}		Atom.
+%% {atom,Atom}
+%%
+%% {integer,[]}		Integer.
+%% {integer,Integer}
+%%
+%% {float,[]}		Float.
+%% {float,Float}
+%%
+%% number		Integer or Float of unknown value
+%%
+
+assert_type(WantedType, Term, Vst) ->
+    assert_type(WantedType, get_term_type(Term, Vst)),
+    Vst.
+
+assert_type(Correct, Correct) -> ok;
+assert_type(float, {float,_}) -> ok;
+assert_type(tuple, {tuple,_}) -> ok;
+assert_type({tuple_element,I}, {tuple,[Sz]})
+  when 1 =< I, I =< Sz ->
+    ok;
+assert_type({tuple_element,I}, {tuple,Sz})
+  when is_integer(Sz), 1 =< I, I =< Sz ->
+    ok;
+assert_type(Needed, Actual) ->
+    error({bad_type,{needed,Needed},{actual,Actual}}).
+
+
+%% upgrade_tuple_type(NewTupleType, OldType) -> TupleType.
+%%  upgrade_tuple_type/2 is used when linear code finds out more and
+%%  more information about a tuple type, so that the type gets more
+%%  specialized. If OldType is not a tuple type, the type information
+%%  is inconsistent, and we know that some instructions will never
+%%  be executed at run-time.
+
+upgrade_tuple_type({tuple,[Sz]}, {tuple,[OldSz]}=T) when Sz < OldSz ->
+    %% The old type has a higher value for the least tuple size.
+    T;
+upgrade_tuple_type({tuple,[Sz]}, {tuple,OldSz}=T) 
+  when is_integer(Sz), is_integer(OldSz), Sz =< OldSz ->
+    %% The old size is exact, and the new size is smaller than the old size.
+    T;
+upgrade_tuple_type({tuple,_}=T, _) ->
+    %% The new type information is exact or has a higher value for
+    %% the least tuple size.
+    %%     Note that inconsistencies are also handled in this
+    %% clause, e.g. if the old type was an integer or a tuple accessed
+    %% outside its size; inconsistences will generally cause an exception
+    %% at run-time but are safe from our point of view.
+    T.
+
+get_tuple_size({integer,[]}) -> 0;
+get_tuple_size({integer,Sz}) -> Sz;
+get_tuple_size(_) -> 0.
+
+validate_src(Ss, Vst) when is_list(Ss) ->
+    foreach(fun(S) -> get_term_type(S, Vst) end, Ss).
+
+%% get_move_term_type(Src, ValidatorState) -> Type
+%%  Get the type of the source Src. The returned type Type will be
+%%  a standard Erlang type (no catch/try tags). Match contexts are OK.
+
+get_move_term_type(Src, Vst) ->
+    case get_term_type_1(Src, Vst) of
+	initialized -> error({unassigned,Src});
+	{catchtag,_} -> error({catchtag,Src});
+	{trytag,_} -> error({trytag,Src});
+	Type -> Type
+    end.
+
+%% get_term_type(Src, ValidatorState) -> Type
+%%  Get the type of the source Src. The returned type Type will be
+%%  a standard Erlang type (no catch/try tags or match contexts).
+
+get_term_type(Src, Vst) ->
+    case get_term_type_1(Src, Vst) of
+	initialized -> error({unassigned,Src});
+	{catchtag,_} -> error({catchtag,Src});
+	{trytag,_} -> error({trytag,Src});
+	{match_context,_,_} -> error({match_context,Src});
+	Type -> Type
+    end.
+
+%% get_special_y_type(Src, ValidatorState) -> Type
+%%  Return the type for the Y register without doing any validity checks.
+
+get_special_y_type({y,_}=Reg, Vst) -> get_term_type_1(Reg, Vst);
+get_special_y_type(Src, _) -> error({source_not_y_reg,Src}).
+
+get_term_type_1(nil=T, _) -> T;
+get_term_type_1({atom,A}=T, _) when is_atom(A) -> T;
+get_term_type_1({float,F}=T, _) when is_float(F) -> T;
+get_term_type_1({integer,I}=T, _) when is_integer(I) -> T;
+get_term_type_1({literal,_}=T, _) -> T;
+get_term_type_1({x,X}=Reg, #vst{current=#st{x=Xs}}) when is_integer(X) ->
+    case gb_trees:lookup(X, Xs) of
+	{value,Type} -> Type;
+	none -> error({uninitialized_reg,Reg})
+    end;
+get_term_type_1({y,Y}=Reg, #vst{current=#st{y=Ys}}) when is_integer(Y) ->
+    case gb_trees:lookup(Y, Ys) of
+ 	none -> error({uninitialized_reg,Reg});
+	{value,uninitialized} -> error({uninitialized_reg,Reg});
+	{value,Type} -> Type
+    end;
+get_term_type_1(Src, _) -> error({bad_source,Src}).
+
+
+branch_arities([], _, #vst{}=Vst) -> Vst;
+branch_arities([Sz,{f,L}|T], Tuple, #vst{current=St}=Vst0) 
+  when is_integer(Sz) ->
+    Vst1 = set_type_reg({tuple,Sz}, Tuple, Vst0),
+    Vst = branch_state(L, Vst1),
+    branch_arities(T, Tuple, Vst#vst{current=St}).
+
+branch_state(0, #vst{}=Vst) -> Vst;
+branch_state(L, #vst{current=St,branched=B}=Vst) ->
+    Vst#vst{
+      branched=case gb_trees:is_defined(L, B) of
+		   false ->
+		       gb_trees:insert(L, St, B);
+		   true ->
+		       MergedSt = merge_states(L, St, B),
+		       gb_trees:update(L, MergedSt, B)
+	       end}.
+
+%% merge_states/3 is used when there are more than one way to arrive
+%% at this point, and the type states for the different paths has
+%% to be merged. The type states are downgraded to the least common
+%% subset for the subsequent code.
+
+merge_states(L, St, Branched) when L =/= 0 ->
+    case gb_trees:lookup(L, Branched) of
+	none -> St;
+	{value,OtherSt} when St =:= none -> OtherSt;
+	{value,OtherSt} -> merge_states_1(St, OtherSt)
+    end.
+
+merge_states_1(#st{x=Xs0,y=Ys0,numy=NumY0,h=H0,ct=Ct0,bsm=Bsm0}=St,
+	       #st{x=Xs1,y=Ys1,numy=NumY1,h=H1,ct=Ct1,bsm=Bsm1}) ->
+    NumY = merge_stk(NumY0, NumY1),
+    Xs = merge_regs(Xs0, Xs1),
+    Ys = merge_y_regs(Ys0, Ys1),
+    Ct = merge_ct(Ct0, Ct1),
+    Bsm = merge_bsm(Bsm0, Bsm1),
+    St#st{x=Xs,y=Ys,numy=NumY,h=min(H0, H1),ct=Ct,bsm=Bsm}.
+
+merge_stk(S, S) -> S;
+merge_stk(_, _) -> undecided.
+
+merge_ct(S, S) -> S;
+merge_ct(Ct0, Ct1) -> merge_ct_1(Ct0, Ct1).
+
+merge_ct_1([C0|Ct0], [C1|Ct1]) ->
+    [ordsets:from_list(C0++C1)|merge_ct_1(Ct0, Ct1)];
+merge_ct_1([], []) -> [];
+merge_ct_1(_, _) -> undecided.
+
+merge_regs(Rs0, Rs1) ->
+    Rs = merge_regs_1(gb_trees:to_list(Rs0), gb_trees:to_list(Rs1)),
+    gb_trees_from_list(Rs).
+
+merge_regs_1([Same|Rs1], [Same|Rs2]) ->
+    [Same|merge_regs_1(Rs1, Rs2)];
+merge_regs_1([{R1,_}|Rs1], [{R2,_}|_]=Rs2) when R1 < R2 ->
+    merge_regs_1(Rs1, Rs2);
+merge_regs_1([{R1,_}|_]=Rs1, [{R2,_}|Rs2]) when R1 > R2 ->
+    merge_regs_1(Rs1, Rs2);
+merge_regs_1([{R,Type1}|Rs1], [{R,Type2}|Rs2]) ->
+    [{R,merge_types(Type1, Type2)}|merge_regs_1(Rs1, Rs2)];
+merge_regs_1([], []) -> [];
+merge_regs_1([], [_|_]) -> [];
+merge_regs_1([_|_], []) -> [].
+
+merge_y_regs(Rs0, Rs1) ->
+    Rs = merge_y_regs_1(gb_trees:to_list(Rs0), gb_trees:to_list(Rs1)),
+    gb_trees_from_list(Rs).
+
+merge_y_regs_1([Same|Rs1], [Same|Rs2]) ->
+    [Same|merge_y_regs_1(Rs1, Rs2)];
+merge_y_regs_1([{R1,_}|Rs1], [{R2,_}|_]=Rs2) when R1 < R2 ->
+    [{R1,uninitialized}|merge_y_regs_1(Rs1, Rs2)];
+merge_y_regs_1([{R1,_}|_]=Rs1, [{R2,_}|Rs2]) when R1 > R2 ->
+    [{R2,uninitialized}|merge_y_regs_1(Rs1, Rs2)];
+merge_y_regs_1([{R,Type1}|Rs1], [{R,Type2}|Rs2]) ->
+    [{R,merge_types(Type1, Type2)}|merge_y_regs_1(Rs1, Rs2)];
+merge_y_regs_1([], []) -> [];
+merge_y_regs_1([], [_|_]=Rs) -> Rs;
+merge_y_regs_1([_|_]=Rs, []) -> Rs.
+
+%% merge_types(Type1, Type2) -> Type
+%%  Return the most specific type possible.
+%%  Note: Type1 must NOT be the same as Type2.
+merge_types(uninitialized=I, _) -> I;
+merge_types(_, uninitialized=I) -> I;
+merge_types(initialized=I, _) -> I;
+merge_types(_, initialized=I) -> I;
+merge_types({catchtag,T0},{catchtag,T1}) ->
+    {catchtag,ordsets:from_list(T0++T1)};
+merge_types({trytag,T0},{trytag,T1}) ->
+    {trytag,ordsets:from_list(T0++T1)};
+merge_types({tuple,A}, {tuple,B}) ->
+    {tuple,[min(tuple_sz(A), tuple_sz(B))]};
+merge_types({Type,A}, {Type,B}) 
+  when Type =:= atom; Type =:= integer; Type =:= float ->
+    if A =:= B -> {Type,A};
+       true -> {Type,[]}
+    end;
+merge_types({Type,_}, number) 
+  when Type =:= integer; Type =:= float ->
+    number;
+merge_types(number, {Type,_}) 
+  when Type =:= integer; Type =:= float ->
+    number;
+merge_types(bool, {atom,A}) ->
+    merge_bool(A);
+merge_types({atom,A}, bool) ->
+    merge_bool(A);
+merge_types({match_context,B0,Slots},{match_context,B1,Slots}) ->
+    {match_context,B0 bor B1,Slots};
+merge_types({match_context,_,_}=M, _) ->
+    M;
+merge_types(_, {match_context,_,_}=M) ->
+    M;
+merge_types(T1, T2) when T1 =/= T2 ->
+    %% Too different. All we know is that the type is a 'term'.
+    term.
+
+merge_bsm(undefined, _) -> undefined;
+merge_bsm(_, undefined) -> undefined;
+merge_bsm(Bsm0, Bsm1) -> gb_sets:intersection(Bsm0, Bsm1).
+
+tuple_sz([Sz]) -> Sz;
+tuple_sz(Sz) -> Sz.
+
+merge_bool([]) -> {atom,[]};
+merge_bool(true) -> bool;
+merge_bool(false) -> bool;
+merge_bool(_) -> {atom,[]}.
+    
+verify_y_init(#vst{current=#st{y=Ys}}) ->
+    verify_y_init_1(gb_trees:to_list(Ys)).
+
+verify_y_init_1([]) -> ok;
+verify_y_init_1([{Y,uninitialized}|_]) ->
+    error({uninitialized_reg,{y,Y}});
+verify_y_init_1([{_,_}|Ys]) ->
+    verify_y_init_1(Ys).
+
+verify_live(0, #vst{}) -> ok;
+verify_live(N, #vst{current=#st{x=Xs}}) ->
+    verify_live_1(N, Xs).
+
+verify_live_1(0, _) -> ok;
+verify_live_1(N, Xs) when is_integer(N) ->
+    X = N-1,
+    case gb_trees:is_defined(X, Xs) of
+	false -> error({{x,X},not_live});
+	true -> verify_live_1(X, Xs)
+    end;
+verify_live_1(N, _) -> error({bad_number_of_live_regs,N}).
+
+verify_no_ct(#vst{current=#st{numy=none}}) -> ok;
+verify_no_ct(#vst{current=#st{numy=undecided}}) ->
+    error(unknown_size_of_stackframe);
+verify_no_ct(#vst{current=#st{y=Ys}}) ->
+    case lists:filter(fun ({_,{catchtag,_}}) -> true;
+			  ({_,{trytag,_}}) -> true;
+			  ({_,_}) -> false
+		      end, gb_trees:to_list(Ys)) of
+	[] -> ok;
+	CT -> error({unfinished_catch_try,CT})
+    end.
+
+eat_heap(N, #vst{current=#st{h=Heap0}=St}=Vst) ->
+    case Heap0-N of
+	Neg when Neg < 0 ->
+	    error({heap_overflow,{left,Heap0},{wanted,N}});
+	Heap ->
+	    Vst#vst{current=St#st{h=Heap}}
+    end.
+
+eat_heap_float(#vst{current=#st{hf=HeapFloats0}=St}=Vst) ->
+    case HeapFloats0-1 of
+	Neg when Neg < 0 ->
+	    error({heap_overflow,{left,{HeapFloats0,floats}},{wanted,{1,floats}}});
+	HeapFloats ->
+	    Vst#vst{current=St#st{hf=HeapFloats}}
+    end.
+
+bif_type('-', Src, Vst) ->
+    arith_type(Src, Vst);
+bif_type('+', Src, Vst) ->
+    arith_type(Src, Vst);
+bif_type('*', Src, Vst) ->
+    arith_type(Src, Vst);
+bif_type(abs, [Num], Vst) ->
+    case get_term_type(Num, Vst) of
+	{float,_}=T -> T;
+	{integer,_}=T -> T;
+	_ -> number
+    end;
+bif_type(float, _, _) -> {float,[]};
+bif_type('/', _, _) -> {float,[]};
+%% Integer operations.
+bif_type('div', [_,_], _) -> {integer,[]};
+bif_type('rem', [_,_], _) -> {integer,[]};
+bif_type(length, [_], _) -> {integer,[]};
+bif_type(size, [_], _) -> {integer,[]};
+bif_type(trunc, [_], _) -> {integer,[]};
+bif_type(round, [_], _) -> {integer,[]};
+bif_type('band', [_,_], _) -> {integer,[]};
+bif_type('bor', [_,_], _) -> {integer,[]};
+bif_type('bxor', [_,_], _) -> {integer,[]};
+bif_type('bnot', [_], _) -> {integer,[]};
+bif_type('bsl', [_,_], _) -> {integer,[]};
+bif_type('bsr', [_,_], _) -> {integer,[]};
+%% Booleans.
+bif_type('==', [_,_], _) -> bool;
+bif_type('/=', [_,_], _) -> bool;
+bif_type('=<', [_,_], _) -> bool;
+bif_type('<', [_,_], _) -> bool;
+bif_type('>=', [_,_], _) -> bool;
+bif_type('>', [_,_], _) -> bool;
+bif_type('=:=', [_,_], _) -> bool;
+bif_type('=/=', [_,_], _) -> bool;
+bif_type('not', [_], _) -> bool;
+bif_type('and', [_,_], _) -> bool;
+bif_type('or', [_,_], _) -> bool;
+bif_type('xor', [_,_], _) -> bool;
+bif_type(is_atom, [_], _) -> bool;
+bif_type(is_boolean, [_], _) -> bool;
+bif_type(is_binary, [_], _) -> bool;
+bif_type(is_constant, [_], _) -> bool;
+bif_type(is_float, [_], _) -> bool;
+bif_type(is_function, [_], _) -> bool;
+bif_type(is_integer, [_], _) -> bool;
+bif_type(is_list, [_], _) -> bool;
+bif_type(is_number, [_], _) -> bool;
+bif_type(is_pid, [_], _) -> bool;
+bif_type(is_port, [_], _) -> bool;
+bif_type(is_reference, [_], _) -> bool;
+bif_type(is_tuple, [_], _) -> bool;
+%% Misc.
+bif_type(node, [], _) -> {atom,[]};
+bif_type(node, [_], _) -> {atom,[]};
+bif_type(hd, [_], _) -> term;
+bif_type(tl, [_], _) -> term;
+bif_type(get, [_], _) -> term;
+bif_type(raise, [_,_], _) -> exception;
+bif_type(Bif, _, _) when is_atom(Bif) -> term.
+
+is_bif_safe('/=', 2) -> true;
+is_bif_safe('<', 2) -> true;
+is_bif_safe('=/=', 2) -> true;
+is_bif_safe('=:=', 2) -> true;
+is_bif_safe('=<', 2) -> true;
+is_bif_safe('==', 2) -> true;
+is_bif_safe('>', 2) -> true;
+is_bif_safe('>=', 2) -> true;
+is_bif_safe(is_atom, 1) -> true;
+is_bif_safe(is_boolean, 1) -> true;
+is_bif_safe(is_binary, 1) -> true;
+is_bif_safe(is_constant, 1) -> true;
+is_bif_safe(is_float, 1) -> true;
+is_bif_safe(is_function, 1) -> true;
+is_bif_safe(is_integer, 1) -> true;
+is_bif_safe(is_list, 1) -> true;
+is_bif_safe(is_number, 1) -> true;
+is_bif_safe(is_pid, 1) -> true;
+is_bif_safe(is_port, 1) -> true;
+is_bif_safe(is_reference, 1) -> true;
+is_bif_safe(is_tuple, 1) -> true;
+is_bif_safe(get, 1) -> true;
+is_bif_safe(_, _) -> false.
+
+arith_type([A,B], Vst) ->
+    case {get_term_type(A, Vst),get_term_type(B, Vst)} of
+	{{float,_},_} -> {float,[]};
+	{_,{float,_}} -> {float,[]};
+	{_,_} -> number
+    end;
+arith_type(_, _) -> number.
+
+return_type({extfunc,M,F,A}, Vst) -> return_type_1(M, F, A, Vst);
+return_type(_, _) -> term.
+
+return_type_1(erlang, setelement, 3, Vst) ->
+    Tuple = {x,1},
+    TupleType =
+	case get_term_type(Tuple, Vst) of
+	    {tuple,_}=TT -> TT;
+	    _ -> {tuple,[0]}
+	end,
+    case get_term_type({x,0}, Vst) of
+	{integer,[]} -> TupleType;
+	{integer,I} -> upgrade_tuple_type({tuple,[I]}, TupleType);
+	_ -> TupleType
+    end;
+return_type_1(erlang, F, A, _) ->
+    return_type_erl(F, A);
+return_type_1(math, F, A, _) ->
+    return_type_math(F, A);
+return_type_1(M, F, A, _) when is_atom(M), is_atom(F), is_integer(A), A >= 0 ->
+    term.
+
+return_type_erl(exit, 1) -> exception;
+return_type_erl(throw, 1) -> exception;
+return_type_erl(fault, 1) -> exception;
+return_type_erl(fault, 2) -> exception;
+return_type_erl(error, 1) -> exception;
+return_type_erl(error, 2) -> exception;
+return_type_erl(F, A) when is_atom(F), is_integer(A), A >= 0 -> term.
+
+return_type_math(cos, 1) -> {float,[]};
+return_type_math(cosh, 1) -> {float,[]};
+return_type_math(sin, 1) -> {float,[]};
+return_type_math(sinh, 1) -> {float,[]};
+return_type_math(tan, 1) -> {float,[]};
+return_type_math(tanh, 1) -> {float,[]};
+return_type_math(acos, 1) -> {float,[]};
+return_type_math(acosh, 1) -> {float,[]};
+return_type_math(asin, 1) -> {float,[]};
+return_type_math(asinh, 1) -> {float,[]};
+return_type_math(atan, 1) -> {float,[]};
+return_type_math(atanh, 1) -> {float,[]};
+return_type_math(erf, 1) -> {float,[]};
+return_type_math(erfc, 1) -> {float,[]};
+return_type_math(exp, 1) -> {float,[]};
+return_type_math(log, 1) -> {float,[]};
+return_type_math(log10, 1) -> {float,[]};
+return_type_math(sqrt, 1) -> {float,[]};
+return_type_math(atan2, 2) -> {float,[]};
+return_type_math(pow, 2) -> {float,[]};
+return_type_math(pi, 0) -> {float,[]};
+return_type_math(F, A) when is_atom(F), is_integer(A), A >= 0 -> term.
+
+limit_check(Num) when is_integer(Num), Num >= ?MAXREG ->
+    error(limit);
+limit_check(_) -> ok.
+
+min(A, B) when is_integer(A), is_integer(B), A < B -> A;
+min(A, B) when is_integer(A), is_integer(B) -> B.
+
+gb_trees_from_list(L) -> gb_trees:from_orddict(lists:sort(L)).
+
+-ifdef(DEBUG).
+error(Error) -> exit(Error).
+-else.
+error(Error) -> throw(Error).
+-endif.
+
+
+%%%
+%%% Rewrite disassembled code to the same format as we used internally
+%%% to not have to worry later.
+%%%
+
+normalize_disassembled_code(Fs) ->
+    Index = ndc_index(Fs, []),
+    ndc(Fs, Index, []).
+
+ndc_index([{function,Name,Arity,Entry,_Code}|Fs], Acc) ->
+    ndc_index(Fs, [{{Name,Arity},Entry}|Acc]);
+ndc_index([], Acc) ->
+    gb_trees:from_orddict(lists:sort(Acc)).
+
+ndc([{function,Name,Arity,Entry,Code0}|Fs], D, Acc) ->
+    Code = ndc_1(Code0, D, []),
+    ndc(Fs, D, [{function,Name,Arity,Entry,Code}|Acc]);
+ndc([], _, Acc) -> reverse(Acc).
+    
+ndc_1([{call=Op,A,{_,F,A}}|Is], D, Acc) ->
+    ndc_1(Is, D, [{Op,A,{f,gb_trees:get({F,A}, D)}}|Acc]);
+ndc_1([{call_only=Op,A,{_,F,A}}|Is], D, Acc) ->
+    ndc_1(Is, D, [{Op,A,{f,gb_trees:get({F,A}, D)}}|Acc]);
+ndc_1([{call_last=Op,A,{_,F,A},Sz}|Is], D, Acc) ->
+    ndc_1(Is, D, [{Op,A,{f,gb_trees:get({F,A}, D)},Sz}|Acc]);
+ndc_1([{arithbif,Op,F,Src,Dst}|Is], D, Acc) ->
+    ndc_1(Is, D, [{bif,Op,F,Src,Dst}|Acc]);
+ndc_1([{arithfbif,Op,F,Src,Dst}|Is], D, Acc) ->
+    ndc_1(Is, D, [{bif,Op,F,Src,Dst}|Acc]);
+ndc_1([I|Is], D, Acc) ->
+    ndc_1(Is, D, [I|Acc]);
+ndc_1([], _, Acc) ->
+    reverse(Acc).
diff -urNp otp_src_R12B-5/lib/compiler/src/cerl.erl minimal_otp_src_R12B-5/lib/compiler/src/cerl.erl
--- otp_src_R12B-5/lib/compiler/src/cerl.erl	2008-11-04 10:51:42.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/cerl.erl	2009-06-23 20:40:10.000000000 +0100
@@ -64,7 +64,8 @@
 	 ann_c_fname/3, ann_c_fun/3, ann_c_int/2, ann_c_let/4,
 	 ann_c_letrec/3, ann_c_module/4, ann_c_module/5, ann_c_nil/1,
 	 ann_c_cons_skel/3, ann_c_tuple_skel/2, ann_c_primop/3,
-	 ann_c_receive/2, ann_c_receive/4, ann_c_seq/3, ann_c_string/2,
+	 ann_c_receive/2, ann_c_receive/4, ann_c_search/2, ann_c_search/4,
+	 ann_c_seq/3, ann_c_string/2,
 	 ann_c_try/6, ann_c_tuple/2, ann_c_values/2, ann_c_var/2,
 	 ann_make_data/3, ann_make_list/2, ann_make_list/3,
 	 ann_make_data_skel/3, ann_make_tree/3, apply_args/1,
@@ -73,7 +74,8 @@
 	 c_char/1, c_clause/2, c_clause/3, c_cons/2, c_float/1,
 	 c_fname/2, c_fun/2, c_int/1, c_let/3, c_letrec/2, c_module/3,
 	 c_module/4, c_nil/0, c_cons_skel/2, c_tuple_skel/1, c_primop/2,
-	 c_receive/1, c_receive/3, c_seq/2, c_string/1, c_try/5,
+	 c_receive/1, c_receive/3, c_search/1, c_search/3,
+	 c_seq/2, c_string/1, c_try/5,
 	 c_tuple/1, c_values/1, c_var/1, call_args/1, call_arity/1,
 	 call_module/1, call_name/1, case_arg/1, case_arity/1,
 	 case_clauses/1, catch_body/1, char_lit/1, char_val/1,
@@ -86,7 +88,8 @@
 	 is_c_call/1, is_c_case/1, is_c_catch/1, is_c_char/1,
 	 is_c_clause/1, is_c_cons/1, is_c_float/1, is_c_fname/1,
 	 is_c_fun/1, is_c_int/1, is_c_let/1, is_c_letrec/1, is_c_list/1,
-	 is_c_module/1, is_c_nil/1, is_c_primop/1, is_c_receive/1,
+	 is_c_module/1, is_c_nil/1, is_c_primop/1,
+	 is_c_receive/1, is_c_search/1,
 	 is_c_seq/1, is_c_string/1, is_c_try/1, is_c_tuple/1,
 	 is_c_values/1, is_c_var/1, is_data/1, is_leaf/1, is_literal/1,
 	 is_literal_term/1, is_print_char/1, is_print_string/1,
@@ -97,7 +100,8 @@
 	 module_exports/1, module_name/1, module_vars/1,
 	 pat_list_vars/1, pat_vars/1, primop_args/1, primop_arity/1,
 	 primop_name/1, receive_action/1, receive_clauses/1,
-	 receive_timeout/1, seq_arg/1, seq_body/1, set_ann/2,
+	 receive_timeout/1, search_action/1, search_clauses/1, search_timeout/1,
+	 seq_arg/1, seq_body/1, set_ann/2,
 	 string_lit/1, string_val/1, subtrees/1, to_records/1,
 	 try_arg/1, try_body/1, try_vars/1, try_evars/1, try_handler/1,
 	 tuple_arity/1, tuple_es/1, type/1, unfold_literal/1,
@@ -106,7 +110,8 @@
 	 update_c_cons/3, update_c_cons_skel/3, update_c_fname/2,
 	 update_c_fname/3, update_c_fun/3, update_c_let/4,
 	 update_c_letrec/3, update_c_module/5, update_c_primop/3,
-	 update_c_receive/4, update_c_seq/3, update_c_try/6,
+	 update_c_receive/4, update_c_search/4,
+	 update_c_seq/3, update_c_try/6,
 	 update_c_tuple/2, update_c_tuple_skel/2, update_c_values/2,
 	 update_c_var/2, update_data/3, update_list/2, update_list/3,
 	 update_data_skel/3, update_tree/2, update_tree/3,
@@ -168,6 +173,7 @@
 %%  </tr><tr>
 %%    <td>primop</td>
 %%    <td>receive</td>
+%%    <td>search</td>
 %%    <td>seq</td>
 %%    <td>try</td>
 %%    <td>tuple</td>
@@ -202,6 +208,7 @@
 %% @see c_module/3
 %% @see c_primop/2
 %% @see c_receive/1
+%% @see c_search/1
 %% @see c_seq/2
 %% @see c_try/3
 %% @see c_tuple/1
@@ -2478,6 +2485,7 @@ c_clause(Patterns, Body) ->
 %% @see is_c_clause/1
 %% @see c_case/2
 %% @see c_receive/3
+%% @see c_search/3
 %% @see clause_pats/1
 %% @see clause_guard/1
 %% @see clause_body/1
@@ -2810,6 +2818,113 @@ receive_timeout(Node) ->
 receive_action(Node) ->
     Node#'receive'.action.
 
+%% --------------- SEARCH ----------------------------------------------
+
+
+%% @spec c_search(Clauses::[cerl()]) -> cerl()
+%% @equiv c_search(Clauses, c_atom(infinity), c_atom(true))
+%% @see c_atom/1
+
+c_search(Clauses) ->
+    c_search(Clauses, c_atom(infinity), c_atom(true)).
+
+
+%% @spec c_search(Clauses::[cerl()], Timeout::cerl(),
+%%                 Action::cerl()) -> cerl()
+%%
+%% @doc Creates an abstract search-expression. If
+%% <code>Clauses</code> is <code>[C1, ..., Cn]</code>, the result
+%% represents "<code>search <em>C1</em> ... <em>Cn</em> after
+%% <em>Timeout</em> -> <em>Action</em> end</code>".
+%%
+%% @see c_search/1
+%% @see ann_c_search/4
+%% @see update_c_search/4
+%% @see is_c_search/1
+%% @see search_clauses/1
+%% @see search_timeout/1
+%% @see search_action/1
+
+-record('search', {ann = [], clauses, timeout, action}).
+
+c_search(Clauses, Timeout, Action) ->
+    #'search'{clauses = Clauses, timeout = Timeout, action = Action}.
+
+
+%% @spec ann_c_search(As::[term()], Clauses::[cerl()]) -> cerl()
+%% @equiv ann_c_search(As, Clauses, c_atom(infinity), c_atom(true))
+%% @see c_search/3
+%% @see c_atom/1
+
+ann_c_search(As, Clauses) ->
+    ann_c_search(As, Clauses, c_atom(infinity), c_atom(true)).
+
+
+%% @spec ann_c_search(As::[term()], Clauses::[cerl()],
+%%                     Timeout::cerl(), Action::cerl()) -> cerl()
+%% @see ann_c_search/2
+%% @see c_search/3
+
+ann_c_search(As, Clauses, Timeout, Action) ->
+    #'search'{clauses = Clauses, timeout = Timeout, action = Action,
+	       ann = As}.
+
+
+%% @spec update_c_search(Old::cerl(), Clauses::[cerl()],
+%%                        Timeout::cerl(), Action::cerl()) -> cerl()
+%% @see c_search/3
+
+update_c_search(Node, Clauses, Timeout, Action) ->
+    #'search'{clauses = Clauses, timeout = Timeout, action = Action,
+	       ann = get_ann(Node)}.
+
+
+%% @spec is_c_search(Node::cerl()) -> bool()
+%%
+%% @doc Returns <code>true</code> if <code>Node</code> is an abstract
+%% search-expression, otherwise <code>false</code>.
+%%
+%% @see c_search/3
+
+is_c_search(#'search'{}) ->
+    true;
+is_c_search(_) ->
+    false.
+
+
+%% @spec search_clauses(cerl()) -> [cerl()]
+%%
+%% @doc Returns the list of clause subtrees of an abstract
+%% search-expression.
+%%
+%% @see c_search/3
+
+search_clauses(Node) ->
+    Node#'search'.clauses.
+
+
+%% @spec search_timeout(cerl()) -> cerl()
+%%
+%% @doc Returns the timeout subtree of an abstract search-expression.
+%%
+%% @see c_search/3
+
+search_timeout(Node) ->
+    Node#'search'.timeout.
+
+
+%% @spec search_action(cerl()) -> cerl()
+%%
+%% @doc Returns the action subtree of an abstract search-expression.
+%%
+%% @see c_search/3
+
+search_action(Node) ->
+    Node#'search'.action.
+
+
+%% --------------- END SEARCH ------------------------------------------
+
 
 %% ---------------------------------------------------------------------
 
@@ -3361,6 +3476,14 @@ to_records(Node) ->
 		       to_records(receive_timeout(Node)),
 		       action = 
 		       to_records(receive_action(Node))};
+	'search' ->
+	    #c_search{anno = A,
+		       clauses = 
+		       list_to_records(search_clauses(Node)),
+		       timeout =
+		       to_records(search_timeout(Node)),
+		       action = 
+		       to_records(search_action(Node))};
 	apply ->
 	    #c_apply{anno = A,
 		     op = to_records(apply_op(Node)),
@@ -3408,7 +3531,7 @@ lit_to_records(V, A) ->
 %%     record_types() = c_alias | c_apply | c_call | c_case | c_catch |
 %%                      c_clause | c_cons | c_fun | c_let |
 %%                      c_letrec | c_lit | c_module | c_primop |
-%%                      c_receive | c_seq | c_try | c_tuple |
+%%                      c_receive | c_search | c_seq | c_try | c_tuple |
 %%                      c_values | c_var
 %%
 %% @doc Translates an explicit record representation to a
@@ -3458,6 +3581,10 @@ from_records(#c_receive{clauses = Cs, ti
 			anno = As}) ->
     ann_c_receive(As, from_records_list(Cs), from_records(T),
 		  from_records(A));
+from_records(#c_search{clauses = Cs, timeout = T, action = A,
+			anno = As}) ->
+    ann_c_search(As, from_records_list(Cs), from_records(T),
+		  from_records(A));
 from_records(#c_apply{op = Op, args = Es, anno = As}) ->
     ann_c_apply(As, from_records(Op), from_records_list(Es));
 from_records(#c_call{module = M, name = N, args = Es, anno = As}) ->
@@ -3769,6 +3896,9 @@ subtrees(T) ->
 		'receive' ->
 		    [receive_clauses(T), [receive_timeout(T)],
 		     [receive_action(T)]];
+		'search' ->
+		    [search_clauses(T), [search_timeout(T)],
+		     [search_action(T)]];
 		'try' ->
 		    [[try_arg(T)], try_vars(T), [try_body(T)],
 		     try_evars(T), [try_handler(T)]];
@@ -3870,6 +4000,8 @@ ann_make_tree(As, alias, [[V], [P]]) -> 
 ann_make_tree(As, 'fun', [Vs, [B]]) -> ann_c_fun(As, Vs, B);
 ann_make_tree(As, 'receive', [Cs, [T], [A]]) ->
     ann_c_receive(As, Cs, T, A);
+ann_make_tree(As, 'search', [Cs, [T], [A]]) ->
+    ann_c_search(As, Cs, T, A);
 ann_make_tree(As, 'try', [[E], Vs, [B], Evs, [H]]) ->
     ann_c_try(As, E, Vs, B, Evs, H);
 ann_make_tree(As, 'catch', [[B]]) -> ann_c_catch(As, B);
@@ -4039,6 +4171,11 @@ meta_1('receive', Node) ->
 	      [make_list(meta_list(receive_clauses(Node))),
 	       meta(receive_timeout(Node)),
 	       meta(receive_action(Node))]);
+meta_1('search', Node) ->
+    meta_call(c_search,
+	      [make_list(meta_list(search_clauses(Node))),
+	       meta(search_timeout(Node)),
+	       meta(search_action(Node))]);
 meta_1('try', Node) ->
     meta_call(c_try,
 	      [meta(try_arg(Node)),
diff -urNp otp_src_R12B-5/lib/compiler/src/cerl_inline.erl minimal_otp_src_R12B-5/lib/compiler/src/cerl_inline.erl
--- otp_src_R12B-5/lib/compiler/src/cerl_inline.erl	2008-11-04 10:51:43.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/cerl_inline.erl	2009-06-23 20:40:10.000000000 +0100
@@ -44,7 +44,9 @@
 	       update_c_call/4, update_c_case/3, update_c_catch/2,
 	       update_c_clause/4, c_fun/2, c_int/1, c_let/3,
 	       update_c_let/4, update_c_letrec/3, update_c_module/5,
-	       update_c_primop/3, update_c_receive/4, update_c_seq/3,
+	       update_c_primop/3,
+	       update_c_receive/4, update_c_search/4,
+	       update_c_seq/3,
 	       c_seq/2, update_c_try/6, c_tuple/1, update_c_values/2,
 	       c_values/1, c_var/1, call_args/1, call_module/1,
 	       call_name/1, case_arity/1, case_arg/1, case_clauses/1,
@@ -59,8 +61,10 @@
 	       list_length/1, list_elements/1, update_data/3,
 	       make_list/1, make_data_skel/2, module_attrs/1,
 	       module_defs/1, module_exports/1, module_name/1,
-	       primop_args/1, primop_name/1, receive_action/1,
-	       receive_clauses/1, receive_timeout/1, seq_arg/1,
+	       primop_args/1, primop_name/1,
+	       receive_action/1, receive_clauses/1, receive_timeout/1,
+	       search_action/1, search_clauses/1, search_timeout/1,
+	       seq_arg/1,
 	       seq_body/1, set_ann/2, try_arg/1, try_body/1, try_vars/1,
 	       try_evars/1, try_handler/1, tuple_es/1, tuple_arity/1,
 	       type/1, values_es/1, var_name/1]).
@@ -121,6 +125,7 @@ weight(letrec) -> 0;    % Like a let-bin
 weight('case') -> 0;	% Case switches have no base cost.
 weight(clause) -> 1;    % Count one jump at the end of each clause body.
 weight('receive') -> 9;	% Initialization/cleanup cost.
+weight('search') -> 9;  % Search cost
 weight('try') -> 1;	% Assume efficient implementation.
 weight('catch') -> 1;	% See `try'.
 weight(apply) -> 3;     % Average base cost: call/return.
@@ -315,6 +320,8 @@ i(E, Ctxt, Ren, Env, S0) ->
                     i_case(E, Ctxt, Ren, Env, S);
                 'receive' ->
                     i_receive(E, Ctxt, Ren, Env, S);
+                'search' ->
+                    i_search(E, Ctxt, Ren, Env, S);
                 apply ->
                     i_apply(E, Ctxt, Ren, Env, S);
                 call ->
@@ -1246,6 +1253,48 @@ i_receive_1(E, Cs, T, B, S) ->
     N = weight('receive') + weight(clause) * length(Cs),
     {update_c_receive(E, Cs, T, B), count_size(N, S)}.
 
+%% ------------- COPY PASTE FOR SEARCH
+
+i_search(E, Ctxt, Ren, Env, S) ->
+    %% We first visit the expiry expression (for value) and the expiry
+    %% body (in the surrounding context).
+    {T, S1} = i(search_timeout(E), value, Ren, Env, S),
+    {B, S2} = i(search_action(E), Ctxt, Ren, Env, S1),
+
+    %% Then we visit the clauses. Note that application contexts may not
+    %% in general be propagated into the branches (and the expiry body),
+    %% because the execution of the `receive' may remove a message from
+    %% the mailbox as a side effect; the situation is thus analogous to
+    %% that in a `case' expression.
+    Ctxt1 = safe_context(Ctxt),
+    case i_clauses(search_clauses(E), Ctxt1, Ren, Env, S2) of
+        {false, {[], _, _, Cs}, S3} ->
+            %% We still have a list of clauses. If the list is empty,
+            %% and the expiry expression is the integer zero, the
+            %% expression reduces to the expiry body.
+	    if Cs =:= [] ->
+		    case is_c_int(T) andalso (int_val(T) =:= 0) of
+			true ->
+			    {B, S3};
+			false ->
+			    i_search_1(E, Cs, T, B, S3)
+		    end;
+	       true ->
+		    i_search_1(E, Cs, T, B, S3)
+	    end;
+        {true, {_, _, _, Cs}, S3} ->
+	    %% Cs is a single clause that will always be matched (if a
+	    %% message exists), but we must keep the `receive' statement
+	    %% in order to fetch the message from the mailbox.
+	    i_search_1(E, Cs, T, B, S3)
+    end.
+
+i_search_1(E, Cs, T, B, S) ->
+    %% Here, we just add the base sizes for the receive-expression
+    %% itself and for each remaining clause; cf. `case'.
+    N = weight('search') + weight(clause) * length(Cs),
+    {update_c_search(E, Cs, T, B), count_size(N, S)}.
+
 %% A module definition is like a `letrec', with some add-ons (export and
 %% attribute declarations) but without an explicit body. Actually, the
 %% exporting of function names has the same effect as if there was a
diff -urNp otp_src_R12B-5/lib/compiler/src/cerl_trees.erl minimal_otp_src_R12B-5/lib/compiler/src/cerl_trees.erl
--- otp_src_R12B-5/lib/compiler/src/cerl_trees.erl	2008-02-05 13:37:57.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/cerl_trees.erl	2009-06-23 20:40:10.000000000 +0100
@@ -34,7 +34,8 @@
 	       ann_c_case/3, ann_c_catch/2, ann_c_clause/4,
 	       ann_c_cons_skel/3, ann_c_fun/3, ann_c_let/4,
 	       ann_c_letrec/3, ann_c_module/5, ann_c_primop/3,
-	       ann_c_receive/4, ann_c_seq/3, ann_c_try/6,
+	       ann_c_receive/4, ann_c_search/4,
+	       ann_c_seq/3, ann_c_try/6,
 	       ann_c_tuple_skel/2, ann_c_values/2, apply_args/1,
 	       apply_op/1, binary_segments/1, bitstr_val/1,
 	       bitstr_size/1, bitstr_unit/1, bitstr_type/1,
@@ -47,6 +48,7 @@
 	       module_defs/1, module_exports/1, module_name/1,
 	       module_vars/1, primop_args/1, primop_name/1,
 	       receive_action/1, receive_clauses/1, receive_timeout/1,
+	       search_action/1, search_clauses/1, search_timeout/1,
 	       seq_arg/1, seq_body/1, set_ann/2, subtrees/1, try_arg/1,
 	       try_body/1, try_vars/1, try_evars/1, try_handler/1,
 	       tuple_es/1, type/1, update_c_alias/3, update_c_apply/3,
@@ -54,7 +56,9 @@
 	       update_c_case/3, update_c_catch/2, update_c_clause/4,
 	       update_c_cons/3, update_c_cons_skel/3, update_c_fun/3,
 	       update_c_let/4, update_c_letrec/3, update_c_module/5,
-	       update_c_primop/3, update_c_receive/4, update_c_seq/3,
+	       update_c_primop/3,
+	       update_c_receive/4, update_c_search/4,
+	       update_c_seq/3,
 	       update_c_try/6, update_c_tuple/2, update_c_tuple_skel/2,
 	       update_c_values/2, values_es/1, var_name/1]).
 
@@ -160,6 +164,10 @@ map_1(F, T) ->
 	    update_c_receive(T, map_list(F, receive_clauses(T)),
 			     map(F, receive_timeout(T)),
 			     map(F, receive_action(T)));
+ 	'search' ->
+	    update_c_search(T, map_list(F, search_clauses(T)),
+			     map(F, search_timeout(T)),
+			     map(F, search_action(T)));
  	'try' ->
  	    update_c_try(T, map(F, try_arg(T)),
 			 map_list(F, try_vars(T)),
@@ -258,6 +266,10 @@ fold_1(F, S, T) ->
 	    fold(F, fold(F, fold_list(F, S, receive_clauses(T)),
 			 receive_timeout(T)),
 		 receive_action(T));
+ 	'search' ->
+	    fold(F, fold(F, fold_list(F, S, search_clauses(T)),
+			 search_timeout(T)),
+		 search_action(T));
  	'try' ->
 	    fold(F, fold_list(F, fold(F, fold_list(F, fold(F, S, try_arg(T)),
 						   try_vars(T)),
@@ -385,6 +397,11 @@ mapfold(F, S0, T) ->
 	    {E, S2} = mapfold(F, S1, receive_timeout(T)),
 	    {A, S3} = mapfold(F, S2, receive_action(T)),
 	    F(update_c_receive(T, Cs, E, A), S3);
+ 	'search' ->
+	    {Cs, S1} = mapfold_list(F, S0, search_clauses(T)),
+	    {E, S2} = mapfold(F, S1, search_timeout(T)),
+	    {A, S3} = mapfold(F, S2, search_action(T)),
+	    F(update_c_search(T, Cs, E, A), S3);
  	'try' ->
 	    {E, S1} = mapfold(F, S0, try_arg(T)),
 	    {Vs, S2} = mapfold_list(F, S1, try_vars(T)),
@@ -530,6 +547,11 @@ variables(T, S) ->
 	      vars_in_list(receive_clauses(T), S),
 	      ordsets:union(variables(receive_timeout(T), S),
 			    variables(receive_action(T), S)));
+	'search' ->
+	    ordsets:union(
+	      vars_in_list(search_clauses(T), S),
+	      ordsets:union(variables(search_timeout(T), S),
+			    variables(search_action(T), S)));
 	'try' ->
 	    Vs = variables(try_body(T), S),
 	    Vs1 = var_list_names(try_vars(T)),
@@ -727,6 +749,12 @@ label(T, N, Env) ->
 	    {A, N3} = label(receive_action(T), N2, Env),
 	    {As, N4} = label_ann(T, N3),
 	    {ann_c_receive(As, Cs, E, A), N4};
+ 	'search' ->
+	    {Cs, N1} = label_list(search_clauses(T), N, Env),
+	    {E, N2} = label(search_timeout(T), N1, Env),
+	    {A, N3} = label(search_action(T), N2, Env),
+	    {As, N4} = label_ann(T, N3),
+	    {ann_c_search(As, Cs, E, A), N4};
  	'try' ->
 	    {E, N1} = label(try_arg(T), N, Env),
 	    {Vs, N2, Env1} = label_vars(try_vars(T), N1, Env),
diff -urNp otp_src_R12B-5/lib/compiler/src/core_lib.erl minimal_otp_src_R12B-5/lib/compiler/src/core_lib.erl
--- otp_src_R12B-5/lib/compiler/src/core_lib.erl	2008-11-04 10:51:35.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_lib.erl	2009-06-23 20:40:10.000000000 +0100
@@ -207,6 +207,10 @@ map(F, #c_receive{clauses=Cls, timeout=T
     F(R#c_receive{clauses=map_list(F, Cls),
 		  timeout=map(F, Tout),
 		  action=map(F, Act)});
+map(F, #c_search{clauses=Cls, timeout=Tout, action=Act}=R) ->
+    F(R#c_search{clauses=map_list(F, Cls),
+		  timeout=map(F, Tout),
+		  action=map(F, Act)});
 map(F, #c_apply{op=Op,args=Args}=R) ->
     F(R#c_apply{op=map(F, Op),
 		args=map_list(F, Args)});
@@ -266,6 +270,8 @@ fold(F, Acc, #c_clause{pats=Ps,guard=G,b
     F(R, fold(F, fold(F, fold_list(F, Acc, Ps), G), B));
 fold(F, Acc, #c_receive{clauses=Cl, timeout=Ti, action=Ac}=R) ->
     F(R, fold_list(F, fold(F, fold(F, Acc, Ac), Ti), Cl));
+fold(F, Acc, #c_search{clauses=Cl, timeout=Ti, action=Ac}=R) ->
+    F(R, fold_list(F, fold(F, fold(F, Acc, Ac), Ti), Cl));
 fold(F, Acc, #c_apply{op=Op, args=Args}=R) ->
     F(R, fold_list(F, fold(F, Acc, Op), Args));
 fold(F, Acc, #c_call{module=Mod,name=Name,args=Args}=R) ->
@@ -347,6 +353,11 @@ mapfold(F, Acc0, #c_receive{clauses=Cs0,
     {Cs1,Acc2} = mapfold_list(F, Acc1, Cs0),
     {A1,Acc3} = mapfold(F, Acc2, A0),
     F(R#c_receive{clauses=Cs1,timeout=T1,action=A1}, Acc3);
+mapfold(F, Acc0, #c_search{clauses=Cs0,timeout=T0,action=A0}=R) ->
+    {T1,Acc1} = mapfold(F, Acc0, T0),
+    {Cs1,Acc2} = mapfold_list(F, Acc1, Cs0),
+    {A1,Acc3} = mapfold(F, Acc2, A0),
+    F(R#c_search{clauses=Cs1,timeout=T1,action=A1}, Acc3);
 mapfold(F, Acc0, #c_apply{op=Op0, args=As0}=R) ->
     {Op1,Acc1} = mapfold(F, Acc0, Op0),
     {As1,Acc2} = mapfold_list(F, Acc1, As0),
@@ -448,6 +459,15 @@ vu_expr(V, #c_receive{clauses=Cs,timeout
 		false -> vu_expr(V, A)
 	    end
     end;
+vu_expr(V, #c_search{clauses=Cs,timeout=T,action=A}) ->
+    case vu_clauses(V, Cs) of
+	true -> true;
+	false ->
+	    case vu_expr(V, T) of
+		true -> true;
+		false -> vu_expr(V, A)
+	    end
+    end;
 vu_expr(V, #c_apply{op=Op,args=As}) ->
     vu_expr_list(V, [Op|As]);
 vu_expr(V, #c_call{module=M,name=N,args=As}) ->
@@ -607,7 +627,9 @@ free(#c_catch{body=B}, Scope, Free) ->
 free(#c_receive{clauses=Cs,timeout=To,action=Action}, Scope, Free0) ->
     Free1 = free_cs(Cs, Scope, Free0),
     Free = free(To, Scope, Free1),
-    free(Action, Scope, Free).
+    free(Action, Scope, Free);
+free(#c_search{clauses=Cs,timeout=To,action=Action}, Scope, Free0) ->
+    free(#c_receive{clauses=Cs,timeout=To,action=Action}, Scope, Free0).
 
 free_list([E|Es], Scope, Free0) ->
     Free = free(E, Scope, Free0),
diff -urNp otp_src_R12B-5/lib/compiler/src/core_lint.erl minimal_otp_src_R12B-5/lib/compiler/src/core_lint.erl
--- otp_src_R12B-5/lib/compiler/src/core_lint.erl	2008-02-05 13:37:38.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_lint.erl	2009-06-23 20:40:10.000000000 +0100
@@ -293,6 +293,8 @@ expr(#c_receive{clauses=Cs,timeout=T,act
     St1 = expr(T, Def, 1, St0),
     St2 = body(A, Def, Rt, St1),
     clauses(Cs, Def, 1, Rt, St2);
+expr(#c_search{clauses=Cs,timeout=T,action=A}, Def, Rt, St0) ->
+    expr(#c_receive{clauses=Cs,timeout=T,action=A}, Def, Rt, St0);
 expr(#c_apply{op=Op,args=As}, Def, _Rt, St0) ->
     St1 = apply_op(Op, Def, length(As), St0),
     expr_list(As, Def, St1);
diff -urNp otp_src_R12B-5/lib/compiler/src/core_lint.erl~ minimal_otp_src_R12B-5/lib/compiler/src/core_lint.erl~
--- otp_src_R12B-5/lib/compiler/src/core_lint.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_lint.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,494 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Do necessary checking of Core Erlang code.
+
+%% Check Core module for errors.  Seeing this module is used in the
+%% compiler after optimisations we do more checking than would be
+%% necessary after just parsing.  Don't check all constructs.
+%%
+%% We check the following:
+%%
+%% All referred functions, called and exported, are defined.
+%% Format of export list.
+%% Format of attributes
+%% Used variables are defined.
+%% Variables in let and funs.
+%% Patterns case clauses.
+%% Values only as multiple values/variables/patterns.
+%% Return same number of values as requested
+%% Correct number of arguments
+%%
+%% Checks to add:
+%%
+%% Consistency of values/variables
+%% Consistency of function return values/calls.
+%%
+%% We keep the names defined variables and functions in a ordered list
+%% of variable names and function name/arity pairs.
+
+-module(core_lint).
+
+
+-export([module/1,module/2,format_error/1]).
+
+-import(lists, [reverse/1,all/2,foldl/3]).
+-import(ordsets, [add_element/2,is_element/2,union/2]).
+
+-include("core_parse.hrl").
+
+%% Define the lint state record.
+
+-record(lint, {module=[],			%Current module
+	       func=[],				%Current function
+	       errors=[],			%Errors
+	       warnings=[]}).			%Warnings
+
+%% format_error(Error)
+%%  Return a string describing the error.
+
+format_error(invalid_exports) -> "invalid exports";
+format_error(invalid_attributes) -> "invalid attributes";
+format_error({undefined_function,{F,A}}) ->
+    io_lib:format("function ~w/~w undefined", [F,A]);
+format_error({undefined_function,{F1,A1},{F2,A2}}) ->
+    io_lib:format("undefined function ~w/~w in ~w/~w", [F1,A1,F2,A2]);
+format_error({illegal_expr,{F,A}}) ->
+    io_lib:format("illegal expression in ~w/~w", [F,A]);
+format_error({illegal_guard,{F,A}}) ->
+    io_lib:format("illegal guard expression in ~w/~w", [F,A]);
+format_error({illegal_pattern,{F,A}}) ->
+    io_lib:format("illegal pattern in ~w/~w", [F,A]);
+format_error({illegal_try,{F,A}}) ->
+    io_lib:format("illegal try expression in ~w/~w", [F,A]);
+format_error({pattern_mismatch,{F,A}}) ->
+    io_lib:format("pattern count mismatch in ~w/~w", [F,A]);
+format_error({return_mismatch,{F,A}}) ->
+    io_lib:format("return count mismatch in ~w/~w", [F,A]);
+format_error({arg_mismatch,{F,A}}) ->
+    io_lib:format("argument count mismatch in ~w/~w", [F,A]);
+format_error({unbound_var,N,{F,A}}) ->
+    io_lib:format("unbound variable ~s in ~w/~w", [N,F,A]);
+format_error({duplicate_var,N,{F,A}}) ->
+    io_lib:format("duplicate variable ~s in ~w/~w", [N,F,A]);
+format_error({not_var,{F,A}}) ->
+    io_lib:format("expecting variable in ~w/~w", [F,A]);
+format_error({not_pattern,{F,A}}) ->
+    io_lib:format("expecting pattern in ~w/~w", [F,A]);
+format_error({not_bs_pattern,{F,A}}) ->
+    io_lib:format("expecting bit syntax pattern in ~w/~w", [F,A]);
+format_error({bittype_unit,{F,A}}) ->
+    io_lib:format("unit without size in bit syntax pattern/expression in ~w/~w", [F,A]).
+
+%% module(CoreMod) ->
+%% module(CoreMod, [CompileOption]) ->
+%%	{ok,[Warning]} | {error,[Error],[Warning]}
+
+module(M) -> module(M, []).
+
+module(#c_module{name=M,exports=Es,attrs=As,defs=Ds}, _Opts) ->
+    Defined = defined_funcs(Ds),
+    St0 = #lint{module=M#c_literal.val},
+    St1 = check_exports(Es, St0),
+    St2 = check_attrs(As, St1),
+    St3 = module_defs(Ds, Defined, St2),
+    St4 = check_state(Es, Defined, St3),
+    return_status(St4).
+
+%% defined_funcs([FuncDef]) -> [Fname].
+
+defined_funcs(Fs) ->
+    foldl(fun ({#c_fname{id=I,arity=A},_}, Def) ->
+		  add_element({I,A}, Def)
+	  end, [], Fs).
+
+%% return_status(State) ->
+%%	{ok,[Warning]} | {error,[Error],[Warning]}
+%%  Pack errors and warnings properly and return ok | error.
+
+return_status(St) ->
+    Ws = reverse(St#lint.warnings),
+    case reverse(St#lint.errors) of
+	[] -> {ok,[{St#lint.module,Ws}]};
+	Es -> {error,[{St#lint.module,Es}],[{St#lint.module,Ws}]}
+    end.
+
+%% add_error(ErrorDescriptor, State) -> State'
+%% add_warning(ErrorDescriptor, State) -> State'
+%%  Note that we don't use line numbers here.
+
+add_error(E, St) -> St#lint{errors=[{?MODULE,E}|St#lint.errors]}.
+
+%%add_warning(W, St) -> St#lint{warnings=[{none,core_lint,W}|St#lint.warnings]}.
+
+check_exports(Es, St) ->
+    case all(fun (#c_fname{id=Name,arity=Arity})
+		 when is_atom(Name), is_integer(Arity) -> true;
+		 (_) -> false
+	     end, Es) of
+	true -> St;
+	false -> add_error(invalid_exports, St)
+    end.
+
+check_attrs(As, St) ->
+    case all(fun ({#c_literal{},V}) -> core_lib:is_literal(V);
+		 (_) -> false
+	     end, As) of
+	true -> St;
+	false -> add_error(invalid_attributes, St)
+    end.
+
+check_state(Es, Defined, St) ->
+    foldl(fun (#c_fname{id=N,arity=A}, St1) ->
+		  F = {N,A},
+		  case is_element(F, Defined) of
+		      true -> St1;
+		      false -> add_error({undefined_function,F}, St)
+		  end
+	  end, St, Es).
+
+%% module_defs(CoreBody, Defined, State) -> State.
+
+module_defs(B, Def, St) ->
+    %% Set top level function name.
+    foldl(fun (Func, St0) ->
+		  {#c_fname{id=F,arity=A},_} = Func,
+		  St1 = St0#lint{func={F,A}},
+		  function(Func, Def, St1)
+	  end, St, B).
+
+%% functions([Fdef], Defined, State) -> State.
+
+functions(Fs, Def, St0) ->
+    foldl(fun (F, St) -> function(F, Def, St) end, St0, Fs).
+
+%% function(CoreFunc, Defined, State) -> State.
+
+function({#c_fname{},B}, Def, St) ->
+    %% Body must be a fun!
+    case B of
+	#c_fun{} -> expr(B, Def, any, St);
+	_ -> add_error({illegal_expr,St#lint.func}, St)
+    end.
+
+%% body(Expr, Defined, RetCount, State) -> State.
+
+body(#c_values{es=Es}, Def, Rt, St) ->
+    return_match(Rt, length(Es), expr_list(Es, Def, St));
+body(E, Def, Rt, St0) ->
+    St1 = expr(E, Def, Rt, St0),
+    case core_lib:is_simple_top(E) of
+	true -> return_match(Rt, 1, St1);
+	false -> St1
+    end.
+
+%% guard(Expr, Defined, State) -> State.
+%%  Guards are boolean expressions with test wrapped in a protected.
+
+guard(Expr, Def, St) -> gexpr(Expr, Def, 1, St).
+
+%% guard_list([Expr], Defined, State) -> State.
+
+%% guard_list(Es, Def, St0) ->
+%%     foldl(fun (E, St) -> guard(E, Def, St) end, St0, Es).
+
+%% gbody(Expr, Defined, RetCount, State) -> State.
+
+gbody(#c_values{es=Es}, Def, Rt, St) ->
+    return_match(Rt, length(Es), gexpr_list(Es, Def, St));
+gbody(E, Def, Rt, St0) ->
+    St1 = gexpr(E, Def, Rt, St0),
+    case core_lib:is_simple_top(E) of
+	true -> return_match(Rt, 1, St1);
+	false -> St1
+    end.
+
+gexpr(#c_var{name=N}, Def, _Rt, St) -> expr_var(N, Def, St);
+gexpr(#c_literal{}, _Def, _Rt, St) -> St;
+gexpr(#c_cons{hd=H,tl=T}, Def, _Rt, St) ->
+    gexpr_list([H,T], Def, St);
+gexpr(#c_tuple{es=Es}, Def, _Rt, St) ->
+    gexpr_list(Es, Def, St);
+gexpr(#c_binary{segments=Ss}, Def, _Rt, St) ->
+    gbitstr_list(Ss, Def, St);
+gexpr(#c_seq{arg=Arg,body=B}, Def, Rt, St0) ->
+    St1 = gexpr(Arg, Def, any, St0),		%Ignore values
+    gbody(B, Def, Rt, St1);
+gexpr(#c_let{vars=Vs,arg=Arg,body=B}, Def, Rt, St0) ->
+    St1 = gbody(Arg, Def, let_varcount(Vs), St0), %This is a guard body
+    {Lvs,St2} = variable_list(Vs, St1),
+    gbody(B, union(Lvs, Def), Rt, St2);
+gexpr(#c_call{module=#c_literal{val=erlang},
+	      name=#c_literal{},
+	      args=As}, Def, 1, St) ->
+    gexpr_list(As, Def, St);
+gexpr(#c_primop{name=#c_literal{val=A},args=As}, Def, _Rt, St0) when is_atom(A) ->
+    gexpr_list(As, Def, St0);
+gexpr(#c_try{arg=E,vars=[#c_var{name=X}],body=#c_var{name=X},
+	     evars=[#c_var{},#c_var{}],handler=#c_literal{val=false}},
+      Def, Rt, St) ->
+    gbody(E, Def, Rt, St);
+gexpr(Core, _, _, St) ->
+    add_error({illegal_guard,St#lint.func}, St).
+
+%% gexpr_list([Expr], Defined, State) -> State.
+
+gexpr_list(Es, Def, St0) ->
+    foldl(fun (E, St) -> gexpr(E, Def, 1, St) end, St0, Es).
+
+%% gbitstr_list([Elem], Defined, State) -> State.
+
+gbitstr_list(Es, Def, St0) ->
+    foldl(fun (E, St) -> gbitstr(E, Def, St) end, St0, Es).
+
+gbitstr(#c_bitstr{val=V,size=S,unit=U,type=T,flags=Fs}, Def, St0) ->
+    St1 = bit_type(U, T, Fs, St0),
+    gexpr_list([V,S], Def, St1).
+
+%% expr(Expr, Defined, RetCount, State) -> State.
+
+expr(#c_var{name=N}, Def, _Rt, St) -> expr_var(N, Def, St);
+expr(#c_literal{}, _Def, _Rt, St) -> St;
+expr(#c_cons{hd=H,tl=T}, Def, _Rt, St) ->
+    expr_list([H,T], Def, St);
+expr(#c_tuple{es=Es}, Def, _Rt, St) ->
+    expr_list(Es, Def, St);
+expr(#c_binary{segments=Ss}, Def, _Rt, St) ->
+    bitstr_list(Ss, Def, St);
+expr(#c_fname{id=I,arity=A}, Def, _Rt, St) ->
+    expr_fname({I,A}, Def, St);
+expr(#c_fun{vars=Vs,body=B}, Def, Rt, St0) ->
+    {Vvs,St1} = variable_list(Vs, St0),
+    return_match(Rt, 1, body(B, union(Vvs, Def), any, St1));
+expr(#c_seq{arg=Arg,body=B}, Def, Rt, St0) ->
+    St1 = expr(Arg, Def, any, St0),		%Ignore values
+    body(B, Def, Rt, St1);
+expr(#c_let{vars=Vs,arg=Arg,body=B}, Def, Rt, St0) ->
+    St1 = body(Arg, Def, let_varcount(Vs), St0), %This is a body
+    {Lvs,St2} = variable_list(Vs, St1),
+    body(B, union(Lvs, Def), Rt, St2);
+expr(#c_letrec{defs=Fs,body=B}, Def0, Rt, St0) ->
+    Def1 = union(defined_funcs(Fs), Def0),	%All defined stuff
+    St1 = functions(Fs, Def1, St0),
+    body(B, Def1, Rt, St1#lint{func=St0#lint.func});
+expr(#c_case{arg=Arg,clauses=Cs}, Def, Rt, St0) ->
+    Pc = case_patcount(Cs),
+    St1 = body(Arg, Def, Pc, St0),
+    clauses(Cs, Def, Pc, Rt, St1);
+expr(#c_receive{clauses=Cs,timeout=T,action=A}, Def, Rt, St0) ->
+    St1 = expr(T, Def, 1, St0),
+    St2 = body(A, Def, Rt, St1),
+    clauses(Cs, Def, 1, Rt, St2);
+expr(#c_search{clauses=Cs,timeout=T,action=A}, Def, Rt, St0) ->
+    St1 = expr(T, Def, 1, St0),
+    St2 = body(A, Def, Rt, St1),
+    clauses(Cs, Def, 1, Rt, St2);
+expr(#c_apply{op=Op,args=As}, Def, _Rt, St0) ->
+    St1 = apply_op(Op, Def, length(As), St0),
+    expr_list(As, Def, St1);
+expr(#c_call{module=M,name=N,args=As}, Def, _Rt, St0) ->
+    St1 = expr(M, Def, 1, St0),
+    St2 = expr(N, Def, 1, St1),
+    expr_list(As, Def, St2);
+expr(#c_primop{name=#c_literal{val=A},args=As}, Def, _Rt, St0) when is_atom(A) ->
+    expr_list(As, Def, St0);
+expr(#c_catch{body=B}, Def, Rt, St) ->
+    return_match(Rt, 1, body(B, Def, 1, St));
+expr(#c_try{arg=A,vars=Vs,body=B,evars=Evs,handler=H}, Def, Rt, St0) ->
+    St1 = case length(Evs) of
+	      3 -> St0;
+	      _ -> add_error({illegal_try,St0#lint.func}, St0)
+	  end,
+    St2 = body(A, Def, let_varcount(Vs), St1),
+    {Ns,St3} = variable_list(Vs, St2),
+    St4 = body(B, union(Ns, Def), Rt, St3),
+    {Ens,St5} = variable_list(Evs, St4),
+    body(H, union(Ens, Def), Rt, St5);
+expr(_, _, _, St) ->
+    %%io:fwrite("clint: ~p~n", [Other]),
+    add_error({illegal_expr,St#lint.func}, St).
+
+%% expr_list([Expr], Defined, State) -> State.
+
+expr_list(Es, Def, St0) ->
+    foldl(fun (E, St) -> expr(E, Def, 1, St) end, St0, Es).
+
+%% bitstr_list([Elem], Defined, State) -> State.
+
+bitstr_list(Es, Def, St0) ->
+    foldl(fun (E, St) -> bitstr(E, Def, St) end, St0, Es).
+
+bitstr(#c_bitstr{val=V,size=S,unit=U,type=T,flags=Fs}, Def, St0) ->
+    St1 = bit_type(U, T, Fs, St0),
+    expr_list([V,S], Def, St1).
+
+%% apply_op(Op, Defined, ArgCount, State) -> State.
+%%  A apply op is either an fname or an expression.
+
+apply_op(#c_fname{id=I,arity=A}, Def, Ac, St0) ->
+    St1 = expr_fname({I,A}, Def, St0),
+    arg_match(Ac, A, St1);
+apply_op(E, Def, _, St) -> expr(E, Def, 1, St).	%Hard to check
+
+%% expr_var(VarName, Defined, State) -> State.
+
+expr_var(N, Def, St) ->
+    case is_element(N, Def) of
+	true -> St;
+	false -> add_error({unbound_var,N,St#lint.func}, St)
+    end.
+
+%% expr_fname(Fname, Defined, State) -> State.
+
+expr_fname(Fname, Def, St) ->
+    case is_element(Fname, Def) of
+	true -> St;
+	false -> add_error({undefined_function,Fname,St#lint.func}, St)
+    end.
+
+%% let_varcount([Var]) -> int().
+
+let_varcount([]) -> any;			%Ignore values
+let_varcount(Es) -> length(Es).
+
+%% case_patcount([Clause]) -> int().
+
+case_patcount([#c_clause{pats=Ps}|_]) -> length(Ps).
+
+%% clauses([Clause], Defined, PatCount, RetCount, State) -> State.
+
+clauses(Cs, Def, Pc, Rt, St0) ->
+    foldl(fun (C, St) -> clause(C, Def, Pc, Rt, St) end, St0, Cs).
+
+%% clause(Clause, Defined, PatCount, RetCount, State) -> State.
+
+clause(#c_clause{pats=Ps,guard=G,body=B}, Def0, Pc, Rt, St0) ->
+    St1 = pattern_match(Pc, length(Ps), St0),
+    {Pvs,St2} = pattern_list(Ps, Def0, St1),
+    Def1 = union(Pvs, Def0),
+    St3 = guard(G, Def1, St2),
+    body(B, Def1, Rt, St3).
+
+%% variable(Var, [PatVar], State) -> {[VarName],State}.
+
+variable(#c_var{name=N}, Ps, St) ->
+    case is_element(N, Ps) of
+	true -> {[],add_error({duplicate_var,N,St#lint.func}, St)};
+	false -> {[N],St}
+    end;
+variable(_, Def, St) -> {Def,add_error({not_var,St#lint.func}, St)}.
+
+%% variable_list([Var], State) -> {[Var],State}.
+%% variable_list([Var], [PatVar], State) -> {[Var],State}.
+
+variable_list(Vs, St) -> variable_list(Vs, [], St).
+
+variable_list(Vs, Ps, St) ->
+    foldl(fun (V, {Ps0,St0}) ->
+		  {Vvs,St1} = variable(V, Ps0, St0),
+		  {union(Vvs, Ps0),St1}
+	  end, {Ps,St}, Vs).
+
+%% pattern(Pattern, Defined, State) -> {[PatVar],State}.
+%% pattern(Pattern, Defined, [PatVar], State) -> {[PatVar],State}.
+%%  Patterns are complicated by sizes in binaries.  These are pure
+%%  input variables which create no bindings.  We, therefor, need to
+%%  carry around the original defined variables to get the correct
+%%  handling.
+
+%% pattern(P, Def, St) -> pattern(P, Def, [], St).
+
+pattern(#c_var{name=N}, Def, Ps, St) ->
+    pat_var(N, Def, Ps, St);
+pattern(#c_literal{}, _Def, Ps, St) -> {Ps,St};
+pattern(#c_cons{hd=H,tl=T}, Def, Ps, St) ->
+    pattern_list([H,T], Def, Ps, St);
+pattern(#c_tuple{es=Es}, Def, Ps, St) ->
+    pattern_list(Es, Def, Ps, St);
+pattern(#c_binary{segments=Ss}, Def, Ps, St) ->
+    pat_bin(Ss, Def, Ps, St);
+pattern(#c_alias{var=V,pat=P}, Def, Ps, St0) ->
+    {Vvs,St1} = variable(V, Ps, St0),
+    pattern(P, Def, union(Vvs, Ps), St1);
+pattern(_, _, Ps, St) -> {Ps,add_error({not_pattern,St#lint.func}, St)}.
+
+pat_var(N, _Def, Ps, St) ->
+    case is_element(N, Ps) of
+	true -> {Ps,add_error({duplicate_var,N,St#lint.func}, St)};
+	false -> {add_element(N, Ps),St}
+    end.
+
+%% pat_bin_list([Elem], Defined, [PatVar], State) -> {[PatVar],State}.
+
+pat_bin(Es, Def, Ps0, St0) ->
+    foldl(fun (E, {Ps,St}) -> pat_segment(E, Def, Ps, St) end, {Ps0,St0}, Es).
+
+pat_segment(#c_bitstr{val=V,size=S,unit=U,type=T,flags=Fs}, Def, Ps, St0) ->
+    St1 = bit_type(U, T, Fs, St0),
+    St2 = pat_bit_expr(S, T, Def, St1),
+    pattern(V, Def, Ps, St2);
+pat_segment(_, _, Ps, St) ->
+    {Ps,add_error({not_bs_pattern,St#lint.func}, St)}.
+
+%% pat_bit_expr(SizePat, Type, Defined, State) -> State.
+%%  Check the Size pattern, this is an input!  Be a bit tough here.
+
+pat_bit_expr(#c_literal{val=I}, _, _, St) when is_integer(I), I >= 0 -> St;
+pat_bit_expr(#c_var{name=N}, _, Def, St) ->
+    expr_var(N, Def, St);
+pat_bit_expr(#c_literal{val=all}, #c_literal{val=binary}, _Def, St) -> St;
+pat_bit_expr(_, _, _, St) ->
+    add_error({illegal_expr,St#lint.func}, St).
+
+bit_type(Unit, Type, Flags, St) ->
+    U = core_lib:literal_value(Unit),
+    T = core_lib:literal_value(Type),
+    Fs = core_lib:literal_value(Flags),
+    case erl_bits:set_bit_type(default, [T,{unit,U}|Fs]) of
+	{ok,_,_} -> St;
+	{error,E} -> add_error({E,St#lint.func}, St)
+    end.
+
+%% pattern_list([Var], Defined, State) -> {[PatVar],State}.
+%% pattern_list([Var], Defined, [PatVar], State) -> {[PatVar],State}.
+
+pattern_list(Pats, Def, St) -> pattern_list(Pats, Def, [], St).
+
+pattern_list(Pats, Def, Ps0, St0) ->
+    foldl(fun (P, {Ps,St}) -> pattern(P, Def, Ps, St) end, {Ps0,St0}, Pats).
+
+%% pattern_match(Required, Supplied, State) -> State.
+%%  Check that the required number of patterns match the supplied.
+
+pattern_match(N, N, St) -> St;
+pattern_match(_Req, _Sup, St) ->
+    add_error({pattern_mismatch,St#lint.func}, St).
+
+%% return_match(Required, Supplied, State) -> State.
+%%  Check that the required number of return values match the supplied.
+
+return_match(any, _Sup, St) -> St;
+return_match(N, N, St) -> St;
+return_match(_Req, _Sup, St) ->
+    add_error({return_mismatch,St#lint.func}, St).
+
+%% arg_match(Required, Supplied, State) -> State.
+
+arg_match(_Req, unknown, St) -> St;
+arg_match(N, N, St) -> St;
+arg_match(_Req, _Sup, St) ->
+    add_error({arg_mismatch,St#lint.func}, St).
diff -urNp otp_src_R12B-5/lib/compiler/src/core_parse.erl minimal_otp_src_R12B-5/lib/compiler/src/core_parse.erl
--- otp_src_R12B-5/lib/compiler/src/core_parse.erl	2008-11-05 11:41:45.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_parse.erl	2009-06-23 20:40:10.000000000 +0100
@@ -1,6 +1,6 @@
 -module(core_parse).
 -export([parse/1, parse_and_scan/1, format_error/1]).
--file("core_parse.yrl", 372).
+-file("core_parse.yrl", 382).
 
 -export([abstract/1,abstract/2,normalise/1]).
 
@@ -19,7 +19,7 @@ abstract(Term) -> core_lib:make_literal(
 
 normalise(Core) -> core_lib:literal_value(Core).
 
--file("/ldisk/daily_build/otp_prebuild_r12b.2008-11-05_12/otp_src_R12B-5/bootstrap/lib/parsetools/include/yeccpre.hrl", 0).
+-file("/home/hubert/libs/otp_src_joins_R12B-5/bootstrap/lib/parsetools/include/yeccpre.hrl", 0).
 %% ``The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
 %% compliance with the License. You should have received a copy of the
@@ -430,8 +430,8 @@ yeccpars2(108=S, Cat, Ss, Stack, T, Ts, 
 %%  yeccpars2_127(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(128=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_128(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(129=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_129(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(129=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_129(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(130=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_130(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(131=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -439,11 +439,11 @@ yeccpars2(131=S, Cat, Ss, Stack, T, Ts, 
 yeccpars2(132=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_132(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(133=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_133(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(134=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_134(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(135=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(135=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_135(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(136=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(137=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -451,59 +451,59 @@ yeccpars2(137=S, Cat, Ss, Stack, T, Ts, 
 yeccpars2(138=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(139=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_139(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(140=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_140(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(141=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_141(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(142=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_142(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(143=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(143=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_143(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(144=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_144(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(145=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_145(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(146=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_146(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(147=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(148=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_143(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(145=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(149=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_149(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(146=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_146(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(147=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_147(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(148=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_148(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(149=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_149(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(150=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_150(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(151=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_151(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(152=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_139(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_152(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(153=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_153(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(154=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_154(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(155=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_155(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(154=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_140(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(155=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_155(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(156=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_156(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(157=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(158=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(158=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_158(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(159=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(160=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_160(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_159(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(160=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_160(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(161=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_139(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(162=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_162(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(163=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_140(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(164=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_164(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(165=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_165(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(165=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(166=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_166(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(167=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -528,160 +528,160 @@ yeccpars2(163=S, Cat, Ss, Stack, T, Ts, 
 %%  yeccpars2_176(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(177=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_177(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(178=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_178(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(179=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_179(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(178=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_178(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(179=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_179(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(180=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_180(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(181=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_181(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(182=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_182(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(183=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_183(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(184=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_184(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(185=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_185(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(186=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_186(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(187=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_187(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(188=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_188(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(189=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_189(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(184=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(185=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_185(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(186=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_186(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(187=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_187(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(188=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_188(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(189=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_189(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(190=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_190(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(191=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(191=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(192=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(193=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(194=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_194(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(195=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(196=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(197=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_197(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(196=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_196(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(197=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_197(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(198=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_198(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(199=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(200=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_200(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(199=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_199(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(200=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_200(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(201=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_201(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(202=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_202(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(203=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_203(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(204=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_204(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(205=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_205(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(205=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(206=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_206(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(207=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(208=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_208(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(207=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_207(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(208=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_208(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(209=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(210=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_210(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(210=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_210(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(211=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_211(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(212=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_205(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(213=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_213(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_212(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(213=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_213(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(214=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_214(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(215=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(216=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_216(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(217=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(218=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_218(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(219=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_207(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(215=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(216=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_216(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(217=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(218=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_218(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(219=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_219(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(220=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_220(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(221=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_221(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(222=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_222(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(223=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_223(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(224=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_224(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(225=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_225(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(226=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_226(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(222=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_222(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(223=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_223(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(224=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_224(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(225=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_225(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(226=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_226(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(227=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_227(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(228=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(229=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_229(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_228(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(229=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_229(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(230=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_230(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(231=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(232=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_232(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(231=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_231(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(232=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_232(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(233=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_233(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(234=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_234(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(235=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_235(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(234=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_234(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(235=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_235(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(236=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_236(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(237=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_237(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(238=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_238(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(239=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_239(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(240=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(237=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_237(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(238=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_238(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(239=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_239(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(240=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_240(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(241=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_241(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(242=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(243=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_243(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(244=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_244(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(244=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(245=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(246=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(246=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(247=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_247(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(248=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(249=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_249(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_178(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(248=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(249=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_249(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(250=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_250(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(251=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_251(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(252=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_252(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(253=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_253(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(253=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_253(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(254=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_254(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(255=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_255(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(256=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -689,59 +689,59 @@ yeccpars2(256=S, Cat, Ss, Stack, T, Ts, 
 %% yeccpars2(257=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_257(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(258=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(259=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_259(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_258(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(259=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(260=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_260(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(261=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_261(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(262=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_262(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(261=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(262=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_262(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(263=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_263(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(264=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(264=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(265=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_265(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(266=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(267=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_244(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(266=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_266(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(267=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_267(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(268=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_268(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(269=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_244(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(269=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_269(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(270=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_270(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(271=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_271(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(272=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_272(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(273=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(274=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_274(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(275=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2(271=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(272=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_249(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(273=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_273(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(274=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_249(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(275=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_275(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(276=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_276(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(277=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_277(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(278=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_271(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(279=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_279(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(280=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_280(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(281=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_281(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(277=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_277(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(278=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(279=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_279(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(280=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(281=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_281(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(282=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_282(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(283=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(284=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_276(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(284=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_284(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(285=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_285(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(286=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -750,36 +750,36 @@ yeccpars2(287=S, Cat, Ss, Stack, T, Ts, 
  yeccpars2_287(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(288=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_288(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(289=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_289(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(290=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_290(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(289=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(290=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_290(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(291=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_291(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(292=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_292(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(293=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(293=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_293(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(294=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_294(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(295=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_295(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(296=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(297=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_297(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_296(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(297=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_297(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(298=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_298(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(299=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_299(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(300=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_300(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(299=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_299(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(300=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_300(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(301=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_301(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(302=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_302(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(303=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_303(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(302=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_302(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(303=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_303(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(304=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_304(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(305=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -787,39 +787,49 @@ yeccpars2(304=S, Cat, Ss, Stack, T, Ts, 
 yeccpars2(306=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_306(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(307=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_307(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(308=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_308(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(309=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_309(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(310=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(311=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_311(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(309=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_309(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(310=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_310(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(311=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_311(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(312=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_312(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(313=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_313(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(314=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_314(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(314=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_314(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(315=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_315(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(316=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_4(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(317=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_5(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(316=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_316(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(317=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_317(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(318=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_318(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(319=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_319(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(319=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_319(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(320=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_320(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(321=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_4(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(322=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_322(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(323=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_323(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_5(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(323=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_323(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(324=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_324(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(325=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_325(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(326=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(327=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_327(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(328=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_328(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(Other, _, _, _, _, _, _) ->
  erlang:error({yecc_bug,"1.3",{missing_state_in_action_table, Other}}).
 
@@ -832,7 +842,7 @@ yeccpars2_1(_S, '$end', _Ss, Stack,  _T,
  {ok, hd(Stack)}.
 
 yeccpars2_2(S, module, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 315, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 320, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_3(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 4, Ss, Stack, T, Ts, Tzr).
@@ -1080,7 +1090,7 @@ yeccpars2_55(_S, Cat, Ss, Stack, T, Ts, 
  yeccgoto_module_attribute(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
 yeccpars2_56(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 314, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 319, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_anno_function_name(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
@@ -1094,7 +1104,7 @@ yeccpars2_59(S, atom, Ss, Stack, T, Ts, 
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
 yeccpars2_59(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_59_(Stack),
- yeccpars2_313(_S, Cat, [59 | Ss], NewStack, T, Ts, Tzr).
+ yeccpars2_318(_S, Cat, [59 | Ss], NewStack, T, Ts, Tzr).
 
 yeccpars2_60(S, '=', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 96, Ss, Stack, T, Ts, Tzr).
@@ -1280,10 +1290,10 @@ yeccpars2_102(_S, Cat, Ss, Stack, T, Ts,
  yeccgoto_anno_variable(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_103(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 306, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 311, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_104(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 304, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 309, Ss, Stack, T, Ts, Tzr);
 yeccpars2_104(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_104_(Stack),
  yeccgoto_anno_variables(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
@@ -1299,7 +1309,7 @@ yeccpars2_107(_S, Cat, Ss, Stack, T, Ts,
  yeccgoto_variable(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_108(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr);
 yeccpars2_108(S, char, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
 yeccpars2_108(S, float, Ss, Stack, T, Ts, Tzr) ->
@@ -1316,35 +1326,37 @@ yeccpars2_108(S, Cat, Ss, Stack, T, Ts, 
  yeccpars2_cont_108(S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_cont_108(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 129, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr);
 yeccpars2_cont_108(S, '<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, '[', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 132, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, apply, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, '[', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 133, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, apply, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 134, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, call, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 135, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, 'case', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, call, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 136, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, 'case', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 137, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, do, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 138, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, 'let', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, do, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 139, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, letrec, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, 'let', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 140, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, primop, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, letrec, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 141, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, 'receive', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, primop, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 142, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_108(S, 'try', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_108(S, 'receive', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 143, Ss, Stack, T, Ts, Tzr);
+yeccpars2_cont_108(S, search, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 144, Ss, Stack, T, Ts, Tzr);
+yeccpars2_cont_108(S, 'try', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 145, Ss, Stack, T, Ts, Tzr);
 yeccpars2_cont_108(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 144, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 146, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_single_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
@@ -1380,10 +1392,10 @@ yeccpars2_119(_S, Cat, Ss, Stack, T, Ts,
  yeccgoto_single_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_anno_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_single_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_single_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_anno_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_single_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
@@ -1404,32 +1416,16 @@ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts,
  yeccgoto_single_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_single_expression(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_129(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_128_(Stack),
+ NewStack = yeccpars2_129_(Stack),
  yeccgoto_fun_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_129(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 287, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_130(S, char, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
-yeccpars2_130(S, float, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 33, Ss, Stack, T, Ts, Tzr);
-yeccpars2_130(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 100, Ss, Stack, T, Ts, Tzr);
-yeccpars2_130(S, integer, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 34, Ss, Stack, T, Ts, Tzr);
-yeccpars2_130(S, string, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 35, Ss, Stack, T, Ts, Tzr);
-yeccpars2_130(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_130(S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_cont_108(S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccpars2_130(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 292, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_131(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr);
-yeccpars2_131(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 281, Ss, Stack, T, Ts, Tzr);
 yeccpars2_131(S, char, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
 yeccpars2_131(S, float, Ss, Stack, T, Ts, Tzr) ->
@@ -1446,9 +1442,9 @@ yeccpars2_131(S, Cat, Ss, Stack, T, Ts, 
  yeccpars2_cont_108(S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_132(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr);
-yeccpars2_132(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr);
+yeccpars2_132(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 286, Ss, Stack, T, Ts, Tzr);
 yeccpars2_132(S, char, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
 yeccpars2_132(S, float, Ss, Stack, T, Ts, Tzr) ->
@@ -1464,947 +1460,984 @@ yeccpars2_132(S, var, Ss, Stack, T, Ts, 
 yeccpars2_132(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_108(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_133: see yeccpars2_108
+yeccpars2_133(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, char, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, float, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 33, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 100, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, integer, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 34, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, string, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 35, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
+yeccpars2_133(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_cont_108(S, Cat, Ss, Stack, T, Ts, Tzr).
+
+%% yeccpars2_134: see yeccpars2_108
 
-yeccpars2_134(S, '/', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_135(S, '/', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_134(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_134_(Stack),
+yeccpars2_135(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_135_(Stack),
  yeccgoto_atomic_literal(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_135: see yeccpars2_108
-
 %% yeccpars2_136: see yeccpars2_108
 
 %% yeccpars2_137: see yeccpars2_108
 
 %% yeccpars2_138: see yeccpars2_108
 
-yeccpars2_139(S, '(', Ss, Stack, T, Ts, Tzr) ->
+%% yeccpars2_139: see yeccpars2_108
+
+yeccpars2_140(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 105, Ss, Stack, T, Ts, Tzr);
-yeccpars2_139(S, '<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 155, Ss, Stack, T, Ts, Tzr);
-yeccpars2_139(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_140(S, '<', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 157, Ss, Stack, T, Ts, Tzr);
+yeccpars2_140(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_140(S, '(', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_141(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr);
-yeccpars2_140(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_141(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_140(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_140_(Stack),
- yeccpars2_250(250, Cat, [140 | Ss], NewStack, T, Ts, Tzr).
-
-%% yeccpars2_141: see yeccpars2_108
-
-yeccpars2_142(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 179, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, '<', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_141_(Stack),
+ yeccpars2_255(255, Cat, [141 | Ss], NewStack, T, Ts, Tzr).
+
+%% yeccpars2_142: see yeccpars2_108
+
+yeccpars2_143(S, '#', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, '[', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_143(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_143(S, '<', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_143(S, '[', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_143(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 184, Ss, Stack, T, Ts, Tzr);
+yeccpars2_143(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_143(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_142(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_143(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
+yeccpars2_143(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_143: see yeccpars2_108
+%% yeccpars2_144: see yeccpars2_143
 
-yeccpars2_144(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, char, Ss, Stack, T, Ts, Tzr) ->
+%% yeccpars2_145: see yeccpars2_108
+
+yeccpars2_146(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr);
+yeccpars2_146(S, char, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, float, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_146(S, float, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 33, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_146(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 100, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, integer, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_146(S, integer, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 34, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, string, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_146(S, string, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 35, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_146(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 147, Ss, Stack, T, Ts, Tzr);
-yeccpars2_144(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_146(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 149, Ss, Stack, T, Ts, Tzr);
+yeccpars2_146(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_108(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_145(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 150, Ss, Stack, T, Ts, Tzr).
+yeccpars2_147(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 152, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_146(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 148, Ss, Stack, T, Ts, Tzr);
-yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_146_(Stack),
+yeccpars2_148(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 150, Ss, Stack, T, Ts, Tzr);
+yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_148_(Stack),
  yeccgoto_anno_expressions(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_147_(Stack),
+ NewStack = yeccpars2_149_(Stack),
  yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_148: see yeccpars2_108
+%% yeccpars2_150: see yeccpars2_108
 
-yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_149_(Stack),
+ NewStack = yeccpars2_151_(Stack),
  yeccgoto_anno_expressions(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_150_(Stack),
+ NewStack = yeccpars2_152_(Stack),
  yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_151(S, 'of', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 152, Ss, Stack, T, Ts, Tzr).
+yeccpars2_153(S, 'of', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 154, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_152: see yeccpars2_139
+%% yeccpars2_154: see yeccpars2_140
 
-yeccpars2_153(S, '->', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 159, Ss, Stack, T, Ts, Tzr).
+yeccpars2_155(S, '->', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 161, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_154_(Stack),
+yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_156_(Stack),
  yeccgoto_let_vars(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_155(S, '(', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_157(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 105, Ss, Stack, T, Ts, Tzr);
-yeccpars2_155(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 157, Ss, Stack, T, Ts, Tzr);
-yeccpars2_155(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_157(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 159, Ss, Stack, T, Ts, Tzr);
+yeccpars2_157(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_156(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 158, Ss, Stack, T, Ts, Tzr).
+yeccpars2_158(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 160, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_159(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_157_(Stack),
+ NewStack = yeccpars2_159_(Stack),
  yeccgoto_let_vars(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_158_(Stack),
+ NewStack = yeccpars2_160_(Stack),
  yeccgoto_let_vars(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_159: see yeccpars2_108
+%% yeccpars2_161: see yeccpars2_108
 
-yeccpars2_160(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 161, Ss, Stack, T, Ts, Tzr).
+yeccpars2_162(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 163, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_161: see yeccpars2_139
+%% yeccpars2_163: see yeccpars2_140
 
-yeccpars2_162(S, '->', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 163, Ss, Stack, T, Ts, Tzr).
+yeccpars2_164(S, '->', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 165, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_163: see yeccpars2_108
+%% yeccpars2_165: see yeccpars2_108
 
-yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_164_(Stack),
+ NewStack = yeccpars2_166_(Stack),
  yeccgoto_try_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_other_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_166_(Stack),
- yeccgoto_receive_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ NewStack = yeccpars2_168_(Stack),
+ yeccgoto_search_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_anno_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_other_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_169(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 240, Ss, Stack, T, Ts, Tzr).
+yeccpars2_171(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 242, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_anno_clause(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_other_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_other_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_atomic_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_174(S, '=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 191, Ss, Stack, T, Ts, Tzr);
-yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_176(S, '=', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
+yeccpars2_176(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_anno_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_175_(Stack),
- yeccgoto_clause_pattern(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
-
-yeccpars2_176(S, 'after', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_177(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 179, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, atom, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, char, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, float, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 33, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, integer, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 34, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, string, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 35, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
 yeccpars2_177(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_177_(Stack),
- yeccgoto_anno_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_clause_pattern(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_178(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 222, Ss, Stack, T, Ts, Tzr).
+yeccpars2_178(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 184, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_179(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
 yeccpars2_179(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
 yeccpars2_179(S, '<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
 yeccpars2_179(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
 yeccpars2_179(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, char, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, float, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 33, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, integer, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 34, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, string, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 35, Ss, Stack, T, Ts, Tzr);
 yeccpars2_179(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
 yeccpars2_179(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_179(S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_179_(Stack),
+ yeccgoto_anno_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_180(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
-yeccpars2_180(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr);
-yeccpars2_180(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 215, Ss, Stack, T, Ts, Tzr);
-yeccpars2_180(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
-yeccpars2_180(S, atom, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
-yeccpars2_180(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
 yeccpars2_180(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_180(S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 224, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_181(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
 yeccpars2_181(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
+yeccpars2_181(S, '<', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
 yeccpars2_181(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
-yeccpars2_181(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
 yeccpars2_181(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
 yeccpars2_181(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
 yeccpars2_181(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
 yeccpars2_181(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_182: see yeccpars2_108
+yeccpars2_182(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
+yeccpars2_182(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
+yeccpars2_182(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 217, Ss, Stack, T, Ts, Tzr);
+yeccpars2_182(S, '[', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_182(S, atom, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
+yeccpars2_182(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
+yeccpars2_182(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
+yeccpars2_182(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_183(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
 yeccpars2_183(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
 yeccpars2_183(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_183(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr);
 yeccpars2_183(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
 yeccpars2_183(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
 yeccpars2_183(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_183(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
 yeccpars2_183(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_184(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr).
+%% yeccpars2_184: see yeccpars2_108
 
-yeccpars2_185(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
-yeccpars2_185(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_185_(Stack),
+yeccpars2_185(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
+yeccpars2_185(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
+yeccpars2_185(S, '[', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_185(S, atom, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
+yeccpars2_185(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
+yeccpars2_185(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
+yeccpars2_185(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_185(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_186(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 203, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_187(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr);
+yeccpars2_187(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_187_(Stack),
  yeccgoto_anno_patterns(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_186(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
-yeccpars2_186(S, '(', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_188(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
+yeccpars2_188(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 105, Ss, Stack, T, Ts, Tzr);
-yeccpars2_186(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
-yeccpars2_186(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_188(S, '[', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_188(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
-yeccpars2_186(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_188(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_186(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_186(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_188(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
+yeccpars2_188(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_187(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_189(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_187_(Stack),
+ NewStack = yeccpars2_189_(Stack),
  yeccgoto_tuple_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_188(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
-yeccpars2_188(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_190(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 198, Ss, Stack, T, Ts, Tzr);
+yeccpars2_190(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_anno_variable(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_189(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr).
+yeccpars2_191(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_190(S, '=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 191, Ss, Stack, T, Ts, Tzr).
+yeccpars2_192(S, '=', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_191(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
-yeccpars2_191(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr);
-yeccpars2_191(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
-yeccpars2_191(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_193(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
+yeccpars2_193(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
+yeccpars2_193(S, '[', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_193(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
-yeccpars2_191(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_193(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_191(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_193(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
+yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_192(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_194(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_192_(Stack),
+ NewStack = yeccpars2_194_(Stack),
  yeccgoto_other_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_193: see yeccpars2_63
+%% yeccpars2_195: see yeccpars2_63
 
-yeccpars2_194(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr).
+yeccpars2_196(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_195(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_195_(Stack),
+ NewStack = yeccpars2_197_(Stack),
  yeccgoto_anno_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_196: see yeccpars2_63
+%% yeccpars2_198: see yeccpars2_63
 
-yeccpars2_197(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 198, Ss, Stack, T, Ts, Tzr).
+yeccpars2_199(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 200, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_198(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_200(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_198_(Stack),
+ NewStack = yeccpars2_200_(Stack),
  yeccgoto_anno_variable(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_199: see yeccpars2_191
+%% yeccpars2_201: see yeccpars2_193
 
-yeccpars2_200(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_200_(Stack),
+ NewStack = yeccpars2_202_(Stack),
  yeccgoto_anno_patterns(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_201(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_203(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_201_(Stack),
+ NewStack = yeccpars2_203_(Stack),
  yeccgoto_tuple_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_202(S, '->', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 203, Ss, Stack, T, Ts, Tzr).
+yeccpars2_204(S, '->', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 205, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_203: see yeccpars2_108
+%% yeccpars2_205: see yeccpars2_108
 
-yeccpars2_204(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_206(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_204_(Stack),
+ NewStack = yeccpars2_206_(Stack),
  yeccgoto_timeout(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_205(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 207, Ss, Stack, T, Ts, Tzr);
-yeccpars2_205(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 208, Ss, Stack, T, Ts, Tzr);
-yeccpars2_205(S, '|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 209, Ss, Stack, T, Ts, Tzr).
+yeccpars2_207(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 209, Ss, Stack, T, Ts, Tzr);
+yeccpars2_207(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 210, Ss, Stack, T, Ts, Tzr);
+yeccpars2_207(S, '|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 211, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_206(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_208(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_206_(Stack),
+ NewStack = yeccpars2_208_(Stack),
  yeccgoto_cons_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_207: see yeccpars2_191
+%% yeccpars2_209: see yeccpars2_193
 
-yeccpars2_208(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_208_(Stack),
+yeccpars2_210(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_210_(Stack),
  yeccgoto_tail_pattern(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_209: see yeccpars2_191
-
-yeccpars2_210(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 211, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_211(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_|Nss] = Ss,
- NewStack = yeccpars2_211_(Stack),
- yeccgoto_tail_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+%% yeccpars2_211: see yeccpars2_193
 
-%% yeccpars2_212: see yeccpars2_205
+yeccpars2_212(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 213, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_213(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
  NewStack = yeccpars2_213_(Stack),
  yeccgoto_tail_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_214(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr).
+%% yeccpars2_214: see yeccpars2_207
 
 yeccpars2_215(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_|Nss] = Ss,
+ [_,_|Nss] = Ss,
  NewStack = yeccpars2_215_(Stack),
- yeccgoto_clause_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ yeccgoto_tail_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_216(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_216(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_217(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_|Nss] = Ss,
+ NewStack = yeccpars2_217_(Stack),
+ yeccgoto_clause_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+
+yeccpars2_218(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_216_(Stack),
+ NewStack = yeccpars2_218_(Stack),
  yeccgoto_clause_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_217(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_217(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_219(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_219(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_anno_pattern(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_218(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 219, Ss, Stack, T, Ts, Tzr).
+yeccpars2_220(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 221, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_219: see yeccpars2_63
+%% yeccpars2_221: see yeccpars2_63
 
-yeccpars2_220(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 221, Ss, Stack, T, Ts, Tzr).
+yeccpars2_222(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 223, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_221(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_223(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_221_(Stack),
+ NewStack = yeccpars2_223_(Stack),
  yeccgoto_anno_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_222(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 225, Ss, Stack, T, Ts, Tzr);
-yeccpars2_222(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 226, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_223(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 236, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_224(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 234, Ss, Stack, T, Ts, Tzr);
-yeccpars2_224(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_224_(Stack),
+yeccpars2_224(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 227, Ss, Stack, T, Ts, Tzr);
+yeccpars2_224(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 228, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_225(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 238, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_226(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 236, Ss, Stack, T, Ts, Tzr);
+yeccpars2_226(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_226_(Stack),
  yeccgoto_segment_patterns(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_225(S, '<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 228, Ss, Stack, T, Ts, Tzr).
+yeccpars2_227(S, '<', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 230, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_226(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 227, Ss, Stack, T, Ts, Tzr).
+yeccpars2_228(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 229, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_227(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_229(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_227_(Stack),
+ NewStack = yeccpars2_229_(Stack),
  yeccgoto_binary_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_228: see yeccpars2_191
+%% yeccpars2_230: see yeccpars2_193
 
-yeccpars2_229(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 230, Ss, Stack, T, Ts, Tzr).
+yeccpars2_231(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 232, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_230(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 231, Ss, Stack, T, Ts, Tzr).
+yeccpars2_232(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 233, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_231: see yeccpars2_191
+%% yeccpars2_233: see yeccpars2_193
 
-yeccpars2_232(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 233, Ss, Stack, T, Ts, Tzr).
+yeccpars2_234(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 235, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_233(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_235(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_233_(Stack),
+ NewStack = yeccpars2_235_(Stack),
  yeccgoto_segment_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_234(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 225, Ss, Stack, T, Ts, Tzr).
+yeccpars2_236(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 227, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_235(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_237(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_235_(Stack),
+ NewStack = yeccpars2_237_(Stack),
  yeccgoto_segment_patterns(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_236(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 237, Ss, Stack, T, Ts, Tzr).
+yeccpars2_238(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 239, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_237(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_237_(Stack),
+ NewStack = yeccpars2_239_(Stack),
  yeccgoto_binary_pattern(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_238(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_240(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_238_(Stack),
+ NewStack = yeccpars2_240_(Stack),
  yeccgoto_anno_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_241(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_239_(Stack),
- yeccgoto_receive_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ NewStack = yeccpars2_241_(Stack),
+ yeccgoto_search_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_240: see yeccpars2_108
+%% yeccpars2_242: see yeccpars2_108
 
-yeccpars2_241(S, '->', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 242, Ss, Stack, T, Ts, Tzr).
+yeccpars2_243(S, '->', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 244, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_242: see yeccpars2_108
+%% yeccpars2_244: see yeccpars2_108
 
-yeccpars2_243(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_245(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_243_(Stack),
+ NewStack = yeccpars2_245_(Stack),
  yeccgoto_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_244(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 246, Ss, Stack, T, Ts, Tzr).
+yeccpars2_246(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_|Nss] = Ss,
+ NewStack = yeccpars2_246_(Stack),
+ yeccgoto_receive_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+
+%% yeccpars2_247: see yeccpars2_178
 
-yeccpars2_245(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_248(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_245_(Stack),
+ NewStack = yeccpars2_248_(Stack),
+ yeccgoto_receive_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+
+yeccpars2_249(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 251, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_250(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_,_|Nss] = Ss,
+ NewStack = yeccpars2_250_(Stack),
  yeccgoto_primop_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_246(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 248, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, char, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_251(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr);
+yeccpars2_251(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 253, Ss, Stack, T, Ts, Tzr);
+yeccpars2_251(S, char, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 32, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, float, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_251(S, float, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 33, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_251(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 100, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, integer, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_251(S, integer, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 34, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, string, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_251(S, string, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 35, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_251(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_251(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_108(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_247(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 249, Ss, Stack, T, Ts, Tzr).
+yeccpars2_252(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 254, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_248(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_253(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_248_(Stack),
+ NewStack = yeccpars2_253_(Stack),
  yeccgoto_arg_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_249(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_254(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_249_(Stack),
+ NewStack = yeccpars2_254_(Stack),
  yeccgoto_arg_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_250(S, in, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 251, Ss, Stack, T, Ts, Tzr).
+yeccpars2_255(S, in, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 256, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_251: see yeccpars2_108
+%% yeccpars2_256: see yeccpars2_108
 
-yeccpars2_252(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_257(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_252_(Stack),
+ NewStack = yeccpars2_257_(Stack),
  yeccgoto_letrec_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_253(S, '=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 254, Ss, Stack, T, Ts, Tzr).
+yeccpars2_258(S, '=', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 259, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_254: see yeccpars2_108
+%% yeccpars2_259: see yeccpars2_108
 
-yeccpars2_255(S, in, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 256, Ss, Stack, T, Ts, Tzr).
+yeccpars2_260(S, in, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 261, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_256: see yeccpars2_108
+%% yeccpars2_261: see yeccpars2_108
 
-yeccpars2_257(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_262(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_257_(Stack),
+ NewStack = yeccpars2_262_(Stack),
  yeccgoto_let_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_258: see yeccpars2_108
+%% yeccpars2_263: see yeccpars2_108
 
-yeccpars2_259(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_264(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_259_(Stack),
+ NewStack = yeccpars2_264_(Stack),
  yeccgoto_sequence(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_260(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_265(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_260_(Stack),
+ NewStack = yeccpars2_265_(Stack),
  yeccgoto_catch_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_261(S, 'of', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 262, Ss, Stack, T, Ts, Tzr).
+yeccpars2_266(S, 'of', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 267, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_262(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
-yeccpars2_262(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 179, Ss, Stack, T, Ts, Tzr);
-yeccpars2_262(S, '<', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_267(S, '#', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_262(S, '[', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_267(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
-yeccpars2_262(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_267(S, '<', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
+yeccpars2_267(S, '[', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_267(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 31, Ss, Stack, T, Ts, Tzr);
-yeccpars2_262(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_267(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr);
-yeccpars2_262(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_262(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_267(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
+yeccpars2_267(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_24(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_263(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 264, Ss, Stack, T, Ts, Tzr).
+yeccpars2_268(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 269, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_264(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_264_(Stack),
+ NewStack = yeccpars2_269_(Stack),
  yeccgoto_case_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_265(S, ':', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 266, Ss, Stack, T, Ts, Tzr).
+yeccpars2_270(S, ':', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 271, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_266: see yeccpars2_108
+%% yeccpars2_271: see yeccpars2_108
 
-%% yeccpars2_267: see yeccpars2_244
+%% yeccpars2_272: see yeccpars2_249
 
-yeccpars2_268(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_273(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_268_(Stack),
+ NewStack = yeccpars2_273_(Stack),
  yeccgoto_call_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_269: see yeccpars2_244
+%% yeccpars2_274: see yeccpars2_249
 
-yeccpars2_270(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_275(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_270_(Stack),
+ NewStack = yeccpars2_275_(Stack),
  yeccgoto_application_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_271(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 273, Ss, Stack, T, Ts, Tzr);
-yeccpars2_271(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 274, Ss, Stack, T, Ts, Tzr);
-yeccpars2_271(S, '|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 275, Ss, Stack, T, Ts, Tzr).
+yeccpars2_276(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 278, Ss, Stack, T, Ts, Tzr);
+yeccpars2_276(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 279, Ss, Stack, T, Ts, Tzr);
+yeccpars2_276(S, '|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 280, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_272(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_272_(Stack),
+ NewStack = yeccpars2_277_(Stack),
  yeccgoto_cons(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_273: see yeccpars2_108
+%% yeccpars2_278: see yeccpars2_108
 
-yeccpars2_274(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_274_(Stack),
+yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_279_(Stack),
  yeccgoto_tail(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_275: see yeccpars2_108
+%% yeccpars2_280: see yeccpars2_108
 
-yeccpars2_276(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 277, Ss, Stack, T, Ts, Tzr).
+yeccpars2_281(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 282, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_282(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_277_(Stack),
+ NewStack = yeccpars2_282_(Stack),
  yeccgoto_tail(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_278: see yeccpars2_271
+%% yeccpars2_283: see yeccpars2_276
 
-yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_279_(Stack),
+ NewStack = yeccpars2_284_(Stack),
  yeccgoto_tail(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_280(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 282, Ss, Stack, T, Ts, Tzr).
+yeccpars2_285(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 287, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_281(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_281_(Stack),
+ NewStack = yeccpars2_286_(Stack),
  yeccgoto_expression(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_282(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_287(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_282_(Stack),
+ NewStack = yeccpars2_287_(Stack),
  yeccgoto_expression(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_283(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 284, Ss, Stack, T, Ts, Tzr).
+yeccpars2_288(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 289, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_284: see yeccpars2_63
+%% yeccpars2_289: see yeccpars2_63
 
-yeccpars2_285(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 286, Ss, Stack, T, Ts, Tzr).
+yeccpars2_290(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 291, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_291(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_286_(Stack),
+ NewStack = yeccpars2_291_(Stack),
  yeccgoto_anno_expression(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_287(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 290, Ss, Stack, T, Ts, Tzr);
-yeccpars2_287(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 291, Ss, Stack, T, Ts, Tzr).
+yeccpars2_292(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 295, Ss, Stack, T, Ts, Tzr);
+yeccpars2_292(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 296, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_288(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 301, Ss, Stack, T, Ts, Tzr).
+yeccpars2_293(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 306, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_289(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 299, Ss, Stack, T, Ts, Tzr);
-yeccpars2_289(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_289_(Stack),
+yeccpars2_294(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 304, Ss, Stack, T, Ts, Tzr);
+yeccpars2_294(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_294_(Stack),
  yeccgoto_segments(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_290(S, '<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 293, Ss, Stack, T, Ts, Tzr).
+yeccpars2_295(S, '<', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 298, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_291(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 292, Ss, Stack, T, Ts, Tzr).
+yeccpars2_296(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_292(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_297(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_292_(Stack),
+ NewStack = yeccpars2_297_(Stack),
  yeccgoto_binary(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_293: see yeccpars2_108
+%% yeccpars2_298: see yeccpars2_108
 
-yeccpars2_294(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 295, Ss, Stack, T, Ts, Tzr).
+yeccpars2_299(S, '>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 300, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_295(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 296, Ss, Stack, T, Ts, Tzr).
+yeccpars2_300(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 301, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_296: see yeccpars2_108
+%% yeccpars2_301: see yeccpars2_108
 
-yeccpars2_297(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 298, Ss, Stack, T, Ts, Tzr).
+yeccpars2_302(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 303, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_298(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_303(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_298_(Stack),
+ NewStack = yeccpars2_303_(Stack),
  yeccgoto_segment(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_299(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 290, Ss, Stack, T, Ts, Tzr).
+yeccpars2_304(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 295, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_300(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_305(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_300_(Stack),
+ NewStack = yeccpars2_305_(Stack),
  yeccgoto_segments(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_301(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 302, Ss, Stack, T, Ts, Tzr).
+yeccpars2_306(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 307, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_302(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_307(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_302_(Stack),
+ NewStack = yeccpars2_307_(Stack),
  yeccgoto_binary(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_303(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr).
+yeccpars2_308(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 198, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_304(S, '(', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_309(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 105, Ss, Stack, T, Ts, Tzr);
-yeccpars2_304(S, var, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_309(S, var, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_305(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_310(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_305_(Stack),
+ NewStack = yeccpars2_310_(Stack),
  yeccgoto_anno_variables(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_306(S, '->', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 307, Ss, Stack, T, Ts, Tzr).
+yeccpars2_311(S, '->', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 312, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_307: see yeccpars2_108
+%% yeccpars2_312: see yeccpars2_108
 
-yeccpars2_308(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_313(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_308_(Stack),
+ NewStack = yeccpars2_313_(Stack),
  yeccgoto_fun_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_309(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 310, Ss, Stack, T, Ts, Tzr).
+yeccpars2_314(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 315, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_310: see yeccpars2_63
+%% yeccpars2_315: see yeccpars2_63
 
-yeccpars2_311(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 312, Ss, Stack, T, Ts, Tzr).
+yeccpars2_316(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 317, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_312(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_317(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_312_(Stack),
+ NewStack = yeccpars2_317_(Stack),
  yeccgoto_anno_fun(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_313(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_313_(Stack),
+ NewStack = yeccpars2_318_(Stack),
  yeccgoto_function_definitions(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_314(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_319(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_314_(Stack),
+ NewStack = yeccpars2_319_(Stack),
  yeccgoto_module_definition(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_315(S, atom, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 316, Ss, Stack, T, Ts, Tzr).
+yeccpars2_320(S, atom, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 321, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_316: see yeccpars2_4
+%% yeccpars2_321: see yeccpars2_4
 
-%% yeccpars2_317: see yeccpars2_5
+%% yeccpars2_322: see yeccpars2_5
 
-yeccpars2_318(S, '(', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_323(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr);
-yeccpars2_318(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_323(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_318_(Stack),
- yeccpars2_58(_S, Cat, [318 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_323(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_323_(Stack),
+ yeccpars2_58(_S, Cat, [323 | Ss], NewStack, T, Ts, Tzr).
 
-yeccpars2_319(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 320, Ss, Stack, T, Ts, Tzr).
+yeccpars2_324(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 325, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_320(S, '-|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 321, Ss, Stack, T, Ts, Tzr).
+yeccpars2_325(S, '-|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 326, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_321: see yeccpars2_63
+%% yeccpars2_326: see yeccpars2_63
 
-yeccpars2_322(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 323, Ss, Stack, T, Ts, Tzr).
+yeccpars2_327(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 328, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_323(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_323_(Stack),
+ NewStack = yeccpars2_328_(Stack),
  yeccgoto_module_definition(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccgoto_anno_clause(142, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_177(177, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_clause(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_177(177, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_clause(262, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_177(177, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_anno_clauses(142, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_clauses(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_238(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_clauses(262, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_anno_clause(143, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_179(179, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_clause(144, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_179(179, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_clause(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_179(179, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_clause(267, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_179(179, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_anno_clauses(143, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_178(247, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_clauses(144, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_178(178, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_clauses(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_240(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_clauses(267, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_268(268, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_anno_expression(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(131, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_129(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_expression(132, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_271(271, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_expression(133, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_244(269, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(135, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_276(276, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(134, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_249(274, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_expression(136, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_261(261, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_260(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(138, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_108(258, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(141, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_244(244, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(143, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_151(151, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(144, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(148, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(159, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(182, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_202(202, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_204(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(240, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_243(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(246, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_252(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(254, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_255(255, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_270(270, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(137, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_266(266, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_265(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(139, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_108(263, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(142, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_249(249, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(145, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(146, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(150, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(161, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(184, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_204(204, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_206(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(242, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_243(243, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_245(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(251, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_expression(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_257(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_259(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(266, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_244(267, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(273, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_271(278, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(275, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_276(276, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(293, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(296, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expression(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_308(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_anno_expressions(131, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_280(280, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expressions(144, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_145(145, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expressions(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expressions(246, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_247(247, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_expressions(296, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_297(297, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_anno_expression(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_260(260, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_262(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_264(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(271, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_249(272, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_276(283, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(280, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_281(281, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(298, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_299(299, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(301, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expression(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_313(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_anno_expressions(132, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expressions(146, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expressions(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expressions(251, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_252(252, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_expressions(301, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_302(302, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_anno_fun(96=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_98(_S, Cat, Ss, Stack, T, Ts, Tzr).
@@ -2413,177 +2446,181 @@ yeccgoto_anno_function_name(17, Cat, Ss,
  yeccpars2_60(60, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_function_name(59, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_60(60, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_function_name(140, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_anno_function_name(141, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_60(60, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_function_name(318, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_anno_function_name(323, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_60(60, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_anno_pattern(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_177(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_177(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_pattern(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(180, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_185(185, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(181, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_205(205, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_177(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_177(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_187(187, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_pattern(183, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_185(185, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_192(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(199, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_185(185, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_205(212, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_207(207, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(185, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_187(187, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_194(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_187(187, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_pattern(209, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_210(210, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(228, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_229(229, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(231, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_185(185, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_pattern(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_anno_patterns(180, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_214(214, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_patterns(183, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_184(184, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_patterns(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_200(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_patterns(231, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_232(232, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_207(214, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(211, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_212(212, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(230, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_231(231, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_187(187, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_pattern(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_177(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_anno_patterns(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_216(216, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_patterns(185, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_186(186, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_patterns(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_patterns(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_234(234, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_anno_variable(101, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_104(104, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(142, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(152=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(155, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_anno_variable(140=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(143, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(144, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(154=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(157, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_104(104, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_variable(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(180, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_variable(181, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_variable(183, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_190(190, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(191, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(199, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(185, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(188, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(193, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_anno_variable(209, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(228, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(231, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(262, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variable(304, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(211, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(230, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(267, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_176(176, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variable(309, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_104(104, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_anno_variables(101, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_103(103, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variables(155, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_anno_variables(304=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_305(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_anno_variables(157, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_anno_variables(309=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_310(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_annotation(63, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_64(64, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_annotation(193, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_194(194, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_annotation(196, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_197(197, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_annotation(219, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_220(220, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_annotation(284, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_annotation(310, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_311(311, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_annotation(321, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_322(322, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_annotation(195, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_annotation(198, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_199(199, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_annotation(221, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_222(222, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_annotation(289, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_290(290, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_annotation(315, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_316(316, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_annotation(326, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_327(327, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_application_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_application_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_application_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_application_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_arg_list(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_245(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_arg_list(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_268(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_arg_list(269=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_270(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_arg_list(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_250(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_arg_list(272=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_273(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_arg_list(274=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_275(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_atomic_constant(65=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_71(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -2611,122 +2648,126 @@ yeccgoto_atomic_literal(46=_S, Cat, Ss, 
 yeccgoto_atomic_literal(48=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(188=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_literal(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_literal(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_literal(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_atomic_pattern(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_pattern(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_pattern(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_pattern(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(188=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic_pattern(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic_pattern(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic_pattern(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_attribute(19, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_21(21, Cat, Ss, Stack, T, Ts, Tzr);
@@ -2739,357 +2780,363 @@ yeccgoto_attribute_list(53=_S, Cat, Ss, 
  yeccpars2_54(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_binary(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_binary_pattern(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(188=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_pattern(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_call_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_call_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_binary_pattern(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_pattern(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_call_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_call_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_case_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_catch_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_catch_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_clause(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_220(220, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_clause_pattern(143, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_pattern(144, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_pattern(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_pattern(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_pattern(267, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_cons(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_catch_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_cons(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_clause(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_218(218, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_clause_pattern(142, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_pattern(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_pattern(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_pattern(262, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_cons(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
 yeccgoto_cons_constant(65=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_70(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_cons_constant(72=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -3116,34 +3163,36 @@ yeccgoto_cons_literal(46=_S, Cat, Ss, St
 yeccgoto_cons_literal(48=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_28(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_cons_pattern(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_cons_pattern(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_cons_pattern(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_cons_pattern(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(188=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_cons_pattern(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cons_pattern(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cons_pattern(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_constant(65, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_69(69, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3176,353 +3225,353 @@ yeccgoto_exported_names(14=_S, Cat, Ss, 
  yeccpars2_15(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_expression(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(131, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_288(288, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expression(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_fun_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(99, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_314(314, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(130, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expression(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_fun_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_fun_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(99, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_309(309, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_definition(17, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_definition(59, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_definition(141, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_definition(323, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_function_definitions(17=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_58(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_definitions(59=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_definitions(141, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_255(255, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_definitions(323=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_58(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_function_name(6=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_7(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_name(14=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_7(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_name(17=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_name(59=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_name(61, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_62(62, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_name(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_name(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_name(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_function_definition(17, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_definition(59, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_definition(140, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_definition(318, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_59(59, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_function_definitions(17=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_58(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_definitions(59=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_313(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_definitions(140, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_250(250, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_definitions(318=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_58(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_function_name(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_name(323=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_function_name(6=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_7(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(14=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_7(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(17=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(59=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(61, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_62(62, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(140=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_name(318=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_let_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_let_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_let_vars(140, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_let_vars(154, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_let_vars(163, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_letrec_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_letrec_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_let_vars(139, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_253(253, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_vars(152, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_let_vars(161, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_letrec_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_letrec_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
 yeccgoto_literal(24=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_27(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_literal(30, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -3543,21 +3592,21 @@ yeccgoto_literals(40=_S, Cat, Ss, Stack,
 
 yeccgoto_module_attribute(5, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_17(17, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_module_attribute(317, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_318(318, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_module_attribute(322, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_323(323, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_module_definition(0, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_module_defs(17, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_56(56, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_module_defs(318, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_319(319, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_module_defs(323, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_324(324, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_module_export(4, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_5(5, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_module_export(316, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_5(317, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_module_export(321, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_5(322, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_nil(24=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3585,15 +3634,13 @@ yeccgoto_nil(92=_S, Cat, Ss, Stack, T, T
  yeccpars2_67(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3601,7 +3648,7 @@ yeccgoto_nil(137=_S, Cat, Ss, Stack, T, 
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3609,17 +3656,17 @@ yeccgoto_nil(143=_S, Cat, Ss, Stack, T, 
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3627,233 +3674,298 @@ yeccgoto_nil(182=_S, Cat, Ss, Stack, T, 
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_nil(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(188=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_nil(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_nil(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_nil(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_nil(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_nil(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_other_pattern(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_217(217, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_219(219, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_other_pattern(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_189(189, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(188, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_191(191, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_other_pattern(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_other_pattern(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_other_pattern(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_primop_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_primop_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_receive_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_primop_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_receive_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(137=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_segment(287, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_289(289, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_segment(299, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_289(289, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_segment_pattern(222, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_224(224, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_segment_pattern(234, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_224(224, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_segment_patterns(222, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_223(223, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_segment_patterns(234=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_235(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_segment(292, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_segment(304, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_segments(287, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_288(288, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_segments(299=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_300(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_segment_pattern(224, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_226(226, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_segment_pattern(236, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_226(226, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_segment_patterns(224, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_225(225, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_segment_patterns(236=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_237(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_segments(292, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_293(293, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_segments(304=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_305(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_sequence(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3861,60 +3973,60 @@ yeccgoto_sequence(137=_S, Cat, Ss, Stack
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_sequence(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_sequence(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_sequence(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_sequence(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_sequence(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_single_expression(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3922,53 +4034,55 @@ yeccgoto_single_expression(137=_S, Cat, 
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_single_expression(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_single_expression(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_single_expression(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_single_expression(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_single_expression(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_tail(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_272(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tail(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_tail(276=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tail(283=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_tail_constant(83=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -3980,27 +4094,29 @@ yeccgoto_tail_literal(43=_S, Cat, Ss, St
 yeccgoto_tail_literal(51=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_52(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_tail_pattern(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_206(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tail_pattern(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_213(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_timeout(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_timeout(176=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_tail_pattern(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_208(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tail_pattern(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_215(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_timeout(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_246(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_timeout(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_timeout(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_241(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_timeout(247=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_248(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_try_expr(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -4008,60 +4124,60 @@ yeccgoto_try_expr(137=_S, Cat, Ss, Stack
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_tuple(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -4069,47 +4185,49 @@ yeccgoto_tuple(137=_S, Cat, Ss, Stack, T
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_tuple_constant(65=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -4138,50 +4256,50 @@ yeccgoto_tuple_literal(46=_S, Cat, Ss, S
 yeccgoto_tuple_literal(48=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_tuple_pattern(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple_pattern(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple_pattern(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple_pattern(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(188=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple_pattern(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple_pattern(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple_pattern(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_variable(101=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(105, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_303(303, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_308(308, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(108=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(130=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(131=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(132=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(133=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(135=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(134=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(136=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -4190,88 +4308,92 @@ yeccgoto_variable(137=_S, Cat, Ss, Stack
 yeccgoto_variable(138=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(139=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(141=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(140=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(142=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(143=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(144=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(145=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(146=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(152=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(150=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(154=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(155=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(157=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(159=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(161=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(163=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(165=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_188(188, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_190(190, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(184=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(185=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_188(188, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(188, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_190(190, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(205=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(228=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(211=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(230=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(240=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(242=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(246=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(244=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(254=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_variable(256=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(258=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(262=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(263=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_variable(267=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(275=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(293=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(298=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(296=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(304=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(309=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_102(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_variable(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_variable(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 -compile({inline,{yeccpars2_9_,1}}).
--file("core_parse.yrl", 89).
+-file("core_parse.yrl", 90).
 yeccpars2_9_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4279,7 +4401,7 @@ yeccpars2_9_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_10_,1}}).
--file("core_parse.yrl", 85).
+-file("core_parse.yrl", 86).
 yeccpars2_10_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4287,7 +4409,7 @@ yeccpars2_10_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_13_,1}}).
--file("core_parse.yrl", 288).
+-file("core_parse.yrl", 290).
 yeccpars2_13_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4295,7 +4417,7 @@ yeccpars2_13_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_15_,1}}).
--file("core_parse.yrl", 88).
+-file("core_parse.yrl", 89).
 yeccpars2_15_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4303,7 +4425,7 @@ yeccpars2_15_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_16_,1}}).
--file("core_parse.yrl", 86).
+-file("core_parse.yrl", 87).
 yeccpars2_16_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4311,14 +4433,14 @@ yeccpars2_16_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_17_,1}}).
--file("core_parse.yrl", 110).
+-file("core_parse.yrl", 111).
 yeccpars2_17_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
 -compile({inline,{yeccpars2_21_,1}}).
--file("core_parse.yrl", 97).
+-file("core_parse.yrl", 98).
 yeccpars2_21_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4326,7 +4448,7 @@ yeccpars2_21_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_22_,1}}).
--file("core_parse.yrl", 93).
+-file("core_parse.yrl", 94).
 yeccpars2_22_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4334,7 +4456,7 @@ yeccpars2_22_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_26_,1}}).
--file("core_parse.yrl", 252).
+-file("core_parse.yrl", 254).
 yeccpars2_26_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4342,7 +4464,7 @@ yeccpars2_26_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_27_,1}}).
--file("core_parse.yrl", 100).
+-file("core_parse.yrl", 101).
 yeccpars2_27_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4350,7 +4472,7 @@ yeccpars2_27_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_31_,1}}).
--file("core_parse.yrl", 250).
+-file("core_parse.yrl", 252).
 yeccpars2_31_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4358,7 +4480,7 @@ yeccpars2_31_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_32_,1}}).
--file("core_parse.yrl", 247).
+-file("core_parse.yrl", 249).
 yeccpars2_32_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4366,7 +4488,7 @@ yeccpars2_32_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_33_,1}}).
--file("core_parse.yrl", 249).
+-file("core_parse.yrl", 251).
 yeccpars2_33_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4374,7 +4496,7 @@ yeccpars2_33_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_34_,1}}).
--file("core_parse.yrl", 248).
+-file("core_parse.yrl", 250).
 yeccpars2_34_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4382,7 +4504,7 @@ yeccpars2_34_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_35_,1}}).
--file("core_parse.yrl", 251).
+-file("core_parse.yrl", 253).
 yeccpars2_35_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4390,7 +4512,7 @@ yeccpars2_35_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_38_,1}}).
--file("core_parse.yrl", 245).
+-file("core_parse.yrl", 247).
 yeccpars2_38_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4398,7 +4520,7 @@ yeccpars2_38_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_39_,1}}).
--file("core_parse.yrl", 254).
+-file("core_parse.yrl", 256).
 yeccpars2_39_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4406,7 +4528,7 @@ yeccpars2_39_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_41_,1}}).
--file("core_parse.yrl", 244).
+-file("core_parse.yrl", 246).
 yeccpars2_41_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4414,7 +4536,7 @@ yeccpars2_41_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_42_,1}}).
--file("core_parse.yrl", 255).
+-file("core_parse.yrl", 257).
 yeccpars2_42_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4422,7 +4544,7 @@ yeccpars2_42_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_44_,1}}).
--file("core_parse.yrl", 66).
+-file("core_parse.yrl", 67).
 yeccpars2_44_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4430,7 +4552,7 @@ yeccpars2_44_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_45_,1}}).
--file("core_parse.yrl", 257).
+-file("core_parse.yrl", 259).
 yeccpars2_45_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4438,7 +4560,7 @@ yeccpars2_45_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_47_,1}}).
--file("core_parse.yrl", 259).
+-file("core_parse.yrl", 261).
 yeccpars2_47_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4446,7 +4568,7 @@ yeccpars2_47_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_50_,1}}).
--file("core_parse.yrl", 260).
+-file("core_parse.yrl", 262).
 yeccpars2_50_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4454,7 +4576,7 @@ yeccpars2_50_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_52_,1}}).
--file("core_parse.yrl", 261).
+-file("core_parse.yrl", 263).
 yeccpars2_52_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4462,7 +4584,7 @@ yeccpars2_52_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_54_,1}}).
--file("core_parse.yrl", 96).
+-file("core_parse.yrl", 97).
 yeccpars2_54_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4470,7 +4592,7 @@ yeccpars2_54_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_55_,1}}).
--file("core_parse.yrl", 94).
+-file("core_parse.yrl", 95).
 yeccpars2_55_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4478,14 +4600,14 @@ yeccpars2_55_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_59_,1}}).
--file("core_parse.yrl", 110).
+-file("core_parse.yrl", 111).
 yeccpars2_59_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
 -compile({inline,{yeccpars2_67_,1}}).
--file("core_parse.yrl", 135).
+-file("core_parse.yrl", 136).
 yeccpars2_67_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4493,7 +4615,7 @@ yeccpars2_67_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_69_,1}}).
--file("core_parse.yrl", 128).
+-file("core_parse.yrl", 129).
 yeccpars2_69_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4501,7 +4623,7 @@ yeccpars2_69_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_73_,1}}).
--file("core_parse.yrl", 104).
+-file("core_parse.yrl", 105).
 yeccpars2_73_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4509,7 +4631,7 @@ yeccpars2_73_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_74_,1}}).
--file("core_parse.yrl", 133).
+-file("core_parse.yrl", 134).
 yeccpars2_74_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4517,7 +4639,7 @@ yeccpars2_74_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_75_,1}}).
--file("core_parse.yrl", 130).
+-file("core_parse.yrl", 131).
 yeccpars2_75_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4525,7 +4647,7 @@ yeccpars2_75_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_76_,1}}).
--file("core_parse.yrl", 132).
+-file("core_parse.yrl", 133).
 yeccpars2_76_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4533,7 +4655,7 @@ yeccpars2_76_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_77_,1}}).
--file("core_parse.yrl", 131).
+-file("core_parse.yrl", 132).
 yeccpars2_77_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4541,7 +4663,7 @@ yeccpars2_77_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_78_,1}}).
--file("core_parse.yrl", 134).
+-file("core_parse.yrl", 135).
 yeccpars2_78_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4549,7 +4671,7 @@ yeccpars2_78_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_81_,1}}).
--file("core_parse.yrl", 137).
+-file("core_parse.yrl", 138).
 yeccpars2_81_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4557,7 +4679,7 @@ yeccpars2_81_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_82_,1}}).
--file("core_parse.yrl", 138).
+-file("core_parse.yrl", 139).
 yeccpars2_82_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4565,7 +4687,7 @@ yeccpars2_82_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_84_,1}}).
--file("core_parse.yrl", 140).
+-file("core_parse.yrl", 141).
 yeccpars2_84_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4573,7 +4695,7 @@ yeccpars2_84_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_86_,1}}).
--file("core_parse.yrl", 142).
+-file("core_parse.yrl", 143).
 yeccpars2_86_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4581,7 +4703,7 @@ yeccpars2_86_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_89_,1}}).
--file("core_parse.yrl", 143).
+-file("core_parse.yrl", 144).
 yeccpars2_89_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4589,7 +4711,7 @@ yeccpars2_89_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_91_,1}}).
--file("core_parse.yrl", 144).
+-file("core_parse.yrl", 145).
 yeccpars2_91_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4597,7 +4719,7 @@ yeccpars2_91_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_93_,1}}).
--file("core_parse.yrl", 127).
+-file("core_parse.yrl", 128).
 yeccpars2_93_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4605,7 +4727,7 @@ yeccpars2_93_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_94_,1}}).
--file("core_parse.yrl", 105).
+-file("core_parse.yrl", 106).
 yeccpars2_94_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4613,7 +4735,7 @@ yeccpars2_94_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_95_,1}}).
--file("core_parse.yrl", 292).
+-file("core_parse.yrl", 294).
 yeccpars2_95_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4621,7 +4743,7 @@ yeccpars2_95_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_98_,1}}).
--file("core_parse.yrl", 114).
+-file("core_parse.yrl", 115).
 yeccpars2_98_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -4629,7 +4751,7 @@ yeccpars2_98_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_104_,1}}).
--file("core_parse.yrl", 201).
+-file("core_parse.yrl", 202).
 yeccpars2_104_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -4637,95 +4759,95 @@ yeccpars2_104_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_107_,1}}).
--file("core_parse.yrl", 198).
+-file("core_parse.yrl", 199).
 yeccpars2_107_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    # c_var { name = tok_val ( __1 ) }
   end | __Stack].
 
--compile({inline,{yeccpars2_128_,1}}).
--file("core_parse.yrl", 302).
-yeccpars2_128_(__Stack0) ->
+-compile({inline,{yeccpars2_129_,1}}).
+-file("core_parse.yrl", 304).
+yeccpars2_129_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_fun { vars = [ ] , body = __5 }
   end | __Stack].
 
--compile({inline,{yeccpars2_134_,1}}).
--file("core_parse.yrl", 250).
-yeccpars2_134_(__Stack0) ->
+-compile({inline,{yeccpars2_135_,1}}).
+-file("core_parse.yrl", 252).
+yeccpars2_135_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    # c_literal { val = tok_val ( __1 ) }
   end | __Stack].
 
--compile({inline,{yeccpars2_140_,1}}).
--file("core_parse.yrl", 110).
-yeccpars2_140_(__Stack0) ->
+-compile({inline,{yeccpars2_141_,1}}).
+-file("core_parse.yrl", 111).
+yeccpars2_141_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--compile({inline,{yeccpars2_146_,1}}).
--file("core_parse.yrl", 216).
-yeccpars2_146_(__Stack0) ->
+-compile({inline,{yeccpars2_148_,1}}).
+-file("core_parse.yrl", 217).
+yeccpars2_148_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_147_,1}}).
--file("core_parse.yrl", 263).
-yeccpars2_147_(__Stack0) ->
+-compile({inline,{yeccpars2_149_,1}}).
+-file("core_parse.yrl", 265).
+yeccpars2_149_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    # c_tuple { es = [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_149_,1}}).
--file("core_parse.yrl", 215).
-yeccpars2_149_(__Stack0) ->
+-compile({inline,{yeccpars2_151_,1}}).
+-file("core_parse.yrl", 216).
+yeccpars2_151_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_150_,1}}).
--file("core_parse.yrl", 264).
-yeccpars2_150_(__Stack0) ->
+-compile({inline,{yeccpars2_152_,1}}).
+-file("core_parse.yrl", 266).
+yeccpars2_152_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_tuple { es = __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_154_,1}}).
--file("core_parse.yrl", 294).
-yeccpars2_154_(__Stack0) ->
+-compile({inline,{yeccpars2_156_,1}}).
+-file("core_parse.yrl", 296).
+yeccpars2_156_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_157_,1}}).
--file("core_parse.yrl", 295).
-yeccpars2_157_(__Stack0) ->
+-compile({inline,{yeccpars2_159_,1}}).
+-file("core_parse.yrl", 297).
+yeccpars2_159_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    [ ]
   end | __Stack].
 
--compile({inline,{yeccpars2_158_,1}}).
--file("core_parse.yrl", 296).
-yeccpars2_158_(__Stack0) ->
+-compile({inline,{yeccpars2_160_,1}}).
+-file("core_parse.yrl", 298).
+yeccpars2_160_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_164_,1}}).
--file("core_parse.yrl", 345).
-yeccpars2_164_(__Stack0) ->
+-compile({inline,{yeccpars2_166_,1}}).
+-file("core_parse.yrl", 347).
+yeccpars2_166_(__Stack0) ->
  [__10,__9,__8,__7,__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    Len = length ( __8 ) ,
@@ -4737,170 +4859,170 @@ yeccpars2_164_(__Stack0) ->
     end
   end | __Stack].
 
--compile({inline,{yeccpars2_166_,1}}).
--file("core_parse.yrl", 356).
-yeccpars2_166_(__Stack0) ->
+-compile({inline,{yeccpars2_168_,1}}).
+-file("core_parse.yrl", 369).
+yeccpars2_168_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { T , A } = __2 ,
-    # c_receive { clauses = [ ] , timeout = T , action = A }
+    # c_search { clauses = [ ] , timeout = T , action = A }
   end | __Stack].
 
--compile({inline,{yeccpars2_175_,1}}).
--file("core_parse.yrl", 325).
-yeccpars2_175_(__Stack0) ->
+-compile({inline,{yeccpars2_177_,1}}).
+-file("core_parse.yrl", 327).
+yeccpars2_177_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_177_,1}}).
--file("core_parse.yrl", 316).
-yeccpars2_177_(__Stack0) ->
+-compile({inline,{yeccpars2_179_,1}}).
+-file("core_parse.yrl", 318).
+yeccpars2_179_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_185_,1}}).
--file("core_parse.yrl", 161).
-yeccpars2_185_(__Stack0) ->
+-compile({inline,{yeccpars2_187_,1}}).
+-file("core_parse.yrl", 162).
+yeccpars2_187_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_187_,1}}).
--file("core_parse.yrl", 172).
-yeccpars2_187_(__Stack0) ->
+-compile({inline,{yeccpars2_189_,1}}).
+-file("core_parse.yrl", 173).
+yeccpars2_189_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    # c_tuple { es = [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_192_,1}}).
--file("core_parse.yrl", 168).
-yeccpars2_192_(__Stack0) ->
+-compile({inline,{yeccpars2_194_,1}}).
+-file("core_parse.yrl", 169).
+yeccpars2_194_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_alias { var = __1 , pat = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_195_,1}}).
--file("core_parse.yrl", 156).
-yeccpars2_195_(__Stack0) ->
+-compile({inline,{yeccpars2_197_,1}}).
+-file("core_parse.yrl", 157).
+yeccpars2_197_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    core_lib : set_anno ( __2 , __4 )
   end | __Stack].
 
--compile({inline,{yeccpars2_198_,1}}).
--file("core_parse.yrl", 205).
-yeccpars2_198_(__Stack0) ->
+-compile({inline,{yeccpars2_200_,1}}).
+-file("core_parse.yrl", 206).
+yeccpars2_200_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    core_lib : set_anno ( __2 , __4 )
   end | __Stack].
 
--compile({inline,{yeccpars2_200_,1}}).
--file("core_parse.yrl", 160).
-yeccpars2_200_(__Stack0) ->
+-compile({inline,{yeccpars2_202_,1}}).
+-file("core_parse.yrl", 161).
+yeccpars2_202_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_201_,1}}).
--file("core_parse.yrl", 173).
-yeccpars2_201_(__Stack0) ->
+-compile({inline,{yeccpars2_203_,1}}).
+-file("core_parse.yrl", 174).
+yeccpars2_203_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_tuple { es = __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_204_,1}}).
--file("core_parse.yrl", 363).
-yeccpars2_204_(__Stack0) ->
+-compile({inline,{yeccpars2_206_,1}}).
+-file("core_parse.yrl", 365).
+yeccpars2_206_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { __2 , __4 }
   end | __Stack].
 
--compile({inline,{yeccpars2_206_,1}}).
--file("core_parse.yrl", 176).
-yeccpars2_206_(__Stack0) ->
+-compile({inline,{yeccpars2_208_,1}}).
+-file("core_parse.yrl", 177).
+yeccpars2_208_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_cons { hd = __2 , tl = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_208_,1}}).
--file("core_parse.yrl", 178).
-yeccpars2_208_(__Stack0) ->
+-compile({inline,{yeccpars2_210_,1}}).
+-file("core_parse.yrl", 179).
+yeccpars2_210_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    # c_literal { val = [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_211_,1}}).
--file("core_parse.yrl", 179).
-yeccpars2_211_(__Stack0) ->
+-compile({inline,{yeccpars2_213_,1}}).
+-file("core_parse.yrl", 180).
+yeccpars2_213_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_213_,1}}).
--file("core_parse.yrl", 181).
-yeccpars2_213_(__Stack0) ->
+-compile({inline,{yeccpars2_215_,1}}).
+-file("core_parse.yrl", 182).
+yeccpars2_215_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_cons { hd = __2 , tl = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_215_,1}}).
--file("core_parse.yrl", 326).
-yeccpars2_215_(__Stack0) ->
+-compile({inline,{yeccpars2_217_,1}}).
+-file("core_parse.yrl", 328).
+yeccpars2_217_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    [ ]
   end | __Stack].
 
--compile({inline,{yeccpars2_216_,1}}).
--file("core_parse.yrl", 327).
-yeccpars2_216_(__Stack0) ->
+-compile({inline,{yeccpars2_218_,1}}).
+-file("core_parse.yrl", 329).
+yeccpars2_218_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_221_,1}}).
--file("core_parse.yrl", 320).
-yeccpars2_221_(__Stack0) ->
+-compile({inline,{yeccpars2_223_,1}}).
+-file("core_parse.yrl", 322).
+yeccpars2_223_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    core_lib : set_anno ( __2 , __4 )
   end | __Stack].
 
--compile({inline,{yeccpars2_224_,1}}).
--file("core_parse.yrl", 187).
-yeccpars2_224_(__Stack0) ->
+-compile({inline,{yeccpars2_226_,1}}).
+-file("core_parse.yrl", 188).
+yeccpars2_226_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_227_,1}}).
--file("core_parse.yrl", 183).
-yeccpars2_227_(__Stack0) ->
+-compile({inline,{yeccpars2_229_,1}}).
+-file("core_parse.yrl", 184).
+yeccpars2_229_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_binary { segments = [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_233_,1}}).
--file("core_parse.yrl", 190).
-yeccpars2_233_(__Stack0) ->
+-compile({inline,{yeccpars2_235_,1}}).
+-file("core_parse.yrl", 191).
+yeccpars2_235_(__Stack0) ->
  [__7,__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    case __6 of
@@ -4912,202 +5034,220 @@ yeccpars2_233_(__Stack0) ->
     end
   end | __Stack].
 
--compile({inline,{yeccpars2_235_,1}}).
--file("core_parse.yrl", 186).
-yeccpars2_235_(__Stack0) ->
+-compile({inline,{yeccpars2_237_,1}}).
+-file("core_parse.yrl", 187).
+yeccpars2_237_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_237_,1}}).
--file("core_parse.yrl", 184).
-yeccpars2_237_(__Stack0) ->
+-compile({inline,{yeccpars2_239_,1}}).
+-file("core_parse.yrl", 185).
+yeccpars2_239_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_binary { segments = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_238_,1}}).
--file("core_parse.yrl", 315).
-yeccpars2_238_(__Stack0) ->
+-compile({inline,{yeccpars2_240_,1}}).
+-file("core_parse.yrl", 317).
+yeccpars2_240_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __2 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_239_,1}}).
--file("core_parse.yrl", 359).
-yeccpars2_239_(__Stack0) ->
+-compile({inline,{yeccpars2_241_,1}}).
+-file("core_parse.yrl", 372).
+yeccpars2_241_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { T , A } = __3 ,
-    # c_receive { clauses = __2 , timeout = T , action = A }
+    # c_search { clauses = __2 , timeout = T , action = A }
   end | __Stack].
 
--compile({inline,{yeccpars2_243_,1}}).
--file("core_parse.yrl", 323).
-yeccpars2_243_(__Stack0) ->
+-compile({inline,{yeccpars2_245_,1}}).
+-file("core_parse.yrl", 325).
+yeccpars2_245_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_clause { pats = __1 , guard = __3 , body = __5 }
   end | __Stack].
 
--compile({inline,{yeccpars2_245_,1}}).
--file("core_parse.yrl", 337).
-yeccpars2_245_(__Stack0) ->
- [__3,__2,__1 | __Stack] = __Stack0,
+-compile({inline,{yeccpars2_246_,1}}).
+-file("core_parse.yrl", 358).
+yeccpars2_246_(__Stack0) ->
+ [__2,__1 | __Stack] = __Stack0,
  [begin
-   # c_primop { name = __2 , args = __3 }
+   { T , A } = __2 ,
+    # c_receive { clauses = [ ] , timeout = T , action = A }
   end | __Stack].
 
 -compile({inline,{yeccpars2_248_,1}}).
--file("core_parse.yrl", 339).
+-file("core_parse.yrl", 361).
 yeccpars2_248_(__Stack0) ->
+ [__3,__2,__1 | __Stack] = __Stack0,
+ [begin
+   { T , A } = __3 ,
+    # c_receive { clauses = __2 , timeout = T , action = A }
+  end | __Stack].
+
+-compile({inline,{yeccpars2_250_,1}}).
+-file("core_parse.yrl", 339).
+yeccpars2_250_(__Stack0) ->
+ [__3,__2,__1 | __Stack] = __Stack0,
+ [begin
+   # c_primop { name = __2 , args = __3 }
+  end | __Stack].
+
+-compile({inline,{yeccpars2_253_,1}}).
+-file("core_parse.yrl", 341).
+yeccpars2_253_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    [ ]
   end | __Stack].
 
--compile({inline,{yeccpars2_249_,1}}).
--file("core_parse.yrl", 340).
-yeccpars2_249_(__Stack0) ->
+-compile({inline,{yeccpars2_254_,1}}).
+-file("core_parse.yrl", 342).
+yeccpars2_254_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_252_,1}}).
--file("core_parse.yrl", 310).
-yeccpars2_252_(__Stack0) ->
+-compile({inline,{yeccpars2_257_,1}}).
+-file("core_parse.yrl", 312).
+yeccpars2_257_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_letrec { defs = __2 , body = __4 }
   end | __Stack].
 
--compile({inline,{yeccpars2_257_,1}}).
--file("core_parse.yrl", 307).
-yeccpars2_257_(__Stack0) ->
+-compile({inline,{yeccpars2_262_,1}}).
+-file("core_parse.yrl", 309).
+yeccpars2_262_(__Stack0) ->
  [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_let { vars = __2 , arg = __4 , body = __6 }
   end | __Stack].
 
--compile({inline,{yeccpars2_259_,1}}).
--file("core_parse.yrl", 299).
-yeccpars2_259_(__Stack0) ->
+-compile({inline,{yeccpars2_264_,1}}).
+-file("core_parse.yrl", 301).
+yeccpars2_264_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_seq { arg = __2 , body = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_260_,1}}).
--file("core_parse.yrl", 353).
-yeccpars2_260_(__Stack0) ->
+-compile({inline,{yeccpars2_265_,1}}).
+-file("core_parse.yrl", 355).
+yeccpars2_265_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    # c_catch { body = __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_264_,1}}).
--file("core_parse.yrl", 313).
-yeccpars2_264_(__Stack0) ->
+-compile({inline,{yeccpars2_269_,1}}).
+-file("core_parse.yrl", 315).
+yeccpars2_269_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_case { arg = __2 , clauses = __4 }
   end | __Stack].
 
--compile({inline,{yeccpars2_268_,1}}).
--file("core_parse.yrl", 334).
-yeccpars2_268_(__Stack0) ->
+-compile({inline,{yeccpars2_273_,1}}).
+-file("core_parse.yrl", 336).
+yeccpars2_273_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_call { module = __2 , name = __4 , args = __5 }
   end | __Stack].
 
--compile({inline,{yeccpars2_270_,1}}).
--file("core_parse.yrl", 330).
-yeccpars2_270_(__Stack0) ->
+-compile({inline,{yeccpars2_275_,1}}).
+-file("core_parse.yrl", 332).
+yeccpars2_275_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_apply { op = __2 , args = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_272_,1}}).
--file("core_parse.yrl", 266).
-yeccpars2_272_(__Stack0) ->
+-compile({inline,{yeccpars2_277_,1}}).
+-file("core_parse.yrl", 268).
+yeccpars2_277_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_cons { hd = __2 , tl = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_274_,1}}).
--file("core_parse.yrl", 268).
-yeccpars2_274_(__Stack0) ->
+-compile({inline,{yeccpars2_279_,1}}).
+-file("core_parse.yrl", 270).
+yeccpars2_279_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    # c_literal { val = [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_277_,1}}).
--file("core_parse.yrl", 269).
-yeccpars2_277_(__Stack0) ->
+-compile({inline,{yeccpars2_282_,1}}).
+-file("core_parse.yrl", 271).
+yeccpars2_282_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_279_,1}}).
--file("core_parse.yrl", 270).
-yeccpars2_279_(__Stack0) ->
+-compile({inline,{yeccpars2_284_,1}}).
+-file("core_parse.yrl", 272).
+yeccpars2_284_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_cons { hd = __2 , tl = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_281_,1}}).
--file("core_parse.yrl", 218).
-yeccpars2_281_(__Stack0) ->
+-compile({inline,{yeccpars2_286_,1}}).
+-file("core_parse.yrl", 219).
+yeccpars2_286_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    # c_values { es = [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_282_,1}}).
--file("core_parse.yrl", 219).
-yeccpars2_282_(__Stack0) ->
+-compile({inline,{yeccpars2_287_,1}}).
+-file("core_parse.yrl", 220).
+yeccpars2_287_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_values { es = __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_286_,1}}).
--file("core_parse.yrl", 213).
-yeccpars2_286_(__Stack0) ->
+-compile({inline,{yeccpars2_291_,1}}).
+-file("core_parse.yrl", 214).
+yeccpars2_291_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    core_lib : set_anno ( __2 , __4 )
   end | __Stack].
 
--compile({inline,{yeccpars2_289_,1}}).
--file("core_parse.yrl", 276).
-yeccpars2_289_(__Stack0) ->
+-compile({inline,{yeccpars2_294_,1}}).
+-file("core_parse.yrl", 278).
+yeccpars2_294_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_292_,1}}).
--file("core_parse.yrl", 272).
-yeccpars2_292_(__Stack0) ->
+-compile({inline,{yeccpars2_297_,1}}).
+-file("core_parse.yrl", 274).
+yeccpars2_297_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_literal { val = << >> }
   end | __Stack].
 
--compile({inline,{yeccpars2_298_,1}}).
--file("core_parse.yrl", 279).
-yeccpars2_298_(__Stack0) ->
+-compile({inline,{yeccpars2_303_,1}}).
+-file("core_parse.yrl", 281).
+yeccpars2_303_(__Stack0) ->
  [__7,__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    case __6 of
@@ -5119,73 +5259,73 @@ yeccpars2_298_(__Stack0) ->
     end
   end | __Stack].
 
--compile({inline,{yeccpars2_300_,1}}).
--file("core_parse.yrl", 275).
-yeccpars2_300_(__Stack0) ->
+-compile({inline,{yeccpars2_305_,1}}).
+-file("core_parse.yrl", 277).
+yeccpars2_305_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_302_,1}}).
--file("core_parse.yrl", 273).
-yeccpars2_302_(__Stack0) ->
+-compile({inline,{yeccpars2_307_,1}}).
+-file("core_parse.yrl", 275).
+yeccpars2_307_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_binary { segments = __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_305_,1}}).
--file("core_parse.yrl", 200).
-yeccpars2_305_(__Stack0) ->
+-compile({inline,{yeccpars2_310_,1}}).
+-file("core_parse.yrl", 201).
+yeccpars2_310_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_308_,1}}).
--file("core_parse.yrl", 304).
-yeccpars2_308_(__Stack0) ->
+-compile({inline,{yeccpars2_313_,1}}).
+-file("core_parse.yrl", 306).
+yeccpars2_313_(__Stack0) ->
  [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_fun { vars = __3 , body = __6 }
   end | __Stack].
 
--compile({inline,{yeccpars2_312_,1}}).
--file("core_parse.yrl", 117).
-yeccpars2_312_(__Stack0) ->
+-compile({inline,{yeccpars2_317_,1}}).
+-file("core_parse.yrl", 118).
+yeccpars2_317_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    core_lib : set_anno ( __2 , __4 )
   end | __Stack].
 
--compile({inline,{yeccpars2_313_,1}}).
--file("core_parse.yrl", 108).
-yeccpars2_313_(__Stack0) ->
+-compile({inline,{yeccpars2_318_,1}}).
+-file("core_parse.yrl", 109).
+yeccpars2_318_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __2 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_314_,1}}).
--file("core_parse.yrl", 77).
-yeccpars2_314_(__Stack0) ->
+-compile({inline,{yeccpars2_319_,1}}).
+-file("core_parse.yrl", 78).
+yeccpars2_319_(__Stack0) ->
  [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_module { name = # c_literal { val = tok_val ( __2 ) } , exports = __3 ,
     attrs = __4 , defs = __5 }
   end | __Stack].
 
--compile({inline,{yeccpars2_318_,1}}).
--file("core_parse.yrl", 110).
-yeccpars2_318_(__Stack0) ->
+-compile({inline,{yeccpars2_323_,1}}).
+-file("core_parse.yrl", 111).
+yeccpars2_323_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--compile({inline,{yeccpars2_323_,1}}).
--file("core_parse.yrl", 82).
-yeccpars2_323_(__Stack0) ->
+-compile({inline,{yeccpars2_328_,1}}).
+-file("core_parse.yrl", 83).
+yeccpars2_328_(__Stack0) ->
  [__10,__9,__8,__7,__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    # c_module { anno = __9 , name = tok_val ( __3 ) , exports = __4 ,
@@ -5193,4 +5333,4 @@ yeccpars2_323_(__Stack0) ->
   end | __Stack].
 
 
--file("core_parse.yrl", 390).
+-file("core_parse.yrl", 400).
diff -urNp otp_src_R12B-5/lib/compiler/src/core_parse.hrl minimal_otp_src_R12B-5/lib/compiler/src/core_parse.hrl
--- otp_src_R12B-5/lib/compiler/src/core_parse.hrl	2007-11-26 18:58:03.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_parse.hrl	2009-06-23 20:40:10.000000000 +0100
@@ -74,6 +74,10 @@
 		    timeout,		% timeout :: Tree,
 		    action}).		% action :: Tree
 
+-record(c_search, {anno=[], clauses,   % clauses :: [Tree],
+                    timeout,            % timeout :: Tree,
+		    action}).           % action :: Tree
+
 -record(c_apply, {anno=[], op,		% op :: Tree,
 		  args}).		% args :: [Tree]
 
diff -urNp otp_src_R12B-5/lib/compiler/src/core_parse.hrl~ minimal_otp_src_R12B-5/lib/compiler/src/core_parse.hrl~
--- otp_src_R12B-5/lib/compiler/src/core_parse.hrl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_parse.hrl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,103 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Core Erlang syntax trees as records.
+
+%% It would be nice to incorporate some generic functions as well but
+%% this could make including this file difficult.
+
+%% Note: the annotation list is *always* the first record field.
+%% Thus it is possible to define the macros:
+%% -define(get_ann(X), element(2, X)).
+%% -define(set_ann(X, Y), setelement(2, X, Y)).
+
+-record(c_literal, {anno=[], val}).	% val :: literal()
+
+-record(c_binary, {anno=[], segments}).	% segments :: [#c_bitstr{}]
+
+-record(c_bitstr, {anno=[],val,	        % val :: Tree,
+		   size,		% size :: Tree,
+		   unit,		% unit :: Tree,
+		   type,		% type :: Tree,
+		   flags}).		% flags :: Tree
+
+-record(c_cons, {anno=[], hd,		% hd :: Tree,
+		 tl}).			% tl :: Tree
+
+-record(c_tuple, {anno=[], es}).	% es :: [Tree]
+
+-record(c_var, {anno=[], name}).	% name :: integer() | atom()
+
+-record(c_fname, {anno=[], id,		% id :: atom(),
+		  arity}).		% arity :: integer()
+
+-record(c_values, {anno=[], es}).	% es :: [Tree]
+
+-record(c_fun, {anno=[], vars,		% vars :: [Tree],
+		body}).			% body :: Tree
+
+-record(c_seq, {anno=[], arg,		% arg :: Tree,
+		body}).			% body :: Tree
+
+-record(c_let, {anno=[], vars,		% vars :: [Tree],
+		arg,			% arg :: Tree,
+		body}).			% body :: Tree
+
+-record(c_letrec, {anno=[], defs,	% defs :: [#c_def{}],
+		   body}).		% body :: Tree
+
+-record(c_case, {anno=[], arg,		% arg :: Tree,
+		 clauses}).		% clauses :: [Tree]
+
+-record(c_clause, {anno=[], pats,	% pats :: [Tree],
+		   guard,		% guard :: Tree,
+		   body}).		% body :: Tree
+
+-record(c_alias, {anno=[], var,		% var :: Tree,
+		  pat}).		% pat :: Tree
+
+-record(c_receive, {anno=[], clauses,	% clauses :: [Tree],
+		    timeout,		% timeout :: Tree,
+		    action}).		% action :: Tree
+
+-record(c_search, {anno=[], clauses,   % clauses :: [Tree],
+                    timeout,            % timeout :: Tree,
+		    action,
+		    opt}).           % action :: Tree
+
+-record(c_apply, {anno=[], op,		% op :: Tree,
+		  args}).		% args :: [Tree]
+
+-record(c_call, {anno=[], module,	% module :: Tree,
+		 name,			% name :: Tree,
+		 args}).		% args :: [Tree]
+
+-record(c_primop, {anno=[], name,	% name :: Tree,
+		   args}).		% args :: [Tree]
+
+-record(c_try, {anno=[], arg,		% arg :: Tree,
+		vars,			% vars :: [Tree],
+		body,			% body :: Tree
+		evars,			% evars :: [Tree],
+		handler}).		% handler :: Tree
+
+-record(c_catch, {anno=[], body}).	% body :: Tree
+
+-record(c_module, {anno=[], name,	% name :: Tree,
+		   exports,		% exports :: [Tree],
+		   attrs,		% attrs :: [#c_def{}],
+		   defs}).		% defs :: [#c_def{}]
diff -urNp otp_src_R12B-5/lib/compiler/src/core_parse.yrl minimal_otp_src_R12B-5/lib/compiler/src/core_parse.yrl
--- otp_src_R12B-5/lib/compiler/src/core_parse.yrl	2008-04-07 14:58:14.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_parse.yrl	2009-06-23 20:40:10.000000000 +0100
@@ -41,6 +41,7 @@ let_expr let_vars letrec_expr case_expr 
 function_name
 application_expr call_expr primop_expr arg_list
 receive_expr timeout try_expr
+search_expr
 sequence catch_expr
 variable clause clause_pattern
 
@@ -59,7 +60,7 @@ Terminals
 
 'module' 'attributes' 'do' 'let' 'in' 'letrec'
 'apply' 'call' 'primop'
-'case' 'of' 'end' 'when' 'fun' 'try' 'catch' 'receive' 'after'
+'case' 'of' 'end' 'when' 'fun' 'try' 'catch' 'receive' 'search' 'after'
 
 %% Literal tokens (provided by the tokeniser):
 
@@ -234,6 +235,7 @@ single_expression -> let_expr : '$1'.
 single_expression -> letrec_expr : '$1'.
 single_expression -> case_expr : '$1'.
 single_expression -> receive_expr : '$1'.
+single_expression -> search_expr : '$1'.
 single_expression -> application_expr : '$1'.
 single_expression -> call_expr : '$1'.
 single_expression -> primop_expr : '$1'.
@@ -366,6 +368,14 @@ receive_expr -> 'receive' anno_clauses t
 timeout ->
     'after' anno_expression '->' anno_expression : {'$2','$4'}.
 
+%% Search message
+search_expr -> 'search' timeout :
+	{T,A} = '$2',
+	#c_search{clauses=[],timeout=T,action=A}.
+search_expr -> 'search' anno_clauses timeout :
+        {T,A} = '$3',
+        #c_search{clauses='$2',timeout=T,action=A}.
+
 %% ====================================================================== %%
 
 
diff -urNp otp_src_R12B-5/lib/compiler/src/core_parse.yrl~ minimal_otp_src_R12B-5/lib/compiler/src/core_parse.yrl~
--- otp_src_R12B-5/lib/compiler/src/core_parse.yrl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_parse.yrl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,408 @@
+%% -*-Erlang-*-
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Core Erlang YECC parser grammar
+
+%% Have explicit productions for annotated phrases named anno_XXX.
+%% This just does an XXX and adds the annotation.
+
+Nonterminals
+
+module_definition module_export module_attribute module_defs
+exported_names exported_name
+attribute_list attribute
+function_definition function_definitions
+
+constant constants atomic_constant tuple_constant cons_constant tail_constant
+other_pattern atomic_pattern tuple_pattern cons_pattern tail_pattern
+binary_pattern segment_patterns segment_pattern
+
+expression single_expression
+literal literals atomic_literal tuple_literal cons_literal tail_literal
+nil tuple cons tail
+binary segments segment
+
+let_expr let_vars letrec_expr case_expr fun_expr
+function_name
+application_expr call_expr primop_expr arg_list
+receive_expr timeout try_expr
+search_expr searchc_expr
+sequence catch_expr
+variable clause clause_pattern
+
+annotation anno_fun anno_expression anno_expressions
+anno_variable anno_variables anno_pattern anno_patterns
+anno_function_name
+anno_clause anno_clauses.
+
+Terminals
+
+%% Separators
+
+'(' ')' '{' '}' '[' ']' '|' ',' '->' '=' '/' '<' '>' ':' '-|' '#'
+
+%% Keywords (atoms are assumed to always be single-quoted).
+
+'module' 'attributes' 'do' 'let' 'in' 'letrec'
+'apply' 'call' 'primop'
+'case' 'of' 'end' 'when' 'fun' 'try' 'catch' 'receive' 'search' 'after'
+
+%% Literal tokens (provided by the tokeniser):
+
+char integer float atom string var.
+
+%% Literal tokens NOT provided by the tokenise:
+
+nil -> '[' ']' : {nil,tok_line('$1')}. 
+
+%% Declare the start rule for parsing
+
+Rootsymbol module_definition.
+
+
+%% Grammar
+
+module_definition ->
+    'module' atom module_export module_attribute module_defs 'end' :
+	#c_module{name=#c_literal{val=tok_val('$2')},exports='$3',
+		  attrs='$4',defs='$5'}.
+module_definition ->
+    '(' 'module' atom module_export module_attribute module_defs 'end'
+	'-|' annotation ')' :
+	#c_module{anno='$9',name=tok_val('$3'),exports='$4',
+		  attrs='$5',defs='$6'}.
+
+module_export -> '[' ']' : [].
+module_export -> '[' exported_names ']' : '$2'.
+
+exported_names -> exported_name ',' exported_names : ['$1' | '$3'].
+exported_names -> exported_name : ['$1'].
+
+exported_name -> function_name : '$1'.
+
+module_attribute -> 'attributes' '[' ']' : [].
+module_attribute -> 'attributes' '[' attribute_list ']' : '$3'.
+
+attribute_list -> attribute ',' attribute_list : ['$1' | '$3'].
+attribute_list -> attribute : ['$1'].
+
+attribute -> atom '=' literal :
+	{#c_literal{val=tok_val('$1')},'$3'}.
+
+module_defs -> function_definitions : '$1'.
+
+annotation -> '[' ']' : [].
+annotation -> '[' constants ']' : '$2'.
+
+function_definitions ->
+    function_definition function_definitions : ['$1' | '$2'].
+function_definitions ->
+    '$empty' : [].
+
+function_definition ->
+    anno_function_name '=' anno_fun :
+	{'$1','$3'}.
+
+anno_fun -> '(' fun_expr '-|' annotation ')' :
+	core_lib:set_anno('$2', '$4').
+anno_fun -> fun_expr : '$1'.
+
+%% Constant terms for annotations and attributes.
+%%  These are represented by straight unabstract Erlang.
+
+constant -> atomic_constant : '$1'.
+constant -> tuple_constant : '$1'.
+constant -> cons_constant : '$1'.
+
+constants -> constant ',' constants : ['$1' | '$3'].
+constants -> constant : ['$1'].
+
+atomic_constant -> char : tok_val('$1').
+atomic_constant -> integer : tok_val('$1').
+atomic_constant -> float : tok_val('$1').
+atomic_constant -> atom : tok_val('$1').
+atomic_constant -> string : tok_val('$1').
+atomic_constant -> nil : [].
+
+tuple_constant -> '{' '}' : {}.
+tuple_constant -> '{' constants '}' : list_to_tuple('$2').
+
+cons_constant -> '[' constant tail_constant : ['$2'|'$3'].
+
+tail_constant -> ']' : [].
+tail_constant -> '|' constant ']' : '$2'.
+tail_constant -> ',' constant tail_constant : ['$2'|'$3'].
+
+%% Patterns
+%%  We have to be a little sneaky here as we would like to be able to
+%%  do:
+%%  V = {a}
+%%  ( V = {a} -| <anno> )
+%%  ( V -| <anno> ) = {a}
+%%  V = ( {a} -| <anno> )
+%%  ( ( V -| <anno> ) = ( {a} -| <anno> ) -| <anno> )
+
+anno_pattern -> '(' other_pattern '-|' annotation ')' :
+	core_lib:set_anno('$2', '$4').
+anno_pattern -> other_pattern : '$1'.
+anno_pattern -> anno_variable : '$1'.
+
+anno_patterns -> anno_pattern ',' anno_patterns : ['$1' | '$3'].
+anno_patterns -> anno_pattern : ['$1'].
+
+other_pattern -> atomic_pattern : '$1'.
+other_pattern -> tuple_pattern : '$1'.
+other_pattern -> cons_pattern : '$1'.
+other_pattern -> binary_pattern : '$1'.
+other_pattern -> anno_variable '=' anno_pattern :
+	#c_alias{var='$1',pat='$3'}.
+
+atomic_pattern -> atomic_literal : '$1'.
+
+tuple_pattern -> '{' '}' : #c_tuple{es=[]}.
+tuple_pattern -> '{' anno_patterns '}' : #c_tuple{es='$2'}.
+
+cons_pattern -> '[' anno_pattern tail_pattern :
+		    #c_cons{hd='$2',tl='$3'}.
+
+tail_pattern -> ']' : #c_literal{val=[]}.
+tail_pattern -> '|' anno_pattern ']' : '$2'.
+tail_pattern -> ',' anno_pattern tail_pattern :
+		    #c_cons{hd='$2',tl='$3'}.
+
+binary_pattern -> '#' '{' '}' '#' : #c_binary{segments=[]}.
+binary_pattern -> '#' '{' segment_patterns '}' '#' : #c_binary{segments='$3'}.
+
+segment_patterns -> segment_pattern ',' segment_patterns : ['$1' | '$3'].
+segment_patterns -> segment_pattern : ['$1'].
+
+segment_pattern -> '#' '<' anno_pattern '>' '(' anno_patterns ')':
+	case '$6' of
+	    [S,U,T,Fs] ->
+		#c_bitstr{val='$3',size=S,unit=U,type=T,flags=Fs};
+	    true ->
+		return_error(tok_line('$1'),
+			     "expected 4 arguments in binary segment")
+	end.
+
+variable -> var : #c_var{name=tok_val('$1')}.
+
+anno_variables -> anno_variable ',' anno_variables : ['$1' | '$3'].
+anno_variables -> anno_variable : ['$1'].
+
+anno_variable -> variable : '$1'.
+anno_variable -> '(' variable '-|' annotation ')' :
+	core_lib:set_anno('$2', '$4').
+
+%% Expressions
+%%  Must split expressions into two levels as nested value expressions
+%%  are illegal.
+
+anno_expression -> expression : '$1'.
+anno_expression -> '(' expression '-|' annotation ')' :
+	core_lib:set_anno('$2', '$4').
+
+anno_expressions -> anno_expression ',' anno_expressions : ['$1' | '$3'].
+anno_expressions -> anno_expression : ['$1'].
+
+expression -> '<' '>' : #c_values{es=[]}.
+expression -> '<' anno_expressions '>' : #c_values{es='$2'}.
+expression -> single_expression : '$1'.
+
+single_expression -> atomic_literal : '$1'.
+single_expression -> tuple : '$1'.
+single_expression -> cons : '$1'.
+single_expression -> binary : '$1'.
+single_expression -> variable : '$1'.
+single_expression -> function_name : '$1'.
+single_expression -> fun_expr : '$1'.
+single_expression -> let_expr : '$1'.
+single_expression -> letrec_expr : '$1'.
+single_expression -> case_expr : '$1'.
+single_expression -> receive_expr : '$1'.
+single_expression -> search_expr : '$1'.
+single_expression -> searchc_expr : '$1'.
+single_expression -> application_expr : '$1'.
+single_expression -> call_expr : '$1'.
+single_expression -> primop_expr : '$1'.
+single_expression -> try_expr : '$1'.
+single_expression -> sequence : '$1'.
+single_expression -> catch_expr : '$1'.
+
+literal -> atomic_literal : '$1'.
+literal -> tuple_literal : '$1'.
+literal -> cons_literal : '$1'.
+
+literals -> literal ',' literals : ['$1' | '$3'].
+literals -> literal : ['$1'].
+
+atomic_literal -> char : #c_literal{val=tok_val('$1')}.
+atomic_literal -> integer : #c_literal{val=tok_val('$1')}.
+atomic_literal -> float : #c_literal{val=tok_val('$1')}.
+atomic_literal -> atom : #c_literal{val=tok_val('$1')}.
+atomic_literal -> string : #c_literal{val=tok_val('$1')}.
+atomic_literal -> nil : #c_literal{val=[]}.
+
+tuple_literal -> '{' '}' : #c_tuple{es=[]}.
+tuple_literal -> '{' literals '}' : #c_tuple{es='$2'}.
+
+cons_literal -> '[' literal tail_literal : #c_cons{hd='$2',tl='$3'}.
+
+tail_literal -> ']' : #c_literal{val=[]}.
+tail_literal -> '|' literal ']' : '$2'.
+tail_literal -> ',' literal tail_literal : #c_cons{hd='$2',tl='$3'}.
+
+tuple -> '{' '}' : #c_tuple{es=[]}.
+tuple -> '{' anno_expressions '}' : #c_tuple{es='$2'}.
+
+cons -> '[' anno_expression tail : #c_cons{hd='$2',tl='$3'}.
+
+tail -> ']' : #c_literal{val=[]}.
+tail -> '|' anno_expression ']' : '$2'.
+tail -> ',' anno_expression tail : #c_cons{hd='$2',tl='$3'}.
+
+binary -> '#' '{' '}' '#' : #c_literal{val = <<>>}.
+binary -> '#' '{' segments '}' '#' : #c_binary{segments='$3'}.
+
+segments -> segment ',' segments : ['$1' | '$3'].
+segments -> segment : ['$1'].
+
+segment -> '#' '<' anno_expression '>' '(' anno_expressions ')':
+	case '$6' of
+	    [S,U,T,Fs] ->
+		#c_bitstr{val='$3',size=S,unit=U,type=T,flags=Fs};
+	    true ->
+		return_error(tok_line('$1'),
+			     "expected 4 arguments in binary segment")
+	end.
+
+function_name -> atom '/' integer :
+	#c_fname{id=tok_val('$1'),arity=tok_val('$3')}.
+
+anno_function_name -> function_name : '$1'.
+anno_function_name -> '(' function_name '-|' annotation ')' :
+	core_lib:set_anno('$2', '$4').
+
+let_vars -> anno_variable : ['$1'].
+let_vars -> '<' '>' : [].
+let_vars -> '<' anno_variables '>' : '$2'.
+
+sequence -> 'do' anno_expression anno_expression :
+	#c_seq{arg='$2',body='$3'}.
+
+fun_expr -> 'fun' '(' ')' '->' anno_expression :
+	#c_fun{vars=[],body='$5'}.
+fun_expr -> 'fun' '(' anno_variables ')' '->' anno_expression :
+	#c_fun{vars='$3',body='$6'}.
+
+let_expr -> 'let' let_vars '=' anno_expression 'in' anno_expression :
+	#c_let{vars='$2',arg='$4',body='$6'}.
+
+letrec_expr -> 'letrec' function_definitions 'in' anno_expression :
+	#c_letrec{defs='$2',body='$4'}.
+
+case_expr -> 'case' anno_expression 'of' anno_clauses 'end' :
+	#c_case{arg='$2',clauses='$4'}.
+
+anno_clauses -> anno_clause anno_clauses : ['$1' | '$2'].
+anno_clauses -> anno_clause : ['$1'].
+
+anno_clause -> clause : '$1'.
+anno_clause -> '(' clause '-|' annotation ')' :
+	core_lib:set_anno('$2', '$4').
+
+clause -> clause_pattern 'when' anno_expression '->' anno_expression :
+	#c_clause{pats='$1',guard='$3',body='$5'}.
+
+clause_pattern -> anno_pattern : ['$1'].
+clause_pattern -> '<' '>' : [].
+clause_pattern -> '<' anno_patterns '>' : '$2'.
+
+application_expr -> 'apply' anno_expression arg_list :
+	#c_apply{op='$2',args='$3'}.
+
+call_expr ->
+    'call' anno_expression ':' anno_expression arg_list :
+	#c_call{module='$2',name='$4',args='$5'}.
+
+primop_expr -> 'primop' anno_expression arg_list :
+	#c_primop{name='$2',args='$3'}.
+
+arg_list -> '(' ')' : [].
+arg_list -> '(' anno_expressions ')' : '$2'.
+
+try_expr ->
+    'try' anno_expression 'of' let_vars '->' anno_expression
+	'catch' let_vars '->' anno_expression :
+	Len = length('$8'),
+        if Len =:= 2; Len =:= 3 ->
+		#c_try{arg='$2',vars='$4',body='$6',evars='$8',handler='$10'};
+	   true ->
+		return_error(tok_line('$7'),
+			     "expected 2 or 3 exception variables in 'try'")
+	end.
+
+catch_expr -> 'catch' anno_expression : #c_catch{body='$2'}.
+
+receive_expr -> 'receive' timeout : 
+	{T,A} = '$2',
+	#c_receive{clauses=[],timeout=T,action=A}.
+receive_expr -> 'receive' anno_clauses timeout : 
+	{T,A} = '$3',
+	#c_receive{clauses='$2',timeout=T,action=A}.
+
+timeout ->
+    'after' anno_expression '->' anno_expression : {'$2','$4'}.
+
+%% Search message
+search_expr -> 'search' timeout :
+	{T,A} = '$2',
+	#c_search{clauses=[],timeout=T,action=A}.
+search_expr -> 'search' anno_clauses timeout :
+        {T,A} = '$3',
+        #c_search{clauses='$2',timeout=T,action=A}.
+
+searchc_expr -> 'searchc' timeout :
+	{T,A} = '$2',
+	#c_search{clauses=[],timeout=T,action=A, opt=continuation}.
+searchc_expr -> 'searchc' anno_clauses timeout :
+        {T,A} = '$3',
+        #c_search{clauses='$2',timeout=T,action=A, opt=continuation}.
+
+
+%% ====================================================================== %%
+
+
+Erlang code.
+
+-export([abstract/1,abstract/2,normalise/1]).
+
+%% The following directive is needed for (significantly) faster compilation
+%% of the generated .erl file by the HiPE compiler.  Please do not remove.
+-compile([{hipe,[{regalloc,linear_scan}]}]).
+
+-include("core_parse.hrl").
+
+tok_val(T) -> element(3, T).
+tok_line(T) -> element(2, T).
+
+abstract(T, _N) -> abstract(T).
+
+abstract(Term) -> core_lib:make_literal(Term).
+
+normalise(Core) -> core_lib:literal_value(Core).
diff -urNp otp_src_R12B-5/lib/compiler/src/core_pp.erl minimal_otp_src_R12B-5/lib/compiler/src/core_pp.erl
--- otp_src_R12B-5/lib/compiler/src/core_pp.erl	2008-11-04 10:51:33.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/core_pp.erl	2009-06-23 20:40:10.000000000 +0100
@@ -227,6 +227,18 @@ format_1(#c_receive{clauses=Cs,timeout=T
      nl_indent(Ctxt1),
      format(A, Ctxt1)
     ];
+format_1(#c_search{clauses=Cs,timeout=T,action=A}, Ctxt) ->
+    Ctxt1 = add_indent(Ctxt, Ctxt#ctxt.item_indent),
+    ["search",
+     nl_indent(Ctxt1),
+     format_clauses(Cs, Ctxt1),
+     nl_indent(Ctxt),
+     "after ",
+     format(T, add_indent(Ctxt, 6)),
+     " ->",
+     nl_indent(Ctxt1),
+     format(A, Ctxt1)
+    ];
 format_1(#c_fname{id=I,arity=A}, _) ->
     [core_atom(I),$/,integer_to_list(A)];
 format_1(#c_fun{vars=Vs,body=B}, Ctxt) ->
diff -urNp otp_src_R12B-5/lib/compiler/src/genop.tab minimal_otp_src_R12B-5/lib/compiler/src/genop.tab
--- otp_src_R12B-5/lib/compiler/src/genop.tab	2008-11-04 10:51:31.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/genop.tab	2009-06-23 20:40:10.000000000 +0100
@@ -269,3 +269,8 @@ BEAM_FORMAT_NUMBER=0
 147: bs_put_utf16/3
 
 148: bs_put_utf32/3
+
+# R12B-5-joins
+149: found_message/0
+150: loop_search/2
+151: loop_search_end/1
diff -urNp otp_src_R12B-5/lib/compiler/src/genop.tab~ minimal_otp_src_R12B-5/lib/compiler/src/genop.tab~
--- otp_src_R12B-5/lib/compiler/src/genop.tab~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/genop.tab~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,277 @@
+# ``The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved via the world wide web at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+# Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+# AB. All Rights Reserved.''
+# 
+#     $Id$
+#
+BEAM_FORMAT_NUMBER=0
+
+#
+# Generic instructions, generated by the compiler.  If any of them change number,
+# arity or semantics, the format number above must be bumped.
+#
+
+1: label/1
+2: func_info/3
+3: int_code_end/0
+
+#
+# Function and BIF calls.
+#
+4: call/2
+5: call_last/3
+6: call_only/2
+
+7: call_ext/2
+8: call_ext_last/3
+
+9: bif0/2
+10: bif1/4
+11: bif2/5
+
+#
+# Allocating, deallocating and returning.
+#
+12: allocate/2
+13: allocate_heap/3
+14: allocate_zero/2
+15: allocate_heap_zero/3
+16: test_heap/2
+17: init/1
+18: deallocate/1
+19: return/0
+
+#
+# Sending & receiving.
+#
+20: send/0
+21: remove_message/0
+22: timeout/0
+23: loop_rec/2
+24: loop_rec_end/1
+25: wait/1
+26: wait_timeout/2
+
+#
+# Arithmethic opcodes.
+#
+27: -m_plus/4
+28: -m_minus/4
+29: -m_times/4
+30: -m_div/4
+31: -int_div/4
+32: -int_rem/4
+33: -int_band/4
+34: -int_bor/4
+35: -int_bxor/4
+36: -int_bsl/4
+37: -int_bsr/4
+38: -int_bnot/3
+
+#
+# Comparision operators.
+#
+39: is_lt/3
+40: is_ge/3
+41: is_eq/3
+42: is_ne/3
+43: is_eq_exact/3
+44: is_ne_exact/3
+
+#
+# Type tests.
+#
+45: is_integer/2
+46: is_float/2
+47: is_number/2
+48: is_atom/2
+49: is_pid/2
+50: is_reference/2
+51: is_port/2
+52: is_nil/2
+53: is_binary/2
+54: is_constant/2
+55: is_list/2
+56: is_nonempty_list/2
+57: is_tuple/2
+58: test_arity/3
+
+#
+# Indexing & jumping.
+#
+59: select_val/3
+60: select_tuple_arity/3
+61: jump/1
+
+#
+# Catch.
+#
+62: catch/2
+63: catch_end/1
+
+#
+# Moving, extracting, modifying.
+#
+64: move/2
+65: get_list/3
+66: get_tuple_element/3
+67: set_tuple_element/3
+
+#
+# Building terms.
+#
+68: put_string/3
+69: put_list/3
+70: put_tuple/2
+71: put/1
+
+#
+# Raising errors.
+#
+72: badmatch/1
+73: if_end/0
+74: case_end/1
+
+#
+# 'fun' support.
+#
+75: call_fun/1
+76: -make_fun/3
+77: is_function/2
+
+#
+# Late additions to R5.
+#
+78: call_ext_only/2
+
+#
+# Binary matching (R7).
+#
+79: -bs_start_match/2
+80: -bs_get_integer/5
+81: -bs_get_float/5
+82: -bs_get_binary/5
+83: -bs_skip_bits/4
+84: -bs_test_tail/2
+85: -bs_save/1
+86: -bs_restore/1
+
+#
+# Binary construction (R7A).
+#
+87: -bs_init/2
+88: -bs_final/2
+89: bs_put_integer/5
+90: bs_put_binary/5
+91: bs_put_float/5
+92: bs_put_string/2
+
+#
+# Binary construction (R7B).
+#
+93: -bs_need_buf/1
+
+#
+# Floating point arithmetic (R8).
+#
+94: fclearerror/0
+95: fcheckerror/1
+96: fmove/2
+97: fconv/2
+98: fadd/4
+99: fsub/4
+100: fmul/4
+101: fdiv/4
+102: fnegate/3
+
+# New fun construction (R8).
+103: make_fun2/1
+
+# Try/catch/raise (R10B).
+104: try/2
+105: try_end/1
+106: try_case/1
+107: try_case_end/1
+108: raise/2
+
+# New instructions in R10B.
+109: bs_init2/6
+110: bs_bits_to_bytes/3
+111: bs_add/5
+112: apply/1
+113: apply_last/2
+114: is_boolean/2
+
+# New instructions in R10B-6.
+115: is_function2/3
+
+# New bit syntax matching in R11B.
+
+116: bs_start_match2/5
+117: bs_get_integer2/7
+118: bs_get_float2/7
+119: bs_get_binary2/7
+120: bs_skip_bits2/5
+121: bs_test_tail2/3
+122: bs_save2/2
+123: bs_restore2/2
+
+# New GC bifs introduced in R11B.
+124: gc_bif1/5
+125: gc_bif2/6
+
+# Experimental new bit_level bifs introduced in R11B.
+# NOT used in R12B.
+126: -bs_final2/2
+127: -bs_bits_to_bytes2/2
+
+# R11B-4
+128: -put_literal/2
+
+# R11B-5
+129: is_bitstr/2
+
+# R12B
+130: bs_context_to_binary/1
+131: bs_test_unit/3
+132: bs_match_string/4
+133: bs_init_writable/0
+134: bs_append/8
+135: bs_private_append/6
+136: trim/2
+137: bs_init_bits/6
+
+# R12B-5
+138: bs_get_utf8/5
+139: bs_skip_utf8/4
+
+140: bs_get_utf16/5
+141: bs_skip_utf16/4
+
+142: bs_get_utf32/5
+143: bs_skip_utf32/4
+
+144: bs_utf8_size/3
+145: bs_put_utf8/3
+
+146: bs_utf16_size/3
+147: bs_put_utf16/3
+
+148: bs_put_utf32/3
+
+# R12B-5-joins
+149: found_message/0
+150: loop_search/2
+151: loop_searchc/2
+152: loop_search_end/1
diff -urNp otp_src_R12B-5/lib/compiler/src/sys_core_dsetel.erl minimal_otp_src_R12B-5/lib/compiler/src/sys_core_dsetel.erl
--- otp_src_R12B-5/lib/compiler/src/sys_core_dsetel.erl	2007-11-26 18:59:22.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/sys_core_dsetel.erl	2009-06-23 20:40:10.000000000 +0100
@@ -124,6 +124,11 @@ visit(Env0, #c_receive{clauses=Cs0,timeo
     {Cs1,Env2} = visit_list(Env1, Cs0),
     {A1,Env3} = visit(Env2, A0),
     {R#c_receive{clauses=Cs1,timeout=T1,action=A1}, Env3};
+visit(Env0, #c_search{clauses=Cs0,timeout=T0,action=A0}=R) ->
+    {T1,Env1} = visit(Env0, T0),
+    {Cs1,Env2} = visit_list(Env1, Cs0),
+    {A1,Env3} = visit(Env2, A0),
+    {R#c_search{clauses=Cs1,timeout=T1,action=A1}, Env3};
 visit(Env0, #c_apply{op=Op0, args=As0}=R) ->
     {Op1,Env1} = visit(Env0, Op0),
     {As1,Env2} = visit_list(Env1, As0),
diff -urNp otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl minimal_otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl
--- otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl	2008-11-04 10:51:33.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl	2009-06-23 20:40:10.000000000 +0100
@@ -317,6 +317,11 @@ expr(#c_receive{clauses=Cs0,timeout=T0,a
     T1 = expr(T0, value, Sub),
     A1 = body(A0, Ctxt, Sub),
     Recv#c_receive{clauses=Cs1,timeout=T1,action=A1};
+expr(#c_search{clauses=Cs0,timeout=T0,action=A0}=Recv, Ctxt, Sub) ->
+    Cs1 = clauses(#c_var{name='_'}, Cs0, Recv, Ctxt, Sub), %This is all we know
+    T1 = expr(T0, value, Sub),
+    A1 = body(A0, Ctxt, Sub),
+    Recv#c_search{clauses=Cs1,timeout=T1,action=A1};
 expr(#c_apply{op=Op0,args=As0}=App, _, Sub) ->
     Op1 = expr(Op0, value, Sub),
     As1 = expr_list(As0, value, Sub),
@@ -1980,6 +1985,9 @@ tuple_to_values(#c_receive{clauses=Cs0,t
 	    _ -> tuple_to_values(A0, Arity)
 	end,
     Rec#c_receive{clauses=Cs,action=A};
+tuple_to_values(#c_search{clauses=Cs0,timeout=Timeout,action=A0}=Search, Arity) ->
+    #c_receive{clauses=Cs, action=A} = tuple_to_values(#c_receive{clauses=Cs0, timeout=Timeout, action=A0}, Arity),
+    Search#c_search{clauses=Cs, action=A};
 tuple_to_values(#c_clause{body=B0}=Clause, Arity) ->
     B = tuple_to_values(B0, Arity),
     Clause#c_clause{body=B};
diff -urNp otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl~ minimal_otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl~
--- otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/sys_core_fold.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,2525 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%%
+%%     $Id$
+%%
+%% Purpose : Constant folding optimisation for Core
+
+%% Propagate atomic values and fold in values of safe calls to
+%% constant arguments.  Also detect and remove literals which are
+%% ignored in a 'seq'.  Could handle lets better by chasing down
+%% complex 'arg' expressions and finding values.
+%%
+%% Try to optimise case expressions by removing unmatchable or
+%% unreachable clauses.  Also change explicit tuple arg into multiple
+%% values and extend clause patterns.  We must be careful here not to
+%% generate cases which we know to be safe but later stages will not
+%% recognise as such, e.g. the following is NOT acceptable:
+%%
+%%    case 'b' of
+%%        <'b'> -> ...
+%%    end
+%%
+%% Variable folding is complicated by variable shadowing, for example
+%% in:
+%%    'foo'/1 =
+%%        fun (X) ->
+%%            let <A> = X
+%%            in  let <X> = Y
+%%                in ... <use A>
+%% If we were to simply substitute X for A then we would be using the
+%% wrong X.  Our solution is to rename variables that are the values
+%% of substitutions.  We could rename all shadowing variables but do
+%% the minimum.  We would then get:
+%%    'foo'/1 =
+%%        fun (X) ->
+%%            let <A> = X
+%%            in  let <X1> = Y
+%%                in ... <use A>
+%% which is optimised to:
+%%    'foo'/1 =
+%%        fun (X) ->
+%%            let <X1> = Y
+%%            in ... <use X>
+%%
+%% This is done by carefully shadowing variables and substituting
+%% values.  See details when defining functions.
+%%
+%% It would be possible to extend to replace repeated evaluation of
+%% "simple" expressions by the value (variable) of the first call.
+%% For example, after a "let Z = X+1" then X+1 would be replaced by Z
+%% where X is valid.  The Sub uses the full Core expression as key.
+%% It would complicate handling of patterns as we would have to remove
+%% all values where the key contains pattern variables.
+
+-module(sys_core_fold).
+
+-export([module/2,format_error/1]).
+
+-import(lists, [map/2,foldl/3,foldr/3,mapfoldl/3,all/2,any/2,
+		reverse/1,reverse/2,member/2,nth/2,flatten/1]).
+-include("core_parse.hrl").
+
+%%-define(DEBUG, 1).
+
+-ifdef(DEBUG).
+-define(ASSERT(E),
+	case E of
+	    true -> ok;
+	    false ->
+		io:format("~p, line ~p: assertion failed\n", [?MODULE,?LINE]),
+		exit(assertion_failed)
+	end).
+-else.
+-define(ASSERT(E), ignore).
+-endif.
+
+%% Variable value info.
+-record(sub, {v=[],				%Variable substitutions
+	      s=[],				%Variables in scope
+	      t=[]}).				%Types
+
+module(#c_module{defs=Ds0}=Mod, Opts) ->
+    put(bin_opt_info, member(bin_opt_info, Opts)),
+    put(no_inline_list_funcs, not member(inline_list_funcs, Opts)),
+    case get(new_var_num) of
+	undefined -> put(new_var_num, 0);
+	_ -> ok
+    end,
+    init_warnings(),
+    Ds1 = [function_1(D) || D <- Ds0],
+    erase(no_inline_list_funcs),
+    erase(bin_opt_info),
+    {ok,Mod#c_module{defs=Ds1},get_warnings()}.
+
+function_1({#c_fname{id=F,arity=Arity}=Name,B0}) ->
+    try
+	?ASSERT([] =:= core_lib:free_vars(B0)),
+	B = expr(B0, value, sub_new()),			%This must be a fun!
+	{Name,B}
+    catch
+	Class:Error ->
+	    Stack = erlang:get_stacktrace(),
+	    io:fwrite("Function: ~w/~w\n", [F,Arity]),
+	    erlang:raise(Class, Error, Stack)
+    end.
+
+%% body(Expr, Sub) -> Expr.
+%% body(Expr, Context, Sub) -> Expr.
+%%  No special handling of anything except values.
+
+body(Body, Sub) ->
+    body(Body, value, Sub).
+
+body(#c_values{anno=A,es=Es0}, Ctxt, Sub) ->
+    Es1 = expr_list(Es0, Ctxt, Sub),
+    #c_values{anno=A,es=Es1};
+body(E, Ctxt, Sub) ->
+    ?ASSERT(verify_scope(E, Sub)),
+    expr(E, Ctxt, Sub).
+
+%% guard(Expr, Sub) -> Expr.
+%%  Do guard expression.  These are boolean expressions with values
+%%  which are tests.  These may be wrapped in a protected.  Seeing
+%%  that guards are side-effect free we can optimise the boolean
+%%  expressions.
+
+guard(Expr, Sub) ->
+    ?ASSERT(verify_scope(Expr, Sub)),
+    guard_1(Expr, Sub).
+
+guard_1(#c_call{module=#c_literal{val=erlang},
+	      name=#c_literal{val='not'},
+	      args=[A]}=Call, Sub) ->
+    case guard_1(A, Sub) of
+	#c_literal{val=true} -> #c_literal{val=false};
+	#c_literal{val=false} -> #c_literal{val=true};
+	Arg -> Call#c_call{args=[Arg]}
+    end;
+guard_1(#c_call{module=#c_literal{val=erlang},
+	      name=#c_literal{val='and'},
+	      args=[A1,A2]}=Call, Sub) ->
+    case {guard_1(A1, Sub),guard_1(A2, Sub)} of
+	{#c_literal{val=true},Arg2} -> Arg2;
+	{#c_literal{val=false},_} -> #c_literal{val=false};
+	{Arg1,#c_literal{val=true}} -> Arg1;
+	{_,#c_literal{val=false}} -> #c_literal{val=false};
+	{Arg1,Arg2} -> Call#c_call{args=[Arg1,Arg2]}
+    end;
+guard_1(#c_call{module=#c_literal{val=erlang},
+	      name=#c_literal{val='or'},
+	      args=[A1,A2]}=Call, Sub) ->
+    case {guard_1(A1, Sub),guard_1(A2, Sub)} of
+	{#c_literal{val=true},_} -> #c_literal{val=true};
+	{#c_literal{val=false},Arg2} -> Arg2;
+	{_,#c_literal{val=true}} -> #c_literal{val=true};
+	{Arg1,#c_literal{val=false}} -> Arg1;
+	{Arg1,Arg2} -> Call#c_call{args=[Arg1,Arg2]}
+    end;
+guard_1(#c_try{arg=E0,vars=[#c_var{name=X}],body=#c_var{name=X},
+	     handler=#c_literal{val=false}=False}=Prot, Sub) ->
+    E1 = body(E0, value, Sub),
+    case will_fail(E1) of
+	false ->
+	    %% We can remove try/catch if value is a simple.
+	    case core_lib:is_simple(E1) of
+		true -> E1;
+		false -> Prot#c_try{arg=E1}
+	    end;
+	true ->
+	    %% Expression will always fail.
+	    False
+    end;
+guard_1(E0, Sub) ->
+    E = expr(E0, value, Sub),
+    case will_fail(E) of
+	true -> #c_literal{val=false};
+	false -> E
+    end.
+
+%% expr(Expr, Sub) -> Expr.
+%% expr(Expr, Context, Sub) -> Expr.
+
+expr(Expr, Sub) ->
+    expr(Expr, value, Sub).
+
+expr(#c_var{}=V, Ctxt, Sub) ->
+    %% Return void() in effect context to potentially shorten the life time
+    %% of the variable and potentially generate better code
+    %% (for instance, if the variable no longer needs to survive a function
+    %% call, there will be no need to save it in the stack frame).
+    case Ctxt of
+	effect -> void();
+	value -> sub_get_var(V, Sub)
+    end;
+expr(#c_literal{val=Val}=L, Ctxt, _Sub) ->
+    case Ctxt of
+	effect ->
+	    case Val of
+		[] ->
+		    %% Keep as [] - might give slightly better code.
+		    L;
+		_ when is_atom(Val) ->
+		    %% For cleanliness replace with void().
+		    void();
+		_ ->
+		    %% Warn and replace with void().
+		    add_warning(L, useless_building),
+		    void()
+	    end;
+	value -> L
+    end;
+expr(#c_cons{hd=H0,tl=T0}=Cons, Ctxt, Sub) ->
+    H1 = expr(H0, Ctxt, Sub),
+    T1 = expr(T0, Ctxt, Sub),
+    case Ctxt of
+	effect ->
+	    add_warning(Cons, useless_building),
+	    expr(make_effect_seq([H1,T1]), Ctxt, Sub);
+	value ->
+	    eval_cons(Cons#c_cons{hd=H1,tl=T1}, H1, T1)
+    end;
+expr(#c_tuple{es=Es0}=Tuple, Ctxt, Sub) ->
+    Es = expr_list(Es0, Ctxt, Sub),
+    case Ctxt of
+	effect ->
+	    add_warning(Tuple, useless_building),
+	    expr(make_effect_seq(Es), Ctxt, Sub);
+	value ->
+	    eval_tuple(Tuple, Es)
+    end;
+expr(#c_binary{segments=Ss}=Bin0, Ctxt, Sub) ->
+    %% Warn for useless building, but always build the binary
+    %% anyway to preserve a possible exception.
+    case Ctxt of
+	effect -> add_warning(Bin0, useless_building);
+	value -> ok
+    end,
+    Bin1 = Bin0#c_binary{segments=bitstr_list(Ss, Sub)},
+    Bin = bin_un_utf(Bin1),
+    eval_binary(Bin);
+expr(#c_fname{}=Fname, _, _) -> Fname;
+expr(#c_fun{}=Fun, effect, _) ->
+    %% A fun is created, but not used. Warn, and replace with the void value.
+    add_warning(Fun, useless_building),
+    void();
+expr(#c_fun{vars=Vs0,body=B0}=Fun, Ctxt0, Sub0) ->
+    {Vs1,Sub1} = pattern_list(Vs0, Sub0),
+    Ctxt = case Ctxt0 of
+	       {letrec,Ctxt1} -> Ctxt1;
+	       value -> value
+	   end,
+    B1 = body(B0, Ctxt, Sub1),
+    Fun#c_fun{vars=Vs1,body=B1};
+expr(#c_seq{arg=Arg0,body=B0}=Seq0, Ctxt, Sub) ->
+    %% Optimise away pure literal arg as its value is ignored.
+    B1 = body(B0, Ctxt, Sub),
+    Arg = body(Arg0, effect, Sub),
+    case will_fail(Arg) of
+	true ->
+	    Arg;
+	false ->
+	    case Arg of
+		#c_values{es=Es} ->
+		    case is_safe_simple_list(Es) of
+			true -> B1;
+			false -> Seq0#c_seq{arg=Arg,body=B1}
+		    end;
+		_ ->
+		    case is_safe_simple(Arg) of
+			true -> B1;
+			false -> Seq0#c_seq{arg=Arg,body=B1}
+		    end
+	    end
+    end;
+expr(#c_let{}=Let, Ctxt, Sub) ->
+    case simplify_let(Let, Sub) of
+	impossible ->
+	    %% The argument for the let is "simple", i.e. has no
+	    %% complex structures such as let or seq that can be entered.
+	    opt_simple_let(Let, Ctxt, Sub);
+	Expr ->
+	    %% The let body was successfully moved into the let argument.
+	    %% Now recursively re-process the new expression.
+	    expr(Expr, Ctxt, sub_new(Sub))
+    end;
+expr(#c_letrec{defs=Fs0,body=B0}=Letrec, Ctxt, Sub) ->
+    Fs1 = map(fun ({Name,Fb}) ->
+		      {Name,expr(Fb, {letrec,Ctxt}, Sub)}
+	      end, Fs0),
+    B1 = body(B0, value, Sub),
+    Letrec#c_letrec{defs=Fs1,body=B1};
+expr(#c_case{}=Case0, Ctxt, Sub) ->
+    case simplify_case(Case0) of
+	#c_case{arg=Arg0,clauses=Cs0}=Case1 ->
+	    Arg1 = body(Arg0, value, Sub),
+	    {Arg2,Cs1} = case_opt(Arg1, Cs0),
+	    Cs2 = clauses(Arg2, Cs1, Case1, Ctxt, Sub),
+	    Case = eval_case(Case1#c_case{arg=Arg2,clauses=Cs2}, Sub),
+	    bsm_an(Case);
+	Other ->
+	    expr(Other, Ctxt, Sub)
+    end;
+expr(#c_receive{clauses=Cs0,timeout=T0,action=A0}=Recv, Ctxt, Sub) ->
+    Cs1 = clauses(#c_var{name='_'}, Cs0, Recv, Ctxt, Sub), %This is all we know
+    T1 = expr(T0, value, Sub),
+    A1 = body(A0, Ctxt, Sub),
+    Recv#c_receive{clauses=Cs1,timeout=T1,action=A1};
+expr(#c_search{clauses=Cs0,timeout=T0,action=A0}=Recv, Ctxt, Sub) ->
+    Cs1 = clauses(#c_var{name='_'}, Cs0, Recv, Ctxt, Sub), %This is all we know
+    T1 = expr(T0, value, Sub),
+    A1 = body(A0, Ctxt, Sub),
+    Recv#c_search{clauses=Cs1,timeout=T1,action=A1};
+expr(#c_apply{op=Op0,args=As0}=App, _, Sub) ->
+    Op1 = expr(Op0, value, Sub),
+    As1 = expr_list(As0, value, Sub),
+    App#c_apply{op=Op1,args=As1};
+expr(#c_call{module=M0,name=N0}=Call0, Ctxt, Sub) ->
+    M1 = expr(M0, value, Sub),
+    N1 = expr(N0, value, Sub),
+    Call = Call0#c_call{module=M1,name=N1},
+    case useless_call(Ctxt, Call) of
+	no -> call(Call, M1, N1, Sub);
+	{yes,Seq} -> expr(Seq, Ctxt, Sub)
+    end;
+expr(#c_primop{args=As0}=Prim, _, Sub) ->
+    As1 = expr_list(As0, value, Sub),
+    Prim#c_primop{args=As1};
+expr(#c_catch{body=B0}=Catch, _, Sub) ->
+    %% We can remove catch if the value is simple
+    B1 = body(B0, value, Sub),
+    case is_safe_simple(B1) of
+	true -> B1;
+	false -> Catch#c_catch{body=B1}
+    end;
+expr(#c_try{arg=E0,vars=[#c_var{name=X}],body=#c_var{name=X},
+	    handler=#c_literal{val=false}=False}=Prot, _, Sub) ->
+    %% Since guard may call expr/2, we must do some optimization of
+    %% the kind of try's that occur in guards.
+    E1 = body(E0, value, Sub),
+    case will_fail(E1) of
+	false ->
+	    %% We can remove try/catch if value is a simple.
+	    case core_lib:is_simple(E1) of
+		true -> E1;
+		false -> Prot#c_try{arg=E1}
+	    end;
+	true ->
+	    %% Expression will always fail.
+	    False
+    end;
+expr(#c_try{anno=A,arg=E0,vars=Vs0,body=B0,evars=Evs0,handler=H0}=Try, _, Sub0) ->
+    %% Here is the general try/catch construct outside of guards.
+    %% We can remove try if the value is simple and replace it with a let.
+    E1 = body(E0, value, Sub0),
+    {Vs1,Sub1} = pattern_list(Vs0, Sub0),
+    B1 = body(B0, value, Sub1),
+    case is_safe_simple(E1) of
+	true ->
+	    expr(#c_let{anno=A,vars=Vs1,arg=E1,body=B1}, value, Sub0);
+	false ->
+	    {Evs1,Sub2} = pattern_list(Evs0, Sub0),
+	    H1 = body(H0, value, Sub2),
+	    Try#c_try{arg=E1,vars=Vs1,body=B1,evars=Evs1,handler=H1}
+    end.
+
+expr_list(Es, Ctxt, Sub) ->
+    [expr(E, Ctxt, Sub) || E <- Es].
+
+bitstr_list(Es, Sub) ->
+    [bitstr(E, Sub) || E <- Es].
+
+bitstr(#c_bitstr{val=Val,size=Size}=BinSeg, Sub) ->
+    BinSeg#c_bitstr{val=expr(Val, Sub),size=expr(Size, value, Sub)}.
+
+%% is_safe_simple(Expr) -> true | false.
+%%  A safe simple cannot fail with badarg.  Binaries are difficult to
+%%  check so we consider them unsafe.
+
+is_safe_simple(#c_var{}) -> true;		%Not atomic
+is_safe_simple(#c_cons{hd=H,tl=T}) ->
+    is_safe_simple(H) andalso is_safe_simple(T);
+is_safe_simple(#c_tuple{es=Es}) -> is_safe_simple_list(Es);
+is_safe_simple(#c_literal{}) -> true;
+is_safe_simple(#c_fname{}) -> true;
+is_safe_simple(_) -> false.
+
+is_safe_simple_list(Es) -> all(fun is_safe_simple/1, Es).
+
+%% will_fail(Expr) -> true|false.
+%%  Determine whether the expression will fail with an exception.
+%%  Return true if the expression always will fail with an exception,
+%%  i.e. never return normally.
+
+will_fail(#c_let{arg=A,body=B}) ->
+    will_fail(A) orelse will_fail(B);
+will_fail(#c_call{module=#c_literal{val=Mod},name=#c_literal{val=Name},args=Args}) ->
+    erl_bifs:is_exit_bif(Mod, Name, length(Args));
+will_fail(#c_primop{name=#c_literal{val=match_fail},args=[_]}) -> true;
+will_fail(_) -> false.
+
+%% eval_cons(Cons, Head, Tail) -> Expr.
+%%  Evaluate constant part of a cons expression.
+
+eval_cons(#c_cons{anno=A}, #c_literal{val=C}, #c_literal{val=S}) ->
+    #c_literal{anno=A,val=[C|S]};
+eval_cons(Cons, H, T) ->
+    Cons#c_cons{hd=H,tl=T}.			%Rebuild cons arguments
+
+eval_tuple(#c_tuple{anno=A}=Tuple, Es0) ->
+    case eval_tuple_1(Es0, []) of
+	no -> Tuple#c_tuple{es=Es0};
+	Es -> #c_literal{anno=A,val=list_to_tuple(Es)}
+    end.
+
+eval_tuple_1([#c_literal{val=Val}|Es], Acc) ->
+    eval_tuple_1(Es, [Val|Acc]);
+eval_tuple_1([_|_], _) -> no;
+eval_tuple_1([], Acc) -> reverse(Acc).
+
+%% bin_un_utf(#c_binary{}) -> #c_binary{}
+%%  Convert any literal UTF-8/16/32 literals to byte-sized
+%%  integer fields.
+
+bin_un_utf(#c_binary{anno=Anno,segments=Ss}=Bin) ->
+    Bin#c_binary{segments=bin_un_utf_1(Ss, Anno)}.
+
+bin_un_utf_1([#c_bitstr{val=#c_literal{},type=#c_literal{val=utf8}}=H|T],
+	     Anno) ->
+    bin_un_utf_eval(H, Anno) ++ bin_un_utf_1(T, Anno);
+bin_un_utf_1([#c_bitstr{val=#c_literal{},type=#c_literal{val=utf16}}=H|T],
+	     Anno) ->
+    bin_un_utf_eval(H, Anno) ++ bin_un_utf_1(T, Anno);
+bin_un_utf_1([#c_bitstr{val=#c_literal{},type=#c_literal{val=utf32}}=H|T],
+	     Anno) ->
+    bin_un_utf_eval(H, Anno) ++ bin_un_utf_1(T, Anno);
+bin_un_utf_1([H|T], Anno) ->
+    [H|bin_un_utf_1(T, Anno)];
+bin_un_utf_1([], _) -> [].
+
+bin_un_utf_eval(Bitstr, Anno) ->
+    Segments = [Bitstr],
+    case eval_binary(#c_binary{anno=Anno,segments=Segments}) of
+	#c_literal{anno=Anno,val=Bytes} when is_binary(Bytes) ->
+	    [#c_bitstr{anno=Anno,
+		       val=#c_literal{anno=Anno,val=B},
+		       size=#c_literal{anno=Anno,val=8},
+		       unit=#c_literal{anno=Anno,val=1},
+		       type=#c_literal{anno=Anno,val=integer},
+		       flags=#c_literal{anno=Anno,val=[unsigned,big]}} ||
+		B <- binary_to_list(Bytes)];
+	_ ->
+	    Segments
+    end.
+
+%% eval_binary(#c_binary{}, matching|construction) ->
+%%      #c_binary{} | #c_literal{}
+%%  Evaluate a binary at compile time if possible to create
+%%  a binary literal.
+
+eval_binary(#c_binary{anno=Anno,segments=Ss}=Bin) ->
+    try
+	#c_literal{anno=Anno,val=eval_binary_1(Ss, <<>>)}
+    catch
+	throw:impossible ->
+	    Bin;
+	  throw:{badarg,Warning} ->
+	    add_warning(Bin, Warning),
+	    #c_call{module=#c_literal{val=erlang},
+		    name=#c_literal{val=error},
+		    args=[#c_literal{val=badarg}]}
+    end.
+
+eval_binary_1([#c_bitstr{val=#c_literal{val=Val},size=#c_literal{val=Sz},
+			 unit=#c_literal{val=Unit},type=#c_literal{val=Type},
+			 flags=#c_literal{val=Flags}}|Ss], Acc0) ->
+    Endian = case member(big, Flags) of
+		 true ->
+		     big;
+		 false ->
+		     case member(little, Flags) of
+			 true -> little;
+			 false -> throw(impossible) %Native endian.
+		     end
+	     end,
+
+    %% Make sure that the size is reasonable.
+    case Type of
+	binary when is_bitstring(Val) ->
+	    if
+		Sz =:= all ->
+		    ok;
+		Sz*Unit =< bit_size(Val) ->
+		    ok;
+		true ->
+		    %% Field size is greater than the actual binary - will fail.
+		    throw({badarg,embedded_binary_size})
+	    end;
+	integer when is_integer(Val) ->
+	    %% Estimate the number of bits needed to to hold the integer
+	    %% literal. Check whether the field size is reasonable in
+	    %% proportion to the number of bits needed.
+	    if
+		Sz*Unit =< 256 ->
+		    %% Don't be cheap - always accept fields up to this size.
+		    ok;
+		true ->
+		    case count_bits(Val) of
+			BitsNeeded when 2*BitsNeeded >= Sz*Unit ->
+			    ok;
+			_ ->
+			    %% More than about half of the field size will be
+			    %% filled out with zeroes - not acceptable.
+			    throw(impossible)
+		    end
+	    end;
+	float when is_float(Val) ->
+	    %% Bad float size.
+	    case Sz*Unit of
+		32 -> ok;
+		64 -> ok;
+		_ -> throw(impossible)
+	    end;
+	utf8 -> ok;
+	utf16 -> ok;
+	utf32 -> ok;
+	_ ->
+	    throw(impossible)
+    end,
+
+    %% Evaluate the field.
+    try eval_binary_2(Acc0, Val, Sz, Unit, Type, Endian) of
+	Acc -> eval_binary_1(Ss, Acc)
+    catch
+	error:_ ->
+	    throw(impossible)
+    end;
+eval_binary_1([], Acc) -> Acc;
+eval_binary_1(_, _) -> throw(impossible).
+
+eval_binary_2(Acc, Val, Size, Unit, integer, little) ->
+    <<Acc/bitstring,Val:(Size*Unit)/little>>;
+eval_binary_2(Acc, Val, Size, Unit, integer, big) ->
+    <<Acc/bitstring,Val:(Size*Unit)/big>>;
+eval_binary_2(Acc, Val, _Size, _Unit, utf8, _) ->
+    %% XXX Simplify this code in the release following R12B-5.
+    %%<<Acc/bitstring,Val/utf8>>;
+    <<Acc/bitstring,(int_to_utf8(Val))/binary>>;
+eval_binary_2(Acc, Val, _Size, _Unit, utf16, big) ->
+    %% XXX Simplify this code in the release following R12B-5.
+    %%<<Acc/bitstring,Val/big-utf16>>;
+    <<Acc/bitstring,(int_to_utf16_be(Val))/binary>>;
+eval_binary_2(Acc, Val, _Size, _Unit, utf16, little) ->
+    %% XXX Simplify this code in the release following R12B-5.
+    %%<<Acc/bitstring,Val/little-utf16>>;
+    <<Acc/bitstring,(int_to_utf16_le(Val))/binary>>;
+eval_binary_2(Acc, Val, _Size, _Unit, utf32, big) ->
+    %% XXX Simplify this code in the release following R12B-5.
+    validate_unicode_char(Val),
+    <<Acc/bitstring,Val:32/big>>;
+eval_binary_2(Acc, Val, _Size, _Unit, utf32, little) ->
+    %% XXX Simplify this code in the release following R12B-5.
+    validate_unicode_char(Val),
+    <<Acc/bitstring,Val:32/little>>;
+eval_binary_2(Acc, Val, Size, Unit, float, little) ->
+    <<Acc/bitstring,Val:(Size*Unit)/little-float>>;
+eval_binary_2(Acc, Val, Size, Unit, float, big) ->
+    <<Acc/bitstring,Val:(Size*Unit)/big-float>>;
+eval_binary_2(Acc, Val, all, Unit, binary, _) ->
+    case bit_size(Val) of
+	Size when Size rem Unit =:= 0 ->
+	    <<Acc/bitstring,Val:Size/bitstring>>;
+	Size ->
+	    throw({badarg,{embedded_unit,Unit,Size}})
+    end;
+eval_binary_2(Acc, Val, Size, Unit, binary, _) ->
+    <<Acc/bitstring,Val:(Size*Unit)/bitstring>>.
+
+int_to_utf8(I) when 0 =< I, I =< 16#7F ->
+    <<I>>;
+int_to_utf8(I) when 0 =< I, I =< 16#7FF ->
+    B2 = I,
+    B1 = (I bsr 6),
+    <<1:1,1:1,0:1,B1:5,1:1,0:1,B2:6>>;
+int_to_utf8(I) when 0 =< I, I =< 16#FFFF ->
+    if
+	16#D800 =< I, I =< 16#DFFF;
+	I =:= 16#FFFE; I =:= 16#FFFF -> throw({badarg,bad_unicode});
+	true -> ok
+    end,
+    B3 = I,
+    B2 = (I bsr 6),
+    B1 = (I bsr 12),
+    <<1:1,1:1,1:1,0:1,B1:4,1:1,0:1,B2:6,1:1,0:1,B3:6>>;
+int_to_utf8(I) when 0 =< I, I =< 16#10FFFF ->
+    B4 = I,
+    B3 = (I bsr 6),
+    B2 = (I bsr 12),
+    B1 = (I bsr 18),
+    <<1:1,1:1,1:1,1:1,0:1,B1:3,1:1,0:1,B2:6,1:1,0:1,B3:6,1:1,0:1,B4:6>>;
+int_to_utf8(_) ->
+    throw({badarg,bad_unicode}).
+
+int_to_utf16_be(I) when 0 =< I, I =< 16#10000 ->
+    if
+	16#D800 =< I, I =< 16#DFFF;
+	I =:= 16#FFFE; I =:= 16#FFFF -> throw({badarg,bad_unicode});
+	true -> ok
+    end,
+    <<I:16/big>>;
+int_to_utf16_be(I) when 16#10000 =< I, I =< 16#10FFFF ->
+    U = I - 16#10000,
+    W1 = 16#D800 bor (U bsr 10),
+    W2 = 16#DC00 bor (U band 16#3FF),
+    <<W1:16/big,W2:16/big>>;
+int_to_utf16_be(_) ->
+    throw({badarg,bad_unicode}).
+
+int_to_utf16_le(I) when 0 =< I, I =< 16#10000 ->
+    if
+	16#D800 =< I, I =< 16#DFFF;
+	I =:= 16#FFFE; I =:= 16#FFFF -> throw({badarg,bad_unicode});
+	true -> ok
+    end,
+    <<I:16/little>>;
+int_to_utf16_le(I) when 16#10000 =< I, I =< 16#10FFFF ->
+    U = I - 16#10000,
+    W1 = 16#D800 bor (U bsr 10),
+    W2 = 16#DC00 bor (U band 16#3FF),
+    <<W1:16/little,W2:16/little>>;
+int_to_utf16_le(_) ->
+    throw({badarg,bad_unicode}).
+
+validate_unicode_char(I) ->
+    if
+	I < 0;
+	16#D800 =< I, I =< 16#DFFF;
+	I =:= 16#FFFE; I =:= 16#FFFF;
+	I > 16#10FFFF -> throw({badarg,bad_unicode});
+	true -> ok
+    end.
+
+%% Count the number of bits approximately needed to store Int.
+%% (We don't need an exact result for this purpose.)
+
+count_bits(Int) -> 
+    count_bits_1(abs(Int), 64).
+
+count_bits_1(0, Bits) -> Bits;
+count_bits_1(Int, Bits) -> count_bits_1(Int bsr 64, Bits+64).
+
+%% useless_call(Context, #c_call{}) -> no | {yes,Expr}
+%%  Check whether the function is called only for effect,
+%%  and if the function either has no effect whatsoever or
+%%  the only effect is an exception. Generate appropriate
+%%  warnings. If the call is "useless" (has no effect),
+%%  a rewritten expression consisting of a sequence of
+%%  the arguments only is returned.
+
+useless_call(effect, #c_call{module=#c_literal{val=Mod},
+			     name=#c_literal{val=Name},
+			     args=Args}=Call) ->
+    A = length(Args),
+    case erl_bifs:is_safe(Mod, Name, A) of
+	false ->
+	    case erl_bifs:is_pure(Mod, Name, A) of
+		true -> add_warning(Call, result_ignored);
+		false -> ok
+	    end,
+	    no;
+	true ->
+	    add_warning(Call, {no_effect,{Mod,Name,A}}),
+	    {yes,make_effect_seq(Args)}
+    end;
+useless_call(_, _) -> no.
+
+%% make_effect_seq([Expr]) -> #c_seq{}|void()
+%%  Convert a list of epressions evaluated in effect context to a chain of
+%%  #c_seq{}. The body in the innermost #c_seq{} will be void().
+%%  Anything that will not have any effect will be thrown away.
+
+make_effect_seq([H|T]) ->
+    case is_safe_simple(H) of
+	true -> make_effect_seq(T);
+	false -> #c_seq{arg=H,body=make_effect_seq(T)}
+    end;
+make_effect_seq([]) -> void().
+
+%% Handling remote calls. The module/name fields have been processed.
+
+call(#c_call{args=As}=Call, #c_literal{val=M}=M0, #c_literal{val=N}=N0, Sub) ->
+    case get(no_inline_list_funcs) of
+  	true ->
+ 	    call_0(Call, M0, N0, As, Sub);
+  	false ->
+  	    call_1(Call, M, N, As, Sub)
+      end;
+call(#c_call{args=As}=Call, M, N, Sub) ->
+    call_0(Call, M, N, As, Sub).
+
+call_0(Call, M, N, As0, Sub) ->
+    As1 = expr_list(As0, value, Sub),
+    fold_call(Call#c_call{args=As1}, M, N, As1).
+
+%% We inline some very common higher order list operations.
+%% We use the same evaluation order as the library function.
+
+call_1(_Call, lists, all, [Arg1,Arg2], Sub) ->
+    Loop = #c_fname{id='lists^all', arity=1},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    Err1 = #c_tuple{es=[#c_literal{val='case_clause'}, X]},
+    CC1 = #c_clause{pats=[#c_literal{val=true}], guard=#c_literal{val=true},
+		    body=#c_apply{op=Loop, args=[Xs]}},
+    CC2 = #c_clause{pats=[#c_literal{val=false}], guard=#c_literal{val=true},
+		    body=#c_literal{val=false}},
+    CC3 = #c_clause{pats=[X], guard=#c_literal{val=true},
+		    body=#c_primop{name=#c_literal{val='match_fail'},
+				   args=[Err1]}},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_case{arg=#c_apply{op=F, args=[X]},
+				clauses = [CC1, CC2, CC3]}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+		   body=#c_literal{val=true}},
+    Err2 = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err2]}},
+    Fun = #c_fun{vars=[Xs],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, L], arg=#c_values{es=[Arg1, Arg2]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L]}}},
+	 Sub);
+call_1(_Call, lists, any, [Arg1,Arg2], Sub) ->
+    Loop = #c_fname{id='lists^any', arity=1},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    Err1 = #c_tuple{es=[#c_literal{val='case_clause'}, X]},
+    CC1 = #c_clause{pats=[#c_literal{val=true}], guard=#c_literal{val=true},
+		    body=#c_literal{val=true}},
+    CC2 = #c_clause{pats=[#c_literal{val=false}], guard=#c_literal{val=true},
+		    body=#c_apply{op=Loop, args=[Xs]}},
+    CC3 = #c_clause{pats=[X], guard=#c_literal{val=true},
+		    body=#c_primop{name=#c_literal{val='match_fail'},
+				   args=[Err1]}},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_case{arg=#c_apply{op=F, args=[X]},
+				clauses = [CC1, CC2, CC3]}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+		   body=#c_literal{val=false}},
+    Err2 = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err2]}},
+    Fun = #c_fun{vars=[Xs],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, L], arg=#c_values{es=[Arg1, Arg2]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L]}}},
+	 Sub);
+call_1(_Call, lists, foreach, [Arg1,Arg2], Sub) ->
+    Loop = #c_fname{id='lists^foreach', arity=1},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_seq{arg=#c_apply{op=F, args=[X]},
+			       body=#c_apply{op=Loop, args=[Xs]}}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+		   body=#c_literal{val=ok}},
+    Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err]}},
+    Fun = #c_fun{vars=[Xs],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, L], arg=#c_values{es=[Arg1, Arg2]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L]}}},
+	 Sub);
+call_1(_Call, lists, map, [Arg1,Arg2], Sub) ->
+    Loop = #c_fname{id='lists^map', arity=1},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    H = #c_var{name='H'},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_let{vars=[H], arg=#c_apply{op=F, args=[X]},
+			       body=#c_cons{hd=H,
+					    tl=#c_apply{op=Loop,
+							args=[Xs]}}}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+		   body=#c_literal{val=[]}},
+    Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err]}},
+    Fun = #c_fun{vars=[Xs],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, L], arg=#c_values{es=[Arg1, Arg2]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L]}}},
+	 Sub);
+call_1(_Call, lists, flatmap, [Arg1,Arg2], Sub) ->
+    Loop = #c_fname{id='lists^flatmap', arity=1},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    H = #c_var{name='H'},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_let{vars=[H],
+			       arg=#c_apply{op=F, args=[X]},
+			       body=#c_call{module=#c_literal{val=erlang},
+					    name=#c_literal{val='++'},
+					    args=[H,
+						  #c_apply{op=Loop,
+							   args=[Xs]}]}}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+		   body=#c_literal{val=[]}},
+    Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err]}},
+    Fun = #c_fun{vars=[Xs],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, L], arg=#c_values{es=[Arg1, Arg2]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L]}}},
+	 Sub);
+call_1(_Call, lists, filter, [Arg1,Arg2], Sub) ->
+    Loop = #c_fname{id='lists^filter', arity=1},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    B = #c_var{name='B'},
+    Err1 = #c_tuple{es=[#c_literal{val='case_clause'}, X]},
+    CC1 = #c_clause{pats=[#c_literal{val=true}], guard=#c_literal{val=true},
+		    body=#c_cons{hd=X, tl=Xs}},
+    CC2 = #c_clause{pats=[#c_literal{val=false}], guard=#c_literal{val=true},
+		    body=Xs},
+    CC3 = #c_clause{pats=[X], guard=#c_literal{val=true},
+		    body=#c_primop{name=#c_literal{val='match_fail'},
+				   args=[Err1]}},
+    Case = #c_case{arg=B, clauses = [CC1, CC2, CC3]},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_let{vars=[B],
+			       arg=#c_apply{op=F, args=[X]},
+			       body=#c_let{vars=[Xs],
+					   arg=#c_apply{op=Loop,
+							args=[Xs]},
+					   body=Case}}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+		   body=#c_literal{val=[]}},
+    Err2 = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err2]}},
+    Fun = #c_fun{vars=[Xs],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, L], arg=#c_values{es=[Arg1, Arg2]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L]}}},
+    Sub);
+call_1(_Call, lists, foldl, [Arg1,Arg2,Arg3], Sub) ->
+    Loop = #c_fname{id='lists^foldl', arity=2},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    A = #c_var{name='A'},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_apply{op=Loop,
+				 args=[Xs, #c_apply{op=F, args=[X, A]}]}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true}, body=A},
+    Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err]}},
+    Fun = #c_fun{vars=[Xs, A],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, A, L], arg=#c_values{es=[Arg1, Arg2, Arg3]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L, A]}}},
+	 Sub);
+call_1(_Call, lists, foldr, [Arg1,Arg2,Arg3], Sub) ->
+    Loop = #c_fname{id='lists^foldr', arity=2},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    A = #c_var{name='A'},
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=#c_apply{op=F, args=[X, #c_apply{op=Loop,
+							 args=[Xs, A]}]}},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true}, body=A},
+    Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err]}},
+    Fun = #c_fun{vars=[Xs, A],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, A, L], arg=#c_values{es=[Arg1, Arg2, Arg3]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+			       body=#c_apply{op=Loop, args=[L, A]}}},
+	 Sub);
+call_1(_Call, lists, mapfoldl, [Arg1,Arg2,Arg3], Sub) ->
+    Loop = #c_fname{id='lists^mapfoldl', arity=2},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    Avar = #c_var{name='A'},
+    Match =
+	fun (A, P, E) ->
+		C1 = #c_clause{pats=[P], guard=#c_literal{val=true}, body=E},
+		Err = #c_tuple{es=[#c_literal{val='badmatch'}, X]},
+		C2 = #c_clause{pats=[X], guard=#c_literal{val=true},
+			       body=#c_primop{name=#c_literal{val='match_fail'},
+					      args=[Err]}},
+		#c_case{arg=A, clauses=[C1, C2]}
+	end,
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+		   body=Match(#c_apply{op=F, args=[X, Avar]},
+			      #c_tuple{es=[X, Avar]},
+%%% Tuple passing version
+			      Match(#c_apply{op=Loop, args=[Xs, Avar]},
+				    #c_tuple{es=[Xs, Avar]},
+				    #c_tuple{es=[#c_cons{hd=X, tl=Xs}, Avar]})
+%%% Multiple-value version
+%%% 			      #c_let{vars=[Xs,A],
+%%% 				     %% The tuple here will be optimised
+%%% 				     %% away later; no worries.
+%%% 				     arg=#c_apply{op=Loop, args=[Xs, A]},
+%%% 				     body=#c_values{es=[#c_cons{hd=X, tl=Xs},
+%%% 							A]}}
+			     )},
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+%%% Tuple passing version
+		   body=#c_tuple{es=[#c_literal{val=[]}, Avar]}},
+%%% Multiple-value version
+%%% 		   body=#c_values{es=[#c_literal{val=[]}, A]}},
+    Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err]}},
+    Fun = #c_fun{vars=[Xs, Avar],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, Avar, L], arg=#c_values{es=[Arg1, Arg2, Arg3]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+%%% Tuple passing version
+			       body=#c_apply{op=Loop, args=[L, Avar]}}},
+%%% Multiple-value version
+%%% 			       body=#c_let{vars=[Xs, A],
+%%% 					   arg=#c_apply{op=Loop,
+%%% 							args=[L, A]},
+%%% 					   body=#c_tuple{es=[Xs, A]}}}},
+	 Sub);
+call_1(_Call, lists, mapfoldr, [Arg1,Arg2,Arg3], Sub) ->
+    Loop = #c_fname{id='lists^mapfoldr', arity=2},
+    F = #c_var{name='F'},
+    Xs = #c_var{name='Xs'},
+    X = #c_var{name='X'},
+    Avar = #c_var{name='A'},
+    Match =
+	fun (A, P, E) ->
+		C1 = #c_clause{pats=[P], guard=#c_literal{val=true}, body=E},
+		Err = #c_tuple{es=[#c_literal{val='badmatch'}, X]},
+		C2 = #c_clause{pats=[X], guard=#c_literal{val=true},
+			       body=#c_primop{name=#c_literal{val='match_fail'},
+					      args=[Err]}},
+		#c_case{arg=A, clauses=[C1, C2]}
+	end,
+    C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
+%%% Tuple passing version
+		   body=Match(#c_apply{op=Loop, args=[Xs, Avar]},
+			      #c_tuple{es=[Xs, Avar]},
+			      Match(#c_apply{op=F, args=[X, Avar]},
+				    #c_tuple{es=[X, Avar]},
+				    #c_tuple{es=[#c_cons{hd=X, tl=Xs}, Avar]}))
+%%% Multiple-value version
+%%% 		   body=#c_let{vars=[Xs,A],
+%%% 			       %% The tuple will be optimised away
+%%% 			       arg=#c_apply{op=Loop, args=[Xs, A]},
+%%% 			       body=Match(#c_apply{op=F, args=[X, A]},
+%%% 					  #c_tuple{es=[X, A]},
+%%% 					  #c_values{es=[#c_cons{hd=X, tl=Xs},
+%%% 						        A]})}
+		  },
+    C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
+%%% Tuple passing version
+		   body=#c_tuple{es=[#c_literal{val=[]}, Avar]}},
+%%% Multiple-value version
+%%% 		   body=#c_values{es=[#c_literal{val=[]}, A]}},
+    Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
+    C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
+		   body=#c_primop{name=#c_literal{val='match_fail'},
+				  args=[Err]}},
+    Fun = #c_fun{vars=[Xs, Avar],
+		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
+    L = #c_var{name='L'},
+    expr(#c_let{vars=[F, Avar, L], arg=#c_values{es=[Arg1, Arg2, Arg3]},
+		body=#c_letrec{defs=[{Loop,Fun}],
+%%% Tuple passing version
+ 			       body=#c_apply{op=Loop, args=[L, Avar]}}},
+%%% Multiple-value version
+%%% 			       body=#c_let{vars=[Xs, A],
+%%% 					   arg=#c_apply{op=Loop,
+%%% 							args=[L, A]},
+%%% 					   body=#c_tuple{es=[Xs, A]}}}},
+	 Sub);
+call_1(#c_call{module=M, name=N}=Call, _, _, As, Sub) ->
+    call_0(Call, M, N, As, Sub).
+
+%% fold_call(Call, Mod, Name, Args) -> Expr.
+%%  Try to safely evaluate the call.  Just try to evaluate arguments,
+%%  do the call and convert return values to literals.  If this
+%%  succeeds then use the new value, otherwise just fail and use
+%%  original call.  Do this at every level.
+%%
+%%  We evaluate length/1 if the shape of the list is known.
+%%
+%%  We evaluate element/2 and setelement/3 if the position is constant and
+%%  the shape of the tuple is known.
+%%
+%%  We evalute '++' if the first operand is a literal (or partly literal).
+
+fold_call(Call, #c_literal{val=M}, #c_literal{val=F}, Args) ->
+    fold_call_1(Call, M, F, Args);
+fold_call(Call, _M, _N, _Args) -> Call.
+
+fold_call_1(Call, lists, append, [Arg1,Arg2]) ->
+    eval_append(Call, Arg1, Arg2);
+fold_call_1(Call, erlang, length, [Arg]) ->
+    eval_length(Call, Arg);
+fold_call_1(Call, erlang, '++', [Arg1,Arg2]) ->
+    eval_append(Call, Arg1, Arg2);
+fold_call_1(Call, erlang, element, [Arg1,Arg2]) ->
+    eval_element(Call, Arg1, Arg2);
+fold_call_1(Call, erlang, setelement, [Arg1,Arg2,Arg3]) ->
+    try
+	eval_setelement(Arg1, Arg2, Arg3)
+    catch _:_ ->
+	    Call
+    end;
+fold_call_1(Call, erlang, apply, [Mod,Func,Args]) ->
+    simplify_apply(Call, Mod, Func, Args);
+fold_call_1(Call, erlang, N, Args) ->
+    eval_erlang_call(Call, N, Args);
+fold_call_1(Call, _Mod, _Name, _Args) -> Call.
+
+eval_erlang_call(Call, N, Args0) ->
+    NumArgs = length(Args0),
+    case erl_bifs:is_pure(erlang, N, NumArgs) of
+	false -> Call;				%Not pure - keep call.
+	true ->
+	    case catch begin
+			   Args = [core_lib:literal_value(A) || A <- Args0],
+			   eval_erlang_call_1(Call, N, Args)
+		       end of
+		{ok,Val} -> Val;
+		_Other ->
+		    case erl_internal:comp_op(N, NumArgs) of
+			false -> Call;
+			true -> eval_rel_op(Call, N, Args0)
+		    end
+	    end
+    end.
+
+eval_erlang_call_1(Call, N, Args) ->
+    case catch apply(erlang, N, Args) of
+	{'EXIT',{Reason,_}} ->
+	    eval_failure(Call, Reason);
+	Val ->
+	    {ok,core_lib:make_literal(Val)}
+    end.
+
+eval_rel_op(Call, Op, [#c_var{name=V},#c_var{name=V}]) ->
+    Bool = erlang:Op(same, same),
+    #c_literal{anno=core_lib:get_anno(Call),val=Bool};
+eval_rel_op(Call, _, _) -> Call.
+
+%% eval_length(Call, List) -> Val.
+%%  Evaluates the length for the prefix of List which has a known
+%%  shape.
+
+eval_length(Call, Core) -> eval_length(Call, Core, 0).
+
+eval_length(Call, #c_literal{val=Val}, Len0) ->
+    try
+	Len = Len0 + length(Val),
+	#c_literal{anno=Call#c_call.anno,val=Len}
+    catch
+	_:_ ->
+	    eval_failure(Call, badarg)
+    end;
+eval_length(Call, #c_cons{tl=T}, Len) ->
+    eval_length(Call, T, Len+1);
+eval_length(Call, _List, 0) ->
+    Call;		%Could do nothing
+eval_length(Call, List, Len) ->
+    A = Call#c_call.anno,
+    #c_call{anno=A,
+	    module=#c_literal{anno=A,val=erlang},
+	    name=#c_literal{anno=A,val='+'},
+	    args=[#c_literal{anno=A,val=Len},Call#c_call{args=[List]}]}.
+
+%% eval_append(Call, FirstList, SecondList) -> Val.
+%%  Evaluates the constant part of '++' expression.
+
+eval_append(Call, #c_literal{val=Cs1}=S1, #c_literal{val=Cs2}) ->
+    try
+	S1#c_literal{val=Cs1 ++ Cs2}
+    catch error:badarg ->
+	    eval_failure(Call, badarg)
+    end;
+eval_append(Call, #c_literal{val=Cs}, List) when length(Cs) =< 4 ->
+    Anno = Call#c_call.anno,
+    foldr(fun (C, L) ->
+		  #c_cons{anno=Anno,hd=#c_literal{val=C},tl=L}
+	  end, List, Cs);
+eval_append(Call, #c_cons{tl=T}=Cons, List) ->
+    Cons#c_cons{tl=eval_append(Call, T, List)};
+eval_append(Call, X, Y) ->
+    Call#c_call{args=[X,Y]}.			%Rebuild call arguments.
+
+%% eval_element(Pos, Tuple) -> Val.
+%%  Evaluates element/2 if Pos and Tuple are literals.
+
+eval_element(Call, #c_literal{val=Pos}, #c_tuple{es=Es}) when is_integer(Pos) ->
+    if
+	1 =< Pos, Pos =< length(Es) ->
+	    lists:nth(Pos, Es);
+	true ->
+	    eval_failure(Call, badarg)
+    end;
+eval_element(Call, #c_literal{val=Pos}, #c_literal{val=Val}=Lit)
+  when is_integer(Pos), is_tuple(Val) ->
+    if
+	1 =< Pos, Pos =< tuple_size(Val) ->
+	    Lit#c_literal{val=element(Pos, Val)};
+	true ->
+	    eval_failure(Call, badarg)
+    end;
+eval_element(Call, Pos, Tuple) ->
+    case is_not_integer(Pos) orelse is_not_tuple(Tuple) of
+	true ->
+	    eval_failure(Call, badarg);
+	false ->
+	    Call
+    end.
+
+%% is_not_integer(Core) -> true | false.
+%%  Returns true if Core is definitely not an integer.
+
+is_not_integer(#c_literal{val=Val}) when not is_integer(Val) -> true;
+is_not_integer(#c_tuple{}) -> true;
+is_not_integer(#c_cons{}) -> true;
+is_not_integer(_) -> false.
+
+%% is_not_tuple(Core) -> true | false.
+%%  Returns true if Core is definitely not a tuple.
+
+is_not_tuple(#c_literal{val=Val}) when not is_tuple(Val) -> true;
+is_not_tuple(#c_cons{}) -> true;
+is_not_tuple(_) -> false.
+
+%% eval_setelement(Pos, Tuple, NewVal) -> Val.
+%%  Evaluates setelement/3 if Pos and Tuple are literals.
+
+eval_setelement(#c_literal{val=Pos}, #c_tuple{anno=A,es=Es}, NewVal)
+  when is_integer(Pos) ->
+    make_tuple(A, eval_setelement_1(Pos, Es, NewVal));
+eval_setelement(#c_literal{val=Pos}, #c_literal{anno=A,val=Es0}, NewVal)
+  when is_integer(Pos) ->
+    Es = [#c_literal{anno=A,val=E} || E <- tuple_to_list(Es0)],
+    make_tuple(A, eval_setelement_1(Pos, Es, NewVal)).
+
+eval_setelement_1(1, [_|T], NewVal) ->
+    [NewVal|T];
+eval_setelement_1(Pos, [H|T], NewVal) when Pos > 1 ->
+    [H|eval_setelement_1(Pos-1, T, NewVal)].
+
+eval_failure(Call, Reason) ->
+    add_warning(Call, {eval_failure,Reason}),
+    #c_call{module=#c_literal{val=erlang},
+	    name=#c_literal{val=error},
+	    args=[core_lib:make_literal(Reason)]}.
+
+make_tuple(Anno, Es0) ->
+    case core_lib:is_literal_list(Es0) of
+	false ->
+	    #c_tuple{anno=Anno,es=Es0};
+	true ->
+	    Es = core_lib:concrete_list(Es0),
+	    #c_literal{anno=Anno,val=list_to_tuple(Es)}
+    end.
+
+%% simplify_apply(Call0, Mod, Func, Args) -> Call
+%%  Simplify an apply/3 to a call if the number of arguments
+%%  are known at compile time.
+
+simplify_apply(Call, Mod, Func, Args) ->
+    case is_atom_or_var(Mod) andalso is_atom_or_var(Func) of
+	true -> simplify_apply_1(Args, Call, Mod, Func, []);
+	false -> Call
+    end.
+
+simplify_apply_1(#c_literal{val=MoreArgs0}, Call, Mod, Func, Args)
+  when length(MoreArgs0) >= 0 ->
+    MoreArgs = core_lib:make_literal_list(MoreArgs0),
+    Call#c_call{module=Mod,name=Func,args=reverse(Args, MoreArgs)};
+simplify_apply_1(#c_cons{hd=Arg,tl=T}, Call, Mod, Func, Args) ->
+    simplify_apply_1(T, Call, Mod, Func, [Arg|Args]);
+simplify_apply_1(_, Call, _, _, _) -> Call.
+
+is_atom_or_var(#c_literal{val=Atom}) when is_atom(Atom) -> true;
+is_atom_or_var(#c_var{}) -> true;
+is_atom_or_var(_) -> false.
+
+%% clause(Clause, Cepxr, Context, Sub) -> Clause.
+
+clause(#c_clause{pats=Ps0,guard=G0,body=B0}=Cl, Cexpr, Ctxt, Sub0) ->
+    {Ps1,Sub1} = pattern_list(Ps0, Sub0),
+    Sub2 = update_types(Cexpr, Ps1, Sub1),
+    GSub = case {Cexpr,Ps1} of
+	       {#c_var{name='_'},_} ->
+		   %% In a 'receive', Cexpr is the variable '_', which represents the
+		   %% message being matched. We must NOT do any extra substiutions.
+		   Sub2;
+	       {#c_var{},[#c_var{}=Var]} ->
+		   %% The idea here is to optimize expressions such as
+		   %%
+		   %%   case A of A -> ...
+		   %%
+		   %% to get rid of the extra guard test that the compiler
+		   %% added when converting to the Core Erlang representation:
+		   %%
+		   %%   case A of NewVar when A =:= NewVar -> ...
+		   %%
+		   %% By replacing NewVar with A everywhere in the guard
+		   %% expression, we get
+		   %%
+		   %%   case A of NewVar when A =:= A -> ...
+		   %%
+		   %% which by constant-expression evaluation is reduced to
+		   %%
+		   %%   case A of NewVar when true -> ...
+		   %%
+		   sub_set_var(Var, Cexpr, Sub2);
+	       _ ->
+		   Sub2
+	   end,
+    G1 = guard(G0, GSub),
+    B1 = body(B0, Ctxt, Sub2),
+    Cl#c_clause{pats=Ps1,guard=G1,body=B1}.
+
+%% let_substs(LetVars, LetArg, Sub) -> {[Var],[Val],Sub}.
+%%  Add suitable substitutions to Sub of variables in LetVars.  First
+%%  remove variables in LetVars from Sub, then fix subs.  N.B. must
+%%  work out new subs in parallel and then apply them to subs.  Return
+%%  the unsubstituted variables and values.
+
+let_substs(Vs0, As0, Sub0) ->
+    {Vs1,Sub1} = pattern_list(Vs0, Sub0),
+    {Vs2,As1,Ss} = let_substs_1(Vs1, As0, Sub1),
+    Sub2 = scope_add([V || #c_var{name=V} <- Vs2], Sub1),
+    {Vs2,As1,
+     foldl(fun ({V,S}, Sub) -> sub_set_name(V, S, Sub) end, Sub2, Ss)}.
+
+let_substs_1(Vs, #c_values{es=As}, Sub) ->
+    let_subst_list(Vs, As, Sub);
+let_substs_1([V], A, Sub) -> let_subst_list([V], [A], Sub);
+let_substs_1(Vs, A, _) -> {Vs,A,[]}.
+
+let_subst_list([V|Vs0], [A|As0], Sub) ->
+    {Vs1,As1,Ss} = let_subst_list(Vs0, As0, Sub),
+    case is_subst(A) of
+	true -> {Vs1,As1,sub_subst_var(V, A, Sub) ++ Ss};
+	false -> {[V|Vs1],[A|As1],Ss}
+    end;
+let_subst_list([], [], _) -> {[],[],[]}.
+
+%% pattern(Pattern, InSub) -> {Pattern,OutSub}.
+%% pattern(Pattern, InSub, OutSub) -> {Pattern,OutSub}.
+%%  Variables occurring in Pattern will shadow so they must be removed
+%%  from Sub.  If they occur as a value in Sub then we create a new
+%%  variable and then add a substitution for that.
+%%
+%%  Patterns are complicated by sizes in binaries.  These are pure
+%%  input variables which create no bindings.  We, therefore, need to
+%%  carry around the original substitutions to get the correct
+%%  handling.
+
+%%pattern(Pat, Sub) -> pattern(Pat, Sub, Sub).
+
+pattern(#c_var{name=V0}=Pat, Isub, Osub) ->
+    case sub_is_val(Pat, Isub) of
+	true ->
+	    V1 = make_var_name(),
+	    Pat1 = #c_var{name=V1},
+	    {Pat1,sub_set_var(Pat, Pat1, scope_add([V1], Osub))};
+	false ->
+	    {Pat,sub_del_var(Pat, scope_add([V0], Osub))}
+    end;
+pattern(#c_literal{}=Pat, _, Osub) -> {Pat,Osub};
+pattern(#c_cons{hd=H0,tl=T0}=Pat, Isub, Osub0) ->
+    {H1,Osub1} = pattern(H0, Isub, Osub0),
+    {T1,Osub2} = pattern(T0, Isub, Osub1),
+    {Pat#c_cons{hd=H1,tl=T1},Osub2};
+pattern(#c_tuple{es=Es0}=Pat, Isub, Osub0) ->
+    {Es1,Osub1} = pattern_list(Es0, Isub, Osub0),
+    {Pat#c_tuple{es=Es1},Osub1};
+pattern(#c_binary{segments=V0}=Pat, Isub, Osub0) ->
+    {V1,Osub1} = bin_pattern_list(V0, Isub, Osub0),
+    {Pat#c_binary{segments=V1},Osub1};
+pattern(#c_alias{var=V0,pat=P0}=Pat, Isub, Osub0) ->
+    {V1,Osub1} = pattern(V0, Isub, Osub0),
+    {P1,Osub2} = pattern(P0, Isub, Osub1),
+    {Pat#c_alias{var=V1,pat=P1},Osub2}.
+
+bin_pattern_list(Ps0, Isub, Osub0) ->
+    {Ps,{_,Osub}} = mapfoldl(fun bin_pattern/2, {Isub,Osub0}, Ps0),
+    {Ps,Osub}.
+
+bin_pattern(#c_bitstr{val=E0,size=Size0}=Pat, {Isub0,Osub0}) ->
+    Size1 = expr(Size0, Isub0),
+    {E1,Osub} = pattern(E0, Isub0, Osub0),
+    Isub = case E0 of
+	       #c_var{} -> sub_set_var(E0, E1, Isub0);
+	       _ -> Isub0
+	   end,
+    {Pat#c_bitstr{val=E1,size=Size1},{Isub,Osub}}.
+
+pattern_list(Ps, Sub) -> pattern_list(Ps, Sub, Sub).
+
+pattern_list(Ps0, Isub, Osub0) ->
+    mapfoldl(fun (P, Osub) -> pattern(P, Isub, Osub) end, Osub0, Ps0).
+
+%% is_subst(Expr) -> true | false.
+%%  Test whether an expression is a suitable substitution.
+
+is_subst(#c_var{}) -> true;
+is_subst(#c_literal{}) -> true;
+is_subst(_) -> false.
+
+%% sub_new() -> #sub{}.
+%% sub_get_var(Var, #sub{}) -> Value.
+%% sub_set_var(Var, Value, #sub{}) -> #sub{}.
+%% sub_set_name(Name, Value, #sub{}) -> #sub{}.
+%% sub_del_var(Var, #sub{}) -> #sub{}.
+%% sub_subst_var(Var, Value, #sub{}) -> [{Name,Value}].
+%% sub_is_val(Var, #sub{}) -> bool().
+%% sub_subst_scope(#sub{}) -> #sub{}
+%%
+%%  We use the variable name as key so as not have problems with
+%%  annotations.  When adding a new substitute we fold substitute
+%%  chains so we never have to search more than once.  Use orddict so
+%%  we know the format.
+%%
+%%  sub_subst_scope/1 adds dummy substitutions for all variables
+%%  in the scope in order to force renaming if variables in the
+%%  scope occurs as pattern variables.
+
+sub_new() -> #sub{v=orddict:new(),s=gb_trees:empty(),t=[]}.
+
+%%sub_new(#sub{}=Sub) -> Sub#sub{v=orddict:new()}.
+sub_new(#sub{}=Sub) -> Sub#sub{v=orddict:new(),t=[]}.
+
+sub_get_var(#c_var{name=V}=Var, #sub{v=S}) ->
+    case orddict:find(V, S) of
+	{ok,Val} -> Val;
+	error -> Var
+    end.
+
+sub_set_var(#c_var{name=V}, Val, Sub) ->
+    sub_set_name(V, Val, Sub).
+
+sub_set_name(V, Val, #sub{v=S,s=Scope,t=Tdb}=Sub) ->
+    Sub#sub{v=orddict:store(V, Val, S),s=gb_sets:add(V, Scope),
+	    t=kill_types(V, Tdb)}.
+
+sub_del_var(#c_var{name=V}, #sub{v=S,t=Tdb}=Sub) ->
+    Sub#sub{v=orddict:erase(V, S),t=kill_types(V, Tdb)}.
+
+sub_subst_var(#c_var{name=V}, Val, #sub{v=S0}) ->
+    %% Fold chained substitutions.
+    [{V,Val}] ++ [ {K,Val} || {K,#c_var{name=V1}} <- S0, V1 =:= V].
+
+sub_subst_scope(#sub{v=S0,s=Scope}=Sub) ->
+    S = [{-1,#c_var{name=Sv}} || Sv <- gb_sets:to_list(Scope)]++S0,
+    Sub#sub{v=S}.
+
+sub_is_val(#c_var{name=V}, #sub{v=S}) ->
+    v_is_value(V, S).
+
+v_is_value(Var, Sub) ->
+    any(fun ({_,#c_var{name=Val}}) when Val =:= Var -> true;
+	    (_) -> false
+	end, Sub).
+
+%% clauses(E, [Clause], TopLevel, Context, Sub) -> [Clause].
+%%  Trim the clauses by removing all clauses AFTER the first one which
+%%  is guaranteed to match.  Also remove all trivially false clauses.
+
+clauses(E, Cs0, TopLevel, Ctxt, Sub) ->
+    Cs = clauses_1(E, Cs0, Ctxt, Sub),
+
+    %% Here we want to warn if no clauses whatsoever will ever
+    %% match, because that is probably a mistake.
+    case all(fun is_compiler_generated/1, Cs) andalso
+	any(fun(C) -> not is_compiler_generated(C) end, Cs0) of
+	true ->
+	    %% The original list of clauses did contain at least one
+	    %% user-specified clause, but none of them will match.
+	    %% That is probably a mistake.
+	    add_warning(TopLevel, no_clause_match);
+	false ->
+	    %% Either there were user-specified clauses left in
+	    %% the transformed clauses, or else none of the original
+	    %% clauses were user-specified to begin with (as in 'andalso').
+	    ok
+    end,
+
+    Cs.
+
+clauses_1(E, [C0|Cs], Ctxt, Sub) ->
+    #c_clause{pats=Ps,guard=G} = C1 = clause(C0, E, Ctxt, Sub),
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,{E,Ps}]),
+    case {will_match(E, Ps),will_succeed(G)} of
+	{yes,yes} ->
+	    Line = get_line(core_lib:get_anno(C1)),
+	    case core_lib:is_literal(E) of
+		false ->
+		    shadow_warning(Cs, Line);
+		true ->
+		    %% If the case expression is a literal,
+		    %% it is probably OK that some clauses don't match.
+		    %% It is a proably some sort of debug macro.
+		    ok
+	    end,
+	    [C1];				%Skip the rest
+	{no,_Suc} ->
+	    clauses_1(E, Cs, Ctxt, Sub);	%Skip this clause
+	{_Mat,no} ->
+	    add_warning(C1, nomatch_guard),
+	    clauses_1(E, Cs, Ctxt, Sub);	%Skip this clause
+	{_Mat,_Suc} ->
+	    [C1|clauses_1(E, Cs, Ctxt, Sub)]
+    end;
+clauses_1(_, [], _, _) -> [].
+
+shadow_warning([C|Cs], none) ->
+    add_warning(C, nomatch_shadow),
+    shadow_warning(Cs, none);
+shadow_warning([C|Cs], Line) ->
+    add_warning(C, {nomatch_shadow, Line}),
+    shadow_warning(Cs, Line);
+shadow_warning([], _) -> ok.
+
+%% will_succeed(Guard) -> yes | maybe | no.
+%%  Test if we know whether a guard will succeed/fail or just don't
+%%  know.  Be VERY conservative!
+
+will_succeed(#c_literal{val=true}) -> yes;
+will_succeed(#c_literal{val=false}) -> no;
+will_succeed(_Guard) -> maybe.
+
+%% will_match(Expr, [Pattern]) -> yes | maybe | no.
+%%  Test if we know whether a match will succeed/fail or just don't
+%%  know.  Be conservative.
+
+will_match(#c_values{es=Es}, Ps) ->
+    will_match_list(Es, Ps, yes);
+will_match(E, [P]) ->
+    will_match_1(E, P).
+
+will_match_1(_E, #c_var{}) -> yes;		%Will always match
+will_match_1(E, #c_alias{pat=P}) ->		%Pattern decides
+    will_match_1(E, P);
+will_match_1(#c_var{}, _P) -> maybe;
+will_match_1(#c_tuple{es=Es}, #c_tuple{es=Ps}) ->
+    will_match_list(Es, Ps, yes);
+will_match_1(#c_literal{val=Lit}, P) ->
+    will_match_lit(Lit, P);
+will_match_1(_, _) -> maybe.
+
+will_match_list([E|Es], [P|Ps], M) ->
+    case will_match_1(E, P) of
+	yes -> will_match_list(Es, Ps, M);
+	maybe -> will_match_list(Es, Ps, maybe);
+	no -> no
+    end;
+will_match_list([], [], M) -> M.
+
+will_match_lit(Cons, #c_cons{hd=Hp,tl=Tp}) ->
+    case Cons of
+	[H|T] ->
+	    case will_match_lit(H, Hp) of
+		yes -> will_match_lit(T, Tp);
+		Other -> Other
+	    end;
+	_ ->
+	    no
+    end;
+will_match_lit(Tuple, #c_tuple{es=Es}) ->
+    case is_tuple(Tuple) andalso tuple_size(Tuple) =:= length(Es) of
+	true -> will_match_lit_list(tuple_to_list(Tuple), Es);
+	false -> no
+    end;
+will_match_lit(Bin, #c_binary{}) ->
+    case is_bitstring(Bin) of
+	true -> maybe;
+	false -> no
+    end;
+will_match_lit(_, #c_var{}) ->
+    yes;
+will_match_lit(Lit, #c_alias{pat=P}) ->
+    will_match_lit(Lit, P);
+will_match_lit(Lit1, #c_literal{val=Lit2}) ->
+    case Lit1 =:= Lit2 of
+	true -> yes;
+	false -> no
+    end.
+
+will_match_lit_list([H|T], [P|Ps]) ->
+    case will_match_lit(H, P) of
+	yes -> will_match_lit_list(T, Ps);
+	Other -> Other
+    end;
+will_match_lit_list([], []) -> yes.
+
+%% simplify_case(Case) -> CoreExpr
+%%  We attempt to simplify the case expression and clauses in several different
+%%  ways:
+%%
+%%  (1) Relational operators in cases can be moved to the guard.
+%%
+%%    case A > B of	 			case <> of
+%%      true -> TrueClause;    	       ==>        <> when A > B -> TrueClause;
+%%      false -> FalseClause			  <> when true -> FalseClause
+%%    end.		 			end
+%%
+%%  Generally, evaluting a type test or comparision operator in a guard should
+%%  be faster than evaulating it in the body.
+%%
+%%  But if the sole purpose of the guard is to verify that the relational
+%%  expression indeed returns true or false, we keep the expression and remove
+%%  case:
+%%
+%%    case A =:= B of
+%%      true -> true   	       	       ==>      A =: B
+%%      false -> false
+%%    end.
+%%
+%%  (2) We try to eliminate the 'not' operator from a case expression.
+%%
+%%       case not CaseExpr of                  case CaseExpr of
+%%          true -> TrueBody;         =>          false -> TrueBody;
+%%          false -> FalseBody			  true -> FalseBody;
+%%       end					  _ -> erlang:error(badarg)
+%%
+
+simplify_case(#c_case{arg=Call}=Case) ->
+    case Call of
+	#c_call{module=#c_literal{val=erlang},
+		name=#c_literal{val=Name},
+		args=Args} ->
+	    simplify_case_0(Name, Args, Call, Case);
+	_ -> Case
+    end.
+
+simplify_case_0('not', [Expr], _, Case) ->
+    simplify_case_not(Expr, Case);
+simplify_case_0(Name, Args, Call, Case) ->
+    Arity = length(Args),
+
+    %% If the call is a comparision operator or type test (which can't fail),
+    %% and the arguments are safe, move this call to the guard.
+    %% Note: v3_core never generates unsafe arguments, but another
+    %% code generator might.
+    case (erl_internal:comp_op(Name, Arity) orelse
+	erl_internal:new_type_test(Name, Arity)) andalso
+	is_safe_simple_list(Args) of
+	false -> Case;
+	true -> simplify_case_1(Call, Case)
+    end.
+
+simplify_case_1(Call, #c_case{clauses=[_,_|Cs]=Cs0}=Case) ->
+    case is_bool_case(Cs0) of
+	true ->
+	    %% The case is not needed. Warn if there
+	    %% are any (non-compiler generated) clauses following
+	    %% the true and false clauses because they will
+	    %% certainly not be reached.
+	    shadow_warning(Cs, none),
+	    Call;				%The case is not needed.
+	false -> simplify_case_2(Call, Case)
+    end;
+simplify_case_1(_, Case) -> Case.
+
+simplify_case_2(Call, #c_case{clauses=[A,B|Cs]}=Case) ->
+    case {A,B} of
+	{#c_clause{pats=[#c_literal{val=true}],guard=#c_literal{val=true}},
+	 #c_clause{pats=[#c_literal{val=false}],guard=#c_literal{val=true}}} ->
+	    True = A#c_clause{pats=[],guard=Call},
+	    False = B#c_clause{pats=[]},
+	    Case#c_case{arg=#c_values{anno=core_lib:get_anno(Call),es=[]},
+			clauses=[True,False|Cs]};
+	{#c_clause{pats=[#c_literal{val=false}],guard=#c_literal{val=true}},
+	 #c_clause{pats=[#c_literal{val=true}],guard=#c_literal{val=true}}} ->
+	    True = B#c_clause{pats=[],guard=Call},
+	    False = A#c_clause{pats=[]},
+	    Case#c_case{arg=#c_values{anno=core_lib:get_anno(Call),es=[]},
+			clauses=[True,False|Cs]};
+	_ -> Case
+    end.
+
+%% simplify_case_not(CaseExpr, Case) -> Case'
+%%  Try to simplify away a 'not' in a case expression.
+
+simplify_case_not(Expr, #c_case{clauses=Cs0}=Case) ->
+    try
+	Cs = simplify_case_not_1(Cs0, false, false),
+	Case#c_case{arg=Expr,clauses=Cs}
+    catch
+	impossible -> Case
+    end.
+
+%% simplify_case_not_1([Clause], SeenTrue, SeenFalse) -> [Clause] | impossible
+%%  Throws a 'impossible' exception if there are complications that make
+%%  the optimization difficult or impossible.
+
+simplify_case_not_1([#c_clause{pats=[#c_literal{val=Lit}],
+			  guard=#c_literal{val=true}}=C0|Cs], SeenT, SeenF) ->
+    case is_boolean(Lit) of
+	false ->
+	    %% Not a boolean - this clause can't match.
+	    add_warning(C0, nomatch_clause_type),
+	    simplify_case_not_1(Cs, SeenT, SeenF);
+	true ->
+	    %% A boolean - invert it and keep the clause.
+	    C = C0#c_clause{pats=[#c_literal{val=not Lit}]},
+	    case Lit of
+		true -> [C|simplify_case_not_1(Cs, true, SeenF)];
+		false -> [C|simplify_case_not_1(Cs, SeenT, true)]
+	    end
+    end;
+simplify_case_not_1([_|_], true, true) ->
+    %% We have seen clauses that handle both 'true' and 'false'.
+    %% That means the expression is not a boolean, and the original
+    %% call to 'not' would have generated a 'badarg'. Therefore,
+    %% ignore this clause and all following and generate a default
+    %% clause that generates a 'badarg' exception.
+
+    simplify_case_not_1([], true, true);
+simplify_case_not_1([], true, true) ->
+    %% Generate a new default clause that generates a 'badarg' exception.
+    [#c_clause{anno=[compiler_generated],
+	       pats=[#c_var{name=cor_variable}],
+	       guard=#c_literal{val=true},
+	       body=#c_call{module=#c_literal{val=erlang},
+			    name=#c_literal{val=error},
+			    args=[#c_literal{val=badarg}]}}];
+simplify_case_not_1(_, _, _) ->
+    %% Some complication, for instance that not both of
+    %% 'true' and 'false' were matched, or there were guards, and so on.
+    throw(impossible).
+
+%% eval_case(Case) -> #c_case{} | #c_let{}.
+%%  If possible, evaluate a case at compile time.  We know that the
+%%  last clause is guaranteed to match so if there is only one clause
+%%  with a pattern containing only variables then rewrite to a let.
+
+eval_case(#c_case{arg=#c_var{name=V},
+		  clauses=[#c_clause{pats=[P],guard=G,body=B}|_]}=Case,
+	  #sub{t=Tdb}=Sub) ->
+    case orddict:find(V, Tdb) of
+	{ok,Type} ->
+	    case {will_match_type(P, Type),will_succeed(G)} of
+		{yes,yes} ->
+		    {Ps,Es} = remove_non_vars(P, Type),
+		    expr(#c_let{vars=Ps,arg=#c_values{es=Es},body=B}, sub_new(Sub));
+		{_,_} -> eval_case_1(Case, Sub)
+	    end;
+	error -> eval_case_1(Case, Sub)
+    end;
+eval_case(Case, Sub) -> eval_case_1(Case, Sub).
+
+eval_case_1(#c_case{arg=E,clauses=[#c_clause{pats=Ps,body=B}]}=Case, Sub) ->
+    case is_var_pat(Ps) of
+	true -> expr(#c_let{vars=Ps,arg=E,body=B}, sub_new(Sub));
+	false -> eval_case_2(E, Ps, B, Case)
+    end;
+eval_case_1(Case, _) -> Case.
+
+eval_case_2(E, [P], B, Case) ->
+    %% Recall that there is only one clause and that it is guaranteed to match.
+    %%   If E and P are literals, they must be the same literal and the body
+    %% can be used directly as there are no variables that need to be bound.
+    %%   Otherwise, P could be an alias meaning that two or more variables
+    %% would be bound to E. We don't bother to optimize that case as it
+    %% is rather uncommon.
+    case core_lib:is_literal(E) andalso core_lib:is_literal(P) of
+	false -> Case;
+	true -> B
+    end;
+eval_case_2(_, _, _, Case) -> Case.
+
+is_var_pat(Ps) ->
+    all(fun (#c_var{}) -> true;
+	    (_Pat) -> false
+	end, Ps).
+
+will_match_type(#c_tuple{es=Es}, #c_tuple{es=Ps}) ->
+    will_match_list_type(Es, Ps);
+will_match_type(#c_literal{val=Atom}, #c_literal{val=Atom}) -> yes;
+will_match_type(#c_var{}, _) -> yes;
+will_match_type(_, _) -> no.
+
+will_match_list_type([E|Es], [P|Ps]) ->
+    case will_match_type(E, P) of
+	yes -> will_match_list_type(Es, Ps);
+	no -> no
+    end;
+will_match_list_type([], []) -> yes;
+will_match_list_type(_, _) -> no.		%Different length
+
+remove_non_vars(Ps0, Es0) ->
+    {Ps,Es} = remove_non_vars(Ps0, Es0, [], []),
+    {reverse(Ps),reverse(Es)}.
+
+remove_non_vars(#c_tuple{es=Ps}, #c_tuple{es=Es}, Pacc, Eacc) ->
+    remove_non_vars_list(Ps, Es, Pacc, Eacc);
+remove_non_vars(#c_var{}=Var, #c_alias{var=Evar}, Pacc, Eacc) ->
+    {[Var|Pacc],[Evar|Eacc]};
+remove_non_vars(#c_var{}=Var, E, Pacc, Eacc) ->
+    {[Var|Pacc],[E|Eacc]};
+remove_non_vars(P, E, Pacc, Eacc) ->
+    true = core_lib:is_literal(P) andalso core_lib:is_literal(E), %Assertion.
+    {Pacc,Eacc}.
+
+remove_non_vars_list([P|Ps], [E|Es], Pacc0, Eacc0) ->
+    {Pacc,Eacc} = remove_non_vars(P, E, Pacc0, Eacc0),
+    remove_non_vars_list(Ps, Es, Pacc, Eacc);
+remove_non_vars_list([], [], Pacc, Eacc) ->
+    {Pacc,Eacc}.
+
+%% case_opt(CaseArg, [Clause]) -> {CaseArg,[Clause]}.
+%%  Try and optimise case by removing building argument terms.
+
+case_opt(#c_tuple{anno=A,es=Es}, Cs0) ->
+    Cs1 = case_opt_cs(Cs0, length(Es)),
+    {core_lib:set_anno(core_lib:make_values(Es), A),Cs1};
+case_opt(Arg, Cs) -> {Arg,Cs}.
+
+case_opt_cs([#c_clause{pats=Ps0,guard=G,body=B}=C|Cs], Arity) ->
+    case case_tuple_pat(Ps0, Arity) of
+	{ok,Ps1,Avs} ->
+	    Flet = fun ({V,Sub}, Body) -> letify(V, Sub, Body) end,
+	    [C#c_clause{pats=Ps1,
+			guard=letify_guard(Flet, Avs, G),
+			body=foldl(Flet, B, Avs)}|case_opt_cs(Cs, Arity)];
+	error ->				%Can't match
+	    add_warning(C, nomatch_clause_type),
+	    case_opt_cs(Cs, Arity)
+    end;
+case_opt_cs([], _) -> [].
+
+letify_guard(Flet, Avs, #c_call{module=#c_literal{val=erlang},
+			       name=#c_literal{val='not'},
+			       args=[A]}=Call) ->
+    Arg = letify_guard(Flet, Avs, A),
+    Call#c_call{args=[Arg]};
+letify_guard(Flet, Avs, #c_call{module=#c_literal{val=erlang},
+			       name=#c_literal{val='and'},
+			       args=[A1,A2]}=Call) ->
+    Arg1 = letify_guard(Flet, Avs, A1),
+    Arg2 = letify_guard(Flet, Avs, A2),
+    Call#c_call{args=[Arg1,Arg2]};
+letify_guard(Flet, Avs, #c_call{module=#c_literal{val=erlang},
+			       name=#c_literal{val='or'},
+			       args=[A1,A2]}=Call) ->
+    Arg1 = letify_guard(Flet, Avs, A1),
+    Arg2 = letify_guard(Flet, Avs, A2),
+    Call#c_call{args=[Arg1,Arg2]};
+letify_guard(Flet, Avs, #c_try{arg=B,
+			       vars=[#c_var{name=X}],body=#c_var{name=X},
+			       handler=#c_literal{val=false}}=Prot) ->
+    Prot#c_try{arg=foldl(Flet, B, Avs)};
+letify_guard(Flet, Avs, E) -> foldl(Flet, E, Avs).
+
+%% case_tuple_pat([Pattern], Arity) -> {ok,[Pattern],[{AliasVar,Pat}]} | error.
+
+case_tuple_pat([#c_tuple{es=Ps}], Arity) when length(Ps) =:= Arity ->
+    {ok,Ps,[]};
+case_tuple_pat([#c_var{anno=A}=V], Arity) ->
+    Vars = make_vars(A, 1, Arity),
+    {ok,Vars,[{V,#c_tuple{es=Vars}}]};
+case_tuple_pat([#c_alias{var=V,pat=P}], Arity) ->
+    case case_tuple_pat([P], Arity) of
+	{ok,Ps,Avs} -> {ok,Ps,[{V,#c_tuple{es=unalias_pat_list(Ps)}}|Avs]};
+	error -> error
+    end;
+case_tuple_pat(_, _) -> error.
+
+%% unalias_pat(Pattern) -> Pattern.
+%%  Remove all the aliases in a pattern but using the alias variables
+%%  instead of the values.  We KNOW they will be bound.
+
+unalias_pat(#c_alias{var=V}) -> V;
+unalias_pat(#c_cons{hd=H0,tl=T0}=Cons) ->
+    H1 = unalias_pat(H0),
+    T1 = unalias_pat(T0),
+    Cons#c_cons{hd=H1,tl=T1};
+unalias_pat(#c_tuple{es=Ps}=Tuple) ->
+    Tuple#c_tuple{es=unalias_pat_list(Ps)};
+unalias_pat(Atomic) -> Atomic.
+
+unalias_pat_list(Ps) -> [unalias_pat(P) || P <- Ps].
+
+make_vars(A, I, Max) when I =< Max ->
+    [make_var(A)|make_vars(A, I+1, Max)];
+make_vars(_, _, _) -> [].
+
+make_var(A) ->
+    #c_var{anno=A,name=make_var_name()}.
+
+make_var_name() ->
+    N = get(new_var_num),
+    put(new_var_num, N+1),
+    list_to_atom("fol"++integer_to_list(N)).
+
+letify(#c_var{name=Vname}=Var, Val, Body) ->
+    case core_lib:is_var_used(Vname, Body) of
+	true ->
+	    A = element(2, Body),
+	    #c_let{anno=A,vars=[Var],arg=Val,body=Body};
+	false -> Body
+    end.
+
+%% opt_case_in_let(LetExpr) -> LetExpr'
+
+opt_case_in_let(#c_let{vars=Vs,arg=Arg,body=B}=Let) ->
+    opt_case_in_let_0(Vs, Arg, B, Let).
+
+opt_case_in_let_0([#c_var{name=V}], Arg,
+		  #c_case{arg=#c_var{name=V},clauses=Cs}=Case, Let) ->
+    case opt_case_in_let_1(V, Arg, Cs) of
+	impossible ->
+	    case is_simple_case_arg(Arg) andalso 
+		not core_lib:is_var_used(V, Case#c_case{arg=#c_literal{val=nil}}) of
+		true ->
+		    simplify_case(Case#c_case{arg=Arg});
+		false ->
+		    Let
+	    end;
+	Expr -> Expr
+    end;
+opt_case_in_let_0(_, _, _, Let) -> Let.
+
+opt_case_in_let_1(V, Arg, Cs) ->
+    try
+	opt_case_in_let_2(V, Arg, Cs)
+    catch
+	_:_ -> impossible
+    end.
+
+opt_case_in_let_2(V, Arg0,
+		  [#c_clause{pats=[#c_tuple{es=Es}],
+			     guard=#c_literal{val=true},body=B}|_]) ->
+
+    %%  In {V1,V2,...} = case E of P -> ... {Val1,Val2,...}; ... end.
+    %%  avoid building tuples, by converting tuples to multiple values.
+    %%  (The optimisation is not done if the built tuple is used or returned.)
+
+    true = all(fun (#c_var{}) -> true;
+		   (_) -> false end, Es),	%Only variables in tuple
+    false = core_lib:is_var_used(V, B),		%Built tuple must not be used.
+    Arg1 = tuple_to_values(Arg0, length(Es)),	%Might fail.
+    #c_let{vars=Es,arg=Arg1,body=B};
+opt_case_in_let_2(_, Arg, Cs) ->
+    %% simplify_bool_case(Case0) -> Case
+    %%  Remove unecessary cases like
+    %%
+    %%     case BoolExpr of
+    %%       true -> true;
+    %%       false -> false;
+    %%       ....
+    %%     end
+    %%
+    %%  where BoolExpr is an expression that can only return true
+    %%  or false (or throw an exception).
+
+    true = is_bool_case(Cs) andalso is_bool_expr(Arg),
+    Arg.
+
+is_bool_case([A,B|_]) ->
+    (is_bool_clause(true, A) andalso is_bool_clause(false, B))
+	orelse (is_bool_clause(false, A) andalso is_bool_clause(true, B)).
+
+is_bool_clause(Bool, #c_clause{pats=[#c_literal{val=Bool}],
+			       guard=#c_literal{val=true},
+			       body=#c_literal{val=Bool}}) ->
+    true;
+is_bool_clause(_, _) -> false.
+
+%% is_simple_case_arg(Expr) -> true|false
+%%  Determine whether the Expr is simple enough to be worth
+%%  substituting into a case argument. (Common substitutions
+%%  of variables and literals are assumed to have been already
+%%  handled by the caller.)
+
+is_simple_case_arg(#c_cons{}) -> true;
+is_simple_case_arg(#c_tuple{}) -> true;
+is_simple_case_arg(#c_call{}) -> true;
+is_simple_case_arg(#c_apply{}) -> true;
+is_simple_case_arg(_) -> false.
+
+%% is_bool_expr(Core) -> true|false
+%%  Check whether the Core expression only can return a boolean
+%%  (or throw an exception).
+
+is_bool_expr(#c_call{module=#c_literal{val=erlang},
+		     name=#c_literal{val=Name},args=Args}=Call) ->
+    NumArgs = length(Args),
+    erl_internal:comp_op(Name, NumArgs) orelse
+	erl_internal:new_type_test(Name, NumArgs) orelse
+	will_fail(Call);
+is_bool_expr(#c_case{clauses=Cs}) ->
+    is_bool_expr_list(Cs);
+is_bool_expr(#c_clause{body=B}) ->
+    is_bool_expr(B);
+is_bool_expr(#c_let{body=B}) ->
+    is_bool_expr(B);
+is_bool_expr(#c_literal{val=false}) ->
+    true;
+is_bool_expr(#c_literal{val=true}) ->
+    true;
+is_bool_expr(_) -> false.
+
+is_bool_expr_list([C|Cs]) ->
+    is_bool_expr(C) andalso is_bool_expr_list(Cs);
+is_bool_expr_list([]) -> true.
+
+%% tuple_to_values(Expr, TupleArity) -> Expr'
+%%  Convert tuples in return position of arity TupleArity to values.
+%%  Throws an exception for constructs that are not handled.
+
+tuple_to_values(#c_tuple{es=Es}, Arity) when length(Es) =:= Arity ->
+    core_lib:make_values(Es);
+tuple_to_values(#c_literal{val=Tuple}=Lit, Arity) when tuple_size(Tuple) =:= Arity ->
+    Es = [Lit#c_literal{val=E} || E <- tuple_to_list(Tuple)],
+    core_lib:make_values(Es);
+tuple_to_values(#c_case{clauses=Cs0}=Case, Arity) ->
+    Cs1 = [tuple_to_values(E, Arity) || E <- Cs0],
+    Case#c_case{clauses=Cs1};
+tuple_to_values(#c_seq{body=B0}=Seq, Arity) ->
+    Seq#c_seq{body=tuple_to_values(B0, Arity)};
+tuple_to_values(#c_let{body=B0}=Let, Arity) ->
+    Let#c_let{body=tuple_to_values(B0, Arity)};
+tuple_to_values(#c_receive{clauses=Cs0,timeout=Timeout,action=A0}=Rec, Arity) ->
+    Cs = [tuple_to_values(E, Arity) || E <- Cs0],
+    A = case Timeout of
+	    #c_literal{val=infinity} -> A0;
+	    _ -> tuple_to_values(A0, Arity)
+	end,
+    Rec#c_receive{clauses=Cs,action=A};
+tuple_to_values(#c_clause{body=B0}=Clause, Arity) ->
+    B = tuple_to_values(B0, Arity),
+    Clause#c_clause{body=B};
+tuple_to_values(Expr, _) ->
+    case will_fail(Expr) of
+	true -> Expr;
+	false -> erlang:error({not_handled,Expr})
+    end.
+
+%% simplify_let(Let, Sub) -> Expr | impossible
+%%  If the argument part of an let contains a complex expression, such
+%%  as a let or a sequence, move the original let body into the complex
+%%  expression.
+
+simplify_let(#c_let{arg=Arg}=Let, Sub) ->
+    move_let_into_expr(Let, Arg, Sub).
+
+move_let_into_expr(#c_let{vars=InnerVs0,body=InnerBody0}=Inner,
+		   #c_let{vars=OuterVs0,arg=Arg0,body=OuterBody0}=Outer, Sub0) ->
+    %%
+    %% let <InnerVars> = let <OuterVars> = <Arg>
+    %%                   in <OuterBody>
+    %% in <InnerBody>
+    %%
+    %%       ==>
+    %%
+    %% let <OuterVars> = <Arg>
+    %% in let <InnerVars> = <OuterBody>
+    %%    in <InnerBody>
+    %%
+    Arg = body(Arg0, Sub0),
+    ScopeSub0 = sub_subst_scope(Sub0#sub{t=[]}),
+    {OuterVs,ScopeSub} = pattern_list(OuterVs0, ScopeSub0),
+    OuterBody = body(OuterBody0, ScopeSub),
+
+    {InnerVs,Sub} = pattern_list(InnerVs0, Sub0),
+    InnerBody = body(InnerBody0, Sub),
+    Outer#c_let{vars=OuterVs,arg=Arg,
+		body=Inner#c_let{vars=InnerVs,arg=OuterBody,body=InnerBody}};
+move_let_into_expr(#c_let{vars=Lvs0,body=Lbody0}=Let,
+		   #c_case{arg=Cexpr0,clauses=[Ca0,Cb0|Cs]}=Case, Sub0) ->
+    %% Test if there are no more clauses than Ca0 and Cb0, or if
+    %% Cb0 is guaranted to match.
+    TwoClauses = Cs =:= [] orelse
+	case Cb0 of
+	    #c_clause{pats=[#c_var{}],guard=#c_literal{val=true}} -> true;
+	    _ -> false
+	end,
+    case {TwoClauses,is_failing_clause(Ca0),is_failing_clause(Cb0)} of
+	{true,false,true} ->
+	    %% let <Lvars> = case <Case-expr> of
+	    %%                  <Cvars> -> <Clause-body>;
+	    %%                  <OtherCvars> -> erlang:error(...)
+	    %%               end
+	    %% in <Let-body>
+	    %%
+	    %%     ==>
+	    %%
+	    %% case <Case-expr> of
+	    %%   <Cvars> ->
+	    %%       let <Lvars> = <Clause-body>
+	    %%       in <Let-body>;
+	    %%   <OtherCvars> -> erlang:error(...)
+	    %% end
+
+	    Cexpr = body(Cexpr0, Sub0),
+	    CaVars0 = Ca0#c_clause.pats,
+	    G0 = Ca0#c_clause.guard,
+	    B0 = Ca0#c_clause.body,
+	    ScopeSub0 = sub_subst_scope(Sub0#sub{t=[]}),
+	    {CaVars,ScopeSub} = pattern_list(CaVars0, ScopeSub0),
+	    G = guard(G0, ScopeSub),
+	    B1 = body(B0, ScopeSub),
+
+	    {Lvs,B2,Sub1} = let_substs(Lvs0, B1, Sub0),
+	    Lbody = body(Lbody0, Sub1),
+	    B = Let#c_let{vars=Lvs,arg=core_lib:make_values(B2),body=Lbody},
+
+	    Ca = Ca0#c_clause{pats=CaVars,guard=G,body=B},
+	    Cb = clause(Cb0, Cexpr, value, Sub0),
+	    Case#c_case{arg=Cexpr,clauses=[Ca,Cb]};
+	{_,_,_} -> impossible
+    end;
+move_let_into_expr(_Let, _Expr, _Sub) -> impossible.
+
+is_failing_clause(#c_clause{body=B}) ->
+    will_fail(B).
+
+scope_add(Vs, #sub{s=Scope0}=Sub) ->
+    Scope = foldl(fun(V, S) when is_integer(V); is_atom(V) ->
+			  gb_sets:add(V, S)
+		  end, Scope0, Vs),
+    Sub#sub{s=Scope}.
+
+%% opt_simple_let(#c_let{}, Context, Sub) -> CoreTerm
+%%  Optimize a let construct that does not contain any lets in
+%%  in its argument.
+
+opt_simple_let(#c_let{arg=Arg0}=Let, Ctxt, Sub0) ->
+    Arg = body(Arg0, value, Sub0),		%This is a body
+    case will_fail(Arg) of
+	true -> Arg;
+	false -> opt_simple_let_1(Let, Arg, Ctxt, Sub0)
+    end.
+
+opt_simple_let_1(#c_let{vars=Vs0,body=B0}=Let, Arg0, Ctxt, Sub0) ->
+    %% Optimise let and add new substitutions.
+    {Vs,Args,Sub1} = let_substs(Vs0, Arg0, Sub0),
+    B = body(B0, Ctxt, Sub1),
+    Arg = core_lib:make_values(Args),
+    opt_simple_let_2(Let, Vs, Arg, B, Ctxt, Sub1).
+
+opt_simple_let_2(Let0, Vs0, Arg0, Body0, effect, Sub) ->
+    case {Vs0,Arg0,Body0} of
+	{[],#c_values{es=[]},Body} ->
+	    %% No variables left (because of substitutions).
+	    Body;
+	{[_|_],Arg,#c_literal{}} ->
+	    %% The body is a literal. That means that we can ignore
+	    %% it and that the return value is Arg revisited in
+	    %% effect context.
+	    body(Arg, effect, sub_new(Sub));
+	{Vs,Arg,Body} ->
+	    %% Since we are in effect context, there is a chance
+	    %% that the body no longer references the variables.
+	    %% In that case we can construct a sequence and visit
+	    %% that in effect context:
+	    %%   let <Var> = Arg in BodyWithoutVar  ==> seq Arg BodyWithoutVar
+	    case is_any_var_used(Vs, Body) of
+		false ->
+		    expr(#c_seq{arg=Arg,body=Body}, effect, sub_new(Sub));
+		true ->
+		    Let = Let0#c_let{vars=Vs,arg=Arg,body=Body},
+		    opt_case_in_let(Let)
+	    end
+    end;
+opt_simple_let_2(Let, Vs0, Arg0, Body0, value, _Sub) ->
+    case {Vs0,Arg0,Body0} of
+	{[#c_var{name=Vname}],Arg,#c_var{name=Vname}} ->
+	    %% let <Var> = Arg in <Var>  ==>  Arg
+	    Arg;
+	{[],#c_values{es=[]},Body} ->
+	    %% No variables left.
+	    Body;
+	{Vs,Arg,Body} ->
+	    opt_case_in_let(Let#c_let{vars=Vs,arg=Arg,body=Body})
+    end.
+
+is_any_var_used([#c_var{name=V}|Vs], Expr) ->
+    case core_lib:is_var_used(V, Expr) of
+	false -> is_any_var_used(Vs, Expr);
+	true -> true
+    end;
+is_any_var_used([], _) -> false.
+
+%% update_types(Expr, Pattern, Sub) -> Sub'
+%%  Update the type database.
+update_types(Expr, Pat, #sub{t=Tdb0}=Sub) ->
+    Tdb = update_types_1(Expr, Pat, Tdb0),
+    Sub#sub{t=Tdb}.
+
+update_types_1(#c_var{name=V,anno=Anno}, Pat, Types) ->
+    case member(reuse_for_context, Anno) of
+	true ->
+	    %% If a variable has been marked for reuse of binary context,
+	    %% optimizations based on type information are unsafe.
+	    kill_types(V, Types);
+	false ->
+	    case Pat of
+		[#c_tuple{}=P] -> orddict:store(V, P, Types);
+		_ -> Types
+	    end
+    end;
+update_types_1(_, _, Types) -> Types.
+
+%% kill_types(V, Tdb) -> Tdb'
+%%  Kill any entries that references the variable,
+%%  either in the key or in the value.
+kill_types(V, [{V,_}|Tdb]) ->
+    kill_types(V, Tdb);
+kill_types(V, [{_,#c_tuple{}=Tuple}=Entry|Tdb]) ->
+    case core_lib:is_var_used(V, Tuple) of
+	false -> [Entry|kill_types(V, Tdb)];
+	true -> kill_types(V, Tdb)
+    end;
+kill_types(_, []) -> [].
+
+
+%% The atom `ok', is widely used in Erlang for "void" values.
+
+void() -> #c_literal{val=ok}.
+
+%%%
+%%% Annotate bit syntax matching to faciliate optimization in further passes.
+%%%
+
+bsm_an(#c_case{arg=#c_var{}=V}=Case) ->
+    bsm_an_1([V], Case);
+bsm_an(#c_case{arg=#c_values{es=Es}}=Case) ->
+    bsm_an_1(Es, Case);
+bsm_an(Other) -> Other.
+
+bsm_an_1(Vs, #c_case{clauses=Cs}=Case) ->
+    case bsm_leftmost(Cs) of
+	none -> Case;
+	Pos -> bsm_an_2(Vs, Cs, Case, Pos)
+    end.
+
+bsm_an_2(Vs, Cs, Case, Pos) ->
+    try
+	bsm_ensure_no_partition(Cs, Pos),
+	bsm_do_an(Vs, Pos, Cs, Case)
+    catch
+	throw:{problem,Where,What} ->
+	    add_bin_opt_info(Where, What),
+	    Case
+    end.
+
+bsm_do_an(Vs0, Pos, Cs0, Case) ->
+    case nth(Pos, Vs0) of
+	#c_var{name=Vname}=V0 ->
+	    Cs = bsm_do_an_var(Vname, Pos, Cs0, []),
+	    V = bsm_annotate_for_reuse(V0),
+	    Bef = lists:sublist(Vs0, Pos-1),
+	    Aft = lists:nthtail(Pos, Vs0),
+	    case Bef ++ [V|Aft] of
+		[_] ->
+		    Case#c_case{arg=V,clauses=Cs};
+		Vs ->
+		    Case#c_case{arg=#c_values{es=Vs},clauses=Cs}
+	    end;
+	_ ->
+	    Case
+    end.
+
+bsm_do_an_var(V, S, [#c_clause{pats=Ps,guard=G,body=B0}=C0|Cs], Acc) ->
+    case nth(S, Ps) of
+	#c_var{name=VarName} ->
+	    case core_lib:is_var_used(V, G) of
+		true -> bsm_problem(C0, orig_bin_var_used_in_guard);
+		false -> ok
+	    end,
+	    case core_lib:is_var_used(VarName, G) of
+		true -> bsm_problem(C0, bin_var_used_in_guard);
+		false -> ok
+	    end,
+	    B1 = bsm_maybe_ctx_to_binary(VarName, B0),
+	    B = bsm_maybe_ctx_to_binary(V, B1),
+	    C = C0#c_clause{body=B},
+	    bsm_do_an_var(V, S, Cs, [C|Acc]);
+	#c_alias{}=P ->
+	    case bsm_could_match_binary(P) of
+		false ->
+		    bsm_do_an_var(V, S, Cs, [C0|Acc]);
+		true ->
+		    bsm_problem(C0, bin_opt_alias)
+	    end;
+	P ->
+	    case bsm_could_match_binary(P) andalso bsm_is_var_used(V, G, B0) of
+		false ->
+		    bsm_do_an_var(V, S, Cs, [C0|Acc]);
+		true ->
+		    bsm_problem(C0, bin_var_used)
+	    end
+    end;
+bsm_do_an_var(_, _, [], Acc) -> reverse(Acc).
+
+bsm_annotate_for_reuse(#c_var{anno=Anno}=Var) ->
+    case member(reuse_for_context, Anno) of
+	false -> Var#c_var{anno=[reuse_for_context|Anno]};
+	true -> Var
+    end.
+
+bsm_is_var_used(V, G, B) ->
+    core_lib:is_var_used(V, G) orelse core_lib:is_var_used(V, B).
+
+bsm_maybe_ctx_to_binary(V, B) ->
+    case core_lib:is_var_used(V, B) andalso not previous_ctx_to_binary(V, B) of
+	false ->
+	    B;
+	true ->
+	    #c_seq{arg=#c_primop{name=#c_literal{val=bs_context_to_binary},
+				 args=[#c_var{name=V}]},
+		   body=B}
+    end.
+
+previous_ctx_to_binary(V, #c_seq{arg=#c_primop{name=Name,args=As}}) ->
+    case {Name,As} of
+	{#c_literal{val=bs_context_to_binary},[#c_var{name=V}]} ->
+	    true;
+	{_,_} ->
+	    false
+    end;
+previous_ctx_to_binary(_, _) -> false.
+
+%% bsm_leftmost(Cs) -> none | ArgumentNumber
+%%  Find the leftmost argument that does binary matching. Return
+%%  the number of the argument (1-N).
+
+bsm_leftmost(Cs) ->
+    bsm_leftmost_1(Cs, none).
+
+bsm_leftmost_1([#c_clause{pats=Ps}|Cs], Pos) ->
+    bsm_leftmost_2(Ps, Cs, 1, Pos);
+bsm_leftmost_1([], Pos) -> Pos.
+
+bsm_leftmost_2(_, Cs, Pos, Pos) ->
+    bsm_leftmost_1(Cs, Pos);
+bsm_leftmost_2([#c_binary{}|_], Cs, N, _) ->
+    bsm_leftmost_1(Cs, N);
+bsm_leftmost_2([_|Ps], Cs, N, Pos) ->
+    bsm_leftmost_2(Ps, Cs, N+1, Pos);
+bsm_leftmost_2([], Cs, _, Pos) ->
+    bsm_leftmost_1(Cs, Pos).
+
+%% bsm_ensure_no_partition(Cs, Pos) -> ok     (exception if problem)
+%%  We must make sure that binary matching is not partitioned between
+%%  variables like this:
+%%             foo(<<...>>) -> ...
+%%             foo(Var) when ... -> ...
+%%             foo(<<...>>) ->
+%%  If there is such partition, we are not allowed to reuse the binary variable
+%%  for the match context. Also, arguments to the left of the argument that
+%%  is matched against a binary, are only allowed to be simple variables, not
+%%  used in guards. The reason is that we must know that the binary is only
+%%  matched in one place.
+
+bsm_ensure_no_partition(Cs, Pos) ->
+    bsm_ensure_no_partition_1(Cs, Pos, before).
+
+%% Loop through each clause.
+bsm_ensure_no_partition_1([#c_clause{pats=Ps,guard=G}|Cs], Pos, State0) ->
+    State = bsm_ensure_no_partition_2(Ps, Pos, G, simple_vars, State0),
+    bsm_ensure_no_partition_1(Cs, Pos, State);
+bsm_ensure_no_partition_1([], _, _) -> ok.
+
+%% Loop through each pattern for this clause.
+bsm_ensure_no_partition_2([#c_binary{}=Where|_], 1, _, Vstate, State) ->
+    case State of
+	before when Vstate =:= simple_vars -> within;
+	before -> bsm_problem(Where, Vstate);
+	within when Vstate =:= simple_vars -> within;
+	within -> bsm_problem(Where, Vstate);
+	'after' -> bsm_problem(Where, bin_partition)
+    end;
+bsm_ensure_no_partition_2([#c_alias{}=Alias|_], 1, N, Vstate, State) ->
+    %% Retrieve the real pattern that the alias refers to and check that.
+    P = bsm_real_pattern(Alias),
+    bsm_ensure_no_partition_2([P], 1, N, Vstate, State);
+bsm_ensure_no_partition_2([_|_], 1, _, _Vstate, before=State) ->
+    %% No binary matching yet - therefore no partition.
+    State;
+bsm_ensure_no_partition_2([P|_], 1, _, Vstate, State) ->
+    case bsm_could_match_binary(P) of
+	false ->
+	    %% If clauses can be freely arranged (Vstate =:= simple_vars),
+	    %% a clause that cannot match a binary will not partition the clause.
+	    %% Example:
+	    %%
+	    %% a(Var, <<>>) -> ...
+	    %% a(Var, []) -> ...
+	    %% a(Var, <<B>>) -> ...
+	    %%
+	    %% But if the clauses can't be freely rearranged, as in
+	    %%
+	    %% b(Var, <<>>) -> ...
+	    %% b(1, 2) -> ...
+	    %%
+	    %% we do have a problem.
+	    %%
+	    case Vstate of
+		simple_vars -> State;
+		_ -> bsm_problem(P, Vstate)
+	    end;
+	true ->
+	    %% The pattern P *may* match a binary, so we must update the state.
+	    %% (P must be a variable.)
+	    case State of
+		within -> 'after';
+		'after' -> 'after'
+	    end
+    end;
+bsm_ensure_no_partition_2([#c_var{name=V}|Ps], N, G, Vstate, S) ->
+    case core_lib:is_var_used(V, G) of
+	false ->
+	    bsm_ensure_no_partition_2(Ps, N-1, G, Vstate, S);
+	true ->
+	    bsm_ensure_no_partition_2(Ps, N-1, G, bin_left_var_used_in_guard, S)
+    end;
+bsm_ensure_no_partition_2([_|Ps], N, G, _, S) ->
+    bsm_ensure_no_partition_2(Ps, N-1, G, bin_argument_order, S).
+
+bsm_could_match_binary(#c_alias{pat=P}) -> bsm_could_match_binary(P);
+bsm_could_match_binary(#c_cons{}) -> false;
+bsm_could_match_binary(#c_tuple{}) -> false;
+bsm_could_match_binary(#c_literal{val=Lit}) -> is_bitstring(Lit);
+bsm_could_match_binary(_) -> true.
+
+bsm_real_pattern(#c_alias{pat=P}) -> bsm_real_pattern(P);
+bsm_real_pattern(P) -> P.
+
+bsm_problem(Where, What) ->
+    throw({problem,Where,What}).
+
+%%%
+%%% Handling of warnings.
+%%%
+
+init_warnings() ->
+    put({?MODULE,warnings}, []).
+
+add_bin_opt_info(Core, Term) ->
+    case get(bin_opt_info) of
+	true -> add_warning(Core, Term);
+	false -> ok
+    end.
+
+add_warning(Core, Term) ->
+    Anno = core_lib:get_anno(Core),
+    case lists:member(compiler_generated, Anno) of
+	true -> ok;
+	false ->
+	    case get_line(Anno) of
+		Line when Line >= 0 ->		%Must be positive.
+                    File = get_file(Anno),
+		    Key = {?MODULE,warnings},
+		    case get(Key) of
+			[{File,[{Line,?MODULE,Term}]}|_] ->
+			    ok;			%We already an identical warning.
+			Ws ->
+			    put(Key, [{File,[{Line,?MODULE,Term}]}|Ws])
+		    end;
+		_ -> ok				%Compiler-generated code.
+	    end
+    end.
+
+get_line([Line|_]) when is_integer(Line) -> Line;
+get_line([_|T]) -> get_line(T);
+get_line([]) -> none.
+
+get_file([{file,File}|_]) -> File;
+get_file([_|T]) -> get_file(T);
+get_file([]) -> "no_file". % should not happen
+
+is_compiler_generated(Core) ->
+    Anno = core_lib:get_anno(Core),
+    case lists:member(compiler_generated, Anno) of
+	true -> true;
+	false ->
+	    case get_line(Anno) of
+		Line when Line >= 0 -> false;
+		_ -> true
+	    end
+    end.
+
+get_warnings() ->
+    ordsets:from_list((erase({?MODULE,warnings}))).
+
+format_error({eval_failure,Reason}) ->
+    flatten(io_lib:format("this expression will fail with a '~p' exception", [Reason]));
+format_error(embedded_binary_size) ->
+    "binary construction will fail with a 'badarg' exception "
+	"(field size for binary/bitstring greater than actual size)";
+format_error({embedded_unit,Unit,Size}) ->
+    M = io_lib:format("binary construction will fail with a 'badarg' exception "
+		      "(size ~p cannot be evenly divided by unit ~p)", [Size,Unit]),
+    flatten(M);
+format_error(bad_unicode) ->
+    "binary construction will fail with a 'badarg' exception "
+	"(invalid Unicode code point in a utf8/utf16/utf32 segment)";
+format_error({nomatch_shadow,Line}) ->
+    M = io_lib:format("this clause cannot match because a previous clause at line ~p "
+		      "always matches", [Line]),
+    flatten(M);
+format_error(nomatch_shadow) ->
+    "this clause cannot match because a previous clause always matches";
+format_error(nomatch_guard) ->
+    "the guard for this clause evaluates to 'false'";
+format_error(no_clause_match) ->
+    "no clause will ever match";
+format_error(nomatch_clause_type) ->
+    "this clause cannot match because of different types/sizes";
+format_error({no_effect,{erlang,F,A}}) ->
+    {Fmt,Args} = case erl_internal:comp_op(F, A) of
+		     true ->
+			 {"use of operator ~p has no effect",[F]};
+		     false ->
+			 case erl_internal:bif(F, A) of
+			     false ->
+				 {"the call to erlang:~p/~p has no effect",[F,A]};
+			     true ->
+				 {"the call to ~p/~p has no effect",[F,A]}
+			 end
+		 end,
+    flatten(io_lib:format(Fmt, Args));
+format_error(result_ignored) ->
+    "the result of the expression is ignored";
+format_error(useless_building) ->
+    "a term is constructed, but never used";
+format_error(bin_opt_alias) ->
+    "INFO: the '=' operator will prevent delayed sub binary optimization";
+format_error(bin_partition) ->
+    "INFO: non-consecutive clauses that match binaries "
+	"will prevent delayed sub binary optimization";
+format_error(bin_left_var_used_in_guard) ->
+    "INFO: a variable to the left of the binary pattern is used in a guard; "
+	"will prevent delayed sub binary optimization";
+format_error(bin_argument_order) ->
+    "INFO: matching anything else but a plain variable to the left of "
+	"binary pattern will prevent delayed sub binary optimization; "
+	"SUGGEST changing argument order";
+format_error(bin_var_used) ->
+    "INFO: using a matched out sub binary will prevent "
+	"delayed sub binary optimization";
+format_error(orig_bin_var_used_in_guard) ->
+    "INFO: using the original binary variable in a guard will prevent "
+	"delayed sub binary optimization";
+format_error(bin_var_used_in_guard) ->
+    "INFO: using a matched out sub binary in a guard will prevent "
+	"delayed sub binary optimization".
+
+-ifdef(DEBUG).
+%% In order for simplify_let/2 to work correctly, the list of
+%% in-scope variables must always be a superset of the free variables
+%% in the current expression (otherwise we might fail to rename a variable
+%% when needed and get a name capture bug).
+
+verify_scope(E, #sub{s=Scope}) ->
+    Free = core_lib:free_vars(E),
+    case ordsets:is_subset(core_lib:free_vars(E), gb_sets:to_list(Scope)) of
+	true -> true;
+	false ->
+	    io:format("~p\n", [E]),
+	    io:format("~p\n", [Free]),
+	    io:format("~p\n", [gb_sets:to_list(Scope)]),
+	    false
+    end.
+-endif.
diff -urNp otp_src_R12B-5/lib/compiler/src/sys_expand_pmod.erl minimal_otp_src_R12B-5/lib/compiler/src/sys_expand_pmod.erl
--- otp_src_R12B-5/lib/compiler/src/sys_expand_pmod.erl	2008-02-05 13:38:12.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/sys_expand_pmod.erl	2009-06-23 20:40:10.000000000 +0100
@@ -317,6 +317,14 @@ expr({'receive',Line,Cs0,To0,ToEs0},St) 
     ToEs1 = exprs(ToEs0,St),
     Cs1 = icr_clauses(Cs0,St),
     {'receive',Line,Cs1,To1,ToEs1};
+expr({'search',Line,Cs0},St) ->
+    Cs1 = icr_clauses(Cs0,St),
+    {'search',Line,Cs1};
+expr({'search',Line,Cs0,To0,ToEs0},St) ->
+    To1 = expr(To0,St),
+    ToEs1 = exprs(ToEs0,St),
+    Cs1 = icr_clauses(Cs0,St),
+    {'search',Line,Cs1,To1,ToEs1};
 expr({'try',Line,Es0,Scs0,Ccs0,As0},St) ->
     Es1 = exprs(Es0,St),
     Scs1 = icr_clauses(Scs0,St),
diff -urNp otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl minimal_otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl
--- otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl	2008-11-04 10:51:16.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl	2009-06-23 20:40:10.000000000 +0100
@@ -397,6 +397,12 @@ expr({'receive',Line,Cs0,To0,ToEs0}, St0
     {ToEs,St2} = exprs(ToEs0, St1),
     {Cs,St3} = icr_clauses(Cs0, St2),
     {{'receive',Line,Cs,To,ToEs},St3};
+expr({'search',Line,Cs0}, St0) ->
+    {{'receive',Line,Cs},St1} = expr({'receive', Line, Cs0}, St0),
+    {{'search', Line, Cs}, St1};
+expr({'search',Line,Cs0,To0,ToEs0}, St0) ->
+    {{'receive',Line,Cs,To,ToEs},St3} = expr({'receive',Line,Cs0,To0,ToEs0}, St0),
+    {{'search',Line,Cs,To,ToEs},St3};
 expr({'fun',Line,Body}, St) ->
     fun_tq(Line, Body, St);
 expr({'cond',Line,Cs}, St0) ->
diff -urNp otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl~ minimal_otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl~
--- otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/sys_pre_expand.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,735 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Expand some source Erlang constructions. This is part of the
+%%           pre-processing phase.
+
+%% N.B. Although structs (tagged tuples) are not yet allowed in the
+%% language there is code included in pattern/2 and expr/3 (commented out)
+%% that handles them by transforming them to tuples.
+
+-module(sys_pre_expand).
+
+%% Main entry point.
+-export([module/2]).
+
+-import(ordsets, [from_list/1,add_element/2,union/2]).
+-import(lists,   [member/2,foldl/3,foldr/3]).
+
+-compile({nowarn_deprecated_function, {erlang,hash,2}}).
+
+-include("../include/erl_bits.hrl").
+
+-record(expand, {module=[],                     %Module name
+                 parameters=undefined,          %Module parameters
+                 package="",                    %Module package
+                 exports=[],                    %Exports
+                 imports=[],                    %Imports
+                 mod_imports,                   %Module Imports
+                 compile=[],                    %Compile flags
+                 attributes=[],                 %Attributes
+                 defined=[],                    %Defined functions
+                 vcount=0,                      %Variable counter
+                 func=[],                       %Current function
+                 arity=[],                      %Arity for current function
+                 fcount=0,                      %Local fun count
+                 fun_index=0,                   %Global index for funs
+                 bitdefault,
+                 bittypes
+                }).
+
+%% module(Forms, CompileOptions)
+%%      {ModuleName,Exports,TransformedForms,CompileOptions'}
+%%  Expand the forms in one module. N.B.: the lists of predefined
+%%  exports and imports are really ordsets!
+%%  CompileOptions is augmented with options from -compile attributes.
+
+module(Fs0, Opts0) ->
+
+    %% Expand records. Normalise guard tests.
+    Fs = erl_expand_records:module(Fs0, Opts0),
+
+    Opts = compiler_options(Fs) ++ Opts0,
+
+    %% Set pre-defined exported functions.
+    PreExp = [{module_info,0},{module_info,1}],
+
+    %% Set pre-defined module imports.
+    PreModImp = [{erlang,erlang},{packages,packages}],
+
+    %% Build initial expand record.
+    St0 = #expand{exports=PreExp,
+                  mod_imports=dict:from_list(PreModImp),
+                  compile=Opts,
+                  defined=PreExp,
+                  bitdefault = erl_bits:system_bitdefault(),
+                  bittypes = erl_bits:system_bittypes()
+                 },
+    %% Expand the functions.
+    {Tfs,St1} = forms(Fs, define_functions(Fs, St0)),
+    {Efs,St2} = expand_pmod(Tfs, St1),
+    %% Get the correct list of exported functions.
+    Exports = case member(export_all, St2#expand.compile) of
+                  true -> St2#expand.defined;
+                  false -> St2#expand.exports
+              end,
+    %% Generate all functions from stored info.
+    {Ats,St3} = module_attrs(St2#expand{exports = Exports}),
+    {Mfs,St4} = module_predef_funcs(St3),
+    {St4#expand.module, St4#expand.exports, Ats ++ Efs ++ Mfs,
+     St4#expand.compile}.
+
+compiler_options(Forms) ->
+    lists:flatten([C || {attribute,_,compile,C} <- Forms]).
+    
+expand_pmod(Fs0, St0) ->
+    case St0#expand.parameters of
+        undefined ->
+            {Fs0,St0};
+        Ps0 ->
+	    Base = get_base(St0#expand.attributes),
+	    Ps = if is_atom(Base) ->
+			 ['BASE' | Ps0];
+		    true ->
+			 Ps0
+		 end,
+            {Fs1,Xs,Ds} = sys_expand_pmod:forms(Fs0, Ps,
+                                                St0#expand.exports,
+                                                St0#expand.defined),
+	    St1 = St0#expand{exports=Xs, defined=Ds},
+	    {Fs2,St2} = add_instance(Ps, Fs1, St1),
+	    {Fs3,St3} = ensure_new(Base, Ps0, Fs2, St2),
+            {Fs3,St3#expand{attributes = [{abstract, [true]}
+					  | St3#expand.attributes]}}
+    end.
+
+get_base(As) ->
+    case lists:keysearch(extends, 1, As) of
+	{value,{extends,[Base]}} when is_atom(Base) ->
+	    Base;
+	_ ->
+	    []
+    end.
+
+ensure_new(Base, Ps, Fs, St) ->
+    case has_new(Fs) of
+	true ->
+	    {Fs, St};
+	false ->
+	    add_new(Base, Ps, Fs, St)
+    end.
+
+has_new([{function,_L,new,_A,_Cs} | _Fs]) ->
+    true;
+has_new([_ | Fs]) ->
+    has_new(Fs);
+has_new([]) ->
+    false.
+
+add_new(Base, Ps, Fs, St) ->
+    Vs = [{var,0,V} || V <- Ps],
+    As = if is_atom(Base) ->
+		 [{call,0,{remote,0,{atom,0,Base},{atom,0,new}},Vs} | Vs];
+	    true ->
+		 Vs
+	 end,
+    Body = [{call,0,{atom,0,instance},As}],
+    add_func(new, Vs, Body, Fs, St).
+
+add_instance(Ps, Fs, St) ->
+    Vs = [{var,0,V} || V <- Ps],
+    AbsMod = [{tuple,0,[{atom,0,St#expand.module}|Vs]}],
+    add_func(instance, Vs, AbsMod, Fs, St).
+
+add_func(Name, Args, Body, Fs, St) ->
+    A = length(Args), 
+    F = {function,0,Name,A,[{clause,0,Args,[],Body}]},
+    {[F|Fs],St#expand{exports=add_element({Name,A}, St#expand.exports),
+		      defined=add_element({Name,A}, St#expand.defined)}}.
+
+%% -type define_function(Form, State) -> State.
+%%  Add function to defined if form is a function.
+
+define_functions(Forms, #expand{defined=Predef}=St) ->
+    Fs = foldl(fun({function,_,N,A,_Cs}, Acc) -> [{N,A}|Acc];
+                  (_, Acc) -> Acc
+               end, Predef, Forms),
+    St#expand{defined=ordsets:from_list(Fs)}.
+
+module_attrs(St) ->
+    {[{attribute,0,Name,Val} || {Name,Val} <- St#expand.attributes],St}.
+
+module_predef_funcs(St) ->
+    PreDef = [{module_info,0},{module_info,1}],
+    PreExp = PreDef,
+    {[{function,0,module_info,0,
+       [{clause,0,[],[],
+        [{call,0,{remote,0,{atom,0,erlang},{atom,0,get_module_info}},
+          [{atom,0,St#expand.module}]}]}]},
+      {function,0,module_info,1,
+       [{clause,0,[{var,0,'X'}],[],
+        [{call,0,{remote,0,{atom,0,erlang},{atom,0,get_module_info}},
+          [{atom,0,St#expand.module},{var,0,'X'}]}]}]}],
+     St#expand{defined=union(from_list(PreDef), St#expand.defined),
+               exports=union(from_list(PreExp), St#expand.exports)}}.
+
+%% forms(Forms, State) ->
+%%      {TransformedForms,State'}
+%%  Process the forms. Attributes are lost and just affect the state.
+%%  Ignore uninteresting forms like eof and type.
+
+forms([{attribute,_,file,_File}=F|Fs0], St0) ->
+    {Fs,St1} = forms(Fs0, St0),
+    {[F|Fs],St1};
+forms([{attribute,_,Name,Val}|Fs0], St0) ->
+    St1 = attribute(Name, Val, St0),
+    forms(Fs0, St1);
+forms([{function,L,N,A,Cs}|Fs0], St0) ->
+    {Ff,St1} = function(L, N, A, Cs, St0),
+    {Fs,St2} = forms(Fs0, St1),
+    {[Ff|Fs],St2};
+forms([_|Fs], St) -> forms(Fs, St);
+forms([], St) -> {[],St}.
+
+%% -type attribute(Attribute, Value, State) ->
+%%      State.
+%%  Process an attribute, this just affects the state.
+
+attribute(module, {Module, As}, St) ->
+    M = package_to_string(Module),
+    St#expand{module=list_to_atom(M),
+              package = packages:strip_last(M),
+              parameters=As};
+attribute(module, Module, St) ->
+    M = package_to_string(Module),
+    St#expand{module=list_to_atom(M),
+              package = packages:strip_last(M)};
+attribute(export, Es, St) ->
+    St#expand{exports=union(from_list(Es), St#expand.exports)};
+attribute(import, Is, St) ->
+    import(Is, St);
+attribute(compile, C, St) when is_list(C) ->
+    St#expand{compile=St#expand.compile ++ C};
+attribute(compile, C, St) ->
+    St#expand{compile=St#expand.compile ++ [C]};
+attribute(Name, Val, St) when is_list(Val) ->
+    St#expand{attributes=St#expand.attributes ++ [{Name,Val}]};
+attribute(Name, Val, St) ->
+    St#expand{attributes=St#expand.attributes ++ [{Name,[Val]}]}.
+
+function(L, N, A, Cs0, St0) ->
+    {Cs,St} = clauses(Cs0, St0#expand{func=N,arity=A,fcount=0}),
+    {{function,L,N,A,Cs},St}.
+
+%% -type clauses([Clause], State) ->
+%%      {[TransformedClause],State}.
+%%  Expand function clauses.
+
+clauses([{clause,Line,H0,G0,B0}|Cs0], St0) ->
+    {H,St1} = head(H0, St0),
+    {G,St2} = guard(G0, St1),
+    {B,St3} = exprs(B0, St2),
+    {Cs,St4} = clauses(Cs0, St3),
+    {[{clause,Line,H,G,B}|Cs],St4};
+clauses([], St) -> {[],St}.
+
+%% head(HeadPatterns, State) ->
+%%      {TransformedPatterns,Variables,UsedVariables,State'}
+
+head(As, St) -> pattern_list(As, St).
+
+%% pattern(Pattern, State) ->
+%%      {TransformedPattern,State'}
+%%
+
+pattern({var,_,'_'}=Var, St) ->                 %Ignore anonymous variable.
+    {Var,St};
+pattern({var,_,_}=Var, St) ->
+    {Var,St};
+pattern({char,_,_}=Char, St) ->
+    {Char,St};
+pattern({integer,_,_}=Int, St) ->
+    {Int,St};
+pattern({float,_,_}=Float, St) ->
+    {Float,St};
+pattern({atom,_,_}=Atom, St) ->
+    {Atom,St};
+pattern({string,_,_}=String, St) ->
+    {String,St};
+pattern({nil,_}=Nil, St) ->
+    {Nil,St};
+pattern({cons,Line,H,T}, St0) ->
+    {TH,St1} = pattern(H, St0),
+    {TT,St2} = pattern(T, St1),
+    {{cons,Line,TH,TT},St2};
+pattern({tuple,Line,Ps}, St0) ->
+    {TPs,St1} = pattern_list(Ps, St0),
+    {{tuple,Line,TPs},St1};
+%%pattern({struct,Line,Tag,Ps}, St0) ->
+%%    {TPs,TPsvs,St1} = pattern_list(Ps, St0),
+%%    {{tuple,Line,[{atom,Line,Tag}|TPs]},TPsvs,St1};
+pattern({record_field,_,_,_}=M, St) ->
+    {expand_package(M, St),St};  % must be a package name
+pattern({bin,Line,Es0}, St0) ->
+    {Es1,St1} = pattern_bin(Es0, St0),
+    {{bin,Line,Es1},St1};
+pattern({op,_,'++',{nil,_},R}, St) ->
+    pattern(R, St);
+pattern({op,_,'++',{cons,Li,H,T},R}, St) ->
+    pattern({cons,Li,H,{op,Li,'++',T,R}}, St);
+pattern({op,_,'++',{string,Li,L},R}, St) ->
+    pattern(string_to_conses(Li, L, R), St);
+pattern({match,Line,Pat1, Pat2}, St0) ->
+    {TH,St1} = pattern(Pat2, St0),
+    {TT,St2} = pattern(Pat1, St1),
+    {{match,Line,TT,TH},St2};
+%% Compile-time pattern expressions, including unary operators.
+pattern({op,Line,Op,A}, St) ->
+    {erl_eval:partial_eval({op,Line,Op,A}),St};
+pattern({op,Line,Op,L,R}, St) ->
+    {erl_eval:partial_eval({op,Line,Op,L,R}),St}.
+
+pattern_list([P0|Ps0], St0) ->
+    {P,St1} = pattern(P0, St0),
+    {Ps,St2} = pattern_list(Ps0, St1),
+    {[P|Ps],St2};
+pattern_list([], St) -> {[],St}.
+
+%% guard(Guard, State) ->
+%%      {TransformedGuard,State'}
+%%  Transform a list of guard tests. We KNOW that this has been checked
+%%  and what the guards test are. Use expr for transforming the guard
+%%  expressions.
+
+guard([G0|Gs0], St0) ->
+    {G,St1} = guard_tests(G0, St0),
+    {Gs,St2} = guard(Gs0, St1),
+    {[G|Gs],St2};
+guard([], St) -> {[],St}.
+
+guard_tests([Gt0|Gts0], St0) ->
+    {Gt1,St1} = guard_test(Gt0, St0),
+    {Gts1,St2} = guard_tests(Gts0, St1),
+    {[Gt1|Gts1],St2};
+guard_tests([], St) -> {[],St}.
+
+guard_test(Test, St) ->
+    expr(Test, St).
+
+%% exprs(Expressions, State) ->
+%%      {TransformedExprs,State'}
+
+exprs([E0|Es0], St0) ->
+    {E,St1} = expr(E0, St0),
+    {Es,St2} = exprs(Es0, St1),
+    {[E|Es],St2};
+exprs([], St) -> {[],St}.
+
+%% expr(Expression, State) ->
+%%      {TransformedExpression,State'}
+
+expr({var,_,_}=Var, St) ->
+    {Var,St};
+expr({char,_,_}=Char, St) ->
+    {Char,St};
+expr({integer,_,_}=Int, St) ->
+    {Int,St};
+expr({float,_,_}=Float, St) ->
+    {Float,St};
+expr({atom,_,_}=Atom, St) ->
+    {Atom,St};
+expr({string,_,_}=String, St) ->
+    {String,St};
+expr({nil,_}=Nil, St) ->
+    {Nil,St};
+expr({cons,Line,H0,T0}, St0) ->
+    {H,St1} = expr(H0, St0),
+    {T,St2} = expr(T0, St1),
+    {{cons,Line,H,T},St2};
+expr({lc,Line,E0,Qs0}, St0) ->
+    {Qs1,St1} = lc_tq(Line, Qs0, St0),
+    {E1,St2} = expr(E0, St1),
+    {{lc,Line,E1,Qs1},St2};
+expr({bc,Line,E0,Qs0}, St0) ->
+    {Qs1,St1} = lc_tq(Line, Qs0, St0),
+    {E1,St2} = expr(E0, St1),
+    {{bc,Line,E1,Qs1},St2};
+expr({tuple,Line,Es0}, St0) ->
+    {Es1,St1} = expr_list(Es0, St0),
+    {{tuple,Line,Es1},St1};
+%%expr({struct,Line,Tag,Es0}, Vs, St0) ->
+%%    {Es1,Esvs,Esus,St1} = expr_list(Es0, Vs, St0),
+%%    {{tuple,Line,[{atom,Line,Tag}|Es1]},Esvs,Esus,St1};
+expr({record_field,_,_,_}=M, St) ->
+    {expand_package(M, St),St};  % must be a package name
+expr({bin,Line,Es0}, St0) ->
+    {Es1,St1} = expr_bin(Es0, St0),
+    {{bin,Line,Es1},St1};
+expr({block,Line,Es0}, St0) ->
+    {Es,St1} = exprs(Es0, St0),
+    {{block,Line,Es},St1};
+expr({'if',Line,Cs0}, St0) ->
+    {Cs,St1} = icr_clauses(Cs0, St0),
+    {{'if',Line,Cs},St1};
+expr({'case',Line,E0,Cs0}, St0) ->
+    {E,St1} = expr(E0, St0),
+    {Cs,St2} = icr_clauses(Cs0, St1),
+    {{'case',Line,E,Cs},St2};
+expr({'receive',Line,Cs0}, St0) ->
+    {Cs,St1} = icr_clauses(Cs0, St0),
+    {{'receive',Line,Cs},St1};
+expr({'receive',Line,Cs0,To0,ToEs0}, St0) ->
+    {To,St1} = expr(To0, St0),
+    {ToEs,St2} = exprs(ToEs0, St1),
+    {Cs,St3} = icr_clauses(Cs0, St2),
+    {{'receive',Line,Cs,To,ToEs},St3};
+expr({'search',Line,Cs0}, St0) ->
+    {Cs,St1} = icr_clauses(Cs0, St0),
+    {{'search',Line,Cs},St1};
+expr({'search',Line,Cs0,To0,ToEs0}, St0) ->
+    {To,St1} = expr(To0, St0),
+    {ToEs,St2} = exprs(ToEs0, St1),
+    {Cs,St3} = icr_clauses(Cs0, St2),
+    {{'search',Line,Cs,To,ToEs},St3};
+expr({'fun',Line,Body}, St) ->
+    fun_tq(Line, Body, St);
+expr({'cond',Line,Cs}, St0) ->
+    {V,St1} = new_var(Line,St0),
+    expr(cond_clauses(Cs, V), St1);
+expr({call,Line,{atom,La,N},As0}, St0) ->
+    {As,St1} = expr_list(As0, St0),
+    Ar = length(As),
+    case erl_internal:bif(N, Ar) of
+        true ->
+            {{call,Line,{remote,La,{atom,La,erlang},{atom,La,N}},As},St1};
+        false ->
+            case imported(N, Ar, St1) of
+                {yes,Mod} ->
+                    {{call,Line,{remote,La,{atom,La,Mod},{atom,La,N}},As},St1};
+                no ->
+                    {{call,Line,{atom,La,N},As},St1}
+            end
+    end;
+expr({call,Line,{record_field,_,_,_}=M,As0}, St0) ->
+    expr({call,Line,expand_package(M, St0),As0}, St0);
+expr({call,Line,{remote,Lr,M,F},As0}, St0) ->
+    M1 = expand_package(M, St0),
+    {[M2,F1|As1],St1} = expr_list([M1,F|As0], St0),
+    {{call,Line,{remote,Lr,M2,F1},As1},St1};
+expr({call,Line,{tuple,_,[{atom,_,_}=M,{atom,_,_}=F]},As}, St) ->
+    %% Rewrite {Mod,Function}(Args...) to Mod:Function(Args...).
+    expr({call,Line,{remote,Line,M,F},As}, St);
+expr({call,Line,F,As0}, St0) ->
+    {[Fun1|As1],St1} = expr_list([F|As0], St0),
+    {{call,Line,Fun1,As1},St1};
+expr({'try',Line,Es0,Scs0,Ccs0,As0}, St0) ->
+    {Es1,St1} = exprs(Es0, St0),
+    {Scs1,St2} = icr_clauses(Scs0, St1),
+    {Ccs1,St3} = icr_clauses(Ccs0, St2),
+    {As1,St4} = exprs(As0, St3),
+    {{'try',Line,Es1,Scs1,Ccs1,As1},St4};
+expr({'catch',Line,E0}, St0) ->
+    %% Catch exports no new variables.
+    {E,St1} = expr(E0, St0),
+    {{'catch',Line,E},St1};
+expr({match,Line,P0,E0}, St0) ->
+    {E,St1} = expr(E0, St0),
+    {P,St2} = pattern(P0, St1),
+    {{match,Line,P,E},St2};
+expr({op,_,'++',{string,L1,S1},{string,_,S2}}, St) ->
+    {{string,L1,S1 ++ S2},St};
+expr({op,Ll,'++',{string,L1,S1}=Str,R0}, St0) ->
+    {R1,St1} = expr(R0, St0),
+    E = case R1 of
+            {string,_,S2} -> {string,L1,S1 ++ S2};
+            _Other when length(S1) < 8 -> string_to_conses(L1, S1, R1);
+            _Other -> {op,Ll,'++',Str,R1}
+        end,
+    {E,St1};
+expr({op,Ll,'++',{cons,Lc,H,T},L2}, St) ->
+    expr({cons,Ll,H,{op,Lc,'++',T,L2}}, St);
+expr({op,_,'++',{nil,_},L2}, St) ->
+    expr(L2, St);
+expr({op,Line,Op,A0}, St0) ->
+    {A,St1} = expr(A0, St0),
+    {{op,Line,Op,A},St1};
+expr({op,Line,Op,L0,R0}, St0) ->
+    {L,St1} = expr(L0, St0),
+    {R,St2} = expr(R0, St1),
+    {{op,Line,Op,L,R},St2}.
+
+expr_list([E0|Es0], St0) ->
+    {E,St1} = expr(E0, St0),
+    {Es,St2} = expr_list(Es0, St1),
+    {[E|Es],St2};
+expr_list([], St) -> {[],St}.
+
+%% icr_clauses([Clause], State) -> {[TransformedClause],State'}
+%%  Be very careful here to return the variables that are really used
+%%  and really new.
+
+icr_clauses([], St) -> {[],St};
+icr_clauses(Clauses, St) -> icr_clauses2(Clauses, St).
+
+icr_clauses2([{clause,Line,H0,G0,B0}|Cs0], St0) ->
+    {H,St1} = head(H0, St0),
+    {G,St2} = guard(G0, St1),
+    {B,St3} = exprs(B0, St2),
+    {Cs,St4} = icr_clauses2(Cs0, St3),
+    {[{clause,Line,H,G,B}|Cs],St4};
+icr_clauses2([], St) -> {[],St}.
+
+%% lc_tq(Line, Qualifiers, State) ->
+%%      {[TransQual],State'}
+
+lc_tq(Line, [{generate,Lg,P0,G0} | Qs0], St0) ->
+    {G1,St1} = expr(G0, St0),
+    {P1,St2} = pattern(P0, St1),
+    {Qs1,St3} = lc_tq(Line, Qs0, St2),
+    {[{generate,Lg,P1,G1} | Qs1],St3};
+
+lc_tq(Line, [{b_generate,Lg,P0,G0}|Qs0], St0) ->
+    {G1,St1} = expr(G0, St0),
+    {P1,St2} = pattern(P0, St1),
+    {Qs1,St3} = lc_tq(Line, Qs0, St2),
+    {[{b_generate,Lg,P1,G1}|Qs1],St3};
+lc_tq(Line, [F0 | Qs0], St0) ->
+    case erl_lint:is_guard_test(F0) of
+        true ->
+            {F1,St1} = guard_test(F0, St0),
+            {Qs1,St2} = lc_tq(Line, Qs0, St1),
+            {[F1|Qs1],St2};
+        false ->
+            {F1,St1} = expr(F0, St0),
+            {Qs1,St2} = lc_tq(Line, Qs0, St1),
+            {[F1 | Qs1],St2}
+    end;
+lc_tq(_Line, [], St0) ->
+    {[],St0}.
+
+
+%% fun_tq(Line, Body, State) ->
+%%      {Fun,State'}
+%% Transform an "explicit" fun {'fun', Line, {clauses, Cs}} into an
+%% extended form {'fun', Line, {clauses, Cs}, Info}, unless it is the
+%% name of a BIF (erl_lint has checked that it is not an import).
+%% Process the body sequence directly to get the new and used variables.
+%% "Implicit" funs {'fun', Line, {function, F, A}} are not changed.
+
+fun_tq(Lf, {function,F,A}, St0) ->
+    {As,St1} = new_vars(A, Lf, St0),
+    Cs = [{clause,Lf,As,[],[{call,Lf,{atom,Lf,F},As}]}],
+    case erl_internal:bif(F, A) of
+        true ->
+            fun_tq(Lf, {clauses,Cs}, St1);
+        false ->
+            Index = St0#expand.fun_index,
+            Uniq = erlang:hash(Cs, (1 bsl 27)-1),
+            {Fname,St2} = new_fun_name(St1),
+            {{'fun',Lf,{function,F,A},{Index,Uniq,Fname}},
+             St2#expand{fun_index=Index+1}}
+    end;
+fun_tq(L, {function,M,F,A}, St) ->
+    {{call,L,{remote,L,{atom,L,erlang},{atom,L,make_fun}},
+      [{atom,L,M},{atom,L,F},{integer,L,A}]},St};
+fun_tq(Lf, {clauses,Cs0}, St0) ->
+    Uniq = erlang:hash(Cs0, (1 bsl 27)-1),
+    {Cs1,St1} = fun_clauses(Cs0, St0),
+    Index = St1#expand.fun_index,
+    {Fname,St2} = new_fun_name(St1),
+    {{'fun',Lf,{clauses,Cs1},{Index,Uniq,Fname}},
+     St2#expand{fun_index=Index+1}}.
+
+fun_clauses([{clause,L,H0,G0,B0}|Cs0], St0) ->
+    {H,St1} = head(H0, St0),
+    {G,St2} = guard(G0, St1),
+    {B,St3} = exprs(B0, St2),
+    {Cs,St4} = fun_clauses(Cs0, St3),
+    {[{clause,L,H,G,B}|Cs],St4};
+fun_clauses([], St) -> {[],St}.
+
+%% new_fun_name(State) -> {FunName,State}.
+
+new_fun_name(#expand{func=F,arity=A,fcount=I}=St) ->
+    Name = "-" ++ atom_to_list(F) ++ "/" ++ integer_to_list(A)
+        ++ "-fun-" ++ integer_to_list(I) ++ "-",
+    {list_to_atom(Name),St#expand{fcount=I+1}}.
+
+%% pattern_bin([Element], State) -> {[Element],[Variable],[UsedVar],State}.
+
+pattern_bin(Es0, St) ->
+    Es1 = bin_expand_strings(Es0),
+    foldr(fun (E, Acc) -> pattern_element(E, Acc) end, {[],St}, Es1).
+
+pattern_element({bin_element,Line,Expr0,Size0,Type0}, {Es,St0}) ->
+    {Expr1,St1} = pattern(Expr0, St0),
+    {Size1,St2} = pat_bit_size(Size0, St1),
+    {Size,Type} = make_bit_type(Line, Size1, Type0),
+    Expr = coerce_to_float(Expr1, Type0),
+    {[{bin_element,Line,Expr,Size,Type}|Es],St2}.
+
+pat_bit_size(default, St) -> {default,St};
+pat_bit_size({atom,_La,all}=All, St) -> {All,St};
+pat_bit_size({var,_Lv,_V}=Var, St) -> {Var,St};
+pat_bit_size(Size, St) ->
+    Line = element(2, Size),
+    {value,Sz,_} = erl_eval:expr(Size, erl_eval:new_bindings()),
+    {{integer,Line,Sz},St}.
+
+make_bit_type(Line, default, Type0) ->
+    case erl_bits:set_bit_type(default, Type0) of
+        {ok,all,Bt} -> {{atom,Line,all},erl_bits:as_list(Bt)};
+	{ok,undefined,Bt} -> {{atom,Line,undefined},erl_bits:as_list(Bt)};
+        {ok,Size,Bt} -> {{integer,Line,Size},erl_bits:as_list(Bt)}
+    end;
+make_bit_type(_Line, Size, Type0) ->            %Integer or 'all'
+    {ok,Size,Bt} = erl_bits:set_bit_type(Size, Type0),
+    {Size,erl_bits:as_list(Bt)}.
+
+coerce_to_float({integer,L,I}=E, [float|_]) ->
+    try
+        {float,L,float(I)}
+    catch
+        error:badarg -> E;
+        error:badarith -> E
+    end;
+coerce_to_float(E, _) -> E.
+    
+%% expr_bin([Element], State) -> {[Element],State}.
+
+expr_bin(Es0, St) ->
+    Es1 = bin_expand_strings(Es0),
+    foldr(fun (E, Acc) -> bin_element(E, Acc) end, {[],St}, Es1).
+
+bin_element({bin_element,Line,Expr,Size,Type}, {Es,St0}) ->
+    {Expr1,St1} = expr(Expr, St0),
+    {Size1,St2} = if Size == default -> {default,St1};
+                             true -> expr(Size, St1)
+                          end,
+    {Size2,Type1} = make_bit_type(Line, Size1, Type),
+    {[{bin_element,Line,Expr1,Size2,Type1}|Es],St2}.
+
+bin_expand_strings(Es) ->
+    foldr(fun ({bin_element,Line,{string,_,S},Sz,Ts}, Es1) ->
+                  foldr(fun (C, Es2) ->
+                                [{bin_element,Line,{char,Line,C},Sz,Ts}|Es2]
+                        end, Es1, S);
+              (E, Es1) -> [E|Es1]
+          end, [], Es).
+
+%% new_var_name(State) -> {VarName,State}.
+
+new_var_name(St) ->
+    C = St#expand.vcount,
+    {list_to_atom("pre" ++ integer_to_list(C)),St#expand{vcount=C+1}}.
+
+%% new_var(Line, State) -> {Var,State}.
+
+new_var(L, St0) ->
+    {New,St1} = new_var_name(St0),
+    {{var,L,New},St1}.
+
+%% new_vars(Count, Line, State) -> {[Var],State}.
+%%  Make Count new variables.
+
+new_vars(N, L, St) -> new_vars(N, L, St, []).
+
+new_vars(N, L, St0, Vs) when N > 0 ->
+    {V,St1} = new_var(L, St0),
+    new_vars(N-1, L, St1, [V|Vs]);
+new_vars(0, _L, St, Vs) -> {Vs,St}.
+
+string_to_conses(Line, Cs, Tail) ->
+    foldr(fun (C, T) -> {cons,Line,{char,Line,C},T} end, Tail, Cs).
+
+
+%% In syntax trees, module/package names are atoms or lists of atoms.
+
+package_to_string(A) when is_atom(A) -> atom_to_list(A);
+package_to_string(L) when is_list(L) -> packages:concat(L).
+
+expand_package({atom,L,A} = M, St) ->
+    case dict:find(A, St#expand.mod_imports) of
+        {ok, A1} ->
+            {atom,L,A1};
+        error ->
+            case packages:is_segmented(A) of
+                true ->
+                    M;
+                false -> 
+                    M1 = packages:concat(St#expand.package, A),
+                    {atom,L,list_to_atom(M1)}
+            end
+    end;
+expand_package(M, _St) ->
+    case erl_parse:package_segments(M) of
+        error ->
+            M;
+        M1 ->
+            {atom,element(2,M),list_to_atom(package_to_string(M1))}
+    end.
+
+%% Create a case-switch on true/false, generating badarg for all other
+%% values.
+
+make_bool_switch(L, E, V, T, F) ->
+    NegL = -abs(L),
+    {'case',NegL,E,
+     [{clause,NegL,[{atom,NegL,true}],[],T},
+      {clause,NegL,[{atom,NegL,false}],[],F},
+      {clause,NegL,[V],[],
+       [call_error(NegL,{tuple,NegL,[{atom,NegL,badarg},V]})]}]}.
+
+%% Expand a list of cond-clauses to a sequence of case-switches.
+
+cond_clauses([{clause,L,[],[[E]],B}],V) ->
+    make_bool_switch(L,E,V,B,[call_error(L,{atom,L,cond_clause})]);
+cond_clauses([{clause,L,[],[[E]],B} | Cs],V) ->
+    make_bool_switch(L,E,V,B,[cond_clauses(Cs,V)]).
+
+%% call_error(Line, Reason) -> Expr.
+%%  Build a call to erlang:error/1 with reason Reason.
+
+call_error(L, R) ->
+    {call,L,{remote,L,{atom,L,erlang},{atom,L,error}},[R]}.
+
+%% import(Line, Imports, State) ->
+%%      State'
+%% imported(Name, Arity, State) ->
+%%      {yes,Module} | no
+%%  Handle import declarations and est for imported functions. No need to
+%%  check when building imports as code is correct.
+
+import({Mod0,Fs}, St) ->
+    Mod = list_to_atom(package_to_string(Mod0)),
+    Mfs = from_list(Fs),
+    St#expand{imports=add_imports(Mod, Mfs, St#expand.imports)};
+import(Mod0, St) ->
+    Mod = package_to_string(Mod0),
+    Key = list_to_atom(packages:last(Mod)),
+    St#expand{mod_imports=dict:store(Key, list_to_atom(Mod),
+                                     St#expand.mod_imports)}.
+
+add_imports(Mod, [F|Fs], Is) ->
+    add_imports(Mod, Fs, orddict:store(F, Mod, Is));
+add_imports(_, [], Is) -> Is.
+
+imported(F, A, St) ->
+    case orddict:find({F,A}, St#expand.imports) of
+        {ok,Mod} -> {yes,Mod};
+        error -> no
+    end.
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_codegen.erl minimal_otp_src_R12B-5/lib/compiler/src/v3_codegen.erl
--- otp_src_R12B-5/lib/compiler/src/v3_codegen.erl	2008-11-04 10:51:32.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_codegen.erl	2009-06-23 20:40:10.000000000 +0100
@@ -134,10 +134,17 @@ cg({bif,Bif,As,Rs}, Le, Vdb, Bef, St) ->
 cg({gc_bif,Bif,As,Rs}, Le, Vdb, Bef, St) ->
     gc_bif_cg(Bif, As, Rs, Le, Vdb, Bef, St);
 cg({receive_loop,Te,Rvar,Rm,Tes,Rs}, Le, Vdb, Bef, St) ->
-    recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St);
+    recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St, fun cg_recv_mesg/5);
 cg(receive_next, Le, Vdb, Bef, St) ->
-    recv_next_cg(Le, Vdb, Bef, St);
+    recv_next_cg(Le, Vdb, Bef, St, loop_rec_end);
 cg(receive_accept, _Le, _Vdb, Bef, St) -> {[remove_message],Bef,St};
+%% Added search 
+cg({search_loop,Te,Rvar,Rm,Tes,Rs}, Le, Vdb, Bef, St) ->
+    recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St, fun cg_search_mesg/5);
+cg(search_next, Le, Vdb, Bef, St) ->
+    recv_next_cg(Le, Vdb, Bef, St, loop_search_end);
+cg(search_accept, _Le, _Vdb, Bef, St) -> {[found_message],Bef,St};
+%% End
 cg({'try',Ta,Vs,Tb,Evs,Th,Rs}, Le, Vdb, Bef, St) ->
     try_cg(Ta, Vs, Tb, Evs, Th, Rs, Le, Vdb, Bef, St);
 cg({try_enter,Ta,Vs,Tb,Evs,Th}, Le, Vdb, Bef, St) ->
@@ -1289,7 +1296,7 @@ bif_fail(fail, Fail, _) -> {f,Fail}.
 %% recv_loop_cg(TimeOut, ReceiveVar, ReceiveMatch, TimeOutExprs,
 %%              [Ret], Le, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
 
-recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St0) ->
+recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St0, FunMessage) ->
     {Sis,Int0} = adjust_stack(Bef, Le#l.i, Le#l.i, Vdb),
     Int1 = Int0#sr{reg=clear_regs(Int0#sr.reg)},
     %% Get labels.
@@ -1297,7 +1304,7 @@ recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, 
     {Tl,St2} = new_label(St1),
     {Bl,St3} = new_label(St2),
     St4 = St3#cg{break=Bl,recv=Rl},		%Set correct receive labels
-    {Ris,Raft,St5} = cg_recv_mesg(Rvar, Rm, Tl, Int1, St4),
+    {Ris,Raft,St5} = FunMessage(Rvar, Rm, Tl, Int1, St4),
     {Wis,Taft,St6} = cg_recv_wait(Te, Tes, Le#l.i, Int1, St5),
     Int2 = sr_merge(Raft, Taft),		%Merge stack/registers
     Reg = load_vars(Rs, Int2#sr.reg),
@@ -1308,12 +1315,19 @@ recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, 
 %% cg_recv_mesg( ) -> {[Ainstr],Aft,St}.
 
 cg_recv_mesg({var,R}, Rm, Tl, Bef, St0) ->
+    cg_recv_mesg({var,R}, Rm, Tl, Bef, St0, loop_rec).
+
+cg_search_mesg({var,R}, Rm, Tl, Bef, St0) ->
+    cg_recv_mesg({var,R}, Rm, Tl, Bef, St0, loop_search).
+
+cg_recv_mesg({var,R}, Rm, Tl, Bef, St0, LabelName) ->
     Int0 = Bef#sr{reg=put_reg(R, Bef#sr.reg)},
     Ret = fetch_reg(R, Int0#sr.reg),
     %% Int1 = clear_dead(Int0, I, Rm#l.vdb),
     Int1 = Int0,
     {Mis,Int2,St1} = match_cg(Rm, none, Int1, St0),
-    {[{'%live',0},{label,St1#cg.recv},{loop_rec,{f,Tl},Ret}|Mis],Int2,St1}.
+    {[{'%live',0},{label,St1#cg.recv},{LabelName,{f,Tl},Ret}|Mis],Int2,St1}.
+
 
 %% cg_recv_wait(Te, Tes, I, Vdb, Int2, St3) -> {[Ainstr],Aft,St}.
 
@@ -1336,12 +1350,12 @@ cg_recv_wait(Te, Tes, I, Bef, St0) ->
 			     Int0#sr{reg=clear_regs(Int0#sr.reg)}, St0),
     {[{wait_timeout,{f,St1#cg.recv},Reg},timeout] ++ Tis,Int,St1}.
 
-%% recv_next_cg(Le, Vdb, StackReg, St) -> {[Ainstr],StackReg,St}.
+%% recv_next_cg(Le, Vdb, StackReg, St, Label) -> {[Ainstr],StackReg,St}.
 %%  Use adjust stack to clear stack, but only need it for Aft.
 
-recv_next_cg(Le, Vdb, Bef, St) ->
+recv_next_cg(Le, Vdb, Bef, St, LabelName) ->
     {Sis,Aft} = adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb),
-    {[{loop_rec_end,{f,St#cg.recv}}] ++ Sis,Aft,St}.	%Joke
+    {[{LabelName,{f,St#cg.recv}}] ++ Sis,Aft,St}.	%Joke
 
 %% try_cg(TryBlock, [BodyVar], TryBody, [ExcpVar], TryHandler, [Ret],
 %%        Le, Vdb, StackReg, St) -> {[Ainstr],StackReg,St}.
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_codegen.erl~ minimal_otp_src_R12B-5/lib/compiler/src/v3_codegen.erl~
--- otp_src_R12B-5/lib/compiler/src/v3_codegen.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_codegen.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,2064 @@
+%% -*- erlang-indent-level: 4 -*-
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Code generator for Beam.
+
+%% The following assumptions have been made:
+%%
+%% 1. Matches, i.e. things with {match,M,Ret} wrappers, only return
+%% values; no variables are exported. If the match would have returned
+%% extra variables then these have been transformed to multiple return
+%% values.
+%% 
+%% 2. All BIF's called in guards are gc-safe so there is no need to
+%% put thing on the stack in the guard.  While this would in principle
+%% work it would be difficult to keep track of the stack depth when
+%% trimming.
+%%
+%% The code generation uses variable lifetime information added by
+%% the v3_life module to save variables, allocate registers and 
+%% move registers to the stack when necessary.
+%%
+%% We try to use a consistent variable name scheme throughout.  The
+%% StackReg record is always called Bef,Int<n>,Aft.
+
+-module(v3_codegen).
+
+%% The main interface.
+-export([module/2]).
+
+-import(lists, [member/2,keymember/3,keysort/2,keysearch/3,keydelete/3,
+		append/1,map/2,flatmap/2,filter/2,foldl/3,foldr/3,mapfoldl/3,
+		sort/1,reverse/1,reverse/2]).
+-import(v3_life, [vdb_find/2]).
+
+%%-compile([export_all]).
+
+-include("v3_life.hrl").
+
+%% Main codegen structure.
+-record(cg, {lcount=1,				%Label counter
+	     finfo,				%Function info label
+	     btype,				%Type of bif used.
+	     bfail,				%Fail label of bif
+	     break,				%Break label
+	     recv,				%Receive label
+	     is_top_block,			%Boolean: top block or not
+	     functable=gb_trees:empty(),	%Gb tree of local functions:
+						% {{Name,Arity},Label}
+	     in_catch=false,			%Inside a catch or not.
+	     need_frame				%Need a stack frame.
+	    }).			
+
+%% Stack/register state record.
+-record(sr, {reg=[],				%Register table
+	     stk=[],				%Stack table
+	     res=[]}).				%Reserved regs: [{reserved,I,V}]
+
+module({Mod,Exp,Attr,Forms}, Options) ->
+    put(?MODULE, Options),
+    {Fs,St} = functions(Forms, {atom,Mod}),
+    erase(?MODULE),
+    {ok,{Mod,Exp,Attr,Fs,St#cg.lcount}}.
+
+functions(Forms, AtomMod) ->
+    mapfoldl(fun (F, St) -> function(F, AtomMod, St) end, #cg{lcount=1}, Forms).
+
+function({function,Name,Arity,As0,Vb,Vdb}, AtomMod, St0) ->
+    %%ok = io:fwrite("cg ~w:~p~n", [?LINE,{Name,Arity}]),
+    try
+	{Asm,EntryLabel,St} = cg_fun(Vb, As0, Vdb, AtomMod, {Name,Arity}, St0),
+	Func = {function,Name,Arity,EntryLabel,Asm},
+	{Func,St}
+    catch
+	Class:Error ->
+	    Stack = erlang:get_stacktrace(),
+	    io:fwrite("Function: ~w/~w\n", [Name,Arity]),
+	    erlang:raise(Class, Error, Stack)
+    end.
+
+%% cg_fun([Lkexpr], [HeadVar], Vdb, State) -> {[Ainstr],State}
+
+cg_fun(Les, Hvs, Vdb, AtomMod, NameArity, St0) ->
+    {Fi,St1} = new_label(St0),			%FuncInfo label
+    {Fl,St2} = local_func_label(NameArity, St1),
+
+    %% Create initial stack/register state, clear unused arguments.
+    Bef = clear_dead(#sr{reg=foldl(fun ({var,V}, Reg) ->
+					   put_reg(V, Reg)
+				   end, [], Hvs),
+			stk=[]}, 0, Vdb),
+    {B2,_Aft,St3} = cg_list(Les, 0, Vdb, Bef, St2#cg{btype=exit,
+						     bfail=Fi,
+						     finfo=Fi,
+						     is_top_block=true}),
+    {Name,Arity} = NameArity,
+    A = [{label,Fi},{func_info,AtomMod,{atom,Name},Arity},
+	 {label,Fl}|B2],
+    {A,Fl,St3}.
+
+%% cg(Lkexpr, Vdb, StackReg, State) -> {[Ainstr],StackReg,State}.
+%%  Generate code for a kexpr.
+%%  Split function into two steps for clarity, not efficiency.
+
+cg(Le, Vdb, Bef, St) ->
+    cg(Le#l.ke, Le, Vdb, Bef, St).
+
+cg({block,Es}, Le, Vdb, Bef, St) ->
+    block_cg(Es, Le, Vdb, Bef, St);
+cg({match,M,Rs}, Le, Vdb, Bef, St) ->
+    match_cg(M, Rs, Le, Vdb, Bef, St);
+cg({match_fail,F}, Le, Vdb, Bef, St) ->
+    match_fail_cg(F, Le, Vdb, Bef, St);
+cg({call,Func,As,Rs}, Le, Vdb, Bef, St) ->
+    call_cg(Func, As, Rs, Le, Vdb, Bef, St);
+cg({enter,Func,As}, Le, Vdb, Bef, St) ->
+    enter_cg(Func, As, Le, Vdb, Bef, St);
+cg({bif,Bif,As,Rs}, Le, Vdb, Bef, St) ->
+    bif_cg(Bif, As, Rs, Le, Vdb, Bef, St);
+cg({gc_bif,Bif,As,Rs}, Le, Vdb, Bef, St) ->
+    gc_bif_cg(Bif, As, Rs, Le, Vdb, Bef, St);
+cg({receive_loop,Te,Rvar,Rm,Tes,Rs}, Le, Vdb, Bef, St) ->
+    recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St, fun cg_recv_mesg/5);
+cg(receive_next, Le, Vdb, Bef, St) ->
+    recv_next_cg(Le, Vdb, Bef, St, loop_rec);
+cg(receive_accept, _Le, _Vdb, Bef, St) -> {[remove_message],Bef,St};
+%% Added search 
+cg({search_loop,Te,Rvar,Rm,Tes,Rs}, Le, Vdb, Bef, St) ->
+    recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St, fun cg_search_mesg/5);
+cg(search_next, Le, Vdb, Bef, St) ->
+    recv_next_cg(Le, Vdb, Bef, St, loop_search);
+cg(search_accept, _Le, _Vdb, Bef, St) -> {[found_message],Bef,St};
+%% End
+cg({'try',Ta,Vs,Tb,Evs,Th,Rs}, Le, Vdb, Bef, St) ->
+    try_cg(Ta, Vs, Tb, Evs, Th, Rs, Le, Vdb, Bef, St);
+cg({try_enter,Ta,Vs,Tb,Evs,Th}, Le, Vdb, Bef, St) ->
+    try_enter_cg(Ta, Vs, Tb, Evs, Th, Le, Vdb, Bef, St);
+cg({'catch',Cb,R}, Le, Vdb, Bef, St) ->
+    catch_cg(Cb, R, Le, Vdb, Bef, St);
+cg({set,Var,Con}, Le, Vdb, Bef, St) ->
+    set_cg(Var, Con, Le, Vdb, Bef, St);
+cg({return,Rs}, Le, Vdb, Bef, St) -> return_cg(Rs, Le, Vdb, Bef, St);
+cg({break,Bs}, Le, Vdb, Bef, St) -> break_cg(Bs, Le, Vdb, Bef, St);
+cg({need_heap,H}, _Le, _Vdb, Bef, St) ->
+    {[{test_heap,H,max_reg(Bef#sr.reg)}],Bef,St}.
+
+%% cg_list([Kexpr], FirstI, Vdb, StackReg, St) -> {[Ainstr],StackReg,St}.
+
+cg_list(Kes, I, Vdb, Bef, St0) ->
+    {Keis,{Aft,St1}} =
+	flatmapfoldl(fun (Ke, {Inta,Sta}) ->
+			     {Keis,Intb,Stb} = cg(Ke, Vdb, Inta, Sta),
+			     {comment(Inta) ++ Keis,{Intb,Stb}}
+		     end, {Bef,St0}, need_heap(Kes, I)),
+    {Keis,Aft,St1}.
+
+%% need_heap([Lkexpr], I, St) -> [Lkexpr].
+%%  Insert need_heap instructions in Kexpr list.  Try to be smart and
+%%  collect them together as much as possible.
+
+need_heap(Kes0, I) ->
+    {Kes,H} = need_heap_0(reverse(Kes0), 0, []),
+
+    %% Prepend need_heap if necessary.
+    need_heap_need(I, H) ++ Kes.
+
+need_heap_0([Ke|Kes], H0, Acc) ->
+    {Ns,H} = need_heap_1(Ke, H0),
+    need_heap_0(Kes, H, [Ke|Ns]++Acc);
+need_heap_0([], H, Acc) ->
+    {Acc,H}.
+
+need_heap_1(#l{ke={set,_,{binary,_}},i=I}, H) ->
+    {need_heap_need(I, H),0};
+need_heap_1(#l{ke={set,_,Val}}, H) ->
+    %% Just pass through adding to needed heap.
+    {[],H + case Val of
+		{cons,_} -> 2;
+		{tuple,Es} -> 1 + length(Es);
+		{string,S} -> 2 * length(S);
+		_Other -> 0
+	    end};
+need_heap_1(#l{ke={bif,dsetelement,_As,_Rs},i=I}, H) ->
+    {need_heap_need(I, H),0};
+need_heap_1(#l{ke={bif,{make_fun,_,_,_,_},_As,_Rs},i=I}, H) ->
+    {need_heap_need(I, H),0};
+need_heap_1(#l{ke={bif,bs_init_writable,_As,_Rs},i=I}, H) ->
+    {need_heap_need(I, H),0};
+need_heap_1(#l{ke={bif,_Bif,_As,_Rs}}, H) ->
+    {[],H};
+need_heap_1(#l{i=I}, H) ->
+    {need_heap_need(I, H),0}.
+
+need_heap_need(_I, 0) -> [];
+need_heap_need(I, H) -> [#l{ke={need_heap,H},i=I}].
+
+%% match_cg(Match, [Ret], Le, Vdb, StackReg, State) ->
+%%	{[Ainstr],StackReg,State}.
+%%  Generate code for a match.  First save all variables on the stack
+%%  that are to survive after the match.  We leave saved variables in
+%%  their registers as they might actually be in the right place.
+
+match_cg(M, Rs, Le, Vdb, Bef, St0) ->
+    I = Le#l.i,
+    {Sis,Int0} = adjust_stack(Bef, I, I+1, Vdb),
+    {B,St1} = new_label(St0),
+    {Mis,Int1,St2} = match_cg(M, none, Int0, St1#cg{break=B}),
+    %% Put return values in registers.
+    Reg = load_vars(Rs, Int1#sr.reg),
+    {Sis ++ Mis ++ [{label,B}],
+     clear_dead(Int1#sr{reg=Reg}, I, Vdb),
+     St2#cg{break=St1#cg.break}}.
+
+%% match_cg(Match, Fail, StackReg, State) -> {[Ainstr],StackReg,State}.
+%%  Generate code for a match tree.  N.B. there is no need pass Vdb
+%%  down as each level which uses this takes its own internal Vdb not
+%%  the outer one.
+
+match_cg(Le, Fail, Bef, St) ->
+    match_cg(Le#l.ke, Le, Fail, Bef, St).
+
+match_cg({alt,F,S}, _Le, Fail, Bef, St0) ->
+    {Tf,St1} = new_label(St0),
+    {Fis,Faft,St2} = match_cg(F, Tf, Bef, St1),
+    {Sis,Saft,St3} = match_cg(S, Fail, Bef, St2),
+    Aft = sr_merge(Faft, Saft),
+    {Fis ++ [{label,Tf}] ++ Sis,Aft,St3};
+match_cg({select,{var,Vname}=V,Scs0}, #l{a=Anno}, Fail, Bef, St) ->
+    ReuseForContext = member(reuse_for_context, Anno) andalso
+	find_reg(Vname, Bef#sr.reg) =/= error,
+    Scs = case ReuseForContext of
+	      false -> Scs0;
+	      true -> bsm_rename_ctx(Scs0, Vname)
+	  end,
+    match_fmf(fun (S, F, Sta) ->
+		      select_cg(S, V, F, Fail, Bef, Sta) end,
+	      Fail, St, Scs);
+match_cg({guard,Gcs}, _Le, Fail, Bef, St) ->
+    match_fmf(fun (G, F, Sta) -> guard_clause_cg(G, F, Bef, Sta) end,
+	      Fail, St, Gcs);
+match_cg({block,Es}, Le, _Fail, Bef, St) ->
+    %% Must clear registers and stack of dead variables.
+    Int = clear_dead(Bef, Le#l.i, Le#l.vdb),
+    block_cg(Es, Le, Int, St).
+
+%% match_fail_cg(FailReason, Le, Vdb, StackReg, State) ->
+%%	{[Ainstr],StackReg,State}.
+%%  Generate code for the match_fail "call".  N.B. there is no generic
+%%  case for when the fail value has been created elsewhere.
+
+match_fail_cg({function_clause,As}, Le, Vdb, Bef, St) ->
+    %% Must have the args in {x,0}, {x,1},...
+    {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
+    {Sis ++ [{jump,{f,St#cg.finfo}}],
+     Int#sr{reg=clear_regs(Int#sr.reg)},St};
+match_fail_cg({badmatch,Term}, Le, Vdb, Bef, St) ->
+    R = cg_reg_arg(Term, Bef),
+    Int0 = clear_dead(Bef, Le#l.i, Vdb),
+    {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
+    {Sis ++ [{badmatch,R}],
+     Int#sr{reg=clear_regs(Int0#sr.reg)},St};
+match_fail_cg({case_clause,Reason}, Le, Vdb, Bef, St) ->
+    R = cg_reg_arg(Reason, Bef),
+    Int0 = clear_dead(Bef, Le#l.i, Vdb),
+    {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
+    {Sis++[{case_end,R}],
+     Int#sr{reg=clear_regs(Bef#sr.reg)},St};
+match_fail_cg(if_clause, Le, Vdb, Bef, St) ->
+    Int0 = clear_dead(Bef, Le#l.i, Vdb),
+    {Sis,Int1} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
+    {Sis++[if_end],Int1#sr{reg=clear_regs(Int1#sr.reg)},St};
+match_fail_cg({try_clause,Reason}, Le, Vdb, Bef, St) ->
+    R = cg_reg_arg(Reason, Bef),
+    Int0 = clear_dead(Bef, Le#l.i, Vdb),
+    {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
+    {Sis ++ [{try_case_end,R}],
+     Int#sr{reg=clear_regs(Int0#sr.reg)},St}.
+
+%% bsm_rename_ctx([Clause], Var) -> [Clause]
+%%  We know from an annotation that the register for a binary can
+%%  be reused for the match context because the two are not truly
+%%  alive at the same time (even though the conservative life time
+%%  information calculated by v3_life says so).
+%%
+%%  The easiest way to have those variables share the same register is
+%%  to rename the variable with the shortest life-span (the match
+%%  context) to the variable for the binary (which can have a very
+%%  long life-time because it is locked during matching). We KNOW that
+%%  the match state variable will only be alive during the matching.
+%%
+%%  We must also remove all information about the match context
+%%  variable from all life-time information databases (Vdb).
+
+bsm_rename_ctx([#l{ke={type_clause,binary,
+		       [#l{ke={val_clause,{binary,{var,Old}},Ke0}}=L2]}}=L1|Cs], New) ->
+    Ke = bsm_rename_ctx(Ke0, Old, New, false),
+    [L1#l{ke={type_clause,binary,
+	      [L2#l{ke={val_clause,{binary,{var,New}},Ke}}]}}|bsm_rename_ctx(Cs, New)];
+bsm_rename_ctx([C|Cs], New) ->
+    [C|bsm_rename_ctx(Cs, New)];
+bsm_rename_ctx([], _) -> [].
+
+%% bsm_rename_ctx(Ke, OldName, NewName, InProt) -> Ke'
+%%  Rename and clear OldName from life-time information. We must
+%%  recurse into any block contained in a protected, but it would
+%%  only complicatate things to recurse into blocks not in a protected
+%%  (the match context variable will is not live inside them).
+
+bsm_rename_ctx(#l{ke={select,{var,V},Cs0}}=L, Old, New, InProt) ->
+    Cs = bsm_rename_ctx_list(Cs0, Old, New, InProt),
+    L#l{ke={select,{var,bsm_rename_var(V, Old, New)},Cs}};
+bsm_rename_ctx(#l{ke={type_clause,Type,Cs0}}=L, Old, New, InProt) ->
+    Cs = bsm_rename_ctx_list(Cs0, Old, New, InProt),
+    L#l{ke={type_clause,Type,Cs}};
+bsm_rename_ctx(#l{ke={val_clause,{bin_end,V},Ke0}}=L, Old, New, InProt) ->
+    Ke = bsm_rename_ctx(Ke0, Old, New, InProt),
+    L#l{ke={val_clause,{bin_end,bsm_rename_var(V, Old, New)},Ke}};
+bsm_rename_ctx(#l{ke={val_clause,{bin_seg,V,Sz,U,Type,Fl,Vs},Ke0}}=L,
+	       Old, New, InProt) ->
+    Ke = bsm_rename_ctx(Ke0, Old, New, InProt),
+    L#l{ke={val_clause,{bin_seg,bsm_rename_var(V, Old, New),Sz,U,Type,Fl,Vs},Ke}};
+bsm_rename_ctx(#l{ke={val_clause,{bin_int,V,Sz,U,Fl,Val,Vs},Ke0}}=L,
+	       Old, New, InProt) ->
+    Ke = bsm_rename_ctx(Ke0, Old, New, InProt),
+    L#l{ke={val_clause,{bin_int,bsm_rename_var(V, Old, New),Sz,U,Fl,Val,Vs},Ke}};
+bsm_rename_ctx(#l{ke={val_clause,Val,Ke0}}=L, Old, New, InProt) ->
+    Ke = bsm_rename_ctx(Ke0, Old, New, InProt),
+    L#l{ke={val_clause,Val,Ke}};
+bsm_rename_ctx(#l{ke={alt,F0,S0}}=L, Old, New, InProt) ->
+    F = bsm_rename_ctx(F0, Old, New, InProt),
+    S = bsm_rename_ctx(S0, Old, New, InProt),
+    L#l{ke={alt,F,S}};
+bsm_rename_ctx(#l{ke={guard,Gcs0}}=L, Old, New, InProt) ->
+    Gcs = bsm_rename_ctx_list(Gcs0, Old, New, InProt),
+    L#l{ke={guard,Gcs}};
+bsm_rename_ctx(#l{ke={guard_clause,G0,B0}}=L, Old, New, InProt) ->
+    G = bsm_rename_ctx(G0, Old, New, InProt),
+    B = bsm_rename_ctx(B0, Old, New, InProt),
+    %% A guard clause may cause unsaved variables to be saved on the stack.
+    %% Since the match state variable Old is an alias for New (uses the
+    %% same register), it is neither in the stack nor register descriptor
+    %% lists and we would crash when we didn't find it unless we remove
+    %% it from the database.
+    bsm_forget_var(L#l{ke={guard_clause,G,B}}, Old);
+bsm_rename_ctx(#l{ke={protected,Ts0,Rs}}=L, Old, New, _InProt) ->
+    InProt = true,
+    Ts = bsm_rename_ctx_list(Ts0, Old, New, InProt),
+    bsm_forget_var(L#l{ke={protected,Ts,Rs}}, Old);
+bsm_rename_ctx(#l{ke={match,Ms0,Rs}}=L, Old, New, InProt) ->
+    Ms = bsm_rename_ctx(Ms0, Old, New, InProt),
+    L#l{ke={match,Ms,Rs}};
+bsm_rename_ctx(#l{ke={test,_,_}}=L, _, _, _) -> L;
+bsm_rename_ctx(#l{ke={bif,_,_,_}}=L, _, _, _) -> L;
+bsm_rename_ctx(#l{ke={gc_bif,_,_,_}}=L, _, _, _) -> L;
+bsm_rename_ctx(#l{ke={set,_,_}}=L, _, _, _) -> L;
+bsm_rename_ctx(#l{ke={block,_}}=L, Old, _, false) ->
+    %% This block is not inside a protected. The match context variable cannot
+    %% possibly be live inside the block.
+    bsm_forget_var(L, Old);
+bsm_rename_ctx(#l{ke={block,Bl0}}=L, Old, New, true) ->
+    %% A block in a protected. We must recursively rename the variable
+    %% inside the block.
+    Bl = bsm_rename_ctx_list(Bl0, Old, New, true),
+    bsm_forget_var(L#l{ke={block,Bl}}, Old);
+bsm_rename_ctx(#l{ke={break,_}}=L, Old, _New, _InProt) ->
+    bsm_forget_var(L, Old).
+
+bsm_rename_ctx_list([C|Cs], Old, New, InProt) ->
+    [bsm_rename_ctx(C, Old, New, InProt)|
+     bsm_rename_ctx_list(Cs, Old, New, InProt)];
+bsm_rename_ctx_list([], _, _, _) -> [].
+    
+bsm_rename_var(Old, Old, New) -> New;
+bsm_rename_var(V, _, _) -> V.
+
+%% bsm_forget_var(#l{}, Variable) -> #l{}
+%%  Remove a variable from the variable life-time database.
+
+bsm_forget_var(#l{vdb=Vdb}=L, V) ->
+    L#l{vdb=keydelete(V, 1, Vdb)}.
+
+%% block_cg([Kexpr], Le, Vdb, StackReg, St) -> {[Ainstr],StackReg,St}.
+%% block_cg([Kexpr], Le, StackReg, St) -> {[Ainstr],StackReg,St}.
+
+block_cg(Es, Le, _Vdb, Bef, St) ->
+    block_cg(Es, Le, Bef, St).
+
+block_cg(Es, Le, Bef, #cg{is_top_block=false}=St) ->
+    cg_block(Es, Le#l.i, Le#l.vdb, Bef, St);
+block_cg(Es, Le, Bef, St0) ->
+    {Is0,Aft,St} = cg_block(Es, Le#l.i, Le#l.vdb, Bef,
+			    St0#cg{is_top_block=false,need_frame=false}),
+    Is = top_level_block(Is0, Aft, max_reg(Bef#sr.reg), St),
+    {Is,Aft,St#cg{is_top_block=true}}.
+
+cg_block([], _I, _Vdb, Bef, St0) ->
+    {[],Bef,St0};
+cg_block(Kes0, I, Vdb, Bef, St0) ->
+    {Kes2,Int1,St1} =
+	case basic_block(Kes0) of
+	    {Kes1,LastI,Args,Rest} ->
+		Ke = hd(Kes1),
+		Fb = Ke#l.i,
+		cg_basic_block(Kes1, Fb, LastI, Args, Vdb, Bef, St0);
+	    {Kes1,Rest} ->
+		cg_list(Kes1, I, Vdb, Bef, St0)
+	end,
+    {Kes3,Int2,St2} = cg_block(Rest, I, Vdb, Int1, St1),
+    {Kes2 ++ Kes3,Int2,St2}.
+
+basic_block(Kes) -> basic_block(Kes, []).
+
+basic_block([Le|Les], Acc) ->
+    case collect_block(Le#l.ke) of
+	include -> basic_block(Les, [Le|Acc]);
+	{block_end,As} ->
+	    case Acc of
+		[] ->
+		    %% If the basic block does not contain any set instructions,
+		    %% it serves no useful purpose to do basic block optimizations.
+		    {[Le],Les};
+		_ ->
+		    {reverse(Acc, [Le]),Le#l.i,As,Les}
+	    end;
+	no_block -> {reverse(Acc, [Le]),Les}
+    end.
+	
+collect_block({set,_,{binary,_}})    -> no_block;
+collect_block({set,_,_})             -> include;
+collect_block({call,{var,_}=Var,As,_Rs}) -> {block_end,As++[Var]};
+collect_block({call,Func,As,_Rs})   -> {block_end,As++func_vars(Func)};
+collect_block({enter,{var,_}=Var,As})-> {block_end,As++[Var]};
+collect_block({enter,Func,As})       -> {block_end,As++func_vars(Func)};
+collect_block({return,Rs})           -> {block_end,Rs};
+collect_block({break,Bs})            -> {block_end,Bs};
+collect_block(_)                     -> no_block.
+
+func_vars({remote,M,F}) when element(1, M) =:= var;
+			     element(1, F) =:= var ->
+    [M,F];
+func_vars(_) -> [].
+
+%% cg_basic_block([Kexpr], FirstI, LastI, As, Vdb, StackReg, State) ->
+%%      {[Ainstr],StackReg,State}.
+
+cg_basic_block(Kes, Fb, Lf, As, Vdb, Bef, St0) ->
+    Res = make_reservation(As, 0),
+    Regs0 = reserve(Res, Bef#sr.reg, Bef#sr.stk),
+    Stk = extend_stack(Bef, Lf, Lf+1, Vdb),
+    Int0 = Bef#sr{reg=Regs0,stk=Stk,res=Res},
+    X0_v0 = x0_vars(As, Fb, Lf, Vdb),
+    {Keis,{Aft,_,St1}} =
+	flatmapfoldl(fun(Ke, St) -> cg_basic_block(Ke, St, Lf, Vdb) end,
+		     {Int0,X0_v0,St0}, need_heap(Kes, Fb)),
+    {Keis,Aft,St1}.
+
+cg_basic_block(#l{ke={need_heap,_}}=Ke, {Inta,X0v,Sta}, _Lf, Vdb) ->
+    {Keis,Intb,Stb} = cg(Ke, Vdb, Inta, Sta),
+    {comment(Inta) ++ Keis, {Intb,X0v,Stb}};
+cg_basic_block(Ke, {Inta,X0_v1,Sta}, Lf, Vdb) ->
+    {Sis,Intb} = save_carefully(Inta, Ke#l.i, Lf+1, Vdb),
+    {X0_v2,Intc} = allocate_x0(X0_v1, Ke#l.i, Intb),
+    Intd = reserve(Intc),
+    {Keis,Inte,Stb} = cg(Ke, Vdb, Intd, Sta),
+    {comment(Inta) ++ Sis ++ Keis, {Inte,X0_v2,Stb}}.
+
+make_reservation([], _) -> [];
+make_reservation([{var,V}|As], I) -> [{I,V}|make_reservation(As, I+1)];
+make_reservation([A|As], I) -> [{I,A}|make_reservation(As, I+1)].
+
+reserve(Sr) -> Sr#sr{reg=reserve(Sr#sr.res, Sr#sr.reg, Sr#sr.stk)}.
+
+reserve([{I,V}|Rs], [free|Regs], Stk) -> [{reserved,I,V}|reserve(Rs, Regs, Stk)];
+reserve([{I,V}|Rs], [{I,V}|Regs], Stk) -> [{I,V}|reserve(Rs, Regs, Stk)];
+reserve([{I,V}|Rs], [{I,Var}|Regs], Stk) ->
+    case on_stack(Var, Stk) of
+	true -> [{reserved,I,V}|reserve(Rs, Regs, Stk)];
+	false -> [{I,Var}|reserve(Rs, Regs, Stk)]
+    end;
+reserve([{I,V}|Rs], [{reserved,I,_}|Regs], Stk) ->
+    [{reserved,I,V}|reserve(Rs, Regs, Stk)];
+%reserve([{I,V}|Rs], [Other|Regs], Stk) -> [Other|reserve(Rs, Regs, Stk)];
+reserve([{I,V}|Rs], [], Stk) -> [{reserved,I,V}|reserve(Rs, [], Stk)];
+reserve([], Regs, _) -> Regs.
+
+extend_stack(Bef, Fb, Lf, Vdb) ->
+    Stk0 = clear_dead_stk(Bef#sr.stk, Fb, Vdb),
+    Saves = [V || {V,F,L} <- Vdb,
+		  F < Fb,
+		  L >= Lf,
+		  not on_stack(V, Stk0)],
+    Stk1 = foldl(fun (V, Stk) -> put_stack(V, Stk) end, Stk0, Saves),
+    Bef#sr.stk ++ lists:duplicate(length(Stk1) - length(Bef#sr.stk), free).
+
+save_carefully(Bef, Fb, Lf, Vdb) ->
+    Stk = Bef#sr.stk,
+    %% New variables that are in use but not on stack.
+    New = [ {V,F,L} || {V,F,L} <- Vdb,
+		       F < Fb,
+		   L >= Lf,
+		       not on_stack(V, Stk) ],
+    Saves = [ V || {V,_,_} <- keysort(2, New) ],
+    save_carefully(Saves, Bef, []).
+
+save_carefully([], Bef, Acc) -> {reverse(Acc),Bef};
+save_carefully([V|Vs], Bef, Acc) ->
+    case put_stack_carefully(V, Bef#sr.stk) of
+	error -> {reverse(Acc),Bef};
+	Stk1 ->
+	    SrcReg = fetch_reg(V, Bef#sr.reg),
+	    Move = {move,SrcReg,fetch_stack(V, Stk1)},
+	    {x,_} = SrcReg,			%Assertion - must be X register.
+	    save_carefully(Vs, Bef#sr{stk=Stk1}, [Move|Acc])
+    end.
+
+x0_vars([], _Fb, _Lf, _Vdb) -> [];
+x0_vars([{var,V}|_], Fb, _Lf, Vdb) ->
+    {V,F,_L} = VFL = vdb_find(V, Vdb),
+    x0_vars1([VFL], Fb, F, Vdb);
+x0_vars([X0|_], Fb, Lf, Vdb) ->
+    x0_vars1([{X0,Lf,Lf}], Fb, Lf, Vdb).
+
+x0_vars1(X0, Fb, Xf, Vdb) ->
+    Vs0 = [VFL || {_V,F,L}=VFL <- Vdb,
+		  F >= Fb,
+		  L < Xf],
+    Vs1 = keysort(3, Vs0),
+    keysort(2, X0++Vs1).
+
+allocate_x0([], _, Bef) -> {[],Bef#sr{res=[]}};
+allocate_x0([{_,_,L}|Vs], I, Bef) when L =< I ->
+    allocate_x0(Vs, I, Bef);
+allocate_x0([{V,_F,_L}=VFL|Vs], _, Bef) ->
+    {[VFL|Vs],Bef#sr{res=reserve_x0(V, Bef#sr.res)}}.
+
+reserve_x0(V, [_|Res]) -> [{0,V}|Res];
+reserve_x0(V, []) -> [{0,V}].
+
+top_level_block(Keis, #sr{stk=[]}, _MaxRegs, #cg{need_frame=false}) ->
+    Keis;
+top_level_block(Keis, Bef, MaxRegs, _St) ->
+    %% This top block needs an allocate instruction before it, and a
+    %% deallocate instruction before each return.
+    FrameSz = length(Bef#sr.stk),
+    MaxY = FrameSz-1,
+    Keis1 = flatmap(fun ({call_only,Arity,Func}) ->
+			    [{call_last,Arity,Func,FrameSz}];
+			({call_ext_only,Arity,Func}) ->
+			    [{call_ext_last,Arity,Func,FrameSz}];
+			({apply_only,Arity}) ->
+			    [{apply_last,Arity,FrameSz}];
+			({break,Fail}) ->
+			    [{deallocate,FrameSz},{jump,Fail}];
+			(return) ->
+			    [{deallocate,FrameSz},return];
+			(Tuple) when is_tuple(Tuple) ->
+			    [turn_yregs(tuple_size(Tuple), Tuple, MaxY)];
+			(Other) ->
+			    [Other]
+		    end, Keis),
+    [{allocate_zero,FrameSz,MaxRegs}|Keis1].
+
+%% turn_yregs(Size, Tuple, MaxY) -> Tuple'
+%%   Renumber y register so that {y,0} becomes {y,FrameSize-1},
+%%   {y,FrameSize-1} becomes {y,0} and so on.  This is to make nested
+%%   catches work.  The code generation algorithm gives a lower register
+%%   number to the outer catch, which is wrong.
+
+turn_yregs(0, Tp, _) -> Tp;
+turn_yregs(El, Tp, MaxY) when element(1, element(El, Tp)) =:= yy ->
+    turn_yregs(El-1, setelement(El, Tp, {y,MaxY-element(2, element(El, Tp))}), MaxY);
+turn_yregs(El, Tp, MaxY) when is_list(element(El, Tp)) ->
+    New = map(fun ({yy,YY}) -> {y,MaxY-YY};
+		  (Other) -> Other end, element(El, Tp)),
+    turn_yregs(El-1, setelement(El, Tp, New), MaxY);
+turn_yregs(El, Tp, MaxY) ->
+    turn_yregs(El-1, Tp, MaxY).
+
+%% select_cg(Sclause, V, TypeFail, ValueFail, StackReg, State) ->
+%%      {Is,StackReg,State}.
+%%  Selecting type and value needs two failure labels, TypeFail is the
+%%  label to jump to of the next type test when this type fails, and
+%%  ValueFail is the label when this type is correct but the value is
+%%  wrong.  These are different as in the second case there is no need
+%%  to try the next type, it will always fail.
+
+select_cg(#l{ke={type_clause,cons,[S]}}, {var,V}, Tf, Vf, Bef, St) ->
+    select_cons(S, V, Tf, Vf, Bef, St);
+select_cg(#l{ke={type_clause,nil,[S]}}, {var,V}, Tf, Vf, Bef, St) ->
+    select_nil(S, V, Tf, Vf, Bef, St);
+select_cg(#l{ke={type_clause,binary,[S]}}, {var,V}, Tf, Vf, Bef, St) ->
+    select_binary(S, V, Tf, Vf, Bef, St);
+select_cg(#l{ke={type_clause,bin_seg,S}}, {var,V}, Tf, _Vf, Bef, St) ->
+    select_bin_segs(S, V, Tf, Bef, St);
+select_cg(#l{ke={type_clause,bin_int,S}}, {var,V}, Tf, _Vf, Bef, St) ->
+    select_bin_segs(S, V, Tf, Bef, St);
+select_cg(#l{ke={type_clause,bin_end,[S]}}, {var,V}, Tf, _Vf, Bef, St) ->
+    select_bin_end(S, V, Tf, Bef, St);
+select_cg(#l{ke={type_clause,Type,Scs}}, {var,V}, Tf, Vf, Bef, St0) ->
+    {Vis,{Aft,St1}} =
+	mapfoldl(fun (S, {Int,Sta}) ->
+			 {Val,Is,Inta,Stb} = select_val(S, V, Vf, Bef, Sta),
+			 {{Is,[Val]},{sr_merge(Int, Inta),Stb}}
+		 end, {void,St0}, Scs),
+    OptVls = combine(lists:sort(combine(Vis))),
+    {Vls,Sis,St2} = select_labels(OptVls, St1, [], []),
+    {select_val_cg(Type, fetch_var(V, Bef), Vls, Tf, Vf, Sis), Aft, St2}.
+
+select_val_cg(tuple, R, [Arity,{f,Lbl}], Tf, Vf, [{label,Lbl}|Sis]) ->
+    [{test,is_tuple,{f,Tf},[R]},{test,test_arity,{f,Vf},[R,Arity]}|Sis];
+select_val_cg(tuple, R, Vls, Tf, Vf, Sis) ->
+    [{test,is_tuple,{f,Tf},[R]},{select_tuple_arity,R,{f,Vf},{list,Vls}}|Sis];
+select_val_cg(Type, R, [Val, {f,Lbl}], Fail, Fail, [{label,Lbl}|Sis]) ->
+    [{test,is_eq_exact,{f,Fail},[R,{Type,Val}]}|Sis];
+select_val_cg(Type, R, [Val, {f,Lbl}], Tf, Vf, [{label,Lbl}|Sis]) ->
+    [{test,select_type_test(Type),{f,Tf},[R]},
+     {test,is_eq_exact,{f,Vf},[R,{Type,Val}]}|Sis];
+select_val_cg(Type, R, Vls0, Tf, Vf, Sis) ->
+    Vls1 = map(fun ({f,Lbl}) -> {f,Lbl};
+		   (Value) -> {Type,Value}
+	       end, Vls0),
+    [{test,select_type_test(Type),{f,Tf},[R]}, {select_val,R,{f,Vf},{list,Vls1}}|Sis].
+    
+select_type_test(integer) -> is_integer;
+select_type_test(atom) -> is_atom;
+select_type_test(float) -> is_float.
+
+combine([{Is,Vs1}, {Is,Vs2}|Vis]) -> combine([{Is,Vs1 ++ Vs2}|Vis]);
+combine([V|Vis]) -> [V|combine(Vis)];
+combine([]) -> [].
+
+select_labels([{Is,Vs}|Vis], St0, Vls, Sis) ->
+    {Lbl,St1} = new_label(St0),
+    select_labels(Vis, St1, add_vls(Vs, Lbl, Vls), [[{label,Lbl}|Is]|Sis]);
+select_labels([], St, Vls, Sis) ->
+    {Vls,append(Sis),St}.
+
+add_vls([V|Vs], Lbl, Acc) ->
+    add_vls(Vs, Lbl, [V, {f,Lbl}|Acc]);
+add_vls([], _, Acc) -> Acc.
+
+select_cons(#l{ke={val_clause,{cons,Es},B},i=I,vdb=Vdb}, V, Tf, Vf, Bef, St0) ->
+    {Eis,Int,St1} = select_extract_cons(V, Es, I, Vdb, Bef, St0),
+    {Bis,Aft,St2} = match_cg(B, Vf, Int, St1),
+    {[{test,is_nonempty_list,{f,Tf},[fetch_var(V, Bef)]}] ++ Eis ++ Bis,Aft,St2}.
+
+select_nil(#l{ke={val_clause,nil,B}}, V, Tf, Vf, Bef, St0) ->
+    {Bis,Aft,St1} = match_cg(B, Vf, Bef, St0),
+    {[{test,is_nil,{f,Tf},[fetch_var(V, Bef)]}] ++ Bis,Aft,St1}.
+
+select_binary(#l{ke={val_clause,{binary,{var,V}},B},i=I,vdb=Vdb},
+	      V, Tf, Vf, Bef, St0) ->
+    Int0 = clear_dead(Bef#sr{reg=Bef#sr.reg}, I, Vdb),
+    {Bis,Aft,St1} = match_cg(B, Vf, Int0, St0),
+    CtxReg = fetch_var(V, Int0),
+    Live = max_reg(Bef#sr.reg),
+    {[{test,bs_start_match2,{f,Tf},[CtxReg,Live,V,CtxReg]},
+      {bs_save2,CtxReg,{V,V}}|Bis],
+     Aft,St1};
+select_binary(#l{ke={val_clause,{binary,{var,Ivar}},B},i=I,vdb=Vdb},
+	      V, Tf, Vf, Bef, St0) ->
+    Regs = put_reg(Ivar, Bef#sr.reg),
+    Int0 = clear_dead(Bef#sr{reg=Regs}, I, Vdb),
+    {Bis,Aft,St1} = match_cg(B, Vf, Int0, St0),
+    CtxReg = fetch_var(Ivar, Int0),
+    Live = max_reg(Bef#sr.reg),
+    {[{test,bs_start_match2,{f,Tf},[fetch_var(V, Bef),Live,Ivar,CtxReg]},
+      {bs_save2,CtxReg,{Ivar,Ivar}}|Bis],
+     Aft,St1}.
+
+%% New instructions for selection of binary segments.
+
+select_bin_segs(Scs, Ivar, Tf, Bef, St) ->
+    match_fmf(fun(S, Fail, Sta) ->
+		      select_bin_seg(S, Ivar, Fail, Bef, Sta) end,
+	      Tf, St, Scs).
+
+select_bin_seg(#l{ke={val_clause,{bin_seg,Ctx,Size,U,T,Fs0,Es},B},i=I,vdb=Vdb,a=A},
+	       Ivar, Fail, Bef, St0) ->
+    Fs = [{anno,A}|Fs0],
+    {Mis,Int,St1} = select_extract_bin(Es, Size, U, T, Fs, Fail,
+				       I, Vdb, Bef, Ctx, B, St0),
+    {Bis,Aft,St2} = match_cg(B, Fail, Int, St1),
+    CtxReg = fetch_var(Ctx, Bef),
+    Is = if
+	     Mis =:= [] ->
+		 %% No bs_restore2 instruction needed if no match instructions.
+		 Bis;
+	     true ->
+		 [{bs_restore2,CtxReg,{Ctx,Ivar}}|Mis++Bis]
+	 end,
+    {Is,Aft,St2};
+select_bin_seg(#l{ke={val_clause,{bin_int,Ctx,Sz,U,Fs,Val,Es},B},i=I,vdb=Vdb},
+	       Ivar, Fail, Bef, St0) ->
+    {Mis,Int,St1} = select_extract_int(Es, Val, Sz, U, Fs, Fail,
+				       I, Vdb, Bef, Ctx, St0),
+    {Bis,Aft,St2} = match_cg(B, Fail, Int, St1),
+    CtxReg = fetch_var(Ctx, Bef),
+    {[{bs_restore2,CtxReg,{Ctx,Ivar}}|Mis] ++ Bis,Aft,St2}.
+
+select_extract_int([{var,Tl}], Val, {integer,Sz}, U, Fs, Vf,
+		   I, Vdb, Bef, Ctx, St) ->
+    Bits = U*Sz,
+    Bin = case member(big, Fs) of
+	      true ->
+		  <<Val:Bits>>;
+	      false ->
+		  true = member(little, Fs),	%Assertion.
+		  <<Val:Bits/little>>
+	  end,
+    Bits = bit_size(Bin),			%Assertion.
+    CtxReg = fetch_var(Ctx, Bef),
+    Is = if
+	     Bits =:= 0 ->
+		 [{bs_save2,CtxReg,{Ctx,Tl}}];
+	     true ->
+		 [{test,bs_match_string,{f,Vf},[CtxReg,Bin]},
+		  {bs_save2,CtxReg,{Ctx,Tl}}]
+	 end,
+    {Is,clear_dead(Bef, I, Vdb),St}.
+
+select_extract_bin([{var,Hd},{var,Tl}], Size0, Unit, Type, Flags, Vf,
+		   I, Vdb, Bef, Ctx, _Body, St) ->
+    SizeReg = get_bin_size_reg(Size0, Bef),
+    {Es,Aft} =
+	case vdb_find(Hd, Vdb) of
+	    {_,_,Lhd} when Lhd =< I ->
+		%% The extracted value will not be used.
+		CtxReg = fetch_var(Ctx, Bef),
+		Live = max_reg(Bef#sr.reg),
+		Skip = build_skip_instr(Type, Vf, CtxReg, Live,
+					SizeReg, Unit, Flags),
+		{[Skip,{bs_save2,CtxReg,{Ctx,Tl}}],Bef};
+	    {_,_,_} ->
+		Reg = put_reg(Hd, Bef#sr.reg),
+		Int1 = Bef#sr{reg=Reg},
+		Rhd = fetch_reg(Hd, Reg),
+		CtxReg = fetch_reg(Ctx, Reg),
+		Live = max_reg(Bef#sr.reg),
+		{[build_bs_instr(Type, Vf, CtxReg, Live, SizeReg,
+				 Unit, Flags, Rhd),
+		  {bs_save2,CtxReg,{Ctx,Tl}}],Int1}
+	end,
+    {Es,clear_dead(Aft, I, Vdb),St};
+select_extract_bin([{var,Hd}], Size0, Unit, Type, Flags, Vf,
+		   I, Vdb, Bef, Ctx, Body, St) ->
+    SizeReg = get_bin_size_reg(Size0, Bef),
+    {Es,Aft} =
+	case vdb_find(Hd, Vdb) of
+	    {_,_,Lhd} when Lhd =< I ->
+		CtxReg = fetch_var(Ctx, Bef),
+		{case SizeReg =:= {atom,all} andalso is_context_unused(Body) of
+		     true when Unit =:= 1 ->
+			 [];
+		     true ->
+			 [{test,bs_test_unit,{f,Vf},[CtxReg,Unit]}];
+		     false ->
+			 [{test,bs_skip_bits2,{f,Vf},
+			   [CtxReg,SizeReg,Unit,{field_flags,Flags}]}]
+		 end,Bef};
+	    {_,_,_} ->
+		case is_context_unused(Body) of
+		    false ->
+			Reg = put_reg(Hd, Bef#sr.reg),
+			Int1 = Bef#sr{reg=Reg},
+			Rhd = fetch_reg(Hd, Reg),
+			CtxReg = fetch_reg(Ctx, Reg),
+			Name = get_bits_instr(Type),
+			Live = max_reg(Bef#sr.reg),
+			{[{test,Name,{f,Vf},[CtxReg,Live,SizeReg,Unit,
+					     {field_flags,Flags},Rhd]}],
+			 Int1};
+		    true ->
+			%% Since the matching context will not be used again,
+			%% we can reuse its register. Reusing the register
+			%% opens some interesting optimizations in the
+			%% run-time system.
+
+			Reg0 = Bef#sr.reg,
+			CtxReg = fetch_reg(Ctx, Reg0),
+			Reg = replace_reg_contents(Ctx, Hd, Reg0),
+			Int1 = Bef#sr{reg=Reg},
+			Name = get_bits_instr(Type),
+			Live = max_reg(Int1#sr.reg),
+			{[{test,Name,{f,Vf},[CtxReg,Live,SizeReg,Unit,
+					     {field_flags,Flags},CtxReg]}],
+			 Int1}
+		end
+	end,
+    {Es,clear_dead(Aft, I, Vdb),St}.
+
+%% is_context_unused(Ke) -> true | false
+%%   Simple heurististic to determine whether the code that follows will
+%%   use the current matching context again. (The information of liveness
+%%   calculcated by v3_life is too conservative to be useful for this purpose.)
+%%   'true' means that the code that follows will definitely not use the context
+%%   again (because it is a block, not guard or matching code); 'false' that we
+%%   are not sure (there is either a guard, or more matching, either which may
+%%   reference the context again).
+
+is_context_unused(#l{ke=Ke}) -> is_context_unused(Ke);
+is_context_unused({block,_}) -> true;
+is_context_unused(_) -> false.
+
+select_bin_end(#l{ke={val_clause,{bin_end,Ctx},B}},
+	       Ivar, Tf, Bef, St0) ->
+    {Bis,Aft,St2} = match_cg(B, Tf, Bef, St0),
+    CtxReg = fetch_var(Ctx, Bef),
+    {[{bs_restore2,CtxReg,{Ctx,Ivar}},{test,bs_test_tail2,{f,Tf},[CtxReg,0]}|Bis],Aft,St2}.
+
+get_bin_size_reg({var,V}, Bef) ->
+    fetch_var(V, Bef);
+get_bin_size_reg(Literal, _Bef) ->
+    Literal.
+
+build_bs_instr(Type, Vf, CtxReg, Live, SizeReg, Unit, Flags, Rhd) ->
+    {Format,Name} = case Type of
+			integer -> {plain,bs_get_integer2};
+			float ->   {plain,bs_get_float2};
+			binary ->  {plain,bs_get_binary2};
+			utf8 ->    {utf,bs_get_utf8};
+			utf16 ->   {utf,bs_get_utf16};
+			utf32 ->   {utf,bs_get_utf32}
+		   end,
+    case Format of
+	plain ->
+	    {test,Name,{f,Vf},
+	     [CtxReg,Live,SizeReg,Unit,{field_flags,Flags},Rhd]};
+	utf ->
+	    {test,Name,{f,Vf},
+	     [CtxReg,Live,{field_flags,Flags},Rhd]}
+    end.
+
+build_skip_instr(Type, Vf, CtxReg, Live, SizeReg, Unit, Flags) ->
+    {Format,Name} = case Type of
+			utf8 -> {utf,bs_skip_utf8};
+			utf16 -> {utf,bs_skip_utf16};
+			utf32 -> {utf,bs_skip_utf32};
+			_ -> {plain,bs_skip_bits2}
+		    end,
+    case Format of
+	plain ->
+	    {test,Name,{f,Vf},[CtxReg,SizeReg,Unit,{field_flags,Flags}]};
+	utf ->
+	    {test,Name,{f,Vf},[CtxReg,Live,{field_flags,Flags}]}
+    end.
+
+%% get_bits_instr(integer) -> bs_get_integer2;
+%% get_bits_instr(float)   -> bs_get_float2;
+get_bits_instr(binary)  -> bs_get_binary2.
+
+select_val(#l{ke={val_clause,{tuple,Es},B},i=I,vdb=Vdb}, V, Vf, Bef, St0) ->
+    {Eis,Int,St1} = select_extract_tuple(V, Es, I, Vdb, Bef, St0),
+    {Bis,Aft,St2} = match_cg(B, Vf, Int, St1),
+    {length(Es),Eis ++ Bis,Aft,St2};
+select_val(#l{ke={val_clause,{_,Val},B}}, _V, Vf, Bef, St0) ->
+    {Bis,Aft,St1} = match_cg(B, Vf, Bef, St0),
+    {Val,Bis,Aft,St1}.
+
+%% select_extract_tuple(Src, [V], I, Vdb, StackReg, State) ->
+%%      {[E],StackReg,State}.
+%%  Extract tuple elements, but only if they do not immediately die.
+
+select_extract_tuple(Src, Vs, I, Vdb, Bef, St) ->
+    F = fun ({var,V}, {Int0,Elem}) ->
+		case vdb_find(V, Vdb) of
+		    {V,_,L} when L =< I -> {[], {Int0,Elem+1}};
+		    _Other ->
+			Reg1 = put_reg(V, Int0#sr.reg),
+			Int1 = Int0#sr{reg=Reg1},
+			Rsrc = fetch_var(Src, Int1),
+			{[{get_tuple_element,Rsrc,Elem,fetch_reg(V, Reg1)}],
+			 {Int1,Elem+1}}
+		end
+	end,
+    {Es,{Aft,_}} = flatmapfoldl(F, {Bef,0}, Vs),
+    {Es,Aft,St}.
+
+select_extract_cons(Src, [{var,Hd}, {var,Tl}], I, Vdb, Bef, St) ->
+    {Es,Aft} = case {vdb_find(Hd, Vdb), vdb_find(Tl, Vdb)} of
+		   {{_,_,Lhd}, {_,_,Ltl}} when Lhd =< I, Ltl =< I ->
+		       %% Both head and tail are dead.  No need to generate
+		       %% any instruction.
+		       {[], Bef};
+		   _ ->
+		       %% At least one of head and tail will be used,
+		       %% but we must always fetch both.  We will call
+		       %% clear_dead/2 to allow reuse of the register
+		       %% in case only of them is used.
+
+		       Reg0 = put_reg(Tl, put_reg(Hd, Bef#sr.reg)),
+		       Int0 = Bef#sr{reg=Reg0},
+		       Rsrc = fetch_var(Src, Int0),
+		       Rhd = fetch_reg(Hd, Reg0),
+		       Rtl = fetch_reg(Tl, Reg0),
+		       Int1 = clear_dead(Int0, I, Vdb),
+		       {[{get_list,Rsrc,Rhd,Rtl}], Int1}
+	       end,
+    {Es,Aft,St}.
+    
+
+guard_clause_cg(#l{ke={guard_clause,G,B},vdb=Vdb,i=I}, Fail, Bef, St0) ->
+    case is_matching_guard(G) of
+	false ->
+	    %% The basic case without the complication of matching
+	    %% in the guard.
+
+	    {Gis,Int,St1} = guard_cg(G, Fail, Vdb, Bef, St0),
+	    {Bis,Aft,St} = match_cg(B, Fail, Int, St1),
+	    {Gis ++ Bis,Aft,St};
+	true ->
+	    %% This top-level guard contains code that matches
+	    %% (because the original source code used andalso/orelse).
+	    %%   We must set up a stack frame. Furthermore
+	    %% we must restore all X registers before leaving the guard.
+	    %% This is messy, so we do it in a separate function.
+
+	    saving_guard_cg(G, B, I, Vdb, Fail, Bef, St0)
+    end.
+
+saving_guard_cg(G, B, _I, Vdb, Fail, Bef, St0) ->
+    {RestoreL,St1} = new_label(St0),
+    {Gis,Int,St2} = guard_cg(G, RestoreL, Vdb, Bef,
+			     St1#cg{is_top_block=false}),
+    Hvs = hvs(Bef, Int),
+    {Bis,Aft,St} = match_cg(B, Fail, Int, St2),
+    {RestoreRegsIs,_} = cg_setup_call(Hvs, Int, 1, Vdb),
+    Break = case St0#cg.is_top_block of
+		false -> [{jump,{f,Fail}}];
+		true -> [{break,{f,Fail}}]
+	    end,
+    Is0 = Gis++Bis++[{label,RestoreL}] ++
+	RestoreRegsIs ++ Break,
+    Is = case St0#cg.is_top_block of
+	     false -> Is0;
+	     true -> top_level_block(Is0, Aft, max_reg(Bef#sr.reg), St)
+	 end,
+    {Is,Aft,St#cg{is_top_block=St0#cg.is_top_block}}.
+
+hvs(#sr{reg=Reg}, #sr{stk=Saved0}) ->
+    Saved = ordsets:from_list([V || {V} <- Saved0]),
+    hvs_1(Reg, Saved, []).
+
+hvs_1([{_,V}|Rs], Saved, Acc) ->
+    case ordsets:is_element(V, Saved) of
+	false -> hvs_1(Rs, Saved, [nil|Acc]);
+	true ->  hvs_1(Rs, Saved, [{var,V}|Acc])
+    end;
+hvs_1([_|Rs], Saved, Acc) ->
+    hvs_1(Rs, Saved, [nil|Acc]);
+hvs_1([], _, Acc) -> hvs_2(Acc).
+
+hvs_2([nil|Vs]) -> hvs_2(Vs);
+hvs_2(Vs) -> reverse(Vs).
+
+
+%% is_matching_guard(GuardExpr) -> true|false
+%%  Determine whether a guard expression contains a match expression.
+
+is_matching_guard(#l{ke={protected,T,_}}) -> is_matching_guard_list(T);
+is_matching_guard(#l{ke={test,_,_}}) -> false;
+is_matching_guard(#l{ke={bif,_,_,_}}) -> false;
+is_matching_guard(#l{ke={gc_bif,_,_,_}}) -> false;
+is_matching_guard(#l{ke={set,_,_}}) -> false;
+is_matching_guard(#l{ke={match,_,_}}) -> true.
+
+is_matching_guard_list([T|Ts]) ->
+    case is_matching_guard(T) of
+	false -> is_matching_guard_list(Ts);
+	true -> true
+    end;
+is_matching_guard_list([]) -> false.
+
+%% guard_cg(Guard, Fail, Vdb, StackReg, State) ->
+%%      {[Ainstr],StackReg,State}.
+%%  A guard is a boolean expression of tests.  Tests return true or
+%%  false.  A fault in a test causes the test to return false.  Tests
+%%  never return the boolean, instead we generate jump code to go to
+%%  the correct exit point.  Primops and tests all go to the next
+%%  instruction on success or jump to a failure label.
+
+guard_cg(#l{ke={protected,Ts,Rs},i=I,vdb=Pdb}, Fail, _Vdb, Bef, St) ->
+    protected_cg(Ts, Rs, Fail, I, Pdb, Bef, St);
+guard_cg(#l{ke={block,Ts},i=I,vdb=Bdb}, Fail, _Vdb, Bef, St) ->
+    guard_cg_list(Ts, Fail, I, Bdb, Bef, St);
+guard_cg(#l{ke={test,Test,As},i=I,vdb=_Tdb}, Fail, Vdb, Bef, St) ->
+    test_cg(Test, As, Fail, I, Vdb, Bef, St);
+guard_cg(G, _Fail, Vdb, Bef, St) ->
+    %%ok = io:fwrite("cg ~w: ~p~n", [?LINE,{G,Fail,Vdb,Bef}]),
+    {Gis,Aft,St1} = cg(G, Vdb, Bef, St),
+    %%ok = io:fwrite("cg ~w: ~p~n", [?LINE,{Aft}]),
+    {Gis,Aft,St1}.
+
+%% protected_cg([Kexpr], [Ret], Fail, I, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+%%  Do a protected.  Protecteds without return values are just done
+%%  for effect, the return value is not checked, success passes on to
+%%  the next instruction and failure jumps to Fail.  If there are
+%%  return values then these must be set to 'false' on failure,
+%%  control always passes to the next instruction.
+
+protected_cg(Ts, Rs, Fail, I, Vdb, Bef, St0) ->
+    case is_matching_guard_list(Ts) of
+	false ->
+	    protected_cg_1(Ts, Rs, Fail, I, Vdb, Bef, St0);
+	true ->
+	    %% A match construct inside a protected means that there was
+	    %% an andalso/orelse in the source code.
+	    %% We must save all variables that are to survive the protected
+	    %% before entering it (i.e. before executing any
+	    %% instruction that could fail, such as a guard BIF).
+
+	    {Sis,Int} = adjust_stack(Bef, I, I+1, Vdb),
+	    {Tis,Aft,St} = protected_cg_1(Ts, Rs, Fail, I, Vdb, Int, St0),
+	    {Sis++Tis,Aft,St}
+    end.
+
+protected_cg_1(Ts, [], Fail, I, Vdb, Bef, St0) ->
+    %% Protect these calls, revert when done.
+    {Tis,Aft,St1} = guard_cg_list(Ts, Fail, I, Vdb, Bef,
+				  St0#cg{btype=fail,bfail=Fail}),
+    {Tis,Aft,St1#cg{btype=St0#cg.btype,bfail=St0#cg.bfail}};
+protected_cg_1(Ts, Rs, _Fail, I, Vdb, Bef, St0) ->
+    {Pfail,St1} = new_label(St0),
+    {Psucc,St2} = new_label(St1),
+    {Tis,Aft,St3} = guard_cg_list(Ts, Pfail, I, Vdb, Bef,
+				  St2#cg{btype=fail,bfail=Pfail}),
+    %%ok = io:fwrite("cg ~w: ~p~n", [?LINE,{Rs,I,Vdb,Aft}]),
+    %% Set return values to false.
+    Mis = map(fun ({var,V}) -> {move,{atom,false},fetch_var(V, Aft)} end, Rs),
+    Live = {'%live',max_reg(Aft#sr.reg)},
+    {Tis ++ [Live,{jump,{f,Psucc}},
+	     {label,Pfail}] ++ Mis ++ [Live,{label,Psucc}],
+     Aft,St3#cg{btype=St0#cg.btype,bfail=St0#cg.bfail}}.    
+
+%% test_cg(TestName, Args, Fail, I, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+%%  Generate test instruction.  Use explicit fail label here.
+
+test_cg(Test, As, Fail, I, Vdb, Bef, St) ->
+    Args = cg_reg_args(As, Bef),
+    Aft = clear_dead(Bef, I, Vdb),
+    {[beam_utils:bif_to_test(Test, Args, {f,Fail})],Aft,St}.
+
+%% guard_cg_list([Kexpr], Fail, I, Vdb, StackReg, St) ->
+%%      {[Ainstr],StackReg,St}.
+
+guard_cg_list(Kes, Fail, I, Vdb, Bef, St0) ->
+    {Keis,{Aft,St1}} =
+	flatmapfoldl(fun (Ke, {Inta,Sta}) ->
+			     {Keis,Intb,Stb} =
+				 guard_cg(Ke, Fail, Vdb, Inta, Sta),
+			     {comment(Inta) ++ Keis,{Intb,Stb}}
+		     end, {Bef,St0}, need_heap(Kes, I)),
+    {Keis,Aft,St1}.
+
+%% match_fmf(Fun, LastFail, State, [Clause]) -> {Is,Aft,State}.
+%%  This is a special flatmapfoldl for match code gen where we
+%%  generate a "failure" label for each clause. The last clause uses
+%%  an externally generated failure label, LastFail.  N.B. We do not
+%%  know or care how the failure labels are used.
+
+match_fmf(F, LastFail, St, [H]) ->
+    F(H, LastFail, St);
+match_fmf(F, LastFail, St0, [H|T]) ->
+    {Fail,St1} = new_label(St0),
+    {R,Aft1,St2} = F(H, Fail, St1),
+    {Rs,Aft2,St3} = match_fmf(F, LastFail, St2, T),
+    {R ++ [{label,Fail}] ++ Rs,sr_merge(Aft1, Aft2),St3}.
+
+%% call_cg(Func, [Arg], [Ret], Le, Vdb, StackReg, State) ->
+%%      {[Ainstr],StackReg,State}.
+%% enter_cg(Func, [Arg], Le, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+%%  Call and enter first put the arguments into registers and save any
+%%  other registers, then clean up and compress the stack and set the
+%%  frame size. Finally the actual call is made.  Call then needs the
+%%  return values filled in.
+
+call_cg({var,V}, As, Rs, Le, Vdb, Bef, St0) ->
+    {Sis,Int} = cg_setup_call(As++[{var,V}], Bef, Le#l.i, Vdb),
+    %% Put return values in registers.
+    Reg = load_vars(Rs, clear_regs(Int#sr.reg)),
+    %% Build complete code and final stack/register state.
+    Arity = length(As),
+    {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
+    {comment({call_fun,{var,V},As}) ++ Sis ++ Frees ++ [{call_fun,Arity}],
+     Aft,need_stack_frame(St0)};
+call_cg({remote,Mod,Name}, As, Rs, Le, Vdb, Bef, St0)
+  when element(1, Mod) =:= var;
+       element(1, Name) =:= var ->
+    {Sis,Int} = cg_setup_call(As++[Mod,Name], Bef, Le#l.i, Vdb),
+    %% Put return values in registers.
+    Reg = load_vars(Rs, clear_regs(Int#sr.reg)),
+    %% Build complete code and final stack/register state.
+    Arity = length(As),
+    Call = {apply,Arity},
+    St = need_stack_frame(St0),
+    %%{Call,St1} = build_call(Func, Arity, St0),
+    {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
+    {Sis ++ Frees ++ [Call],Aft,St};
+call_cg(Func, As, Rs, Le, Vdb, Bef, St0) ->
+    {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
+    %% Put return values in registers.
+    Reg = load_vars(Rs, clear_regs(Int#sr.reg)),
+    %% Build complete code and final stack/register state.
+    Arity = length(As),
+    {Call,St1} = build_call(Func, Arity, St0),
+    {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
+    {comment({call,Func,As}) ++ Sis ++ Frees ++ Call,Aft,St1}.
+
+build_call({remote,{atom,erlang},{atom,'!'}}, 2, St0) ->
+    {[send],need_stack_frame(St0)};
+build_call({remote,{atom,Mod},{atom,Name}}, Arity, St0) ->
+    {[{call_ext,Arity,{extfunc,Mod,Name,Arity}}],need_stack_frame(St0)};
+build_call(Name, Arity, St0) when is_atom(Name) ->
+    {Lbl,St1} = local_func_label(Name, Arity, need_stack_frame(St0)),
+    {[{call,Arity,{f,Lbl}}],St1}.
+
+free_dead(#sr{stk=Stk0}=Aft) ->
+    {Instr,Stk} = free_dead(Stk0, 0, [], []),
+    {Instr,Aft#sr{stk=Stk}}.
+
+free_dead([dead|Stk], Y, Instr, StkAcc) ->
+    %% Note: kill/1 is equivalent to init/1 (translated by beam_asm).
+    %% We use kill/1 to help further optimisation passes.
+    free_dead(Stk, Y+1, [{kill,{yy,Y}}|Instr], [free|StkAcc]);
+free_dead([Any|Stk], Y, Instr, StkAcc) ->
+    free_dead(Stk, Y+1, Instr, [Any|StkAcc]);
+free_dead([], _, Instr, StkAcc) -> {Instr,reverse(StkAcc)}.
+
+enter_cg({var,V}, As, Le, Vdb, Bef, St0) ->
+    {Sis,Int} = cg_setup_call(As++[{var,V}], Bef, Le#l.i, Vdb),
+    %% Build complete code and final stack/register state.
+    Arity = length(As),
+    {comment({call_fun,{var,V},As}) ++ Sis ++ [{call_fun,Arity},return],
+     clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
+     need_stack_frame(St0)};
+enter_cg({remote,Mod,Name}=Func, As, Le, Vdb, Bef, St0)
+  when element(1, Mod) =:= var;
+       element(1, Name) =:= var ->
+    {Sis,Int} = cg_setup_call(As++[Mod,Name], Bef, Le#l.i, Vdb),
+    %% Build complete code and final stack/register state.
+    Arity = length(As),
+    Call = {apply_only,Arity},
+    St = need_stack_frame(St0),
+    {comment({enter,Func,As}) ++ Sis ++ [Call],
+     clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
+     St};
+enter_cg(Func, As, Le, Vdb, Bef, St0) ->
+    {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
+    %% Build complete code and final stack/register state.
+    Arity = length(As),
+    {Call,St1} = build_enter(Func, Arity, St0),
+    {comment({enter,Func,As}) ++ Sis ++ Call,
+     clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
+     St1}.
+
+build_enter({remote,{atom,erlang},{atom,'!'}}, 2, St0) ->
+    {[send,return],need_stack_frame(St0)};
+build_enter({remote,{atom,Mod},{atom,Name}}, Arity, St0) ->
+    St1 = case trap_bif(Mod, Name, Arity) of
+	      true -> need_stack_frame(St0);
+	      false -> St0
+	  end,
+    {[{call_ext_only,Arity,{extfunc,Mod,Name,Arity}}],St1};
+build_enter(Name, Arity, St0) when is_atom(Name) ->
+    {Lbl,St1} = local_func_label(Name, Arity, St0),
+    {[{call_only,Arity,{f,Lbl}}],St1}.
+
+%% local_func_label(Name, Arity, State) -> {Label,State'}
+%% local_func_label({Name,Arity}, State) -> {Label,State'}
+%%  Get the function entry label for a local function.
+
+local_func_label(Name, Arity, St) ->
+    local_func_label({Name,Arity}, St).
+
+local_func_label(Key, #cg{functable=Tab}=St0) ->
+    case gb_trees:lookup(Key, Tab) of
+	{value,Label} ->
+	    {Label,St0};
+	none ->
+  	    {Label,St} = new_label(St0),
+	    {Label,St#cg{functable=gb_trees:insert(Key, Label, Tab)}}
+    end.
+
+%% need_stack_frame(State) -> State'
+%%  Make a note in the state that this function will need a stack frame.
+
+need_stack_frame(#cg{need_frame=true}=St) -> St;
+need_stack_frame(St) -> St#cg{need_frame=true}.
+
+%% trap_bif(Mod, Name, Arity) -> true|false
+%%   Trap bifs that need a stack frame.
+
+trap_bif(erlang, link, 1) -> true;
+trap_bif(erlang, unlink, 1) -> true;
+trap_bif(erlang, monitor_node, 2) -> true;
+trap_bif(erlang, group_leader, 2) -> true;
+trap_bif(erlang, exit, 2) -> true;
+trap_bif(_, _, _) -> false.
+
+%% bif_cg(Bif, [Arg], [Ret], Le, Vdb, StackReg, State) ->
+%%      {[Ainstr],StackReg,State}.
+
+bif_cg(bs_context_to_binary=Instr, [Src0], [], Le, Vdb, Bef, St0) ->
+    [Src] = cg_reg_args([Src0], Bef),
+    {[{Instr,Src}],clear_dead(Bef, Le#l.i, Vdb), St0};
+bif_cg(dsetelement, [Index0,Tuple0,New0], _Rs, Le, Vdb, Bef, St0) ->
+    [New,Tuple,{integer,Index1}] = cg_reg_args([New0,Tuple0,Index0], Bef),
+    Index = Index1-1,
+    {[{set_tuple_element,New,Tuple,Index}],
+     clear_dead(Bef, Le#l.i, Vdb), St0};
+bif_cg({make_fun,Func,Arity,Index,Uniq}, As, Rs, Le, Vdb, Bef, St0) ->
+    %% This behaves more like a function call.
+    {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
+    Reg = load_vars(Rs, clear_regs(Int#sr.reg)),
+    {FuncLbl,St1} = local_func_label(Func, Arity, St0),
+    MakeFun = {make_fun2,{f,FuncLbl},Index,Uniq,length(As)},
+    {Sis ++ [MakeFun],
+     clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb),
+     St1};
+bif_cg(bs_init_writable=I, As, Rs, Le, Vdb, Bef, St) ->
+    %% This behaves like a function call.
+    {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
+    Reg = load_vars(Rs, clear_regs(Int#sr.reg)),
+    {Sis++[I],clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb),St};
+bif_cg(Bif, As, [{var,V}], Le, Vdb, Bef, St0) ->
+    Ars = cg_reg_args(As, Bef),
+
+    %% If we are inside a catch, we must save everything that will
+    %% be alive after the catch (because the BIF might fail and there
+    %% will be a jump to the code after the catch).
+    %%   Currently, we are somewhat pessimistic in
+    %% that we save any variable that will be live after this BIF call.
+
+    {Sis,Int0} = case St0#cg.in_catch andalso
+		     not erl_bifs:is_safe(erlang, Bif, length(As)) of
+		     true -> adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb);
+		     false -> {[],Bef}
+		 end,
+    Int1 = clear_dead(Int0, Le#l.i, Vdb),
+    Reg = put_reg(V, Int1#sr.reg),
+    Int = Int1#sr{reg=Reg},
+    Arity = length(Ars),
+    Dst = fetch_reg(V, Reg),
+    BifFail = bif_fail(St0#cg.btype, St0#cg.bfail, Arity),
+    {Sis++[{bif,Bif,BifFail,Ars,Dst}],
+     clear_dead(Int, Le#l.i, Vdb), St0}.
+
+
+%% gc_bif_cg(Bif, [Arg], [Ret], Le, Vdb, StackReg, State) ->
+%%      {[Ainstr],StackReg,State}.
+
+gc_bif_cg(Bif, As, [{var,V}], Le, Vdb, Bef, St0) ->
+    Ars = cg_reg_args(As, Bef),
+
+    %% If we are inside a catch, we must save everything that will
+    %% be alive after the catch (because the BIF might fail and there
+    %% will be a jump to the code after the catch).
+    %%   Currently, we are somewhat pessimistic in
+    %% that we save any variable that will be live after this BIF call.
+
+    {Sis,Int0} =
+	case St0#cg.in_catch of
+	    true -> adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb);
+	    false -> {[],Bef}
+	end,
+
+    Int1 = clear_dead(Int0, Le#l.i, Vdb),
+    Reg = put_reg(V, Int1#sr.reg),
+    Int = Int1#sr{reg=Reg},
+    Dst = fetch_reg(V, Reg),
+    BifFail = case St0#cg.btype of
+		  exit -> {f,0};
+		  fail -> {f,St0#cg.bfail}
+	      end,
+    {Sis++[{gc_bif,Bif,BifFail,max_reg(Bef#sr.reg),Ars,Dst}],
+     clear_dead(Int, Le#l.i, Vdb), St0}.
+
+bif_fail(_, _, 0) -> nofail;
+bif_fail(exit, _, _) -> {f,0};
+bif_fail(fail, Fail, _) -> {f,Fail}.
+
+%% recv_loop_cg(TimeOut, ReceiveVar, ReceiveMatch, TimeOutExprs,
+%%              [Ret], Le, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+
+recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St0, FunMessage) ->
+    {Sis,Int0} = adjust_stack(Bef, Le#l.i, Le#l.i, Vdb),
+    Int1 = Int0#sr{reg=clear_regs(Int0#sr.reg)},
+    %% Get labels.
+    {Rl,St1} = new_label(St0),
+    {Tl,St2} = new_label(St1),
+    {Bl,St3} = new_label(St2),
+    St4 = St3#cg{break=Bl,recv=Rl},		%Set correct receive labels
+    {Ris,Raft,St5} = FunMessage(Rvar, Rm, Tl, Int1, St4),
+    {Wis,Taft,St6} = cg_recv_wait(Te, Tes, Le#l.i, Int1, St5),
+    Int2 = sr_merge(Raft, Taft),		%Merge stack/registers
+    Reg = load_vars(Rs, Int2#sr.reg),
+    {Sis ++ Ris ++ [{label,Tl}] ++ Wis ++ [{label,Bl}],
+     clear_dead(Int2#sr{reg=Reg}, Le#l.i, Vdb),
+     St6#cg{break=St0#cg.break,recv=St0#cg.recv}}.
+
+%% cg_recv_mesg( ) -> {[Ainstr],Aft,St}.
+
+cg_recv_mesg({var,R}, Rm, Tl, Bef, St0) ->
+    cg_recv_mesg({var,R}, Rm, Tl, Bef, St0, loop_rec).
+
+cg_search_mesg({var,R}, Rm, Tl, Bef, St0) ->
+    cg_recv_mesg({var,R}, Rm, Tl, Bef, St0, loop_search).
+
+cg_recv_mesg({var,R}, Rm, Tl, Bef, St0, LabelName) ->
+    Int0 = Bef#sr{reg=put_reg(R, Bef#sr.reg)},
+    Ret = fetch_reg(R, Int0#sr.reg),
+    %% Int1 = clear_dead(Int0, I, Rm#l.vdb),
+    Int1 = Int0,
+    {Mis,Int2,St1} = match_cg(Rm, none, Int1, St0),
+    {[{'%live',0},{label,St1#cg.recv},{LabelName,{f,Tl},Ret}|Mis],Int2,St1}.
+
+
+%% cg_recv_wait(Te, Tes, I, Vdb, Int2, St3) -> {[Ainstr],Aft,St}.
+
+cg_recv_wait({atom,infinity}, Tes, I, Bef, St0) ->
+    %% We know that the 'after' body will never be executed.
+    %% But to keep the stack and register information up to date,
+    %% we will generate the code for the 'after' body, and then discard it.
+    Int1 = clear_dead(Bef, I, Tes#l.vdb),
+    {_,Int2,St1} = cg_block(Tes#l.ke, Tes#l.i, Tes#l.vdb,
+			      Int1#sr{reg=clear_regs(Int1#sr.reg)}, St0),
+    {[{wait,{f,St1#cg.recv}}],Int2,St1};
+cg_recv_wait({integer,0}, Tes, _I, Bef, St0) ->
+    {Tis,Int,St1} = cg_block(Tes#l.ke, Tes#l.i, Tes#l.vdb, Bef, St0),
+    {[timeout|Tis],Int,St1};
+cg_recv_wait(Te, Tes, I, Bef, St0) ->
+    Reg = cg_reg_arg(Te, Bef),
+    %% Must have empty registers here!  Bug if anything in registers.
+    Int0 = clear_dead(Bef, I, Tes#l.vdb),
+    {Tis,Int,St1} = cg_block(Tes#l.ke, Tes#l.i, Tes#l.vdb,
+			     Int0#sr{reg=clear_regs(Int0#sr.reg)}, St0),
+    {[{wait_timeout,{f,St1#cg.recv},Reg},timeout] ++ Tis,Int,St1}.
+
+%% recv_next_cg(Le, Vdb, StackReg, St, Label) -> {[Ainstr],StackReg,St}.
+%%  Use adjust stack to clear stack, but only need it for Aft.
+
+recv_next_cg(Le, Vdb, Bef, St, LabelName) ->
+    {Sis,Aft} = adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb),
+    {[{LabelName,{f,St#cg.recv}}] ++ Sis,Aft,St}.	%Joke
+
+%% try_cg(TryBlock, [BodyVar], TryBody, [ExcpVar], TryHandler, [Ret],
+%%        Le, Vdb, StackReg, St) -> {[Ainstr],StackReg,St}.
+
+try_cg(Ta, Vs, Tb, Evs, Th, Rs, Le, Vdb, Bef, St0) ->
+    {B,St1} = new_label(St0),			%Body label
+    {H,St2} = new_label(St1),			%Handler label
+    {E,St3} = new_label(St2),			%End label
+    TryTag = Ta#l.i,
+    Int1 = Bef#sr{stk=put_catch(TryTag, Bef#sr.stk)},
+    TryReg = fetch_stack({catch_tag,TryTag}, Int1#sr.stk),
+    {Ais,Int2,St4} = cg(Ta, Vdb, Int1, St3#cg{break=B,in_catch=true}),
+    Int3 = Int2#sr{stk=drop_catch(TryTag, Int2#sr.stk)},
+    St5 = St4#cg{break=E,in_catch=St3#cg.in_catch},
+    {Bis,Baft,St6} = cg(Tb, Vdb, Int3#sr{reg=load_vars(Vs, Int3#sr.reg)}, St5),
+    {His,Haft,St7} = cg(Th, Vdb, Int3#sr{reg=load_vars(Evs, Int3#sr.reg)}, St6),
+    Int4 = sr_merge(Baft, Haft),		%Merge stack/registers
+    Aft = Int4#sr{reg=load_vars(Rs, Int4#sr.reg)},
+    {[{'try',TryReg,{f,H}}] ++ Ais ++ 
+     [{label,B},{try_end,TryReg}] ++ Bis ++
+     [{label,H},{try_case,TryReg}] ++ His ++
+     [{label,E}],
+     clear_dead(Aft, Le#l.i, Vdb),
+     St7#cg{break=St0#cg.break}}.     
+
+try_enter_cg(Ta, Vs, Tb, Evs, Th, Le, Vdb, Bef, St0) ->
+    {B,St1} = new_label(St0),			%Body label
+    {H,St2} = new_label(St1),			%Handler label
+    TryTag = Ta#l.i,
+    Int1 = Bef#sr{stk=put_catch(TryTag, Bef#sr.stk)},
+    TryReg = fetch_stack({catch_tag,TryTag}, Int1#sr.stk),
+    {Ais,Int2,St3} = cg(Ta, Vdb, Int1, St2#cg{break=B,in_catch=true}),
+    Int3 = Int2#sr{stk=drop_catch(TryTag, Int2#sr.stk)},
+    St4 = St3#cg{in_catch=St2#cg.in_catch},
+    {Bis,Baft,St5} = cg(Tb, Vdb, Int3#sr{reg=load_vars(Vs, Int3#sr.reg)}, St4),
+    {His,Haft,St6} = cg(Th, Vdb, Int3#sr{reg=load_vars(Evs, Int3#sr.reg)}, St5),
+    Int4 = sr_merge(Baft, Haft),		%Merge stack/registers
+    Aft = Int4,
+    {[{'try',TryReg,{f,H}}] ++ Ais ++ 
+     [{label,B},{try_end,TryReg}] ++ Bis ++
+     [{label,H},{try_case,TryReg}] ++ His,
+     clear_dead(Aft, Le#l.i, Vdb),
+     St6#cg{break=St0#cg.break}}.     
+
+%% catch_cg(CatchBlock, Ret, Le, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+
+catch_cg(C, {var,R}, Le, Vdb, Bef, St0) ->
+    {B,St1} = new_label(St0),
+    CatchTag = Le#l.i,
+    Int1 = Bef#sr{stk=put_catch(CatchTag, Bef#sr.stk)},
+    CatchReg = fetch_stack({catch_tag,CatchTag}, Int1#sr.stk),
+    {Cis,Int2,St2} = cg_block(C, Le#l.i, Le#l.vdb, Int1,
+			      St1#cg{break=B,in_catch=true}),
+    [] = Int2#sr.reg,				%Assertion.
+    Aft = Int2#sr{reg=[{0,R}],stk=drop_catch(CatchTag, Int2#sr.stk)},
+    {[{'catch',CatchReg,{f,B}}] ++ Cis ++
+     [{label,B},{catch_end,CatchReg}],
+     clear_dead(Aft, Le#l.i, Vdb),
+     St2#cg{break=St1#cg.break,in_catch=St1#cg.in_catch}}.
+
+%% set_cg([Var], Constr, Le, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+%%  We have to be careful how a 'set' works. First the structure is
+%%  built, then it is filled and finally things can be cleared. The
+%%  annotation must reflect this and make sure that the return
+%%  variable is allocated first.
+%%
+%%  put_list for constructing a cons is an atomic instruction
+%%  which can safely resuse one of the source registers as target.
+%%  Also binaries can reuse a source register as target.
+
+set_cg([{var,R}], {cons,Es}, Le, Vdb, Bef, St) ->
+    [S1,S2] = map(fun ({var,V}) -> fetch_var(V, Bef);
+		      (Other) -> Other
+		  end, Es),
+    Int0 = clear_dead(Bef, Le#l.i, Vdb),
+    Int1 = Int0#sr{reg=put_reg(R, Int0#sr.reg)},
+    Ret = fetch_reg(R, Int1#sr.reg),
+    {[{put_list,S1,S2,Ret}], Int1, St};
+set_cg([{var,R}], {binary,Segs}, Le, Vdb, Bef, #cg{in_catch=InCatch}=St) ->
+    Int0 = Bef#sr{reg=put_reg(R, Bef#sr.reg)},
+    Target = fetch_reg(R, Int0#sr.reg),
+    Fail = bif_fail(St#cg.btype, St#cg.bfail, 42),
+    Temp = find_scratch_reg(Int0#sr.reg),
+    PutCode = cg_bin_put(Segs, Fail, Bef),
+    {Sis,Int1} =
+	case InCatch of
+	    true -> adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb);
+	    false -> {[],Int0}
+	end,
+    MaxRegs = max_reg(Bef#sr.reg),
+    Aft = clear_dead(Int1, Le#l.i, Vdb),
+    Code = cg_binary(PutCode, Target, Temp, Fail, MaxRegs, Le#l.a),
+    {Sis++Code,Aft,St};
+set_cg([{var,R}], Con, Le, Vdb, Bef, St) ->
+    %% Find a place for the return register first.
+    Int = Bef#sr{reg=put_reg(R, Bef#sr.reg)},
+    Ret = fetch_reg(R, Int#sr.reg),
+    Ais = case Con of
+	      {tuple,Es} ->
+		  [{put_tuple,length(Es),Ret}] ++ cg_build_args(Es, Bef);
+	      {var,V} ->			% Normally removed by kernel optimizer.
+		  [{move,fetch_var(V, Int),Ret}];
+	      {string,Str} ->
+		  [{put_string,length(Str),{string,Str},Ret}];
+	      Other ->
+		  [{move,Other,Ret}]
+	  end,
+    {Ais,clear_dead(Int, Le#l.i, Vdb),St};
+set_cg([], {binary,Segs}, Le, Vdb, Bef, St) ->
+    Fail = bif_fail(St#cg.btype, St#cg.bfail, 42),
+    Target = find_scratch_reg(Bef#sr.reg),
+    Temp = find_scratch_reg(put_reg(Target, Bef#sr.reg)),
+    PutCode = cg_bin_put(Segs, Fail, Bef),
+    MaxRegs = max_reg(Bef#sr.reg),
+    Code = cg_binary(PutCode, Target, Temp, Fail, MaxRegs, Le#l.a),
+    Aft = clear_dead(Bef, Le#l.i, Vdb),
+    {Code,Aft,St};
+set_cg([], _, Le, Vdb, Bef, St) ->
+    %% This should have been stripped by compiler, just cleanup.
+    {[],clear_dead(Bef, Le#l.i, Vdb), St}.
+
+
+%%%
+%%% Code generation for constructing binaries.
+%%%
+
+cg_binary([{bs_put_binary,Fail,{atom,all},U,_Flags,Src}|PutCode],
+	  Target, Temp, Fail, MaxRegs, Anno) ->
+    Live = cg_live(Target, MaxRegs),
+    SzCode = cg_bitstr_size(PutCode, Target, Temp, Fail, Live),
+    BinFlags = {field_flags,[]},
+    Code = SzCode ++
+	[case member(single_use, Anno) of
+	     true ->
+		 {bs_private_append,Fail,Target,U,Src,BinFlags,Target};
+	     false ->
+		 {bs_append,Fail,Target,0,MaxRegs,U,Src,BinFlags,Target}
+	 end] ++ PutCode,
+    cg_bin_opt(Code);
+cg_binary(PutCode, Target, Temp, Fail, MaxRegs, _Anno) ->
+    Live = cg_live(Target, MaxRegs),
+    {InitOp,SzCode} = cg_binary_size(PutCode, Target, Temp, Fail, Live),
+
+    Code = SzCode ++ [{InitOp,Fail,Target,0,MaxRegs,
+		       {field_flags,[]},Target}|PutCode],
+    cg_bin_opt(Code).
+
+cg_live({x,X}, MaxRegs) when X =:= MaxRegs -> MaxRegs+1;
+cg_live({x,X}, MaxRegs) when X < MaxRegs -> MaxRegs.
+
+%% Generate code that calculate the size of the bitstr to be
+%% built in BITS.
+
+cg_bitstr_size(PutCode, Target, Temp, Fail, Live) ->
+    {Bits,Es} = cg_bitstr_size_1(PutCode, 0, []),
+    reverse(cg_gen_binsize(Es, Target, Temp, Fail, Live,
+			   [{move,{integer,Bits},Target}])).
+
+cg_bitstr_size_1([{bs_put_utf8,_,_,Src}|Next], Bits, Acc) ->
+    cg_bitstr_size_1(Next, Bits, [{'*',{bs_utf8_size,Src},8}|Acc]);
+cg_bitstr_size_1([{bs_put_utf16,_,_,Src}|Next], Bits, Acc) ->
+    cg_bitstr_size_1(Next, Bits, [{'*',{bs_utf16_size,Src},8}|Acc]);
+cg_bitstr_size_1([{bs_put_utf32,_,_,_}|Next], Bits, Acc) ->
+    cg_bitstr_size_1(Next, Bits+32, Acc);
+cg_bitstr_size_1([{_,_,S,U,_,Src}|Next], Bits, Acc) ->
+    case S of
+	{integer,N} -> cg_bitstr_size_1(Next, Bits+N*U, Acc);
+	{atom,all} -> cg_bitstr_size_1(Next, Bits, [{bit_size,Src}|Acc]);
+	_ when U =:= 1 -> cg_bitstr_size_1(Next, Bits, [S|Acc]);
+	_ -> cg_bitstr_size_1(Next, Bits, [{'*',S,U}|Acc])
+    end;
+cg_bitstr_size_1([], Bits, Acc) -> {Bits,Acc}.
+
+%% Generate code that calculate the size of the bitstr to be
+%% built in BYTES or BITS (depending on what is easiest).
+
+cg_binary_size(PutCode, Target, Temp, Fail, Live) ->
+    {InitInstruction,Szs} = cg_binary_size_1(PutCode, 0, []),
+    SizeExpr = reverse(cg_gen_binsize(Szs, Target, Temp, Fail, Live, [{move,{integer,0},Target}])),
+    {InitInstruction,SizeExpr}.
+
+cg_binary_size_1([{bs_put_utf8,_Fail,_Flags,Src}|T], Bits, Acc) ->
+    cg_binary_size_1(T, Bits, [{8,{bs_utf8_size,Src}}|Acc]);
+cg_binary_size_1([{bs_put_utf16,_Fail,_Flags,Src}|T], Bits, Acc) ->
+    cg_binary_size_1(T, Bits, [{8,{bs_utf16_size,Src}}|Acc]);
+cg_binary_size_1([{bs_put_utf32,_Fail,_Flags,_Src}|T], Bits, Acc) ->
+    cg_binary_size_1(T, Bits+32, Acc);
+cg_binary_size_1([{_Put,_Fail,S,U,_Flags,Src}|T], Bits, Acc) ->
+    cg_binary_size_2(S, U, Src, T, Bits, Acc);
+cg_binary_size_1([], Bits, Acc) ->
+    Bytes = Bits div 8,
+    RemBits = Bits rem 8,
+    Sizes0 = sort([{1,{integer,RemBits}},{8,{integer,Bytes}}|Acc]),
+    Sizes = filter(fun({_,{integer,0}}) -> false;
+		      (_) -> true end, Sizes0),
+    case Sizes of
+	[{1,_}|_] ->
+	    {bs_init_bits,cg_binary_bytes_to_bits(Sizes, [])};
+	[{8,_}|_] ->
+	    {bs_init2,[E || {8,E} <- Sizes]}
+    end.
+
+cg_binary_size_2({integer,N}, U, _, Next, Bits, Acc) ->
+    cg_binary_size_1(Next, Bits+N*U, Acc);
+cg_binary_size_2({atom,all}, U, E, Next, Bits, Acc) ->
+    if 
+	U rem 8 =:= 0 ->
+	    cg_binary_size_1(Next, Bits, [{8,{byte_size,E}}|Acc]);
+	true ->
+	    cg_binary_size_1(Next, Bits, [{1,{bit_size,E}}|Acc])
+    end;
+cg_binary_size_2(Reg, 1, _, Next, Bits, Acc) ->
+    cg_binary_size_1(Next, Bits, [{1,Reg}|Acc]);
+cg_binary_size_2(Reg, 8, _, Next, Bits, Acc) ->
+    cg_binary_size_1(Next, Bits, [{8,Reg}|Acc]);
+cg_binary_size_2(Reg, U, _, Next, Bits, Acc) ->
+    cg_binary_size_1(Next, Bits, [{1,{'*',Reg,U}}|Acc]).
+
+cg_binary_bytes_to_bits([{8,{integer,N}}|T], Acc) ->
+    cg_binary_bytes_to_bits(T, [{integer,8*N}|Acc]);
+cg_binary_bytes_to_bits([{8,{byte_size,Reg}}|T], Acc) ->
+    cg_binary_bytes_to_bits(T, [{bit_size,Reg}|Acc]);
+cg_binary_bytes_to_bits([{8,Reg}|T], Acc) ->
+    cg_binary_bytes_to_bits(T, [{'*',Reg,8}|Acc]);
+cg_binary_bytes_to_bits([{1,Sz}|T], Acc) ->
+    cg_binary_bytes_to_bits(T, [Sz|Acc]);
+cg_binary_bytes_to_bits([], Acc) ->
+    cg_binary_bytes_to_bits_1(sort(Acc)).
+
+cg_binary_bytes_to_bits_1([{integer,I},{integer,J}|T]) ->
+    cg_binary_bytes_to_bits_1([{integer,I+J}|T]);
+cg_binary_bytes_to_bits_1([H|T]) ->
+    [H|cg_binary_bytes_to_bits_1(T)];
+cg_binary_bytes_to_bits_1([]) -> [].
+
+cg_gen_binsize([{'*',{bs_utf8_size,Src},B}|T], Target, Temp, Fail, Live, Acc) ->
+    Size = {bs_utf8_size,Fail,Src,Temp},
+    Add = {bs_add,Fail,[Target,Temp,B],Target},
+    cg_gen_binsize(T, Target, Temp, Fail, Live,
+		   [Add,Size|Acc]);
+cg_gen_binsize([{'*',{bs_utf16_size,Src},B}|T], Target, Temp, Fail, Live, Acc) ->
+    Size = {bs_utf16_size,Fail,Src,Temp},
+    Add = {bs_add,Fail,[Target,Temp,B],Target},
+    cg_gen_binsize(T, Target, Temp, Fail, Live,
+		   [Add,Size|Acc]);
+cg_gen_binsize([{'*',{bs_utf32_size,Src},B}|T], Target, Temp, Fail, Live, Acc) ->
+    Size = {bs_utf32_size,Fail,Src,Temp},
+    Add = {bs_add,Fail,[Target,Temp,B],Target},
+    cg_gen_binsize(T, Target, Temp, Fail, Live,
+		   [Add,Size|Acc]);
+cg_gen_binsize([{'*',A,B}|T], Target, Temp, Fail, Live, Acc) ->
+    cg_gen_binsize(T, Target, Temp, Fail, Live,
+		   [{bs_add,Fail,[Target,A,B],Target}|Acc]);
+cg_gen_binsize([{bit_size,B}|T], Target, Temp, Fail, Live, Acc) ->
+    cg_gen_binsize([Temp|T], Target, Temp, Fail, Live,
+		   [{gc_bif,bit_size,Fail,Live,[B],Temp}|Acc]);
+cg_gen_binsize([{byte_size,B}|T], Target, Temp, Fail, Live, Acc) ->
+    cg_gen_binsize([Temp|T], Target, Temp, Fail, Live,
+		   [{gc_bif,byte_size,Fail,Live,[B],Temp}|Acc]);
+cg_gen_binsize([{bs_utf8_size,B}|T], Target, Temp, Fail, Live, Acc) ->
+    cg_gen_binsize([Temp|T], Target, Temp, Fail, Live,
+		   [{bs_utf8_size,Fail,B,Temp}|Acc]);
+cg_gen_binsize([{bs_utf16_size,B}|T], Target, Temp, Fail, Live, Acc) ->
+    cg_gen_binsize([Temp|T], Target, Temp, Fail, Live,
+		   [{bs_utf16_size,Fail,B,Temp}|Acc]);
+cg_gen_binsize([{bs_utf32_size,B}|T], Target, Temp, Fail, Live, Acc) ->
+    cg_gen_binsize([Temp|T], Target, Temp, Fail, Live,
+		   [{bs_utf32_size,Fail,B,Temp}|Acc]);
+cg_gen_binsize([E0|T], Target, Temp, Fail, Live, Acc) ->
+    cg_gen_binsize(T, Target, Temp, Fail, Live,
+		   [{bs_add,Fail,[Target,E0,1],Target}|Acc]);
+cg_gen_binsize([], _, _, _, _, Acc) -> Acc.
+
+
+%% cg_bin_opt(Code0) -> Code
+%%  Optimize the size calculations for binary construction.
+
+cg_bin_opt([{move,Size,D},{bs_append,Fail,D,Extra,Regs0,U,Bin,Flags,D}|Is]) ->
+    Regs = cg_bo_newregs(Regs0, D),
+    cg_bin_opt([{bs_append,Fail,Size,Extra,Regs,U,Bin,Flags,D}|Is]);
+cg_bin_opt([{move,Size,D},{bs_private_append,Fail,D,U,Bin,Flags,D}|Is]) ->
+    cg_bin_opt([{bs_private_append,Fail,Size,U,Bin,Flags,D}|Is]);
+cg_bin_opt([{move,{integer,0},D},{bs_add,_,[D,{integer,_}=S,1],Dst}|Is]) ->
+    cg_bin_opt([{move,S,Dst}|Is]);
+cg_bin_opt([{move,{integer,0},D},{bs_add,Fail,[D,S,U],Dst}|Is]) ->
+    cg_bin_opt([{bs_add,Fail,[{integer,0},S,U],Dst}|Is]);
+cg_bin_opt([{move,{integer,Bytes},D},{Op,Fail,D,Extra,Regs0,Flags,D}|Is])
+  when Op =:= bs_init2; Op =:= bs_init_bits ->
+    Regs = cg_bo_newregs(Regs0, D),
+    cg_bin_opt([{Op,Fail,Bytes,Extra,Regs,Flags,D}|Is]);
+cg_bin_opt([{move,Src1,Dst},{bs_add,Fail,[Dst,Src2,U],Dst}|Is]) ->
+    cg_bin_opt([{bs_add,Fail,[Src1,Src2,U],Dst}|Is]);
+cg_bin_opt([I|Is]) ->
+    [I|cg_bin_opt(Is)];
+cg_bin_opt([]) -> [].
+
+cg_bo_newregs(R, {x,X}) when R-1 =:= X -> R-1;
+cg_bo_newregs(R, _) -> R.
+
+%% Common for new and old binary code generation.
+
+cg_bin_put({bin_seg,[],S0,U,T,Fs,[E0,Next]}, Fail, Bef) ->
+    S1 = case S0 of
+	     {var,Sv} -> fetch_var(Sv, Bef);
+	     _ -> S0
+	 end,
+    E1 = case E0 of
+	     {var,V} -> fetch_var(V, Bef);
+	     Other ->   Other
+	 end,
+    {Format,Op} = case T of
+		      integer -> {plain,bs_put_integer};
+		      utf8 ->    {utf,bs_put_utf8};
+		      utf16 ->   {utf,bs_put_utf16};
+		      utf32 ->   {utf,bs_put_utf32};
+		      binary  -> {plain,bs_put_binary};
+		      float   -> {plain,bs_put_float}
+		  end,
+    case Format of
+	plain ->
+	    [{Op,Fail,S1,U,{field_flags,Fs},E1}|cg_bin_put(Next, Fail, Bef)];
+	utf ->
+	    [{Op,Fail,{field_flags,Fs},E1}|cg_bin_put(Next, Fail, Bef)]
+    end;
+cg_bin_put({bin_end,[]}, _, _) -> [].
+
+cg_build_args(As, Bef) ->
+    map(fun ({var,V}) -> {put,fetch_var(V, Bef)};
+	    (Other) -> {put,Other}
+	end, As).
+
+%% return_cg([Val], Le, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+%% break_cg([Val], Le, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
+%%  These are very simple, just put return/break values in registers
+%%  from 0, then return/break.  Use the call setup to clean up stack,
+%%  but must clear registers to ensure sr_merge works correctly.
+
+return_cg(Rs, Le, Vdb, Bef, St) ->
+    {Ms,Int} = cg_setup_call(Rs, Bef, Le#l.i, Vdb),
+    {comment({return,Rs}) ++ Ms ++ [return],
+     Int#sr{reg=clear_regs(Int#sr.reg)},St}.
+
+break_cg(Bs, Le, Vdb, Bef, St) ->
+    {Ms,Int} = cg_setup_call(Bs, Bef, Le#l.i, Vdb),
+    {comment({break,Bs}) ++ Ms ++ [{jump,{f,St#cg.break}}],
+     Int#sr{reg=clear_regs(Int#sr.reg)},St}.
+
+%% cg_reg_arg(Arg0, Info) -> Arg
+%% cg_reg_args([Arg0], Info) -> [Arg]
+%%  Convert argument[s] into registers. Literal values are returned unchanged.
+
+cg_reg_args(As, Bef) -> [cg_reg_arg(A, Bef) || A <- As].
+
+cg_reg_arg({var,V}, Bef) -> fetch_var(V, Bef);
+cg_reg_arg(Literal, _) -> Literal.
+
+%% cg_setup_call([Arg], Bef, Cur, Vdb) -> {[Instr],Aft}.
+%%  Do the complete setup for a call/enter.
+
+cg_setup_call(As, Bef, I, Vdb) ->
+    {Ms,Int0} = cg_call_args(As, Bef, I, Vdb),
+    %% Have set up arguments, can now clean up, compress and save to stack.
+    Int1 = Int0#sr{stk=clear_dead_stk(Int0#sr.stk, I, Vdb),res=[]},
+    {Sis,Int2} = adjust_stack(Int1, I, I+1, Vdb),
+    {Ms ++ Sis ++ [{'%live',length(As)}],Int2}.
+
+%% cg_call_args([Arg], SrState) -> {[Instr],SrState}.
+%%  Setup the arguments to a call/enter/bif. Put the arguments into
+%%  consecutive registers starting at {x,0} moving any data which
+%%  needs to be saved. Return a modified SrState structure with the
+%%  new register contents.  N.B. the resultant register info will
+%%  contain non-variable values when there are non-variable values.
+%%
+%%  This routine is complicated by unsaved values in x registers.
+%%  We'll move away any unsaved values that are in the registers
+%%  to be overwritten by the arguments.
+
+cg_call_args(As, Bef, I, Vdb) ->
+    Regs0 = load_arg_regs(Bef#sr.reg, As),
+    Unsaved = unsaved_registers(Regs0, Bef#sr.stk, I, I+1, Vdb),
+    {UnsavedMoves,Regs} = move_unsaved(Unsaved, Bef#sr.reg, Regs0),
+    Moves0 = gen_moves(As, Bef),
+    Moves = order_moves(Moves0, find_scratch_reg(Regs)),
+    {UnsavedMoves ++ Moves,Bef#sr{reg=Regs}}.
+
+%% load_arg_regs([Reg], Arguments) -> [Reg]
+%%  Update the register descriptor to include the arguments (from {x,0}
+%%  and upwards). Values in argument register are overwritten.
+%%  Values in x registers above the arguments are preserved.
+
+load_arg_regs(Regs, As) -> load_arg_regs(Regs, As, 0).
+
+load_arg_regs([_|Rs], [{var,V}|As], I) -> [{I,V}|load_arg_regs(Rs, As, I+1)];
+load_arg_regs([_|Rs], [A|As], I) -> [{I,A}|load_arg_regs(Rs, As, I+1)];
+load_arg_regs([], [{var,V}|As], I) -> [{I,V}|load_arg_regs([], As, I+1)];
+load_arg_regs([], [A|As], I) -> [{I,A}|load_arg_regs([], As, I+1)];
+load_arg_regs(Rs, [], _) -> Rs.
+
+%% Returns the variables must be saved and are currently in the
+%% x registers that are about to be overwritten by the arguments.
+
+unsaved_registers(Regs, Stk, Fb, Lf, Vdb) ->
+    [V || {V,F,L} <- Vdb,
+	  F < Fb,
+	  L >= Lf,
+	  not on_stack(V, Stk),
+	  not in_reg(V, Regs)].
+
+in_reg(V, Regs) -> keymember(V, 2, Regs).
+
+%% Move away unsaved variables from the registers that are to be
+%% overwritten by the arguments.
+move_unsaved(Vs, OrigRegs, NewRegs) ->
+    move_unsaved(Vs, OrigRegs, NewRegs, []).
+    
+move_unsaved([V|Vs], OrigRegs, NewRegs0, Acc) ->
+    NewRegs = put_reg(V, NewRegs0),
+    Src = fetch_reg(V, OrigRegs),
+    Dst = fetch_reg(V, NewRegs),
+    move_unsaved(Vs, OrigRegs, NewRegs, [{move,Src,Dst}|Acc]);
+move_unsaved([], _, Regs, Acc) -> {Acc,Regs}.
+    
+%% gen_moves(As, Sr)
+%%  Generate the basic move instruction to move the arguments
+%%  to their proper registers. The list will be sorted on
+%%  destinations. (I.e. the move to {x,0} will be first --
+%%  see the comment to order_moves/2.)
+
+gen_moves(As, Sr) -> gen_moves(As, Sr, 0, []).
+
+gen_moves([{var,V}|As], Sr, I, Acc) ->
+    case fetch_var(V, Sr) of
+	{x,I} -> gen_moves(As, Sr, I+1, Acc);
+	Reg -> gen_moves(As, Sr, I+1, [{move,Reg,{x,I}}|Acc])
+    end;
+gen_moves([A|As], Sr, I, Acc) ->
+    gen_moves(As, Sr, I+1, [{move,A,{x,I}}|Acc]);
+gen_moves([], _, _, Acc) -> lists:keysort(3, Acc).
+
+%% order_moves([Move], ScratchReg) -> [Move]
+%%  Orders move instruction so that source registers are not
+%%  destroyed before they are used. If there are cycles
+%%  (such as {move,{x,0},{x,1}}, {move,{x,1},{x,1}}),
+%%  the scratch register is used to break up the cycle.
+%%    If possible, the first move of the input list is placed
+%%  last in the result list (to make the move to {x,0} occur
+%%  just before the call to allow the Beam loader to coalesce
+%%  the instructions).
+
+order_moves(Ms, Scr) -> order_moves(Ms, Scr, []).
+
+order_moves([{move,_,_}=M|Ms0], ScrReg, Acc0) ->
+    {Chain,Ms} = collect_chain(Ms0, [M], ScrReg),
+    Acc = reverse(Chain, Acc0),
+    order_moves(Ms, ScrReg, Acc);
+order_moves([], _, Acc) -> Acc.
+
+collect_chain(Ms, Path, ScrReg) ->
+    collect_chain(Ms, Path, [], ScrReg).
+
+collect_chain([{move,Src,Same}=M|Ms0], [{move,Same,_}|_]=Path, Others, ScrReg) ->
+    case keysearch(Src, 3, Path) of
+	{value,_} ->				%We have a cycle.
+	    {break_up_cycle(M, Path, ScrReg),reverse(Others, Ms0)};
+	false ->
+	    collect_chain(reverse(Others, Ms0), [M|Path], [], ScrReg)
+    end;
+collect_chain([M|Ms], Path, Others, ScrReg) ->
+    collect_chain(Ms, Path, [M|Others], ScrReg);
+collect_chain([], Path, Others, _) ->
+    {Path,Others}.
+
+break_up_cycle({move,Src,_}=M, Path, ScrReg) ->
+    [{move,ScrReg,Src},M|break_up_cycle1(Src, Path, ScrReg)].
+
+break_up_cycle1(Dst, [{move,Src,Dst}|Path], ScrReg) ->
+    [{move,Src,ScrReg}|Path];
+break_up_cycle1(Dst, [M|Path], LastMove) ->
+    [M|break_up_cycle1(Dst, Path, LastMove)].
+
+%% clear_dead(Sr, Until, Vdb) -> Aft.
+%%  Remove all variables in Sr which have died AT ALL so far.
+
+clear_dead(Sr, Until, Vdb) ->
+    Sr#sr{reg=clear_dead_reg(Sr, Until, Vdb),
+	  stk=clear_dead_stk(Sr#sr.stk, Until, Vdb)}.
+
+clear_dead_reg(Sr, Until, Vdb) ->
+    Reg = map(fun ({I,V}) ->
+		      case vdb_find(V, Vdb) of
+			  {V,_,L} when L > Until -> {I,V};
+			  _ -> free		%Remove anything else
+		      end;
+		  ({reserved,I,V}) -> {reserved,I,V};
+		  (free) -> free
+	      end, Sr#sr.reg),
+    reserve(Sr#sr.res, Reg, Sr#sr.stk).
+
+clear_dead_stk(Stk, Until, Vdb) ->
+    map(fun ({V}) ->
+		case vdb_find(V, Vdb) of
+		    {V,_,L} when L > Until -> {V};
+		    _ -> dead			%Remove anything else
+		end;
+	    (free) -> free;
+	    (dead) -> dead
+	end, Stk).
+
+%% sr_merge(Sr1, Sr2) -> Sr.
+%%  Merge two stack/register states keeping the longest of both stack
+%%  and register. Perform consistency check on both, elements must be
+%%  the same.  Allow frame size 'void' to make easy creation of
+%%  "empty" frame.
+
+sr_merge(#sr{reg=R1,stk=S1,res=[]}, #sr{reg=R2,stk=S2,res=[]}) ->
+    #sr{reg=longest(R1, R2),stk=longest(S1, S2),res=[]};
+sr_merge(void, S2) -> S2#sr{res=[]}.
+
+longest([H|T1], [H|T2]) -> [H|longest(T1, T2)];
+longest([dead|T1], [free|T2]) -> [dead|longest(T1, T2)];
+longest([free|T1], [dead|T2]) -> [dead|longest(T1, T2)];
+longest([dead|T1], []) -> [dead|T1];
+longest([], [dead|T2]) -> [dead|T2];
+longest([free|T1], []) -> [free|T1];
+longest([], [free|T2]) -> [free|T2];
+longest([], []) -> [].
+
+%% adjust_stack(Bef, FirstBefore, LastFrom, Vdb) -> {[Ainstr],Aft}.
+%%  Do complete stack adjustment by compressing stack and adding
+%%  variables to be saved.  Try to optimise ordering on stack by
+%%  having reverse order to their lifetimes.
+%%
+%%  In Beam, there is a fixed stack frame and no need to do stack compression.
+
+adjust_stack(Bef, Fb, Lf, Vdb) ->
+    Stk0 = Bef#sr.stk,
+    {Stk1,Saves} = save_stack(Stk0, Fb, Lf, Vdb),
+    {saves(Saves, Bef#sr.reg, Stk1),
+     Bef#sr{stk=Stk1}}.
+
+%% save_stack(Stack, FirstBefore, LastFrom, Vdb) -> {[SaveVar],NewStack}.
+%%  Save variables which are used past current point and which are not
+%%  already on the stack.
+
+save_stack(Stk0, Fb, Lf, Vdb) ->
+    %% New variables that are in use but not on stack.
+    New = [ {V,F,L} || {V,F,L} <- Vdb,
+		   F < Fb,
+		   L >= Lf,
+		   not on_stack(V, Stk0) ],
+    %% Add new variables that are not just dropped immediately.
+    %% N.B. foldr works backwards from the end!!
+    Saves = [ V || {V,_,_} <- keysort(3, New) ],
+    Stk1 = foldr(fun (V, Stk) -> put_stack(V, Stk) end, Stk0, Saves),
+    {Stk1,Saves}.
+
+%% saves([SaveVar], Reg, Stk) -> [{move,Reg,Stk}].
+%%  Generate move instructions to save variables onto stack.  The
+%%  stack/reg info used is that after the new stack has been made.
+
+saves(Ss, Reg, Stk) ->
+    [{move,fetch_reg(V, Reg),fetch_stack(V, Stk)} || V <- Ss].
+
+%% comment(C) -> ['%'{C}].
+
+%comment(C) -> [{'%',C}].
+comment(_) -> [].
+
+%% fetch_var(VarName, StkReg) -> r{R} | sp{Sp}.
+%% find_var(VarName, StkReg) -> ok{r{R} | sp{Sp}} | error.
+%%  Fetch/find a variable in either the registers or on the
+%%  stack. Fetch KNOWS it's there.
+
+fetch_var(V, Sr) ->
+    case find_reg(V, Sr#sr.reg) of
+	{ok,R} -> R;
+	error -> fetch_stack(V, Sr#sr.stk)
+    end.
+
+% find_var(V, Sr) ->
+%     case find_reg(V, Sr#sr.reg) of
+% 	{ok,R} -> {ok,R};
+% 	error ->
+% 	    case find_stack(V, Sr#sr.stk) of
+% 		{ok,S} -> {ok,S};
+% 		error -> error
+% 	    end
+%     end.
+
+load_vars(Vs, Regs) ->
+    foldl(fun ({var,V}, Rs) -> put_reg(V, Rs) end, Regs, Vs).
+
+%% put_reg(Val, Regs) -> Regs.
+%% free_reg(Val, Regs) -> Regs.
+%% find_reg(Val, Regs) -> ok{r{R}} | error.
+%% fetch_reg(Val, Regs) -> r{R}.
+%%  Functions to interface the registers.
+%%  put_reg puts a value into a free register,
+%%  load_reg loads a value into a fixed register
+%%  free_reg frees a register containing a specific value.
+
+% put_regs(Vs, Rs) -> foldl(fun put_reg/2, Rs, Vs).
+
+put_reg(V, Rs) -> put_reg_1(V, Rs, 0).
+
+put_reg_1(V, [free|Rs], I) -> [{I,V}|Rs];
+put_reg_1(V, [{reserved,I,V}|Rs], I) -> [{I,V}|Rs];
+put_reg_1(V, [R|Rs], I) -> [R|put_reg_1(V, Rs, I+1)];
+put_reg_1(V, [], I) -> [{I,V}].
+
+% free_reg(V, [{I,V}|Rs]) -> [free|Rs];
+% free_reg(V, [R|Rs]) -> [R|free_reg(V, Rs)];
+% free_reg(V, []) -> [].
+
+fetch_reg(V, [{I,V}|_]) -> {x,I};
+fetch_reg(V, [_|SRs]) -> fetch_reg(V, SRs).
+
+find_reg(V, [{I,V}|_]) -> {ok,{x,I}};
+find_reg(V, [_|SRs]) -> find_reg(V, SRs);
+find_reg(_, []) -> error.
+
+%% For the bit syntax, we need a scratch register if we are constructing
+%% a binary that will not be used.
+
+find_scratch_reg(Rs) -> find_scratch_reg(Rs, 0).
+    
+find_scratch_reg([free|_], I) -> {x,I};
+find_scratch_reg([_|Rs], I) -> find_scratch_reg(Rs, I+1);
+find_scratch_reg([], I) -> {x,I}.
+
+%%copy_reg(Val, R, Regs) -> load_reg(Val, R, Regs).
+%%move_reg(Val, R, Regs) -> load_reg(Val, R, free_reg(Val, Regs)).
+
+replace_reg_contents(Old, New, [{I,Old}|Rs]) -> [{I,New}|Rs];
+replace_reg_contents(Old, New, [R|Rs]) -> [R|replace_reg_contents(Old, New, Rs)].
+
+%%clear_regs(Regs) -> map(fun (R) -> free end, Regs).
+clear_regs(_) -> [].
+
+max_reg(Regs) ->
+    foldl(fun ({I,_}, _) -> I;
+	      (_, Max) -> Max end,
+	  -1, Regs) + 1.
+
+%% put_stack(Val, [{Val}]) -> [{Val}].
+%% fetch_stack(Var, Stk) -> sp{S}.
+%% find_stack(Var, Stk) -> ok{sp{S}} | error.
+%%  Functions to interface the stack.
+
+put_stack(Val, []) -> [{Val}];
+put_stack(Val, [dead|Stk]) -> [{Val}|Stk];
+put_stack(Val, [free|Stk]) -> [{Val}|Stk];
+put_stack(Val, [NotFree|Stk]) -> [NotFree|put_stack(Val, Stk)].
+
+put_stack_carefully(Val, Stk0) ->
+    case catch put_stack_carefully1(Val, Stk0) of
+	error -> error;
+	Stk1 when is_list(Stk1) -> Stk1
+    end.
+
+put_stack_carefully1(_, []) -> throw(error);
+put_stack_carefully1(Val, [dead|Stk]) -> [{Val}|Stk];
+put_stack_carefully1(Val, [free|Stk]) -> [{Val}|Stk];
+put_stack_carefully1(Val, [NotFree|Stk]) ->
+    [NotFree|put_stack_carefully1(Val, Stk)].
+
+fetch_stack(Var, Stk) -> fetch_stack(Var, Stk, 0).
+
+fetch_stack(V, [{V}|_], I) -> {yy,I};
+fetch_stack(V, [_|Stk], I) -> fetch_stack(V, Stk, I+1).
+
+% find_stack(Var, Stk) -> find_stack(Var, Stk, 0).
+
+% find_stack(V, [{V}|Stk], I) -> {ok,{yy,I}};
+% find_stack(V, [O|Stk], I) -> find_stack(V, Stk, I+1);
+% find_stack(V, [], I) -> error.
+
+on_stack(V, Stk) -> keymember(V, 1, Stk).
+
+%% put_catch(CatchTag, Stack) -> Stack'
+%% drop_catch(CatchTag, Stack) -> Stack'
+%%  Special interface for putting and removing catch tags, to ensure that
+%%  catches nest properly. Also used for try tags.
+
+put_catch(Tag, Stk0) -> put_catch(Tag, reverse(Stk0), []).
+
+put_catch(Tag, [], Stk) ->
+    put_stack({catch_tag,Tag}, Stk);
+put_catch(Tag, [{{catch_tag,_}}|_]=RevStk, Stk) ->
+    reverse(RevStk, put_stack({catch_tag,Tag}, Stk));
+put_catch(Tag, [Other|Stk], Acc) ->
+    put_catch(Tag, Stk, [Other|Acc]).
+
+drop_catch(Tag, [{{catch_tag,Tag}}|Stk]) -> [free|Stk];
+drop_catch(Tag, [Other|Stk]) -> [Other|drop_catch(Tag, Stk)].
+
+%% new_label(St) -> {L,St}.
+
+new_label(#cg{lcount=Next}=St) ->
+    {Next,St#cg{lcount=Next+1}}.
+
+flatmapfoldl(F, Accu0, [Hd|Tail]) ->
+    {R,Accu1} = F(Hd, Accu0),
+    {Rs,Accu2} = flatmapfoldl(F, Accu1, Tail),
+    {R++Rs,Accu2};
+flatmapfoldl(_, Accu, []) -> {[],Accu}.
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_core.erl minimal_otp_src_R12B-5/lib/compiler/src/v3_core.erl
--- otp_src_R12B-5/lib/compiler/src/v3_core.erl	2008-11-04 10:51:33.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_core.erl	2009-06-23 20:40:10.000000000 +0100
@@ -97,6 +97,8 @@
 -record(icatch, {anno=#a{},body}).
 -record(ireceive1, {anno=#a{},clauses}).
 -record(ireceive2, {anno=#a{},clauses,timeout,action}).
+-record(isearch1, {anno=#a{},clauses}).
+-record(isearch2, {anno=#a{},clauses,timeout,action}).
 -record(iprotect, {anno=#a{},body}).
 -record(ibinary, {anno=#a{},segments}).		%Not used in patterns.
 
@@ -433,6 +435,15 @@ expr({'receive',L,Cs0,Te0,Tes0}, St0) ->
     {Cs1,St3} = clauses(Cs0, St2),
     {#ireceive2{anno=#a{anno=lineno_anno(L, St3)},
 		clauses=Cs1,timeout=Te1,action=Tes1},Teps,St3};
+expr({'search',L,Cs0}, St0) ->
+    {Cs1,St1} = clauses(Cs0, St0),
+    {#isearch1{anno=#a{anno=lineno_anno(L, St1)},clauses=Cs1}, [], St1};
+expr({'search',L,Cs0,Te0,Tes0}, St0) ->
+    {Te1,Teps,St1} = novars(Te0, St0),
+    {Tes1,St2} = exprs(Tes0, St1),
+    {Cs1,St3} = clauses(Cs0, St2),
+    {#isearch2{anno=#a{anno=lineno_anno(L, St3)},
+		clauses=Cs1,timeout=Te1,action=Tes1},Teps,St3};
 expr({'try',L,Es0,[],Ecs,[]}, St0) ->
     %% 'try ... catch ... end'
     {Es1,St1} = exprs(Es0, St0),
@@ -1442,6 +1453,14 @@ uexpr(#ireceive2{anno=A,clauses=Cs0,time
 	  end,
     {#ireceive2{anno=A#a{us=Used,ns=New},
 		clauses=Cs1,timeout=Te1,action=Tes1},St3};
+uexpr(#isearch1{anno=A,clauses=Cs0}, Ks, St0) ->
+    {Cs1,St1} = uclauses(Cs0, Ks, St0),
+    {#isearch1{anno=A#a{us=used_in_any(Cs1),ns=new_in_all(Cs1)},
+		clauses=Cs1},St1};
+uexpr(#isearch2{anno=A0,clauses=Cs0,timeout=Te0,action=Tes0}, Ks, St0) ->
+    {#ireceive2{anno=A, clauses=Cs1,timeout=Te1,action=Tes1},St3} = 
+	uexpr(#ireceive2{anno=A0, clauses=Cs0, timeout=Te0, action=Tes0}, Ks, St0),
+    {#isearch2{anno=A, clauses=Cs1,timeout=Te1,action=Tes1},St3};
 uexpr(#iprotect{anno=A,body=Es0}, Ks, St0) ->
     {Es1,St1} = uexprs(Es0, Ks, St0),
     Used = used_in_any(Es1),
@@ -1674,6 +1693,22 @@ cexpr(#ireceive2{anno=A,clauses=Lcs,time
     {#c_receive{anno=A#a.anno,
 		clauses=Ccs,timeout=Cto,action=Ces},
      Exp,A#a.us,St3};
+%% FIXME: don't duplicate the code
+cexpr(#isearch1{anno=A,clauses=Lcs}, As, St0) ->
+    Exp = intersection(A#a.ns, As),		%Exports
+    {Ccs,St1} = cclauses(Lcs, Exp, St0),
+    {#c_search{anno=A#a.anno,
+		clauses=Ccs,
+	       timeout=#c_literal{val=infinity},action=#c_literal{val=true}},
+     Exp,A#a.us,St1};
+cexpr(#isearch2{anno=A,clauses=Lcs,timeout=Lto,action=Les}, As, St0) ->
+    Exp = intersection(A#a.ns, As),		%Exports
+    {Cto,[],_Us1,St1} = cexpr(Lto, As, St0),
+    {Ccs,St2} = cclauses(Lcs, Exp, St1),
+    {Ces,_Us2,St3} = cexprs(Les, Exp, St2),
+    {#c_search{anno=A#a.anno,
+		clauses=Ccs,timeout=Cto,action=Ces},
+     Exp,A#a.us,St3};
 cexpr(#itry{anno=A,args=La,vars=Vs,body=Lb,evars=Evs,handler=Lh}, As, St0) ->
     Exp = intersection(A#a.ns, As),           %Exports
     {Ca,_Us1,St1} = cexprs(La, [], St0),
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_core.erl~ minimal_otp_src_R12B-5/lib/compiler/src/v3_core.erl~
--- otp_src_R12B-5/lib/compiler/src/v3_core.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_core.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,1844 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Transform normal Erlang to Core Erlang
+
+%% At this stage all preprocessing has been done. All that is left are
+%% "pure" Erlang functions.
+%%
+%% Core transformation is done in three stages:
+%%
+%% 1. Flatten expressions into an internal core form without doing
+%%    matching.
+%%
+%% 2. Step "forwards" over the icore code annotating each "top-level"
+%%    thing with variable usage.  Detect bound variables in matching
+%%    and replace with explicit guard test.  Annotate "internal-core"
+%%    expressions with variables they use and create.  Convert matches
+%%    to cases when not pure assignments.
+%%
+%% 3. Step "backwards" over icore code using variable usage
+%%    annotations to change implicit exported variables to explicit
+%%    returns.
+%%
+%% To ensure the evaluation order we ensure that all arguments are
+%% safe.  A "safe" is basically a core_lib simple with VERY restricted
+%% binaries.
+%%
+%% We have to be very careful with matches as these create variables.
+%% While we try not to flatten things more than necessary we must make
+%% sure that all matches are at the top level.  For this we use the
+%% type "novars" which are non-match expressions.  Cases and receives
+%% can also create problems due to exports variables so they are not
+%% "novars" either.  I.e. a novars will not export variables.
+%%
+%% Annotations in the #iset, #iletrec, and all other internal records
+%% is kept in a record, #a, not in a list as in proper core.  This is
+%% easier and faster and creates no problems as we have complete control
+%% over all annotations.
+%%
+%% On output, the annotation for most Core Erlang terms will contain
+%% the source line number. A few terms will be marked with the atom
+%% atom 'compiler_generated', to indicate that the compiler has generated
+%% them and that no warning should be generated if they are optimized
+%% away.
+%% 
+%%
+%% In this translation:
+%%
+%% call ops are safes
+%% call arguments are safes
+%% match arguments are novars
+%% case arguments are novars
+%% receive timeouts are novars
+%% let/set arguments are expressions
+%% fun is not a safe
+
+-module(v3_core).
+
+-export([module/2,format_error/1]).
+
+-import(lists, [reverse/1,map/2,member/2,foldl/3,foldr/3,mapfoldl/3,
+		splitwith/2,keysearch/3]).
+-import(ordsets, [add_element/2,del_element/2,is_element/2,
+		  union/1,union/2,intersection/2,subtract/2]).
+
+-include("core_parse.hrl").
+
+%% Internal core expressions and help functions.
+%% N.B. annotations fields in place as normal Core expressions.
+
+-record(a, {us=[],ns=[],anno=[]}).		%Internal annotation
+
+-record(iset, {anno=#a{},var,arg}).
+-record(iletrec, {anno=#a{},defs,body}).
+-record(imatch, {anno=#a{},pat,guard=[],arg,fc}).
+-record(icase, {anno=#a{},args,clauses,fc}).
+-record(iclause, {anno=#a{},pats,pguard=[],guard,body}).
+-record(ifun, {anno=#a{},id,vars,clauses,fc}).
+-record(iapply, {anno=#a{},op,args}).
+-record(icall, {anno=#a{},module,name,args}).
+-record(iprimop, {anno=#a{},name,args}).
+-record(itry, {anno=#a{},args,vars,body,evars,handler}).
+-record(icatch, {anno=#a{},body}).
+-record(ireceive1, {anno=#a{},clauses}).
+-record(ireceive2, {anno=#a{},clauses,timeout,action}).
+-record(isearch1, {anno=#a{},clauses}).
+-record(isearch2, {anno=#a{},clauses,timeout,action}).
+-record(iprotect, {anno=#a{},body}).
+-record(ibinary, {anno=#a{},segments}).		%Not used in patterns.
+
+-record(core, {vcount=0,			%Variable counter
+	       fcount=0,			%Function counter
+	       in_guard=false,			%In guard or not.
+	       opts,				%Options.
+	       es=[],				%Errors.
+	       ws=[],				%Warnings.
+               file=[{file,""}]}).              %File
+
+module({Mod,Exp,Forms}, Opts) ->
+    Cexp = map(fun ({N,A}) -> #c_fname{id=N,arity=A} end, Exp),
+    {Kfs0,As0,Es,Ws,_File} = foldl(fun (F, Acc) ->
+					form(F, Acc, Opts)
+				end, {[],[],[],[],[]}, Forms),
+    Kfs = reverse(Kfs0),
+    As = reverse(As0),
+    case Es of
+	[] ->
+	    {ok,#c_module{name=#c_literal{val=Mod},exports=Cexp,attrs=As,defs=Kfs},Ws};
+	_ ->
+	    {error,Es,Ws}
+    end.
+
+form({function,_,_,_,_}=F0, {Fs,As,Es0,Ws0,File}, Opts) ->
+    {F,Es,Ws} = function(F0, Es0, Ws0, File, Opts),
+    {[F|Fs],As,Es,Ws,File};
+form({attribute,_,file,{File,_Line}}, {Fs,As,Es,Ws,_}, _Opts) ->
+    {Fs,As,Es,Ws,File};
+form({attribute,_,_,_}=F, {Fs,As,Es,Ws,File}, _Opts) ->
+    {Fs,[attribute(F)|As],Es,Ws,File}.
+
+attribute({attribute,_,Name,Val}) ->
+    {core_lib:make_literal(Name),core_lib:make_literal(Val)}.
+
+function({function,_,Name,Arity,Cs0}, Es0, Ws0, File, Opts) ->
+    %%ok = io:fwrite("~p - ", [{Name,Arity}]),
+    St0 = #core{vcount=0,opts=Opts,es=Es0,ws=Ws0,file=[{file,File}]},
+    {B0,St1} = body(Cs0, Name, Arity, St0),
+    %%ok = io:fwrite("1", []),
+    %%ok = io:fwrite("~w:~p~n", [?LINE,B0]),
+    {B1,St2} = ubody(B0, St1),
+    %%ok = io:fwrite("2", []),
+    %%ok = io:fwrite("~w:~p~n", [?LINE,B1]),
+    {B2,#core{es=Es,ws=Ws}} = cbody(B1, St2),
+    %%ok = io:fwrite("3~n", []),
+    %%ok = io:fwrite("~w:~p~n", [?LINE,B2]),
+    {{#c_fname{id=Name,arity=Arity},B2},Es,Ws}.
+
+body(Cs0, Name, Arity, St0) ->
+    Anno = lineno_anno(element(2, hd(Cs0)), St0),
+    {Args,St1} = new_vars(Anno, Arity, St0),
+    {Cs1,St2} = clauses(Cs0, St1),
+    {Ps,St3} = new_vars(Arity, St2),    %Need new variables here
+    Fc = function_clause(Ps, {Name,Arity}),
+    {#ifun{anno=#a{anno=Anno},id=[],vars=Args,clauses=Cs1,fc=Fc},St3}.
+
+%% clause(Clause, State) -> {Cclause,State} | noclause.
+%% clauses([Clause], State) -> {[Cclause],State}.
+%%  Convert clauses.  Trap bad pattern aliases and remove clause from
+%%  clause list.
+
+clauses([C0|Cs0], St0) ->
+    case clause(C0, St0) of
+	{noclause,St} -> clauses(Cs0, St);
+	{C,St1} ->
+	    {Cs,St2} = clauses(Cs0, St1),
+	    {[C|Cs],St2}
+    end;
+clauses([], St) -> {[],St}.
+
+clause({clause,Lc,H0,G0,B0}, St0) ->
+    try head(H0, St0) of
+	H1 ->
+	    {G1,St1} = guard(G0, St0),
+	    {B1,St2} = exprs(B0, St1),
+            Anno = lineno_anno(Lc, St2),
+	    {#iclause{anno=#a{anno=Anno},pats=H1,guard=G1,body=B1},St2}
+    catch
+	throw:nomatch ->
+	    St = add_warning(Lc, nomatch, St0),
+	    {noclause,St};			%Bad pattern
+	throw:no_binaries ->
+	    St = add_error(Lc, no_binaries, St0),
+	    {noclause,St}
+    end.
+
+clause_arity({clause,_,H0,_,_}) -> length(H0).
+
+%% head([P], State) -> [P].
+
+head(Ps, St) -> pattern_list(Ps, St).
+
+%% guard([Expr], State) -> {[Cexpr],State}.
+%%  Build an explict and/or tree of guard alternatives, then traverse
+%%  top-level and/or tree and "protect" inner tests.
+
+guard([], St) -> {[],St};
+guard(Gs0, St0) ->
+    Gs1 = foldr(fun (Gt0, Rhs) ->
+			Gt1 = guard_tests(Gt0),
+			L = element(2, Gt1),
+			{op,L,'or',Gt1,Rhs}
+		end, guard_tests(last(Gs0)), first(Gs0)),
+    {Gs,St} = gexpr_top(Gs1, St0#core{in_guard=true}),
+    {Gs,St#core{in_guard=false}}.
+    
+guard_tests(Gs) ->
+    L = element(2, hd(Gs)),
+    {protect,L,foldr(fun (G, Rhs) -> {op,L,'and',G,Rhs} end, last(Gs), first(Gs))}.
+
+%% gexpr_top(Expr, State) -> {Cexpr,State}.
+%%  Generate an internal core expression of a guard test.  Explicitly
+%%  handle outer boolean expressions and "protect" inner tests in a
+%%  reasonably smart way.
+
+gexpr_top(E0, St0) ->
+    {E1,Eps0,Bools,St1} = gexpr(E0, [], St0),
+    {E,Eps,St} = force_booleans(Bools, E1, Eps0, St1),
+    {Eps++[E],St}.
+
+%% gexpr(Expr, Bools, State) -> {Cexpr,[PreExp],Bools,State}.
+%%  Generate an internal core expression of a guard test.
+
+gexpr({protect,Line,Arg}, Bools0, St0) ->
+    case gexpr(Arg, [], St0) of
+	{E0,[],Bools,St1} ->
+	    {E,Eps,St} = force_booleans(Bools, E0, [], St1),
+	    {E,Eps,Bools0,St};
+	{E0,Eps0,Bools,St1} ->
+	    {E,Eps,St} = force_booleans(Bools, E0, Eps0, St1),
+            Anno = lineno_anno(Line, St),
+	    {#iprotect{anno=#a{anno=Anno},body=Eps++[E]},[],Bools0,St}
+    end;
+gexpr({op,L,'andalso',E1,E2}, Bools, St0) ->
+    {#c_var{name=V0},St} = new_var(L, St0),
+    V = {var,L,V0},
+    False = {atom,L,false},
+    E = make_bool_switch_guard(L, E1, V,
+			       make_bool_switch_guard(L, E2, V,
+						      {atom,L,true}, False),
+			       False),
+    gexpr(E, Bools, St);
+gexpr({op,L,'orelse',E1,E2}, Bools, St0) ->
+    {#c_var{name=V0},St} = new_var(L, St0),
+    V = {var,L,V0},
+    True = {atom,L,true},
+    E = make_bool_switch_guard(L, E1, V, True,
+			       make_bool_switch_guard(L, E2, V,
+						     True, {atom,L,false})),
+    gexpr(E, Bools, St);
+gexpr({op,Line,Op,L,R}=Call, Bools0, St0) ->
+    case erl_internal:bool_op(Op, 2) of
+	true ->
+	    {Le,Lps,Bools1,St1} = gexpr(L, Bools0, St0),
+	    {Ll,Llps,St2} = force_safe(Le, St1),
+	    {Re,Rps,Bools,St3} = gexpr(R, Bools1, St2),
+	    {Rl,Rlps,St4} = force_safe(Re, St3),
+	    Anno = lineno_anno(Line, St4),
+	    {#icall{anno=#a{anno=Anno},	%Must have an #a{}
+		    module=#c_literal{anno=Anno,val=erlang},
+		    name=#c_literal{anno=Anno,val=Op},
+		    args=[Ll,Rl]},Lps ++ Llps ++ Rps ++ Rlps,Bools,St4};
+	false ->
+	    gexpr_test(Call, Bools0, St0)
+    end;
+gexpr({op,Line,Op,A}=Call, Bools0, St0) ->
+    case erl_internal:bool_op(Op, 1) of
+	true ->
+	    {Ae,Aps,Bools,St1} = gexpr(A, Bools0, St0),
+	    {Al,Alps,St2} = force_safe(Ae, St1),
+	    Anno = lineno_anno(Line, St2),
+	    {#icall{anno=#a{anno=Anno},	%Must have an #a{}
+		    module=#c_literal{anno=Anno,val=erlang},
+		    name=#c_literal{anno=Anno,val=Op},
+		    args=[Al]},Aps ++ Alps,Bools,St2};
+	false ->
+	    gexpr_test(Call, Bools0, St0)
+    end;
+gexpr(E0, Bools, St0) ->
+    gexpr_test(E0, Bools, St0).
+
+%% gexpr_test(Expr, Bools, State) -> {Cexpr,[PreExp],Bools,State}.
+%%  Generate a guard test.  At this stage we must be sure that we have
+%%  a proper boolean value here so wrap things with an true test if we
+%%  don't know, i.e. if it is not a comparison or a type test.
+
+gexpr_test({atom,L,true}, Bools, St0) ->
+    {#c_literal{anno=lineno_anno(L, St0),val=true},[],Bools,St0};
+gexpr_test({atom,L,false}, Bools, St0) ->
+    {#c_literal{anno=lineno_anno(L, St0),val=false},[],Bools,St0};
+gexpr_test(E0, Bools0, St0) ->
+    {E1,Eps0,St1} = expr(E0, St0),
+    %% Generate "top-level" test and argument calls.
+    case E1 of
+	#icall{anno=Anno,module=#c_literal{val=erlang},name=#c_literal{val=N},args=As} ->
+	    Ar = length(As),
+	    case erl_internal:type_test(N, Ar) orelse
+		erl_internal:comp_op(N, Ar) of
+		true -> {E1,Eps0,Bools0,St1};
+		false ->
+		    Lanno = Anno#a.anno,
+		    {New,St2} = new_var(Lanno, St1),
+		    Bools = [New|Bools0],
+		    {#icall{anno=Anno,	%Must have an #a{}
+			    module=#c_literal{anno=Lanno,val=erlang},
+			    name=#c_literal{anno=Lanno,val='=:='},
+			    args=[New,#c_literal{anno=Lanno,val=true}]},
+		     Eps0 ++ [#iset{anno=Anno,var=New,arg=E1}],Bools,St2}
+	    end;
+	_ ->
+	    Anno = get_ianno(E1),
+	    Lanno = get_lineno_anno(E1),
+	    case core_lib:is_simple(E1) of
+		true ->
+		    Bools = [E1|Bools0],
+		    {#icall{anno=Anno,	%Must have an #a{}
+			    module=#c_literal{anno=Lanno,val=erlang},
+			    name=#c_literal{anno=Lanno,val='=:='},
+			    args=[E1,#c_literal{anno=Lanno,val=true}]},Eps0,Bools,St1};
+		false ->
+		    {New,St2} = new_var(Lanno, St1),
+		    Bools = [New|Bools0],
+		    {#icall{anno=Anno,	%Must have an #a{}
+			    module=#c_literal{anno=Lanno,val=erlang},
+			    name=#c_literal{anno=Lanno,val='=:='},
+			    args=[New,#c_literal{anno=Lanno,val=true}]},
+		     Eps0 ++ [#iset{anno=Anno,var=New,arg=E1}],Bools,St2}
+	    end
+    end.
+
+force_booleans([], E, Eps, St) ->
+    {E,Eps,St};
+force_booleans([V|Vs], E0, Eps0, St0) ->
+    {E1,Eps1,St1} = force_safe(E0, St0),
+    Lanno = element(2, V),
+    Anno = #a{anno=Lanno},
+    Call = #icall{anno=Anno,module=#c_literal{anno=Lanno,val=erlang},
+		  name=#c_literal{anno=Lanno,val=is_boolean},
+		  args=[V]},
+    {New,St} = new_var(Lanno, St1),
+    Iset = #iset{anno=Anno,var=New,arg=Call},
+    Eps = Eps0 ++ Eps1 ++ [Iset],
+    E = #icall{anno=Anno,
+	       module=#c_literal{anno=Lanno,val=erlang},name=#c_literal{anno=Lanno,val='and'},
+	       args=[E1,New]},
+    force_booleans(Vs, E, Eps, St).
+
+%% exprs([Expr], State) -> {[Cexpr],State}.
+%%  Flatten top-level exprs.
+
+exprs([E0|Es0], St0) ->
+    {E1,Eps,St1} = expr(E0, St0),
+    {Es1,St2} = exprs(Es0, St1),
+    {Eps ++ [E1] ++ Es1,St2};
+exprs([], St) -> {[],St}.
+
+%% expr(Expr, State) -> {Cexpr,[PreExp],State}.
+%%  Generate an internal core expression.
+
+expr({var,L,V}, St) -> {#c_var{anno=lineno_anno(L, St),name=V},[],St};
+expr({char,L,C}, St) -> {#c_literal{anno=lineno_anno(L, St),val=C},[],St};
+expr({integer,L,I}, St) -> {#c_literal{anno=lineno_anno(L, St),val=I},[],St};
+expr({float,L,F}, St) -> {#c_literal{anno=lineno_anno(L, St),val=F},[],St};
+expr({atom,L,A}, St) -> {#c_literal{anno=lineno_anno(L, St),val=A},[],St};
+expr({nil,L}, St) -> {#c_literal{anno=lineno_anno(L, St),val=[]},[],St};
+expr({string,L,S}, St) -> {#c_literal{anno=lineno_anno(L, St),val=S},[],St};
+expr({cons,L,H0,T0}, St0) ->
+    {H1,Hps,St1} = safe(H0, St0),
+    {T1,Tps,St2} = safe(T0, St1),
+    A = lineno_anno(L, St2),
+    case {H1,T1,Hps,Tps} of
+	{#c_literal{val=H2},#c_literal{val=T2},[],[]} ->
+	    {#c_literal{anno=A,val=[H2|T2]},[],St2};
+	_ ->
+	    {#c_cons{anno=A,hd=H1,tl=T1},Hps ++ Tps,St2}
+    end;
+expr({lc,L,E,Qs}, St) ->
+    lc_tq(L, E, Qs, #c_literal{anno=lineno_anno(L, St),val=[]}, St);
+expr({bc,L,E,Qs}, St) ->
+    bc_tq(L, E, Qs, {nil,L}, St);
+expr({tuple,L,Es0}, St0) ->
+    {Es1,Eps,St1} = safe_list(Es0, St0),
+    A = lineno_anno(L, St1),
+    case Eps =:= [] andalso lists:all(fun(#c_literal{}) -> true;
+					 (_) -> false end, Es1) of
+	true ->
+	    Tuple = list_to_tuple([V || #c_literal{val=V} <- Es1]),
+	    {#c_literal{anno=A,val=Tuple},[],St1};
+	false ->
+	    {#c_tuple{anno=A,es=Es1},Eps,St1}
+    end;
+expr({bin,L,Es0}, #core{opts=Opts}=St0) ->
+    St1 = case member(no_binaries, Opts) of
+	      false -> St0;
+	      true -> add_error(L, no_binaries, St0)
+	  end,
+    try expr_bin(Es0, lineno_anno(L, St1), St1) of
+	{_,_,_}=Res -> Res
+    catch
+	throw:bad_binary ->
+	    St2 = add_warning(L, bad_binary, St1),
+	    LineAnno = lineno_anno(L, St2),
+	    As = [#c_literal{anno=LineAnno,val=badarg}],
+	    {#icall{anno=#a{anno=LineAnno},	%Must have an #a{}
+		    module=#c_literal{anno=LineAnno,val=erlang},
+		    name=#c_literal{anno=LineAnno,val=error},
+		    args=As},[],St2}
+    end;
+expr({block,_,Es0}, St0) ->
+    %% Inline the block directly.
+    {Es1,St1} = exprs(first(Es0), St0),
+    {E1,Eps,St2} = expr(last(Es0), St1),
+    {E1,Es1 ++ Eps,St2};
+expr({'if',L,Cs0}, St0) ->
+    {Cs1,St1} = clauses(Cs0, St0),
+    Fc = fail_clause([], #c_literal{val=if_clause}),
+    Lanno = lineno_anno(L, St1),
+    {#icase{anno=#a{anno=Lanno},args=[],clauses=Cs1,fc=Fc},[],St1};
+expr({'case',L,E0,Cs0}, St0) ->
+    {E1,Eps,St1} = novars(E0, St0),
+    {Cs1,St2} = clauses(Cs0, St1),
+    {Fpat,St3} = new_var(St2),
+    Fc = fail_clause([Fpat], #c_tuple{es=[#c_literal{val=case_clause},Fpat]}),
+    Lanno = lineno_anno(L, St3),
+    {#icase{anno=#a{anno=Lanno},args=[E1],clauses=Cs1,fc=Fc},Eps,St3};
+expr({'receive',L,Cs0}, St0) ->
+    {Cs1,St1} = clauses(Cs0, St0),
+    {#ireceive1{anno=#a{anno=lineno_anno(L, St1)},clauses=Cs1}, [], St1};
+expr({'receive',L,Cs0,Te0,Tes0}, St0) ->
+    {Te1,Teps,St1} = novars(Te0, St0),
+    {Tes1,St2} = exprs(Tes0, St1),
+    {Cs1,St3} = clauses(Cs0, St2),
+    {#ireceive2{anno=#a{anno=lineno_anno(L, St3)},
+		clauses=Cs1,timeout=Te1,action=Tes1},Teps,St3};
+expr({'search',L,Cs0}, St0) ->
+    {Cs1,St1} = clauses(Cs0, St0),
+    {#isearch1{anno=#a{anno=lineno_anno(L, St1)},clauses=Cs1}, [], St1};
+expr({'search',L,Cs0,Te0,Tes0}, St0) ->
+    {Te1,Teps,St1} = novars(Te0, St0),
+    {Tes1,St2} = exprs(Tes0, St1),
+    {Cs1,St3} = clauses(Cs0, St2),
+    {#isearch2{anno=#a{anno=lineno_anno(L, St3)},
+		clauses=Cs1,timeout=Te1,action=Tes1},Teps,St3};
+expr({'try',L,Es0,[],Ecs,[]}, St0) ->
+    %% 'try ... catch ... end'
+    {Es1,St1} = exprs(Es0, St0),
+    {V,St2} = new_var(St1),		%This name should be arbitrary
+    {Evs,Hs,St3} = try_exception(Ecs, St2),
+    Lanno = lineno_anno(L, St3),
+    {#itry{anno=#a{anno=Lanno},args=Es1,vars=[V],body=[V],
+	   evars=Evs,handler=Hs},
+     [],St3};
+expr({'try',L,Es0,Cs0,Ecs,[]}, St0) ->
+    %% 'try ... of ... catch ... end'
+    {Es1,St1} = exprs(Es0, St0),
+    {V,St2} = new_var(St1),		%This name should be arbitrary
+    {Cs1,St3} = clauses(Cs0, St2),
+    {Fpat,St4} = new_var(St3),
+    Fc = fail_clause([Fpat], #c_tuple{es=[#c_literal{val=try_clause},Fpat]}),
+    {Evs,Hs,St5} = try_exception(Ecs, St4),
+    Lanno = lineno_anno(L, St1),
+    {#itry{anno=#a{anno=lineno_anno(L, St5)},args=Es1,
+	   vars=[V],body=[#icase{anno=#a{anno=Lanno},args=[V],clauses=Cs1,fc=Fc}],
+	   evars=Evs,handler=Hs},
+     [],St5};
+expr({'try',L,Es0,[],[],As0}, St0) ->
+    %% 'try ... after ... end'
+    {Es1,St1} = exprs(Es0, St0),
+    {As1,St2} = exprs(As0, St1),
+    {Evs,Hs0,St3} = try_after(As1,St2),
+    %% We must kill the id for any funs in the duplicated after body,
+    %% to avoid getting two local functions having the same name.
+    Hs = kill_id_anns(Hs0),
+    {V,St4} = new_var(St3),		% (must not exist in As1)
+    %% TODO: this duplicates the 'after'-code; should lift to function.
+    Lanno = lineno_anno(L, St4),
+    {#itry{anno=#a{anno=Lanno},args=Es1,vars=[V],body=As1++[V],
+	   evars=Evs,handler=Hs},
+     [],St4};
+expr({'try',L,Es,Cs,Ecs,As}, St0) ->
+    %% 'try ... [of ...] [catch ...] after ... end'
+    expr({'try',L,[{'try',L,Es,Cs,Ecs,[]}],[],[],As}, St0);
+expr({'catch',L,E0}, St0) ->
+    {E1,Eps,St1} = expr(E0, St0),
+    Lanno = lineno_anno(L, St1),
+    {#icatch{anno=#a{anno=Lanno},body=Eps ++ [E1]},[],St1};
+expr({'fun',L,{function,F,A},{_,_,_}=Id}, St) ->
+    Lanno = lineno_anno(L, St),
+    {#c_fname{anno=Lanno++[{id,Id}],id=F,arity=A},[],St};
+expr({'fun',L,{clauses,Cs},Id}, St) ->
+    fun_tq(Id, Cs, L, St);
+expr({call,L,{remote,_,M,F},As0}, St0) ->
+    {[M1,F1|As1],Aps,St1} = safe_list([M,F|As0], St0),
+    Lanno = lineno_anno(L, St1),
+    {#icall{anno=#a{anno=Lanno},module=M1,name=F1,args=As1},Aps,St1};
+expr({call,Lc,{atom,Lf,F},As0}, St0) ->
+    {As1,Aps,St1} = safe_list(As0, St0),
+    Op = #c_fname{anno=lineno_anno(Lf, St1),id=F,arity=length(As1)},
+    {#iapply{anno=#a{anno=lineno_anno(Lc, St1)},op=Op,args=As1},Aps,St1};
+expr({call,L,FunExp,As0}, St0) ->
+    {Fun,Fps,St1} = safe(FunExp, St0),
+    {As1,Aps,St2} = safe_list(As0, St1),
+    Lanno = lineno_anno(L, St2),
+    {#iapply{anno=#a{anno=Lanno},op=Fun,args=As1},Fps ++ Aps,St2};
+expr({match,L,P0,E0}, St0) ->
+    %% First fold matches together to create aliases.
+    {P1,E1} = fold_match(E0, P0),
+    {E2,Eps,St1} = novars(E1, St0),
+    P2 = try
+	     pattern(P1, St1)
+	 catch
+	     throw:Thrown ->
+		 Thrown
+	 end,
+    {Fpat,St2} = new_var(St1),
+    Fc = fail_clause([Fpat], #c_tuple{es=[#c_literal{val=badmatch},Fpat]}),
+    Lanno = lineno_anno(L, St2),
+    case P2 of
+	nomatch ->
+	    St = add_warning(L, nomatch, St2),
+	    {#icase{anno=#a{anno=Lanno},
+		    args=[E2],clauses=[],fc=Fc},Eps,St};
+	no_binaries ->
+	    St = add_error(L, no_binaries, St2),
+	    {#icase{anno=#a{anno=Lanno},
+		    args=[E2],clauses=[],fc=Fc},Eps,St};
+	Other when not is_atom(Other) ->
+	    {#imatch{anno=#a{anno=Lanno},pat=P2,arg=E2,fc=Fc},Eps,St2}
+    end;
+expr({op,_,'++',{lc,Llc,E,Qs},More}, St0) ->
+    %% Optimise '++' here because of the list comprehension algorithm.
+    %%
+    %% To avoid achieving quadratic complexity if there is a chain of
+    %% list comprehensions without generators combined with '++', force
+    %% evaluation of More now. Evaluating More here could also reduce the
+    %% number variables in the environment for letrec.
+    {Mc,Mps,St1} = safe(More, St0),
+    {Y,Yps,St} = lc_tq(Llc, E, Qs, Mc, St1),
+    {Y,Mps++Yps,St};
+expr({op,L,'andalso',E1,E2}, St0) ->
+    {#c_var{name=V0},St} = new_var(L, St0),
+    V = {var,L,V0},
+    False = {atom,L,false},
+    E = make_bool_switch(L, E1, V,
+			 make_bool_switch(L, E2, V,
+					  {atom,L,true}, False, St0),
+			 False, St0),
+    expr(E, St);
+expr({op,L,'orelse',E1,E2}, St0) ->
+    {#c_var{name=V0},St} = new_var(L, St0),
+    V = {var,L,V0},
+    True = {atom,L,true},
+    E = make_bool_switch(L, E1, V, True,
+			 make_bool_switch(L, E2, V,
+					  True, {atom,L,false}, St0), St0),
+    expr(E, St);
+expr({op,L,Op,A0}, St0) ->
+    {A1,Aps,St1} = safe(A0, St0),
+    LineAnno = lineno_anno(L, St1),
+    {#icall{anno=#a{anno=LineAnno},		%Must have an #a{}
+	    module=#c_literal{anno=LineAnno,val=erlang},
+	    name=#c_literal{anno=LineAnno,val=Op},args=[A1]},Aps,St1};
+expr({op,L,Op,L0,R0}, St0) ->
+    {As,Aps,St1} = safe_list([L0,R0], St0),
+    LineAnno = lineno_anno(L, St1),
+    {#icall{anno=#a{anno=LineAnno},		%Must have an #a{}
+	    module=#c_literal{anno=LineAnno,val=erlang},
+	    name=#c_literal{anno=LineAnno,val=Op},args=As},Aps,St1}.
+
+make_bool_switch(L, E, V, T, F, #core{in_guard=true}) ->
+    make_bool_switch_guard(L, E, V, T, F);
+make_bool_switch(L, E, V, T, F, #core{}) ->
+    make_bool_switch_body(L, E, V, T, F).
+
+make_bool_switch_body(L, E, V, T, F) ->
+    NegL = -abs(L),
+    Error = {tuple,NegL,[{atom,NegL,badarg},V]},
+    {'case',NegL,E,
+     [{clause,NegL,[{atom,NegL,true}],[],[T]},
+      {clause,NegL,[{atom,NegL,false}],[],[F]},
+      {clause,NegL,[V],[],
+       [{call,NegL,{remote,NegL,{atom,NegL,erlang},{atom,NegL,error}},
+	 [Error]}]}]}.
+
+make_bool_switch_guard(_, E, _, {atom,_,true}, {atom,_,false}) -> E;
+make_bool_switch_guard(L, E, V, T, F) ->
+    NegL = -abs(L),
+    {'case',NegL,E,
+     [{clause,NegL,[{atom,NegL,true}],[],[T]},
+      {clause,NegL,[{atom,NegL,false}],[],[F]},
+      {clause,NegL,[V],[],[V]}
+     ]}.
+
+
+%% try_exception([ExcpClause], St) -> {[ExcpVar],Handler,St}.
+
+try_exception(Ecs0, St0) ->
+    %% Note that Tag is not needed for rethrow - it is already in Info.
+    {Evs,St1} = new_vars(3, St0), % Tag, Value, Info
+    {Ecs1,St2} = clauses(Ecs0, St1),
+    [_,Value,Info] = Evs,
+    Ec = #iclause{anno=#a{anno=[compiler_generated]},
+		  pats=[#c_tuple{es=Evs}],guard=[#c_literal{val=true}],
+		  body=[#iprimop{anno=#a{},       %Must have an #a{}
+				 name=#c_literal{val=raise},
+				 args=[Info,Value]}]},
+    Hs = [#icase{anno=#a{},args=[#c_tuple{es=Evs}],clauses=Ecs1,fc=Ec}],
+    {Evs,Hs,St2}.
+
+try_after(As, St0) ->
+    %% See above.
+    {Evs,St1} = new_vars(3, St0), % Tag, Value, Info
+    [_,Value,Info] = Evs,
+    B = As ++ [#iprimop{anno=#a{},       %Must have an #a{}
+			 name=#c_literal{val=raise},
+			 args=[Info,Value]}],
+    Ec = #iclause{anno=#a{anno=[compiler_generated]},
+		  pats=[#c_tuple{es=Evs}],guard=[#c_literal{val=true}],
+		  body=B},
+    Hs = [#icase{anno=#a{},args=[#c_tuple{es=Evs}],clauses=[],fc=Ec}],
+    {Evs,Hs,St1}.
+
+%% expr_bin([ArgExpr], St) -> {[Arg],[PreExpr],St}.
+%%  Flatten the arguments of a bin. Do this straight left to right!
+%%  Note that ibinary needs to have its annotation wrapped in a #a{}
+%%  record whereas c_literal should not have a wrapped annotation
+ 
+expr_bin(Es0, Anno, St0) ->
+    case constant_bin(Es0) of
+	error ->
+	    {Es,Eps,St} = expr_bin_1(Es0, St0),
+	    {#ibinary{anno=#a{anno=Anno},segments=Es},Eps,St};
+	Bin ->
+	    {#c_literal{anno=Anno,val=Bin},[],St0}
+    end.
+
+%% constant_bin([{bin_element,_,_,_,_}]) -> binary() | error
+%%  If the binary construction is truly constant (no variables,
+%%  no native fields), and does not contain fields whose expansion
+%%  become huge (such as <<0:100000000>>), evaluate and return the binary;
+%%  otherwise return 'error'.
+
+constant_bin(Es) ->
+    try
+	constant_bin_1(Es)
+    catch
+	error -> error
+    end.
+
+constant_bin_1(Es) ->
+    verify_suitable_fields(Es),
+    EmptyBindings = erl_eval:new_bindings(),
+    EvalFun = fun({integer,_,I}, B) -> {value,I,B};
+		 ({char,_,C}, B) -> {value,C,B};
+		 ({float,_,F}, B) -> {value,F,B};
+		 ({atom,_,undefined}, B) -> {value,undefined,B}
+	      end,
+    case eval_bits:expr_grp(Es, EmptyBindings, EvalFun) of
+	{value,Bin,EmptyBindings} ->
+	    Bin;
+	_ ->
+	    error
+    end.
+
+%% verify_suitable_fields([{bin_element,_,Sz,Opts}=E|Es]) ->
+    
+verify_suitable_fields([{bin_element,_,Val,SzTerm,Opts}|Es]) ->
+    case member(big, Opts) orelse member(little, Opts) of
+	true -> ok;
+	false -> throw(error)			%Native endian.
+    end,
+    {value,{unit,Unit}} = keysearch(unit, 1, Opts),
+    case {SzTerm,Val} of
+	{{atom,_,undefined},{char,_,_}} ->
+	    %% UTF-8/16/32.
+	    ok;
+	{{atom,_,undefined},{integer,_,_}} ->
+	    %% UTF-8/16/32.
+	    ok;
+	{{integer,_,Sz},_} when Sz*Unit =< 256 ->
+	    %% Don't be cheap - always accept fields up to this size.
+	    ok;
+	{{integer,_,Sz0},{integer,_,Int}} ->
+	    %% Estimate the number of bits needed to to hold the integer
+	    %% literal. Check whether the field size is reasonable in
+	    %% proportion to the number of bits needed.
+	    Sz = Sz0*Unit,
+	    case count_bits(Int) of
+		BitsNeeded when 2*BitsNeeded >= Sz ->
+		    ok;
+		_ ->
+		    %% More than about half of the field size will be
+		    %% filled out with zeroes - not acceptable.
+		    throw(error)
+	    end;
+	{_,_} ->
+	    %% Reject anything else. There are either variables,
+	    %% or a float with a huge size or an embedded binary.
+	    throw(error)
+    end,
+    verify_suitable_fields(Es);
+verify_suitable_fields([]) -> ok.
+
+%% Count the number of bits approximately needed to store Int.
+%% (We don't need an exact result for this purpose.)
+
+count_bits(Int) -> 
+    count_bits_1(abs(Int), 64).
+
+count_bits_1(0, Bits) -> Bits;
+count_bits_1(Int, Bits) -> count_bits_1(Int bsr 64, Bits+64).
+
+expr_bin_1(Es, St) ->
+    foldr(fun (E, {Ces,Esp,St0}) ->
+		  {Ce,Ep,St1} = bitstr(E, St0),
+		  {[Ce|Ces],Ep ++ Esp,St1}
+	  end, {[],[],St}, Es).
+
+bitstr({bin_element,_,E0,Size0,[Type,{unit,Unit}|Flags]}, St0) ->
+    {E1,Eps,St1} = safe(E0, St0),
+    {Size1,Eps2,St2} = safe(Size0, St1),
+    case {Type,E1} of
+	{_,#c_var{}} -> ok;
+	{integer,#c_literal{val=I}} when is_integer(I) -> ok;
+	{utf8,#c_literal{val=I}} when is_integer(I) -> ok;
+	{utf16,#c_literal{val=I}} when is_integer(I) -> ok;
+	{utf32,#c_literal{val=I}} when is_integer(I) -> ok;
+	{float,#c_literal{val=V}} when is_number(V) -> ok;
+	{binary,#c_literal{val=V}} when is_bitstring(V) -> ok;
+	{_,_} ->
+	    throw(bad_binary)
+    end,
+    {#c_bitstr{val=E1,size=Size1,
+	       unit=core_lib:make_literal(Unit),
+	       type=core_lib:make_literal(Type),
+	       flags=core_lib:make_literal(Flags)},
+     Eps ++ Eps2,St2}.
+
+%% fun_tq(Id, [Clauses], Line, State) -> {Fun,[PreExp],State}.
+
+fun_tq({_,_,Name}=Id, Cs0, L, St0) ->
+    Arity = clause_arity(hd(Cs0)),
+    {Cs1,St1} = clauses(Cs0, St0),
+    {Args,St2} = new_vars(Arity, St1),
+    {Ps,St3} = new_vars(Arity, St2),		%Need new variables here
+    Fc = function_clause(Ps, {Name,Arity}),
+    Fun = #ifun{anno=#a{anno=lineno_anno(L, St3)},
+		id=[{id,Id}],				%We KNOW!
+		vars=Args,clauses=Cs1,fc=Fc},
+    {Fun,[],St3}.
+
+%% lc_tq(Line, Exp, [Qualifier], Mc, State) -> {LetRec,[PreExp],State}.
+%%  This TQ from Simon PJ pp 127-138.  
+%%  This gets a bit messy as we must transform all directly here.  We
+%%  recognise guard tests and try to fold them together and join to a
+%%  preceding generators, this should give us better and more compact
+%%  code.
+
+lc_tq(Line, E, [{generate,Lg,P,G}|Qs0], Mc, St0) ->
+    {Gs,Qs1} =  splitwith(fun is_guard_test/1, Qs0),
+    {Name,St1} = new_fun_name("lc", St0),
+    {Head,St2} = new_var(St1),
+    {Tname,St3} = new_var_name(St2),
+    LA = lineno_anno(Line, St2),
+    LAnno = #a{anno=LA},
+    Tail = #c_var{anno=LA,name=Tname},
+    {Arg,St4} = new_var(St3),
+    {Nc,[],St5} = expr({call,Lg,{atom,Lg,Name},[{var,Lg,Tname}]}, St4),
+    {Guardc,St6} = lc_guard_tests(Gs, St5),	%These are always flat!
+    {Lc,Lps,St7} = lc_tq(Line, E, Qs1, Nc, St6),
+    {Pc,St8} = list_gen_pattern(P, Line, St7),
+    {Gc,Gps,St9} = safe(G, St8),		%Will be a function argument!
+    Fc = function_clause([Arg], LA, {Name,1}),
+
+    %% Avoid constructing a default clause if the list comprehension
+    %% only has a variable as generator and there are no guard
+    %% tests. In other words, if the comprehension is equivalent to
+    %% lists:map/2.
+    case {Guardc, Pc} of
+	{[], #c_var{}} ->
+	    Cs0 = [#iclause{anno=LAnno,
+			    pats=[#c_literal{anno=LA,val=[]}],guard=[],
+			    body=[Mc]}];
+	_ ->
+	    Cs0 = [#iclause{anno=#a{anno=[compiler_generated|LA]},
+			    pats=[#c_cons{anno=LA,hd=Head,tl=Tail}],
+			    guard=[],
+			    body=[Nc]},
+		   #iclause{anno=LAnno,
+			    pats=[#c_literal{anno=LA,val=[]}],guard=[],
+			    body=[Mc]}]
+    end,
+    Cs = case Pc of
+	     nomatch -> Cs0;
+	     _ ->
+		 [#iclause{anno=LAnno,
+			   pats=[#c_cons{anno=LA,hd=Pc,tl=Tail}],
+			   guard=Guardc,
+			   body=Lps ++ [Lc]}|Cs0]
+	 end,
+    Fun = #ifun{anno=LAnno,id=[],vars=[Arg],clauses=Cs,fc=Fc},
+    {#iletrec{anno=LAnno,defs=[{{Name,1},Fun}],
+	      body=Gps ++ [#iapply{anno=LAnno,
+				   op=#c_fname{anno=LA,id=Name,arity=1},
+				   args=[Gc]}]},
+     [],St9};
+lc_tq(Line, E, [{b_generate,Lg,P,G}|Qs0], Mc, St0) ->
+    {Gs,Qs1} =  splitwith(fun is_guard_test/1, Qs0),
+    {Name,St1} = new_fun_name("blc", St0),
+    {Tname,St2} = new_var_name(St1),
+    LA = lineno_anno(Line, St2),
+    LAnno = #a{anno=LA},
+    HeadBinPattern = pattern(P,St2),
+    #c_binary{segments=Ps} = HeadBinPattern,
+    {EPs,St3} = emasculate_segments(Ps,St2),
+    Tail = #c_var{anno=LA,name=Tname},
+    TailSegment = #c_bitstr{val=Tail,size=core_lib:make_literal(all),
+			    unit=core_lib:make_literal(1),
+			    type=core_lib:make_literal(binary),
+			    flags=core_lib:make_literal([big,unsigned])},
+    Pattern = HeadBinPattern#c_binary{segments=Ps ++ [TailSegment]},
+    EPattern = HeadBinPattern#c_binary{segments=EPs ++ [TailSegment]},
+    {Arg,St4} = new_var(St3),
+    {Guardc,St5} = lc_guard_tests(Gs, St4),	%These are always flat!
+    {Nc,[],St6} = expr({call,Lg,{atom,Lg,Name},[{var,Lg,Tname}]}, St5),
+    {Bc,Bps,St7} = lc_tq(Line, E, Qs1, Nc, St6),
+    {Gc,Gps,St10} = safe(G, St7),		%Will be a function argument!
+    Fc = function_clause([Arg], LA, {Name,1}),
+    Cs = [#iclause{anno=#a{anno=[compiler_generated|LA]},
+		   pats=[Pattern],
+		   guard=Guardc,
+		   body=Bps ++ [Bc]},
+	  #iclause{anno=#a{anno=[compiler_generated|LA]},
+		   pats=[EPattern],
+		   guard=[],
+		   body=[#iapply{anno=LAnno,
+				 op=#c_fname{anno=LA,id=Name,arity=1},
+				 args=[Tail]}]},
+	  #iclause{anno=LAnno,
+		   pats=[#c_binary{anno=LA, segments=[TailSegment]}],guard=[],
+		   body=[Mc]}],
+    Fun = #ifun{anno=LAnno,id=[],vars=[Arg],clauses=Cs,fc=Fc},
+    {#iletrec{anno=LAnno,defs=[{{Name,1},Fun}],
+	      body=Gps ++ [#iapply{anno=LAnno,
+				   op=#c_fname{anno=LA,id=Name,arity=1},
+				   args=[Gc]}]},
+     [],St10};
+lc_tq(Line, E, [Fil0|Qs0], Mc, St0) ->
+    %% Special case sequences guard tests.
+    LA = lineno_anno(Line, St0),
+    LAnno = #a{anno=LA},
+    case is_guard_test(Fil0) of
+	true ->
+	    {Gs0,Qs1} = splitwith(fun is_guard_test/1, Qs0),
+	    {Lc,Lps,St1} = lc_tq(Line, E, Qs1, Mc, St0),
+	    {Gs,St2} = lc_guard_tests([Fil0|Gs0], St1), %These are always flat!
+	    {#icase{anno=LAnno,
+		    args=[],
+		    clauses=[#iclause{anno=LAnno,pats=[],
+				      guard=Gs,body=Lps ++ [Lc]}],
+		    fc=#iclause{anno=LAnno,pats=[],guard=[],body=[Mc]}},
+	     [],St2};
+	false ->
+	    {Lc,Lps,St1} = lc_tq(Line, E, Qs0, Mc, St0),
+	    {Fpat,St2} = new_var(St1),
+	    Fc = fail_clause([Fpat], #c_tuple{es=[#c_literal{val=case_clause},Fpat]}),
+	    %% Do a novars little optimisation here.
+	    {Filc,Fps,St3} = novars(Fil0, St2),
+	    {#icase{anno=LAnno,
+		    args=[Filc],
+		    clauses=[#iclause{anno=LAnno,
+				      pats=[#c_literal{anno=LA,val=true}],
+				      guard=[],
+				      body=Lps ++ [Lc]},
+			     #iclause{anno=LAnno,
+				      pats=[#c_literal{anno=LA,val=false}],
+				      guard=[],
+				      body=[Mc]}],
+		    fc=Fc},
+	     Fps,St3}
+    end;
+lc_tq(Line, E0, [], Mc0, St0) ->
+    {H1,Hps,St1} = safe(E0, St0),
+    {T1,Tps,St} = force_safe(Mc0, St1),
+    A = lineno_anno(Line, St),
+    {E,Pre} = case {H1,T1,Hps,Tps} of
+		  {#c_literal{val=H2},#c_literal{val=T2},[],[]} ->
+		      {#c_literal{anno=A,val=[H2|T2]},[]};
+		  _ ->
+		      {#c_cons{anno=A,hd=H1,tl=T1},Hps ++ Tps}
+	      end,
+    Anno = core_lib:get_anno(E),
+    {core_lib:set_anno(E, [compiler_generated|Anno]),Pre,St}.
+
+%% bc_tq(Line, Exp, [Qualifier], More, State) -> {LetRec,[PreExp],State}.
+%%  This TQ from Gustafsson ERLANG'05.  
+%%  This gets a bit messy as we must transform all directly here.  We
+%%  recognise guard tests and try to fold them together and join to a
+%%  preceding generators, this should give us better and more compact
+%%  code.
+%%  More could be transformed before calling bc_tq.
+
+bc_tq(Line, Exp, Qualifiers, _, St0) ->
+    {BinVar,St1} = new_var(St0),
+    {E,Pre,St} = bc_tq1(Line, Exp, Qualifiers, BinVar, St1),
+    InitAcc = #iset{var=BinVar,
+ 		    arg=#iprimop{name=#c_literal{val=bs_init_writable},
+				 args=[#c_literal{val=60*1024}]}},
+    {E,[InitAcc|Pre],St}.
+    
+
+bc_tq1(Line, E, [{generate,Lg,P,G}|Qs0], AccExpr, St0) ->
+    {Gs,Qs1} =  splitwith(fun is_guard_test/1, Qs0),
+    {Name,St1} = new_fun_name("lbc", St0),
+    LA = lineno_anno(Line, St1),
+    {[Head,Tail,AccVar],St2} = new_vars(LA, 3, St1),
+    LAnno = #a{anno=LA},
+    {Arg,St3} = new_var(St2),
+    NewMore = {call,Lg,{atom,Lg,Name},[{var,Lg,Tail#c_var.name},
+				       {var,Lg,AccVar#c_var.name}]},
+    {Guardc,St4} = lc_guard_tests(Gs, St3),	%These are always flat!
+    {Lc,Lps,St5} = bc_tq1(Line, E, Qs1, AccVar, St4),
+    {Nc,Nps,St6} = expr(NewMore, St5),
+    {Pc,St7} = list_gen_pattern(P, Line, St6),
+    {Gc,Gps,St8} = safe(G, St7),		%Will be a function argument!
+    Fc = function_clause([Arg,AccVar], LA, {Name,2}),
+    case {Guardc, Pc} of
+	{[], #c_var{}} ->
+	    Cs0 = [#iclause{anno=LAnno,
+			    pats=[#c_literal{anno=LA,val=[]},AccVar],guard=[],
+			    body=[AccVar]}];
+	_ ->
+	    Cs0 = [#iclause{anno=#a{anno=[compiler_generated|LA]},
+			    pats=[#c_cons{anno=LA,hd=Head,tl=Tail},AccVar],
+			    guard=[],
+			    body=Nps ++ [Nc]},
+		   #iclause{anno=LAnno,
+			    pats=[#c_literal{anno=LA,val=[]},AccVar],guard=[],
+			    body=[AccVar]}]
+    end,
+    Cs = case Pc of
+	     nomatch -> Cs0;
+	     _ ->
+		 Body = Lps ++ Nps ++ [#iset{var=AccVar,arg=Lc},Nc],
+		 [#iclause{anno=LAnno,
+			   pats=[#c_cons{anno=LA,hd=Pc,tl=Tail},AccVar],
+			   guard=Guardc,
+			   body=Body}|Cs0]
+	 end,
+    Fun = #ifun{anno=LAnno,id=[],vars=[Arg,AccVar],clauses=Cs,fc=Fc},
+    {#iletrec{anno=LAnno,defs=[{{Name,2},Fun}],
+	      body=Gps ++ [#iapply{anno=LAnno,
+				   op=#c_fname{anno=LA,id=Name,arity=2},
+				   args=[Gc,AccExpr]}]},
+     [],St8};
+bc_tq1(Line, E, [{b_generate,Lg,P,G}|Qs0], AccExpr, St0) ->
+    {Gs,Qs1} =  splitwith(fun is_guard_test/1, Qs0),
+    {Name,St1} = new_fun_name("lbc", St0),
+    LA = lineno_anno(Line, St1),
+    {[Tail,AccVar],St2} = new_vars(LA, 2, St1),
+    LAnno = #a{anno=LA},
+    HeadBinPattern = pattern(P, St2),
+    #c_binary{segments=Ps} = HeadBinPattern,
+    {EPs,St3} = emasculate_segments(Ps, St2),
+    TailSegment = #c_bitstr{val=Tail,size=core_lib:make_literal(all),
+			    unit=core_lib:make_literal(1),
+			    type=core_lib:make_literal(binary),
+			    flags=core_lib:make_literal([big,unsigned])},
+    Pattern = HeadBinPattern#c_binary{segments=Ps ++ [TailSegment]},
+    EPattern = HeadBinPattern#c_binary{segments=EPs ++ [TailSegment]},
+    {Arg,St4} = new_var(St3),
+    NewMore = {call,Lg,{atom,Lg,Name},[{var,Lg,Tail#c_var.name},
+				       {var,Lg,AccVar#c_var.name}]},
+    {Guardc,St5} = lc_guard_tests(Gs, St4),	%These are always flat!
+    {Bc,Bps,St6} = bc_tq1(Line, E, Qs1, AccVar, St5),
+    {Nc,Nps,St7} = expr(NewMore, St6),
+    {Gc,Gps,St8} = safe(G, St7),		%Will be a function argument!
+    Fc = function_clause([Arg,AccVar], LA, {Name,2}),
+    Body = Bps ++ Nps ++ [#iset{var=AccVar,arg=Bc},Nc],
+    Cs = [#iclause{anno=LAnno,
+		   pats=[Pattern,AccVar],
+		   guard=Guardc,
+		   body=Body},
+	  #iclause{anno=#a{anno=[compiler_generated|LA]},
+		   pats=[EPattern,AccVar],
+		   guard=[],
+		   body=Nps ++ [Nc]},
+	  #iclause{anno=LAnno,
+		   pats=[#c_binary{anno=LA,segments=[TailSegment]},AccVar],
+		   guard=[],
+		   body=[AccVar]}],
+    Fun = #ifun{anno=LAnno,id=[],vars=[Arg,AccVar],clauses=Cs,fc=Fc},
+    {#iletrec{anno=LAnno,defs=[{{Name,2},Fun}],
+	      body=Gps ++ [#iapply{anno=LAnno,
+				   op=#c_fname{anno=LA,id=Name,arity=2},
+				   args=[Gc,AccExpr]}]},
+     [],St8};
+bc_tq1(Line, E, [Fil0|Qs0], AccVar, St0) ->
+    %% Special case sequences guard tests.
+    LA = lineno_anno(Line, St0),
+    LAnno = #a{anno=LA},
+    case is_guard_test(Fil0) of
+	true ->
+	    {Gs0,Qs1} = splitwith(fun is_guard_test/1, Qs0),
+	    {Bc,Bps,St1} = bc_tq1(Line, E, Qs1, AccVar, St0),
+	    {Gs,St} = lc_guard_tests([Fil0|Gs0], St1), %These are always flat!
+	    {#icase{anno=LAnno,
+		    args=[],
+		    clauses=[#iclause{anno=LAnno,
+				      pats=[],
+				      guard=Gs,body=Bps ++ [Bc]}],
+		    fc=#iclause{anno=LAnno,pats=[],guard=[],body=[AccVar]}},
+	     [],St};
+	false ->
+	    {Bc,Bps,St1} = bc_tq1(Line, E, Qs0, AccVar, St0),
+	    {Fpat,St2} = new_var(St1),
+	    Fc = fail_clause([Fpat], #c_tuple{es=[#c_literal{val=case_clause},Fpat]}),
+	    %% Do a novars little optimisation here.
+	    {Filc,Fps,St} = novars(Fil0, St2),
+	    {#icase{anno=LAnno,
+		    args=[Filc],
+		    clauses=[#iclause{anno=LAnno,
+				      pats=[#c_literal{anno=LA,val=true}],
+				      guard=[],
+				      body=Bps ++ [Bc]},
+			     #iclause{anno=LAnno,
+				      pats=[#c_literal{anno=LA,val=false}],
+				      guard=[],
+				      body=[AccVar]}],
+		    fc=Fc},
+	     Fps,St}
+    end;
+bc_tq1(_, {bin,Bl,Elements}, [], AccVar, St0) ->
+    {E,Pre,St} = expr({bin,Bl,[{bin_element,Bl,
+				{var,Bl,AccVar#c_var.name},
+				{atom,Bl,all},
+				[binary,{unit,1}]}|Elements]}, St0),
+    #a{anno=A} = Anno0 = core_lib:get_anno(E),
+    Anno = Anno0#a{anno=[compiler_generated,single_use|A]},
+    %%Anno = Anno0#a{anno=[compiler_generated|A]},
+    {core_lib:set_anno(E, Anno),Pre,St}.
+
+emasculate_segments(Segs, St) ->
+    emasculate_segments(Segs, St, []).
+
+emasculate_segments([#c_bitstr{val=#c_var{}}=B|Rest], St, Acc) ->
+    emasculate_segments(Rest, St, [B|Acc]);
+emasculate_segments([B|Rest], St0, Acc) ->
+    {Var,St1} = new_var(St0),
+    emasculate_segments(Rest, St1, [B#c_bitstr{val=Var}|Acc]);
+emasculate_segments([], St, Acc) ->
+    {lists:reverse(Acc),St}.
+
+lc_guard_tests([], St) -> {[],St};
+lc_guard_tests(Gs0, St) ->
+    Gs = guard_tests(Gs0),
+    gexpr_top(Gs, St).
+
+list_gen_pattern(P0, Line, St) ->
+    try
+	{pattern(P0, St),St}
+    catch 
+	nomatch -> {nomatch,add_warning(Line, nomatch, St)}
+    end.
+
+%% is_guard_test(Expression) -> true | false.
+%%  Test if a general expression is a guard test.  Use erl_lint here
+%%  as it now allows sys_pre_expand transformed source.
+
+is_guard_test(E) -> erl_lint:is_guard_test(E).
+
+%% novars(Expr, State) -> {Novars,[PreExpr],State}.
+%%  Generate a novars expression, basically a call or a safe.  At this
+%%  level we do not need to do a deep check.
+
+novars(E0, St0) ->
+    {E1,Eps,St1} = expr(E0, St0),
+    {Se,Sps,St2} = force_novars(E1, St1),
+    {Se,Eps ++ Sps,St2}.
+
+force_novars(#iapply{}=App, St) -> {App,[],St};
+force_novars(#icall{}=Call, St) -> {Call,[],St};
+force_novars(#ifun{}=Fun, St) -> {Fun,[],St};	%These are novars too
+force_novars(#ibinary{}=Bin, St) -> {Bin,[],St};
+force_novars(Ce, St) ->
+    force_safe(Ce, St).
+
+%% safe(Expr, State) -> {Safe,[PreExpr],State}.
+%%  Generate an internal safe expression.  These are simples without
+%%  binaries which can fail.  At this level we do not need to do a
+%%  deep check.  Must do special things with matches here.
+
+safe(E0, St0) ->
+    {E1,Eps,St1} = expr(E0, St0),
+    {Se,Sps,St2} = force_safe(E1, St1),
+    {Se,Eps ++ Sps,St2}.
+
+safe_list(Es, St) ->
+    foldr(fun (E, {Ces,Esp,St0}) ->
+		  {Ce,Ep,St1} = safe(E, St0),
+		  {[Ce|Ces],Ep ++ Esp,St1}
+	  end, {[],[],St}, Es).
+
+force_safe(#imatch{pat=P,arg=E}=Imatch, St0) ->
+    {Le,Lps0,St1} = force_safe(E, St0),
+    Lps = Lps0 ++ [Imatch#imatch{arg=Le}],
+
+    %% Make sure we don't duplicate the expression E. sys_core_fold
+    %% will usually optimize away the duplicate expression, but may
+    %% generate a warning while doing so.
+    case Le of
+	#c_var{} ->
+	    %% Le is a variable.
+	    %% Thus: P = Le, Le.  (Traditional, since the V2 compiler.)
+	    {Le,Lps,St1};
+	_ ->
+	    %% Le is not a variable.
+	    %% Thus: NewVar = P = Le, NewVar.   (New for R12B-1.)
+	    %%
+	    %% Note: It is tempting to rewrite V = Le to V = Le, V,
+	    %% but that will generate extra warnings in sys_core_fold
+	    %% for this expression:
+	    %%
+	    %%    [{X,Y} || {X,_} <- E, (Y = X) =:= (Y = 1 + 1)]
+	    %%
+	    %% (There will be a 'case Y =:= Y of...' which will generate
+	    %% a warning.)
+	    {V,St2} = new_var(St1),
+	    {V,Lps0 ++ [Imatch#imatch{pat=#c_alias{var=V,pat=P},arg=Le}],St2}
+    end;
+force_safe(Ce, St0) ->
+    case is_safe(Ce) of
+	true -> {Ce,[],St0};
+	false ->
+	    {V,St1} = new_var(St0),
+	    {V,[#iset{var=V,arg=Ce}],St1}
+    end.
+
+is_safe(#c_cons{}) -> true;
+is_safe(#c_tuple{}) -> true;
+is_safe(#c_var{}) -> true;
+is_safe(#c_literal{}) -> true;
+is_safe(#c_fname{}) -> true;
+is_safe(_) -> false.
+
+%% fold_match(MatchExpr, Pat) -> {MatchPat,Expr}.
+%%  Fold nested matches into one match with aliased patterns.
+
+fold_match({match,L,P0,E0}, P) ->
+    {P1,E1} = fold_match(E0, P),
+    {{match,L,P0,P1},E1};
+fold_match(E, P) -> {P,E}.
+
+%% pattern(Pattern, State) -> CorePat.
+%% Transform a pattern by removing line numbers.  We also normalise
+%% aliases in patterns to standard form, {alias,Pat,[Var]}.
+
+pattern({var,L,V}, St) -> #c_var{anno=lineno_anno(L, St),name=V};
+pattern({char,L,C}, St) -> #c_literal{anno=lineno_anno(L, St),val=C};
+pattern({integer,L,I}, St) -> #c_literal{anno=lineno_anno(L, St),val=I};
+pattern({float,L,F}, St) -> #c_literal{anno=lineno_anno(L, St),val=F};
+pattern({atom,L,A}, St) -> #c_literal{anno=lineno_anno(L, St),val=A};
+pattern({string,L,S}, St) -> #c_literal{anno=lineno_anno(L, St),val=S};
+pattern({nil,L}, St) -> #c_literal{anno=lineno_anno(L, St),val=[]};
+pattern({cons,L,H,T}, St) ->
+    #c_cons{anno=lineno_anno(L, St),hd=pattern(H, St),tl=pattern(T, St)};
+pattern({tuple,L,Ps}, St) ->
+    #c_tuple{anno=lineno_anno(L, St),es=pattern_list(Ps, St)};
+pattern({bin,L,Ps}, #core{opts=Opts}=St) ->
+    case member(no_binaries, Opts) of
+	false ->
+	    %% We don't create a #ibinary record here, since there is
+	    %% no need to hold any used/new annotations in a pattern.
+	    #c_binary{anno=lineno_anno(L, St),segments=pat_bin(Ps, St)};
+	true ->
+	    throw(no_binaries)
+    end;
+pattern({match,_,P1,P2}, St) ->
+    pat_alias(pattern(P1, St), pattern(P2, St)).
+
+%% pat_bin([BinElement], State) -> [BinSeg].
+
+pat_bin(Ps, St) -> [pat_segment(P, St) || P <- Ps].
+
+pat_segment({bin_element,_,Term,Size,[Type,{unit,Unit}|Flags]}, St) ->
+    #c_bitstr{val=pattern(Term, St),size=pattern(Size, St),
+	      unit=core_lib:make_literal(Unit),
+	      type=core_lib:make_literal(Type),
+	      flags=core_lib:make_literal(Flags)}.
+
+%% pat_alias(CorePat, CorePat) -> AliasPat.
+%%  Normalise aliases.  Trap bad aliases by throwing 'nomatch'.
+
+pat_alias(#c_var{name=V1}, P2) -> #c_alias{var=#c_var{name=V1},pat=P2};
+pat_alias(P1, #c_var{name=V2}) -> #c_alias{var=#c_var{name=V2},pat=P1};
+pat_alias(#c_cons{}=Cons, #c_literal{anno=A,val=[H|T]}=S) ->
+    pat_alias(Cons, #c_cons{anno=A,hd=#c_literal{anno=A,val=H},
+			    tl=S#c_literal{val=T}});
+pat_alias(#c_literal{anno=A,val=[H|T]}=S, #c_cons{}=Cons) ->
+    pat_alias(#c_cons{anno=A,hd=#c_literal{anno=A,val=H},
+		      tl=S#c_literal{val=T}}, Cons);
+pat_alias(#c_cons{anno=A,hd=H1,tl=T1}, #c_cons{hd=H2,tl=T2}) ->
+    #c_cons{anno=A,hd=pat_alias(H1, H2),tl=pat_alias(T1, T2)};
+pat_alias(#c_tuple{es=Es1}, #c_tuple{es=Es2}) ->
+    #c_tuple{es=pat_alias_list(Es1, Es2)};
+pat_alias(#c_alias{var=V1,pat=P1},
+	  #c_alias{var=V2,pat=P2}) ->
+    if V1 =:= V2 -> #c_alias{var=V1,pat=pat_alias(P1, P2)};
+       true -> #c_alias{var=V1,pat=#c_alias{var=V2,pat=pat_alias(P1, P2)}}
+    end;
+pat_alias(#c_alias{var=V1,pat=P1}, P2) ->
+    #c_alias{var=V1,pat=pat_alias(P1, P2)};
+pat_alias(P1, #c_alias{var=V2,pat=P2}) ->
+    #c_alias{var=V2,pat=pat_alias(P1, P2)};
+pat_alias(P1, P2) ->
+    case {core_lib:set_anno(P1, []),core_lib:set_anno(P2, [])} of
+	{P,P} -> P;
+	_ -> throw(nomatch)
+    end.
+
+%% pat_alias_list([A1], [A2]) -> [A].
+
+pat_alias_list([A1|A1s], [A2|A2s]) ->
+    [pat_alias(A1, A2)|pat_alias_list(A1s, A2s)];
+pat_alias_list([], []) -> [];
+pat_alias_list(_, _) -> throw(nomatch).
+
+%% pattern_list([P], State) -> [P].
+
+pattern_list(Ps, St) -> [pattern(P, St) || P <- Ps].
+
+%% first([A]) -> [A].
+%% last([A]) -> A.
+
+first([_]) -> [];
+first([H|T]) -> [H|first(T)].
+
+last([L]) -> L;
+last([_|T]) -> last(T).
+
+%% make_vars([Name]) -> [{Var,Name}].
+
+make_vars(Vs) -> [ #c_var{name=V} || V <- Vs ].
+
+%% new_fun_name(Type, State) -> {FunName,State}.
+
+new_fun_name(Type, #core{fcount=C}=St) ->
+    {list_to_atom(Type ++ "$^" ++ integer_to_list(C)),St#core{fcount=C+1}}.
+
+%% new_var_name(State) -> {VarName,State}.
+
+new_var_name(#core{vcount=C}=St) ->
+    {list_to_atom("cor" ++ integer_to_list(C)),St#core{vcount=C + 1}}.
+
+%% new_var(State) -> {{var,Name},State}.
+%% new_var(LineAnno, State) -> {{var,Name},State}.
+
+new_var(St) ->
+    new_var([], St).
+
+new_var(Anno, St0) ->
+    {New,St} = new_var_name(St0),
+    {#c_var{anno=Anno,name=New},St}.
+
+%% new_vars(Count, State) -> {[Var],State}.
+%% new_vars(Anno, Count, State) -> {[Var],State}.
+%%  Make Count new variables.
+
+new_vars(N, St) -> new_vars_1(N, [], St, []).
+new_vars(Anno, N, St) -> new_vars_1(N, Anno, St, []).
+
+new_vars_1(N, Anno, St0, Vs) when N > 0 ->
+    {V,St1} = new_var(Anno, St0),
+    new_vars_1(N-1, Anno, St1, [V|Vs]);
+new_vars_1(0, _, St, Vs) -> {Vs,St}.
+
+function_clause(Ps, Name) ->
+    fail_clause(Ps, #c_tuple{es=[#c_literal{anno=[{name,Name}],
+					    val=function_clause}|Ps]}).
+function_clause(Ps, Anno, Name) ->
+    fail_clause(Ps, #c_tuple{anno=Anno,
+			     es=[#c_literal{anno=[{name,Name}],
+					    val=function_clause}|Ps]}).
+
+fail_clause(Pats, A) ->
+    #iclause{anno=#a{anno=[compiler_generated]},
+	     pats=Pats,guard=[],
+	     body=[#iprimop{anno=#a{},name=#c_literal{val=match_fail},args=[A]}]}.
+
+ubody(B, St) -> uexpr(B, [], St).
+
+%% uclauses([Lclause], [KnownVar], State) -> {[Lclause],State}.
+
+uclauses(Lcs, Ks, St0) ->
+    mapfoldl(fun (Lc, St) -> uclause(Lc, Ks, St) end, St0, Lcs).
+
+%% uclause(Lclause, [KnownVar], State) -> {Lclause,State}.
+
+uclause(Cl0, Ks, St0) ->
+    {Cl1,_Pvs,Used,New,St1} = uclause(Cl0, Ks, Ks, St0),
+    A0 = get_ianno(Cl1),
+    A = A0#a{us=Used,ns=New},
+    {Cl1#iclause{anno=A},St1}.
+
+uclause(#iclause{anno=Anno,pats=Ps0,guard=G0,body=B0}, Pks, Ks0, St0) ->
+    {Ps1,Pg,Pvs,Pus,St1} = upattern_list(Ps0, Pks, St0),
+    Pu = union(Pus, intersection(Pvs, Ks0)),
+    Pn = subtract(Pvs, Pu),
+    Ks1 = union(Pn, Ks0),
+    {G1,St2} = uguard(Pg, G0, Ks1, St1),
+    Gu = used_in_any(G1),
+    Gn = new_in_any(G1),
+    Ks2 = union(Gn, Ks1),
+    {B1,St3} = uexprs(B0, Ks2, St2),
+    Used = intersection(union([Pu,Gu,used_in_any(B1)]), Ks0),
+    New = union([Pn,Gn,new_in_any(B1)]),
+    {#iclause{anno=Anno,pats=Ps1,guard=G1,body=B1},Pvs,Used,New,St3}.
+
+%% uguard([Test], [Kexpr], [KnownVar], State) -> {[Kexpr],State}.
+%%  Build a guard expression list by folding in the equality tests.
+
+uguard([], [], _, St) -> {[],St};
+uguard(Pg, [], Ks, St) ->
+    %% No guard, so fold together equality tests.
+    uguard(first(Pg), [last(Pg)], Ks, St);
+uguard(Pg, Gs0, Ks, St0) ->
+    %% Gs0 must contain at least one element here.
+    {Gs3,St5} = foldr(fun (T, {Gs1,St1}) ->
+			      {L,St2} = new_var(St1),
+			      {R,St3} = new_var(St2),
+			      {[#iset{var=L,arg=T}] ++ first(Gs1) ++
+			       [#iset{var=R,arg=last(Gs1)},
+				#icall{anno=#a{}, %Must have an #a{}
+				       module=#c_literal{val=erlang},
+				       name=#c_literal{val='and'},
+				       args=[L,R]}],
+			       St3}
+		      end, {Gs0,St0}, Pg),
+    %%ok = io:fwrite("core ~w: ~p~n", [?LINE,Gs3]),
+    uexprs(Gs3, Ks, St5).
+
+%% uexprs([Kexpr], [KnownVar], State) -> {[Kexpr],State}.
+
+uexprs([#imatch{anno=A,pat=P0,arg=Arg,fc=Fc}|Les], Ks, St0) ->
+    %% Optimise for simple set of unbound variable.
+    case upattern(P0, Ks, St0) of
+	{#c_var{},[],_Pvs,_Pus,_} ->
+	    %% Throw our work away and just set to iset.
+	    uexprs([#iset{var=P0,arg=Arg}|Les], Ks, St0);
+	_Other ->
+	    %% Throw our work away and set to icase.
+	    if
+		Les =:= [] ->
+		    %% Need to explicitly return match "value", make
+		    %% safe for efficiency.
+		    {La0,Lps,St1} = force_safe(Arg, St0),
+		    La = mark_compiler_generated(La0),
+		    Mc = #iclause{anno=A,pats=[P0],guard=[],body=[La]},
+		    uexprs(Lps ++ [#icase{anno=A,
+					  args=[La0],clauses=[Mc],fc=Fc}], Ks, St1);
+		true ->
+		    Mc = #iclause{anno=A,pats=[P0],guard=[],body=Les},
+		    uexprs([#icase{anno=A,args=[Arg],
+				   clauses=[Mc],fc=Fc}], Ks, St0)
+	    end
+    end;
+uexprs([Le0|Les0], Ks, St0) ->
+    {Le1,St1} = uexpr(Le0, Ks, St0),
+    {Les1,St2} = uexprs(Les0, union((core_lib:get_anno(Le1))#a.ns, Ks), St1),
+    {[Le1|Les1],St2};
+uexprs([], _, St) -> {[],St}.
+
+%% Mark a "safe" as compiler-generated.
+mark_compiler_generated(#c_cons{anno=A,hd=H,tl=T}) ->
+    #c_cons{anno=[compiler_generated|A],hd=mark_compiler_generated(H),
+	    tl=mark_compiler_generated(T)};
+mark_compiler_generated(#c_tuple{anno=A,es=Es0}) ->
+    Es = [mark_compiler_generated(E) || E <- Es0],
+    #c_tuple{anno=[compiler_generated|A],es=Es};
+mark_compiler_generated(#c_var{anno=A}=Var) ->
+    Var#c_var{anno=[compiler_generated|A]};
+mark_compiler_generated(#c_literal{anno=A}=Lit) ->
+    Lit#c_literal{anno=[compiler_generated|A]}.
+
+uexpr(#iset{anno=A,var=V,arg=A0}, Ks, St0) ->
+    {A1,St1} = uexpr(A0, Ks, St0),
+    {#iset{anno=A#a{us=del_element(V#c_var.name, (core_lib:get_anno(A1))#a.us),
+		    ns=add_element(V#c_var.name, (core_lib:get_anno(A1))#a.ns)},
+	   var=V,arg=A1},St1};
+%% imatch done in uexprs.
+uexpr(#iletrec{anno=A,defs=Fs0,body=B0}, Ks, St0) ->
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,{Fs0,B0}]),
+    {Fs1,St1} = mapfoldl(fun ({Name,F0}, S0) ->
+				 {F1,S1} = uexpr(F0, Ks, S0),
+				 {{Name,F1},S1}
+			 end, St0, Fs0),
+    {B1,St2} = uexprs(B0, Ks, St1),
+    Used = used_in_any(map(fun ({_,F}) -> F end, Fs1) ++ B1),
+    {#iletrec{anno=A#a{us=Used,ns=[]},defs=Fs1,body=B1},St2};
+uexpr(#icase{anno=A,args=As0,clauses=Cs0,fc=Fc0}, Ks, St0) ->
+    %% As0 will never generate new variables.
+    {As1,St1} = uexpr_list(As0, Ks, St0),
+    {Cs1,St2} = uclauses(Cs0, Ks, St1),
+    {Fc1,St3} = uclause(Fc0, Ks, St2),
+    Used = union(used_in_any(As1), used_in_any(Cs1)),
+    New = new_in_all(Cs1),
+    {#icase{anno=A#a{us=Used,ns=New},args=As1,clauses=Cs1,fc=Fc1},St3};
+uexpr(#ifun{anno=A,id=Id,vars=As,clauses=Cs0,fc=Fc0}, Ks0, St0) ->
+    Avs = lit_list_vars(As),
+    Ks1 = union(Avs, Ks0),
+    {Cs1,St1} = ufun_clauses(Cs0, Ks1, St0),
+    {Fc1,St2} = ufun_clause(Fc0, Ks1, St1),
+    Used = subtract(intersection(used_in_any(Cs1), Ks0), Avs),
+    {#ifun{anno=A#a{us=Used,ns=[]},id=Id,vars=As,clauses=Cs1,fc=Fc1},St2};
+uexpr(#iapply{anno=A,op=Op,args=As}, _, St) ->
+    Used = union(lit_vars(Op), lit_list_vars(As)),
+    {#iapply{anno=A#a{us=Used},op=Op,args=As},St};
+uexpr(#iprimop{anno=A,name=Name,args=As}, _, St) ->
+    Used = lit_list_vars(As),
+    {#iprimop{anno=A#a{us=Used},name=Name,args=As},St};
+uexpr(#icall{anno=A,module=Mod,name=Name,args=As}, _, St) ->
+    Used = union([lit_vars(Mod),lit_vars(Name),lit_list_vars(As)]),
+    {#icall{anno=A#a{us=Used},module=Mod,name=Name,args=As},St};
+uexpr(#itry{anno=A,args=As0,vars=Vs,body=Bs0,evars=Evs,handler=Hs0}, Ks, St0) ->
+    %% Note that we export only from body and exception.
+    {As1,St1} = uexprs(As0, Ks, St0),
+    {Bs1,St2} = uexprs(Bs0, Ks, St1),
+    {Hs1,St3} = uexprs(Hs0, Ks, St2),
+    Used = intersection(used_in_any(Bs1++Hs1++As1), Ks),
+    New = new_in_all(Bs1++Hs1),
+    {#itry{anno=A#a{us=Used,ns=New},
+	   args=As1,vars=Vs,body=Bs1,evars=Evs,handler=Hs1},St3};
+uexpr(#icatch{anno=A,body=Es0}, Ks, St0) ->
+    {Es1,St1} = uexprs(Es0, Ks, St0),
+    {#icatch{anno=A#a{us=used_in_any(Es1)},body=Es1},St1};
+uexpr(#ireceive1{anno=A,clauses=Cs0}, Ks, St0) ->
+    {Cs1,St1} = uclauses(Cs0, Ks, St0),
+    {#ireceive1{anno=A#a{us=used_in_any(Cs1),ns=new_in_all(Cs1)},
+		clauses=Cs1},St1};
+uexpr(#ireceive2{anno=A,clauses=Cs0,timeout=Te0,action=Tes0}, Ks, St0) ->
+    %% Te0 will never generate new variables.
+    {Te1,St1} = uexpr(Te0, Ks, St0),
+    {Cs1,St2} = uclauses(Cs0, Ks, St1),
+    {Tes1,St3} = uexprs(Tes0, Ks, St2),
+    Used = union([used_in_any(Cs1),used_in_any(Tes1),
+		  (core_lib:get_anno(Te1))#a.us]),
+    New = case Cs1 of
+	      [] -> new_in_any(Tes1);
+	      _ -> intersection(new_in_all(Cs1), new_in_any(Tes1))
+	  end,
+    {#ireceive2{anno=A#a{us=Used,ns=New},
+		clauses=Cs1,timeout=Te1,action=Tes1},St3};
+uexpr(#isearch1{anno=A,clauses=Cs0}, Ks, St0) ->
+    {Cs1,St1} = uclauses(Cs0, Ks, St0),
+    {#isearch1{anno=A#a{us=used_in_any(Cs1),ns=new_in_all(Cs1)},
+		clauses=Cs1},St1};
+uexpr(#isearch2{anno=A,clauses=Cs0,timeout=Te0,action=Tes0}, Ks, St0) ->
+    %% Te0 will never generate new variables.
+    {Te1,St1} = uexpr(Te0, Ks, St0),
+    {Cs1,St2} = uclauses(Cs0, Ks, St1),
+    {Tes1,St3} = uexprs(Tes0, Ks, St2),
+    Used = union([used_in_any(Cs1),used_in_any(Tes1),
+		  (core_lib:get_anno(Te1))#a.us]),
+    New = case Cs1 of
+	      [] -> new_in_any(Tes1);
+	      _ -> intersection(new_in_all(Cs1), new_in_any(Tes1))
+	  end,
+    {#isearch2{anno=A#a{us=Used,ns=New},
+		clauses=Cs1,timeout=Te1,action=Tes1},St3};
+uexpr(#iprotect{anno=A,body=Es0}, Ks, St0) ->
+    {Es1,St1} = uexprs(Es0, Ks, St0),
+    Used = used_in_any(Es1),
+    {#iprotect{anno=A#a{us=Used},body=Es1},St1}; %No new variables escape!
+uexpr(#ibinary{anno=A,segments=Ss}, _, St) ->
+    Used = bitstr_vars(Ss),
+    {#ibinary{anno=A#a{us=Used},segments=Ss},St};
+uexpr(#c_literal{}=Lit, _, St) ->
+    Anno = core_lib:get_anno(Lit),
+    {core_lib:set_anno(Lit, #a{us=[],anno=Anno}),St};
+uexpr(Lit, _, St) ->
+    true = core_lib:is_simple(Lit),		%Sanity check!
+    Vs = lit_vars(Lit),
+    Anno = core_lib:get_anno(Lit),
+    {core_lib:set_anno(Lit, #a{us=Vs,anno=Anno}),St}.
+
+uexpr_list(Les0, Ks, St0) ->
+    mapfoldl(fun (Le, St) -> uexpr(Le, Ks, St) end, St0, Les0).
+
+%% ufun_clauses([Lclause], [KnownVar], State) -> {[Lclause],State}.
+
+ufun_clauses(Lcs, Ks, St0) ->
+    mapfoldl(fun (Lc, St) -> ufun_clause(Lc, Ks, St) end, St0, Lcs).
+
+%% ufun_clause(Lclause, [KnownVar], State) -> {Lclause,State}.
+
+ufun_clause(Cl0, Ks, St0) ->
+    {Cl1,Pvs,Used,_,St1} = uclause(Cl0, [], Ks, St0),
+    A0 = get_ianno(Cl1),
+    A = A0#a{us=subtract(intersection(Used, Ks), Pvs),ns=[]},
+    {Cl1#iclause{anno=A},St1}.
+
+%% upattern(Pat, [KnownVar], State) ->
+%%              {Pat,[GuardTest],[NewVar],[UsedVar],State}.
+
+upattern(#c_var{name='_'}, _, St0) ->
+    {New,St1} = new_var_name(St0),
+    {#c_var{name=New},[],[New],[],St1};
+upattern(#c_var{name=V}=Var, Ks, St0) ->
+    case is_element(V, Ks) of
+	true ->
+	    {N,St1} = new_var_name(St0),
+	    New = #c_var{name=N},
+	    Test = #icall{anno=#a{us=add_element(N, [V])},
+			  module=#c_literal{val=erlang},
+			  name=#c_literal{val='=:='},
+			  args=[New,Var]},
+	    %% Test doesn't need protecting.
+	    {New,[Test],[N],[],St1};
+	false -> {Var,[],[V],[],St0}
+    end;
+upattern(#c_cons{hd=H0,tl=T0}=Cons, Ks, St0) ->
+    {H1,Hg,Hv,Hu,St1} = upattern(H0, Ks, St0),
+    {T1,Tg,Tv,Tu,St2} = upattern(T0, union(Hv, Ks), St1),
+    {Cons#c_cons{hd=H1,tl=T1},Hg ++ Tg,union(Hv, Tv),union(Hu, Tu),St2};
+upattern(#c_tuple{es=Es0}=Tuple, Ks, St0) ->
+    {Es1,Esg,Esv,Eus,St1} = upattern_list(Es0, Ks, St0),
+    {Tuple#c_tuple{es=Es1},Esg,Esv,Eus,St1};
+upattern(#c_binary{segments=Es0}=Bin, Ks, St0) ->
+    {Es1,Esg,Esv,Eus,St1} = upat_bin(Es0, Ks, St0),
+    {Bin#c_binary{segments=Es1},Esg,Esv,Eus,St1};
+upattern(#c_alias{var=V0,pat=P0}=Alias, Ks, St0) ->
+    {V1,Vg,Vv,Vu,St1} = upattern(V0, Ks, St0),
+    {P1,Pg,Pv,Pu,St2} = upattern(P0, union(Vv, Ks), St1),
+    {Alias#c_alias{var=V1,pat=P1},Vg ++ Pg,union(Vv, Pv),union(Vu, Pu),St2};
+upattern(Other, _, St) -> {Other,[],[],[],St}.	%Constants
+
+%% upattern_list([Pat], [KnownVar], State) ->
+%%                        {[Pat],[GuardTest],[NewVar],[UsedVar],State}.
+
+upattern_list([P0|Ps0], Ks, St0) ->
+    {P1,Pg,Pv,Pu,St1} = upattern(P0, Ks, St0),
+    {Ps1,Psg,Psv,Psu,St2} = upattern_list(Ps0, union(Pv, Ks), St1),
+    {[P1|Ps1],Pg ++ Psg,union(Pv, Psv),union(Pu, Psu),St2};
+upattern_list([], _, St) -> {[],[],[],[],St}.    
+
+%% upat_bin([Pat], [KnownVar], State) ->
+%%                        {[Pat],[GuardTest],[NewVar],[UsedVar],State}.
+upat_bin(Es0, Ks, St0) ->
+  upat_bin(Es0, Ks, [], St0).
+
+%% upat_bin([Pat], [KnownVar], [LocalVar], State) ->
+%%                        {[Pat],[GuardTest],[NewVar],[UsedVar],State}.
+upat_bin([P0|Ps0], Ks, Bs, St0) ->
+    {P1,Pg,Pv,Pu,Bs1,St1} = upat_element(P0, Ks, Bs, St0),
+    {Ps1,Psg,Psv,Psu,St2} = upat_bin(Ps0, union(Pv, Ks), Bs1, St1),
+    {[P1|Ps1],Pg ++ Psg,union(Pv, Psv),union(Pu, Psu),St2};
+upat_bin([], _, _, St) -> {[],[],[],[],St}.    
+
+
+%% upat_element(Segment, [KnownVar], [LocalVar], State) ->
+%%                        {Segment,[GuardTest],[NewVar],[UsedVar],[LocalVar],State}
+upat_element(#c_bitstr{val=H0,size=Sz}=Seg, Ks, Bs, St0) ->
+  {H1,Hg,Hv,[],St1} = upattern(H0, Ks, St0),
+  Bs1 = case H0 of
+	  #c_var{name=Hname} ->
+	    case H1 of
+	      #c_var{name=Hname} ->
+		Bs;
+	      #c_var{name=Other} ->
+		[{Hname, Other}|Bs]
+	    end;
+	  _ ->
+	    Bs
+	end,
+  {Sz1, Us} = case Sz of
+		  #c_var{name=Vname} -> 
+		    rename_bitstr_size(Vname, Bs);
+		  _Other -> {Sz, []}
+		end,
+  {Seg#c_bitstr{val=H1, size=Sz1},Hg,Hv,Us,Bs1,St1}.
+
+rename_bitstr_size(V, [{V, N}|_]) ->
+   New = #c_var{name=N},
+  {New, [N]};
+rename_bitstr_size(V, [_|Rest]) ->
+  rename_bitstr_size(V, Rest);
+rename_bitstr_size(V, []) ->
+  Old = #c_var{name=V},
+  {Old, [V]}.
+ 
+used_in_any(Les) ->
+    foldl(fun (Le, Ns) -> union((core_lib:get_anno(Le))#a.us, Ns) end,
+	  [], Les).
+
+new_in_any(Les) ->
+    foldl(fun (Le, Ns) -> union((core_lib:get_anno(Le))#a.ns, Ns) end,
+	  [], Les).
+
+new_in_all([Le|Les]) ->
+    foldl(fun (L, Ns) -> intersection((core_lib:get_anno(L))#a.ns, Ns) end,
+	  (core_lib:get_anno(Le))#a.ns, Les);
+new_in_all([]) -> [].
+
+%% The AfterVars are the variables which are used afterwards.  We need
+%% this to work out which variables are actually exported and used
+%% from case/receive.  In subblocks/clauses the AfterVars of the block
+%% are just the exported variables.
+
+cbody(B0, St0) ->
+    {B1,_,_,St1} = cexpr(B0, [], St0),
+    {B1,St1}.
+
+%% cclause(Lclause, [AfterVar], State) -> {Cclause,State}.
+%%  The AfterVars are the exported variables.
+
+cclause(#iclause{anno=#a{anno=Anno},pats=Ps,guard=G0,body=B0}, Exp, St0) ->
+    {B1,_Us1,St1} = cexprs(B0, Exp, St0),
+    {G1,St2} = cguard(G0, St1),
+    {#c_clause{anno=Anno,pats=Ps,guard=G1,body=B1},St2}.
+
+cclauses(Lcs, Es, St0) ->
+    mapfoldl(fun (Lc, St) -> cclause(Lc, Es, St) end, St0, Lcs).
+
+cguard([], St) -> {#c_literal{val=true},St};
+cguard(Gs, St0) ->
+    {G,_,St1} = cexprs(Gs, [], St0),
+    {G,St1}.
+ 
+%% cexprs([Lexpr], [AfterVar], State) -> {Cexpr,[AfterVar],State}.
+%%  Must be sneaky here at the last expr when combining exports for the
+%%  whole sequence and exports for that expr.
+
+cexprs([#iset{var=#c_var{name=Name}=Var}=Iset], As, St) ->
+    %% Make return value explicit, and make Var true top level.
+    cexprs([Iset,Var#c_var{anno=#a{us=[Name]}}], As, St);
+cexprs([Le], As, St0) ->
+    {Ce,Es,Us,St1} = cexpr(Le, As, St0),
+    Exp = make_vars(As),			%The export variables
+    if
+	Es =:= [] -> {core_lib:make_values([Ce|Exp]),union(Us, As),St1};
+	true ->
+	    {R,St2} = new_var(St1),
+	    {#c_let{anno=get_lineno_anno(Ce),
+		    vars=[R|make_vars(Es)],arg=Ce,
+		    body=core_lib:make_values([R|Exp])},
+	     union(Us, As),St2}
+    end;
+cexprs([#iset{anno=#a{anno=A},var=V,arg=A0}|Les], As0, St0) ->
+    {Ces,As1,St1} = cexprs(Les, As0, St0),
+    {A1,Es,Us,St2} = cexpr(A0, As1, St1),
+    {#c_let{anno=A,vars=[V|make_vars(Es)],arg=A1,body=Ces},
+     union(Us, As1),St2};
+cexprs([Le|Les], As0, St0) ->
+    {Ces,As1,St1} = cexprs(Les, As0, St0),
+    {Ce,Es,Us,St2} = cexpr(Le, As1, St1),
+    if
+	Es =:= [] ->
+	    {#c_seq{arg=Ce,body=Ces},union(Us, As1),St2};
+	true ->
+	    {R,St3} = new_var(St2),
+	    {#c_let{vars=[R|make_vars(Es)],arg=Ce,body=Ces},
+	     union(Us, As1),St3}
+    end.
+
+%% cexpr(Lexpr, [AfterVar], State) -> {Cexpr,[ExpVar],[UsedVar],State}.
+
+cexpr(#iletrec{anno=A,defs=Fs0,body=B0}, As, St0) ->
+    {Fs1,{_,St1}} = mapfoldl(fun ({{Name,Arity},F0}, {Used,S0}) ->
+				     {F1,[],Us,S1} = cexpr(F0, [], S0),
+				     {{#c_fname{id=Name,arity=Arity},F1},
+				      {union(Us, Used),S1}}
+			     end, {[],St0}, Fs0),
+    Exp = intersection(A#a.ns, As),
+    {B1,_Us,St2} = cexprs(B0, Exp, St1),
+    {#c_letrec{anno=A#a.anno,defs=Fs1,body=B1},Exp,A#a.us,St2};
+cexpr(#icase{anno=A,args=Largs,clauses=Lcs,fc=Lfc}, As, St0) ->
+    Exp = intersection(A#a.ns, As),		%Exports
+    {Cargs,St1} = foldr(fun (La, {Cas,Sta}) ->
+				{Ca,[],_Us1,Stb} = cexpr(La, As, Sta),
+				{[Ca|Cas],Stb}
+			end, {[],St0}, Largs),
+    {Ccs,St2} = cclauses(Lcs, Exp, St1),
+    {Cfc,St3} = cclause(Lfc, [], St2),		%Never exports
+    {#c_case{anno=A#a.anno,
+	     arg=core_lib:make_values(Cargs),clauses=Ccs ++ [Cfc]},
+     Exp,A#a.us,St3};
+cexpr(#ireceive1{anno=A,clauses=Lcs}, As, St0) ->
+    Exp = intersection(A#a.ns, As),		%Exports
+    {Ccs,St1} = cclauses(Lcs, Exp, St0),
+    {#c_receive{anno=A#a.anno,
+		clauses=Ccs,
+	       timeout=#c_literal{val=infinity},action=#c_literal{val=true}},
+     Exp,A#a.us,St1};
+cexpr(#ireceive2{anno=A,clauses=Lcs,timeout=Lto,action=Les}, As, St0) ->
+    Exp = intersection(A#a.ns, As),		%Exports
+    {Cto,[],_Us1,St1} = cexpr(Lto, As, St0),
+    {Ccs,St2} = cclauses(Lcs, Exp, St1),
+    {Ces,_Us2,St3} = cexprs(Les, Exp, St2),
+    {#c_receive{anno=A#a.anno,
+		clauses=Ccs,timeout=Cto,action=Ces},
+     Exp,A#a.us,St3};
+cexpr(#isearch1{anno=A,clauses=Lcs}, As, St0) ->
+    Exp = intersection(A#a.ns, As),		%Exports
+    {Ccs,St1} = cclauses(Lcs, Exp, St0),
+    {#c_search{anno=A#a.anno,
+		clauses=Ccs,
+	       timeout=#c_literal{val=infinity},action=#c_literal{val=true}},
+     Exp,A#a.us,St1};
+cexpr(#isearch2{anno=A,clauses=Lcs,timeout=Lto,action=Les}, As, St0) ->
+    Exp = intersection(A#a.ns, As),		%Exports
+    {Cto,[],_Us1,St1} = cexpr(Lto, As, St0),
+    {Ccs,St2} = cclauses(Lcs, Exp, St1),
+    {Ces,_Us2,St3} = cexprs(Les, Exp, St2),
+    {#c_search{anno=A#a.anno,
+		clauses=Ccs,timeout=Cto,action=Ces},
+     Exp,A#a.us,St3};
+cexpr(#itry{anno=A,args=La,vars=Vs,body=Lb,evars=Evs,handler=Lh}, As, St0) ->
+    Exp = intersection(A#a.ns, As),           %Exports
+    {Ca,_Us1,St1} = cexprs(La, [], St0),
+    {Cb,_Us2,St2} = cexprs(Lb, Exp, St1),
+    {Ch,_Us3,St3} = cexprs(Lh, Exp, St2),
+    {#c_try{anno=A#a.anno,arg=Ca,vars=Vs,body=Cb,evars=Evs,handler=Ch},
+     Exp,A#a.us,St3};
+cexpr(#icatch{anno=A,body=Les}, _As, St0) ->
+    {Ces,_Us1,St1} = cexprs(Les, [], St0),	%Never export!
+    {#c_catch{body=Ces},[],A#a.us,St1};
+cexpr(#ifun{anno=A,id=Id,vars=Args,clauses=Lcs,fc=Lfc}, _As, St0) ->
+    {Ccs,St1} = cclauses(Lcs, [], St0),		%NEVER export!
+    {Cfc,St2} = cclause(Lfc, [], St1),
+    Anno = A#a.anno,
+    {#c_fun{anno=Id++Anno,vars=Args,
+	    body=#c_case{anno=Anno,
+			 arg=core_lib:set_anno(core_lib:make_values(Args), Anno),
+			 clauses=Ccs ++ [Cfc]}},
+     [],A#a.us,St2};
+cexpr(#iapply{anno=A,op=Op,args=Args}, _As, St) ->
+    {#c_apply{anno=A#a.anno,op=Op,args=Args},[],A#a.us,St};
+cexpr(#icall{anno=A,module=Mod,name=Name,args=Args}, _As, St) ->
+    {#c_call{anno=A#a.anno,module=Mod,name=Name,args=Args},[],A#a.us,St};
+cexpr(#iprimop{anno=A,name=Name,args=Args}, _As, St) ->
+    {#c_primop{anno=A#a.anno,name=Name,args=Args},[],A#a.us,St};
+cexpr(#iprotect{anno=A,body=Es}, _As, St0) ->
+    {Ce,_,St1} = cexprs(Es, [], St0),
+    V = #c_var{name='Try'},		%The names are arbitrary
+    Vs = [#c_var{name='T'},#c_var{name='R'}],
+    {#c_try{anno=A#a.anno,arg=Ce,vars=[V],body=V,
+	    evars=Vs,handler=#c_literal{val=false}},
+     [],A#a.us,St1};
+cexpr(#ibinary{anno=#a{anno=Anno,us=Us},segments=Segs}, _As, St) ->
+    {#c_binary{anno=Anno,segments=Segs},[],Us,St};
+cexpr(#c_literal{}=Lit, _As, St) ->
+    Anno = core_lib:get_anno(Lit),
+    Vs = Anno#a.us,
+    {core_lib:set_anno(Lit, Anno#a.anno),[],Vs,St};
+cexpr(Lit, _As, St) ->
+    true = core_lib:is_simple(Lit),		%Sanity check!
+    Anno = core_lib:get_anno(Lit),
+    Vs = Anno#a.us,
+    %%Vs = lit_vars(Lit),
+    {core_lib:set_anno(Lit, Anno#a.anno),[],Vs,St}.
+
+%% Kill the id annotations for any fun inside the expression.
+%% Necessary when duplicating code in try ... after.
+
+kill_id_anns(#ifun{clauses=Cs0}=Fun) ->
+    Cs = kill_id_anns(Cs0),
+    Fun#ifun{clauses=Cs,id=[]};
+kill_id_anns(#a{}=A) ->
+    %% Optimization: Don't waste time searching for funs inside annotations.
+    A;
+kill_id_anns([H|T]) ->
+    [kill_id_anns(H)|kill_id_anns(T)];
+kill_id_anns([]) -> [];
+kill_id_anns(Tuple) when is_tuple(Tuple) ->
+    L0 = tuple_to_list(Tuple),
+    L = kill_id_anns(L0),
+    list_to_tuple(L);
+kill_id_anns(Other) -> Other.
+
+%% lit_vars(Literal) -> [Var].
+
+lit_vars(Lit) -> lit_vars(Lit, []).
+
+lit_vars(#c_cons{hd=H,tl=T}, Vs) -> lit_vars(H, lit_vars(T, Vs));
+lit_vars(#c_tuple{es=Es}, Vs) -> lit_list_vars(Es, Vs);
+lit_vars(#c_var{name=V}, Vs) -> add_element(V, Vs); 
+lit_vars(_, Vs) -> Vs.				%These are atomic
+
+% lit_bin_vars(Segs, Vs) ->
+%     foldl(fun (#c_bitstr{val=V,size=S}, Vs0) ->
+% 		  lit_vars(V, lit_vars(S, Vs0))
+% 	  end, Vs, Segs).
+
+lit_list_vars(Ls) -> lit_list_vars(Ls, []).
+
+lit_list_vars(Ls, Vs) ->
+    foldl(fun (L, Vs0) -> lit_vars(L, Vs0) end, Vs, Ls).
+
+bitstr_vars(Segs) ->
+    bitstr_vars(Segs, []).
+
+bitstr_vars(Segs, Vs) ->
+    foldl(fun (#c_bitstr{val=V,size=S}, Vs0) ->
+ 		  lit_vars(V, lit_vars(S, Vs0))
+	  end, Vs, Segs).
+
+lineno_anno(L, St) when is_integer(L) ->
+    [L] ++ St#core.file.
+
+get_ianno(Ce) ->
+    case core_lib:get_anno(Ce) of
+	#a{}=A -> A;
+	A when is_list(A) -> #a{anno=A}
+    end.
+
+get_lineno_anno(Ce) ->
+    case core_lib:get_anno(Ce) of
+	#a{anno=A} -> A;
+	A when is_list(A) -> A
+    end.
+
+
+
+%%%
+%%% Handling of warnings.
+%%%
+
+format_error(nomatch) ->
+    "pattern cannot possibly match";
+format_error(bad_binary) ->
+    "binary construction will fail because of a type mismatch";
+format_error(no_binaries) ->
+    "bit syntax is not allowed to be used when compatibility with a previous "
+	"version has been requested".
+
+add_warning(Line, Term, #core{ws=Ws,file=[{file,File}]}=St) when Line >= 0 ->
+    St#core{ws=[{File,[{Line,?MODULE,Term}]}|Ws]};
+add_warning(_, _, St) -> St.
+
+add_error(Line, Term, #core{es=Es,file=[{file,File}]}=St) ->
+    St#core{es=[{File,[{abs(Line),?MODULE,Term}]}|Es]}.
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_kernel.erl minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.erl
--- otp_src_R12B-5/lib/compiler/src/v3_kernel.erl	2008-11-04 10:51:31.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.erl	2009-06-23 20:40:10.000000000 +0100
@@ -107,6 +107,8 @@ copy_anno(Kdst, Ksrc) ->
 -record(iclause, {anno=[],isub,osub,pats,guard,body}).
 -record(ireceive_accept, {anno=[],arg}).
 -record(ireceive_next, {anno=[],arg}).
+-record(isearch_accept, {anno=[],arg}).
+-record(isearch_next, {anno=[],arg}).
 
 %% State record for kernel translator.
 -record(kern, {func,				%Current host function
@@ -160,6 +162,8 @@ body(#c_values{anno=A,es=Ces}, Sub, St0)
     {#ivalues{anno=A,args=Kes},Pe,St1};
 body(#ireceive_next{anno=A}, _, St) ->
     {#k_receive_next{anno=A},[],St};
+body(#isearch_next{anno=A}, _, St) ->
+    {#k_search_next{anno=A},[],St};
 body(Ce, Sub, St0) ->
     expr(Ce, Sub, St0).
 
@@ -368,6 +372,22 @@ expr(#c_receive{anno=A,clauses=Ccs0,time
     {Ka,Pa,St5} = body(Ca, Sub, St4),
     {#k_receive{anno=A,var=Rvar,body=Km,timeout=Ke,action=pre_seq(Pa, Ka)},
      Pe,St5};
+expr(#c_search{anno=A,clauses=Ccs0,timeout=Ce,action=Ca}, Sub, St0) ->
+    {Ke,Pe,St1} = atomic(Ce, Sub, St0),		%Force this to be atomic!
+    {Rvar,St2} = new_var(St1),
+    %% Need to massage accept clauses and add reject clause before matching.
+    Ccs1 = map(fun (#c_clause{anno=Banno,body=B0}=C) ->
+		       B1 = #c_seq{arg=#isearch_accept{anno=A},body=B0},
+		       C#c_clause{anno=Banno,body=B1}
+	       end, Ccs0),
+    {Mpat,St3} = new_var_name(St2),
+    Rc = #c_clause{anno=[compiler_generated|A],
+		   pats=[#c_var{name=Mpat}],guard=#c_literal{anno=A,val=true},
+		   body=#isearch_next{anno=A}},
+    {Km,St4} = kmatch([Rvar], Ccs1 ++ [Rc], Sub, add_var_def(Rvar, St3)),
+    {Ka,Pa,St5} = body(Ca, Sub, St4),
+    {#k_search{anno=A,var=Rvar,body=Km,timeout=Ke,action=pre_seq(Pa, Ka)},
+     Pe,St5};
 expr(#c_apply{anno=A,op=Cop,args=Cargs}, Sub, St) ->
     c_apply(A, Cop, Cargs, Sub, St);
 expr(#c_call{anno=A,module=#c_literal{val=erlang},name=#c_literal{val=is_record},
@@ -443,7 +463,9 @@ expr(#c_catch{anno=A,body=Cb}, Sub, St0)
     {Kb,Pb,St1} = body(Cb, Sub, St0),
     {#k_catch{anno=A,body=pre_seq(Pb, Kb)},[],St1};
 %% Handle internal expressions.
-expr(#ireceive_accept{anno=A}, _Sub, St) -> {#k_receive_accept{anno=A},[],St}.
+expr(#ireceive_accept{anno=A}, _Sub, St) -> {#k_receive_accept{anno=A},[],St};
+%%Search
+expr(#isearch_accept{anno=A}, _Sub, St) -> {#k_search_accept{anno=A},[],St}.
 
 %% Translate a function_clause to case_clause if it has been moved into
 %% another function.
@@ -810,7 +832,7 @@ first([H|T]) -> [H|first(T)].
 %% longer as the meaning of constructors is different from the book.
 %%
 %% In Erlang many constructors can have different values, e.g. 'atom'
-%% or 'integer', whereas in the original algorithm thse would be
+%% or 'integer', whereas in the original algorithm these would be
 %% different constructors. Our view makes it easier in later passes to
 %% handle indexing over each type.
 %%
@@ -1464,6 +1486,7 @@ is_exit_expr(#k_call{op=#k_internal{name
 is_exit_expr(#k_call{op=#k_remote{mod=Mod,name=Name,arity=Arity}}) ->
     erl_bifs:is_exit_bif(Mod, Name, Arity);
 is_exit_expr(#k_receive_next{}) -> true;
+is_exit_expr(#k_search_next{}) -> true;
 is_exit_expr(_) -> false.
 
 %% is_enter_expr(Kexpr) -> bool().
@@ -1475,6 +1498,8 @@ is_enter_expr(#k_call{}) -> true;
 is_enter_expr(#k_match{}) -> true;
 is_enter_expr(#k_receive{}) -> true;
 is_enter_expr(#k_receive_next{}) -> true;
+is_enter_expr(#k_search{}) -> true;
+is_enter_expr(#k_search_next{}) -> true;
 is_enter_expr(_) -> false.
 
 %% uguard(Expr, State) -> {Expr,[UsedVar],State}.
@@ -1579,10 +1604,20 @@ uexpr(#k_receive{anno=A,var=V,body=B0,ti
     {#k_receive{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A},
 		var=V,body=B1,timeout=T,action=A1,ret=Rs},
      Used,St2};
+uexpr(#k_search{anno=A,var=V,body=B0,timeout=T,action=A0}, Br, St0) ->
+    {#k_receive{anno=ARec,var=V,body=B1,timeout=T,action=A1,ret=Rs},
+     Used, St2} =
+	uexpr(#k_receive{anno=A,var=V,body=B0,timeout=T,action=A0}, Br, St0),
+    {#k_search{anno=ARec, var=V, body=B1, timeout=T, action=A1, ret=Rs},
+     Used, St2};    
 uexpr(#k_receive_accept{anno=A}, _, St) ->
     {#k_receive_accept{anno=#k{us=[],ns=[],a=A}},[],St};
 uexpr(#k_receive_next{anno=A}, _, St) ->
     {#k_receive_next{anno=#k{us=[],ns=[],a=A}},[],St};
+uexpr(#k_search_accept{anno=A}, _, St) ->
+    {#k_search_accept{anno=#k{us=[],ns=[],a=A}},[],St};
+uexpr(#k_search_next{anno=A}, _, St) ->
+    {#k_search_next{anno=#k{us=[],ns=[],a=A}},[],St};
 uexpr(#k_try{anno=A,arg=A0,vars=Vs,body=B0,evars=Evs,handler=H0},
       {break,Rs0}, St0) ->
     {Avs,St1} = new_vars(length(Vs), St0),	%Need dummy names here
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_kernel.erl~ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.erl~
--- otp_src_R12B-5/lib/compiler/src/v3_kernel.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,1920 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Transform Core Erlang to Kernel Erlang
+
+%% Kernel erlang is like Core Erlang with a few significant
+%% differences:
+%%
+%% 1. It is flat!  There are no nested calls or sub-blocks.
+%%
+%% 2. All variables are unique in a function.  There is no scoping, or
+%% rather the scope is the whole function.
+%%
+%% 3. Pattern matching (in cases and receives) has been compiled.
+%%
+%% 4. The annotations contain variable usages.  Seeing we have to work
+%% this out anyway for funs we might as well pass it on for free to
+%% later passes.
+%%
+%% 5. All remote-calls are to statically named m:f/a. Meta-calls are
+%% passed via erlang:apply/3.
+%%
+%% The translation is done in two passes:
+%%
+%% 1. Basic translation, translate variable/function names, flatten
+%% completely, pattern matching compilation.
+%%
+%% 2. Fun-lifting (lambda-lifting), variable usage annotation and
+%% last-call handling.
+%%
+%% All new Kexprs are created in the first pass, they are just
+%% annotated in the second.
+%%
+%% Functions and BIFs
+%%
+%% Functions are "call"ed or "enter"ed if it is a last call, their
+%% return values may be ignored.  BIFs are things which are known to
+%% be internal by the compiler and can only be called, their return
+%% values cannot be ignored.
+%%
+%% Letrec's are handled rather naively.  All the functions in one
+%% letrec are handled as one block to find the free variables.  While
+%% this is not optimal it reflects how letrec's often are used.  We
+%% don't have to worry about variable shadowing and nested letrec's as
+%% this is handled in the variable/function name translation.  There
+%% is a little bit of trickery to ensure letrec transformations fit
+%% into the scheme of things.
+%%
+%% To ensure unique variable names we use a variable substitution
+%% table and keep the set of all defined variables.  The nested
+%% scoping of Core means that we must also nest the substitution
+%% tables, but the defined set must be passed through to match the
+%% flat structure of Kernel and to make sure variables with the same
+%% name from different scopes get different substitutions.
+%%
+%% We also use these substitutions to handle the variable renaming
+%% necessary in pattern matching compilation.
+%%
+%% The pattern matching compilation assumes that the values of
+%% different types don't overlap.  This means that as there is no
+%% character type yet in the machine all characters must be converted
+%% to integers!
+
+-module(v3_kernel).
+
+-export([module/2,format_error/1]).
+
+-import(lists, [map/2,foldl/3,foldr/3,mapfoldl/3,splitwith/2,member/2]).
+-import(ordsets, [add_element/2,del_element/2,union/2,union/1,subtract/2]).
+
+-compile({nowarn_deprecated_function, {erlang,hash,2}}).
+
+-include("core_parse.hrl").
+-include("v3_kernel.hrl").
+
+-define(EXPENSIVE_BINARY_LIMIT, 256).
+
+%% These are not defined in v3_kernel.hrl.
+get_kanno(Kthing) -> element(2, Kthing).
+set_kanno(Kthing, Anno) -> setelement(2, Kthing, Anno).
+copy_anno(Kdst, Ksrc) ->
+    Anno = get_kanno(Ksrc),
+    set_kanno(Kdst, Anno).
+
+%% Internal kernel expressions and help functions.
+%% N.B. the annotation field is ALWAYS the first field!
+
+-record(ivalues, {anno=[],args}).
+-record(ifun, {anno=[],vars,body}).
+-record(iset, {anno=[],vars,arg,body}).
+-record(iletrec, {anno=[],defs}).
+-record(ialias, {anno=[],vars,pat}).
+-record(iclause, {anno=[],isub,osub,pats,guard,body}).
+-record(ireceive_accept, {anno=[],arg}).
+-record(ireceive_next, {anno=[],arg}).
+-record(isearch_accept, {anno=[],arg}).
+
+%% State record for kernel translator.
+-record(kern, {func,				%Current host function
+	       ff,				%Current function
+	       vcount=0,			%Variable counter
+	       fcount=0,			%Fun counter
+	       ds=[],				%Defined variables
+	       funs=[],				%Fun functions
+	       free=[],				%Free variables
+	       ws=[],				%Warnings.
+	       lit}).			        %Constant pool for literals.
+
+module(#c_module{anno=A,name=M,exports=Es,attrs=As,defs=Fs}, Options) ->
+    Lit = case member(no_constant_pool, Options) of
+	      true -> no;
+	      false -> dict:new()
+	  end,
+    St0 = #kern{lit=Lit},
+    {Kfs,St} = mapfoldl(fun function/2, St0, Fs),
+    Kes = map(fun (#c_fname{id=N,arity=Ar}) -> {N,Ar} end, Es),
+    Kas = map(fun ({#c_literal{val=N},V}) ->
+		      {N,core_lib:literal_value(V)} end, As),
+    {ok,#k_mdef{anno=A,name=M#c_literal.val,exports=Kes,attributes=Kas,
+		body=Kfs ++ St#kern.funs},lists:sort(St#kern.ws)}.
+
+function({#c_fname{id=F,arity=Arity},Body}, St0) ->
+    try
+	FA = {F,Arity},
+	St1 = St0#kern{func=FA,ff=undefined,vcount=0,fcount=0,ds=sets:new()},
+	{#ifun{anno=Ab,vars=Kvs,body=B0},[],St2} = expr(Body, new_sub(), St1),
+	{B1,_,St3} = ubody(B0, return, St2),
+	%%B1 = B0, St3 = St2,				%Null second pass
+	{#k_fdef{anno=#k{us=[],ns=[],a=Ab},
+		 func=F,arity=Arity,vars=Kvs,body=B1},St3}
+    catch
+	Class:Error ->
+	    Stack = erlang:get_stacktrace(),
+	    io:fwrite("Function: ~w/~w\n", [F,Arity]),
+	    erlang:raise(Class, Error, Stack)
+    end.
+	
+
+%% body(Cexpr, Sub, State) -> {Kexpr,[PreKepxr],State}.
+%%  Do the main sequence of a body.  A body ends in an atomic value or
+%%  values.  Must check if vector first so do expr.
+
+body(#c_values{anno=A,es=Ces}, Sub, St0) ->
+    %% Do this here even if only in bodies.
+    {Kes,Pe,St1} = atomic_list(Ces, Sub, St0),
+    %%{Kes,Pe,St1} = expr_list(Ces, Sub, St0),
+    {#ivalues{anno=A,args=Kes},Pe,St1};
+body(#ireceive_next{anno=A}, _, St) ->
+    {#k_receive_next{anno=A},[],St};
+body(Ce, Sub, St0) ->
+    expr(Ce, Sub, St0).
+
+%% guard(Cexpr, Sub, State) -> {Kexpr,State}.
+%%  We handle guards almost as bodies. The only special thing we
+%%  must do is to make the final Kexpr a #k_test{}.
+%%  Also, we wrap the entire guard in a try/catch which is
+%%  not strictly needed, but makes sure that every 'bif' instruction
+%%  will get a proper failure label.
+
+guard(G0, Sub, St0) ->
+    {G1,St1} = wrap_guard(G0, St0),
+    {Ge0,Pre,St2} = expr(G1, Sub, St1),
+    {Ge,St} = gexpr_test(Ge0, St2),
+    {pre_seq(Pre, Ge),St}.
+
+%% Wrap the entire guard in a try/catch if needed.
+
+wrap_guard(#c_try{}=Try, St) -> {Try,St};
+wrap_guard(Core, St0) ->
+    {VarName,St} = new_var_name(St0),
+    Var = #c_var{name=VarName},
+    Try = #c_try{arg=Core,vars=[Var],body=Var,evars=[],handler=#c_literal{val=false}},
+    {Try,St}.
+    
+%% gexpr_test(Kexpr, State) -> {Kexpr,State}.
+%%  Builds the final boolean test from the last Kexpr in a guard test.
+%%  Must enter try blocks and isets and find the last Kexpr in them.
+%%  This must end in a recognised BEAM test!
+
+gexpr_test(#k_bif{anno=A,op=#k_remote{mod=#k_atom{val=erlang},
+				      name=#k_atom{val=F},arity=Ar}=Op,
+		  args=Kargs}=Ke, St) ->
+    %% Either convert to test if ok, or add test.
+    %% At this stage, erlang:float/1 is not a type test. (It should
+    %% have been converted to erlang:is_float/1.)
+    case erl_internal:new_type_test(F, Ar) orelse
+	erl_internal:comp_op(F, Ar)
+	orelse (F =:= is_bitstr andalso Ar =:= 1) of %XXX Remove in R12B.
+	true -> {#k_test{anno=A,op=Op,args=Kargs},St};
+	false -> gexpr_test_add(Ke, St)		%Add equality test
+    end;
+gexpr_test(#k_try{arg=B0,vars=[#k_var{name=X}],body=#k_var{name=X},
+		  handler=#k_atom{val=false}}=Try, St0) ->
+    {B,St} = gexpr_test(B0, St0),
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,{B0,B}]),
+    {Try#k_try{arg=B},St};
+gexpr_test(#iset{body=B0}=Iset, St0) ->
+    {B1,St1} = gexpr_test(B0, St0),
+    {Iset#iset{body=B1},St1};
+gexpr_test(Ke, St) -> gexpr_test_add(Ke, St).	%Add equality test
+
+gexpr_test_add(Ke, St0) ->
+    Test = #k_remote{mod=#k_atom{val='erlang'},
+		     name=#k_atom{val='=:='},
+		     arity=2},
+    {Ae,Ap,St1} = force_atomic(Ke, St0),
+    {pre_seq(Ap, #k_test{anno=get_kanno(Ke),
+			 op=Test,args=[Ae,#k_atom{val='true'}]}),St1}.
+
+%% expr(Cexpr, Sub, State) -> {Kexpr,[PreKexpr],State}.
+%%  Convert a Core expression, flattening it at the same time.
+
+expr(#c_var{anno=A,name=V}, Sub, St) ->
+    {#k_var{anno=A,name=get_vsub(V, Sub)},[],St};
+expr(#c_literal{anno=A,val=Lit}, Sub, #kern{lit=no}=St) ->
+    %% No constant pools for compatibility with a previous version.
+    %% Fully expand the literal.
+    Core = expand_literal(Lit, A),
+    expr(Core, Sub, St);
+expr(#c_literal{}=Lit, Sub, St) ->
+    Core = handle_literal(Lit),
+    expr(Core, Sub, St);
+expr(#k_literal{val=Val0}=Klit, _Sub, #kern{lit=Literals0}=St) ->
+    %% Share identical literals to save some space and time during compilation.
+    case dict:find(Val0, Literals0) of
+	{ok,Val} ->
+	    {Klit#k_literal{val=Val},[],St};
+	error ->
+	    Literals = dict:store(Val0, Val0, Literals0),
+	    {Klit,[],St#kern{lit=Literals}}
+    end;
+expr(#k_nil{}=V, _Sub, St) ->
+    {V,[],St};
+expr(#k_int{}=V, _Sub, St) ->
+    {V,[],St};
+expr(#k_float{}=V, _Sub, St) ->
+    {V,[],St};
+expr(#k_atom{}=V, _Sub, St) ->
+    {V,[],St};
+expr(#k_string{}=V, _Sub, St) ->
+    %% Only for compatibility with a previous version.
+    {V,[],St};
+expr(#c_cons{anno=A,hd=Ch,tl=Ct}, Sub, St0) ->
+    %% Do cons in two steps, first the expressions left to right, then
+    %% any remaining literals right to left.
+    {Kh0,Hp0,St1} = expr(Ch, Sub, St0),
+    {Kt0,Tp0,St2} = expr(Ct, Sub, St1),
+    {Kt1,Tp1,St3} = force_atomic(Kt0, St2),
+    {Kh1,Hp1,St4} = force_atomic(Kh0, St3),
+    {#k_cons{anno=A,hd=Kh1,tl=Kt1},Hp0 ++ Tp0 ++ Tp1 ++ Hp1,St4};
+expr(#c_tuple{anno=A,es=Ces}, Sub, St0) ->
+    {Kes,Ep,St1} = atomic_list(Ces, Sub, St0),
+    {#k_tuple{anno=A,es=Kes},Ep,St1};
+expr(#c_binary{anno=A,segments=Cv}, Sub, St0) ->
+    try atomic_bin(Cv, Sub, St0) of
+	{Kv,Ep,St1} ->
+	    {#k_binary{anno=A,segs=Kv},Ep,St1}
+    catch
+	throw:bad_element_size ->
+	    Erl = #c_literal{val=erlang},
+	    Name = #c_literal{val=error},
+	    Args = [#c_literal{val=badarg}],
+	    Error = #c_call{module=Erl,name=Name,args=Args},
+	    expr(Error, Sub, St0)
+    end;
+expr(#c_fname{anno=A,arity=Ar}=Fname, Sub, St) ->
+    %% A local in an expression.
+    %% For now, these are wrapped into a fun by reverse
+    %% etha-conversion, but really, there should be exactly one
+    %% such "lambda function" for each escaping local name,
+    %% instead of one for each occurrence as done now.
+    Vs = [#c_var{name=list_to_atom("V" ++ integer_to_list(V))} ||
+	     V <- integers(1, Ar)],
+    Fun = #c_fun{anno=A,vars=Vs,body=#c_apply{op=Fname,args=Vs}},
+    expr(Fun, Sub, St);
+expr(#c_fun{anno=A,vars=Cvs,body=Cb}, Sub0, #kern{ff=OldFF}=St0) ->
+    FA = case OldFF of
+	     undefined ->
+		 St0#kern.func;
+	     _ ->
+		 case lists:keysearch(id, 1, A) of
+		     {value,{id,{_,_,Name}}} -> Name;
+		     _ -> unknown_fun
+		 end
+	 end,
+    {Kvs,Sub1,St1} = pattern_list(Cvs, Sub0, St0#kern{ff=FA}),
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,{{Cvs,Sub0,St0},{Kvs,Sub1,St1}}]),
+    {Kb,Pb,St2} = body(Cb, Sub1, St1#kern{ff=FA}),
+    {#ifun{anno=A,vars=Kvs,body=pre_seq(Pb, Kb)},[],St2#kern{ff=OldFF}};
+expr(#c_seq{arg=Ca,body=Cb}, Sub, St0) ->
+    {Ka,Pa,St1} = body(Ca, Sub, St0),
+    case is_exit_expr(Ka) of
+	true -> {Ka,Pa,St1};
+	false ->
+	    {Kb,Pb,St2} = body(Cb, Sub, St1),
+	    {Kb,Pa ++ [Ka] ++ Pb,St2}
+    end;
+expr(#c_let{anno=A,vars=Cvs,arg=Ca,body=Cb}, Sub0, St0) ->
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,{Cvs,Sub0,St0}]),
+    {Ka,Pa,St1} = body(Ca, Sub0, St0),
+    case is_exit_expr(Ka) of
+	true -> {Ka,Pa,St1};
+	false ->
+	    {Kps,Sub1,St2} = pattern_list(Cvs, Sub0, St1),
+	    %%ok = io:fwrite("~w: ~p~n", [?LINE,{Kps,Sub1,St1,St2}]),
+	    %% Break known multiple values into separate sets.
+	    Sets = case Ka of
+		       #ivalues{args=Kas} ->
+			   foldr2(fun (V, Val, Sb) ->
+					  [#iset{vars=[V],arg=Val}|Sb] end,
+				  [], Kps, Kas);
+		       _Other ->
+			   [#iset{anno=A,vars=Kps,arg=Ka}]
+		   end,
+	    {Kb,Pb,St3} = body(Cb, Sub1, St2),
+	    {Kb,Pa ++ Sets ++ Pb,St3}
+    end;
+expr(#c_letrec{anno=A,defs=Cfs,body=Cb}, Sub0, St0) ->
+    %% Make new function names and store substitution.
+    {Fs0,{Sub1,St1}} =
+	mapfoldl(fun ({#c_fname{id=F,arity=Ar},B}, {Sub,S0}) ->
+			 {N,St1} = new_fun_name(atom_to_list(F)
+						++ "/" ++
+						integer_to_list(Ar),
+						S0),
+			 {{N,B},{set_fsub(F, Ar, N, Sub),St1}}
+		 end, {Sub0,St0}, Cfs),
+    %% Run translation on functions and body.
+    {Fs1,St2} = mapfoldl(fun ({N,Fd0}, S1) ->
+				 {Fd1,[],St2} = expr(Fd0, Sub1, S1),
+				 Fd = set_kanno(Fd1, A),
+				 {{N,Fd},St2}
+			 end, St1, Fs0),
+    {Kb,Pb,St3} = body(Cb, Sub1, St2),
+    {Kb,[#iletrec{anno=A,defs=Fs1}|Pb],St3};
+expr(#c_case{arg=Ca,clauses=Ccs}, Sub, St0) ->
+    {Ka,Pa,St1} = body(Ca, Sub, St0),		%This is a body!
+    {Kvs,Pv,St2} = match_vars(Ka, St1),		%Must have variables here!
+    {Km,St3} = kmatch(Kvs, Ccs, Sub, St2),
+    Match = flatten_seq(build_match(Kvs, Km)),
+    {last(Match),Pa ++ Pv ++ first(Match),St3};
+expr(#c_receive{anno=A,clauses=Ccs0,timeout=Ce,action=Ca}, Sub, St0) ->
+    {Ke,Pe,St1} = atomic(Ce, Sub, St0),		%Force this to be atomic!
+    {Rvar,St2} = new_var(St1),
+    %% Need to massage accept clauses and add reject clause before matching.
+    Ccs1 = map(fun (#c_clause{anno=Banno,body=B0}=C) ->
+		       B1 = #c_seq{arg=#ireceive_accept{anno=A},body=B0},
+		       C#c_clause{anno=Banno,body=B1}
+	       end, Ccs0),
+    {Mpat,St3} = new_var_name(St2),
+    Rc = #c_clause{anno=[compiler_generated|A],
+		   pats=[#c_var{name=Mpat}],guard=#c_literal{anno=A,val=true},
+		   body=#ireceive_next{anno=A}},
+    {Km,St4} = kmatch([Rvar], Ccs1 ++ [Rc], Sub, add_var_def(Rvar, St3)),
+    {Ka,Pa,St5} = body(Ca, Sub, St4),
+    {#k_receive{anno=A,var=Rvar,body=Km,timeout=Ke,action=pre_seq(Pa, Ka)},
+     Pe,St5};
+expr(#c_search{anno=A,clauses=Ccs0,timeout=Ce,action=Ca}, Sub, St0) ->
+    {Ke,Pe,St1} = atomic(Ce, Sub, St0),		%Force this to be atomic!
+    {Rvar,St2} = new_var(St1),
+    %% Need to massage accept clauses and add reject clause before matching.
+    Ccs1 = map(fun (#c_clause{anno=Banno,body=B0}=C) ->
+		       B1 = #c_seq{arg=#isearch_accept{anno=A},body=B0},
+		       C#c_clause{anno=Banno,body=B1}
+	       end, Ccs0),
+    {Mpat,St3} = new_var_name(St2),
+    Rc = #c_clause{anno=[compiler_generated|A],
+		   pats=[#c_var{name=Mpat}],guard=#c_literal{anno=A,val=true},
+		   body=#ireceive_next{anno=A}},
+    {Km,St4} = kmatch([Rvar], Ccs1 ++ [Rc], Sub, add_var_def(Rvar, St3)),
+    {Ka,Pa,St5} = body(Ca, Sub, St4),
+    {#k_receive{anno=A,var=Rvar,body=Km,timeout=Ke,action=pre_seq(Pa, Ka)},
+     Pe,St5};
+expr(#c_apply{anno=A,op=Cop,args=Cargs}, Sub, St) ->
+    c_apply(A, Cop, Cargs, Sub, St);
+expr(#c_call{anno=A,module=#c_literal{val=erlang},name=#c_literal{val=is_record},
+	     args=[_,Tag,Sz]=Args0}, Sub, St0) ->
+    {Args,Ap,St} = atomic_list(Args0, Sub, St0),
+    Remote = #k_remote{mod=#k_atom{val=erlang},name=#k_atom{val=is_record},arity=3},
+    case {Tag,Sz} of
+	{#c_literal{val=Atom},#c_literal{val=Int}}
+	when is_atom(Atom), is_integer(Int) ->
+	    %% Tag and size are literals. Make it a BIF, which will actually
+	    %% be expanded out in a later pass.
+	    {#k_bif{anno=A,op=Remote,args=Args},Ap,St};
+	{_,_} ->
+	    %% (Only in bodies.) Make it into an actual call to the BIF.
+	    {#k_call{anno=A,op=Remote,args=Args},Ap,St}
+    end;
+expr(#c_call{anno=A,module=M0,name=F0,args=Cargs}, Sub, St0) ->
+    Ar = length(Cargs),
+    {Type,St1} = case call_type(M0, F0, Ar) of
+		     error ->
+			 %% Invalid call (e.g. M:42/3). Issue a warning,
+			 %% and let the generated code use the old explict apply.
+			 {old_apply,add_warning(get_line(A), bad_call, A, St0)};
+		     Type0 ->
+			 {Type0,St0}
+		 end,
+
+    case Type of
+	old_apply ->
+	    Call = #c_call{anno=A,
+			   module=#c_literal{val=erlang},
+			   name=#c_literal{val=apply},
+			   args=[M0,F0,make_list(Cargs)]},
+	    expr(Call, Sub, St1);
+	_ ->
+	    {[M1,F1|Kargs],Ap,St} = atomic_list([M0,F0|Cargs], Sub, St1),
+	    Call = case Type of
+		       bif ->
+			   #k_bif{anno=A,op=#k_remote{mod=M1,name=F1,arity=Ar},
+				  args=Kargs};
+		       call ->
+			   #k_call{anno=A,op=#k_remote{mod=M1,name=F1,arity=Ar},
+				   args=Kargs};
+		       apply ->
+			   #k_call{anno=A,op=#k_remote{mod=M1,name=F1,arity=Ar},
+				   args=Kargs}
+		   end,
+	    {Call,Ap,St}
+    end;
+expr(#c_primop{anno=A,name=#c_literal{val=match_fail},args=Cargs0}, Sub, St0) ->
+    Cargs = translate_match_fail(Cargs0, St0),
+    %% This special case will disappear.
+    {Kargs,Ap,St} = atomic_list(Cargs, Sub, St0),
+    Ar = length(Cargs),
+    Call = #k_call{anno=A,op=#k_internal{name=match_fail,arity=Ar},args=Kargs},
+    {Call,Ap,St};
+expr(#c_primop{anno=A,name=#c_literal{val=N},args=Cargs}, Sub, St0) ->
+    {Kargs,Ap,St1} = atomic_list(Cargs, Sub, St0),
+    Ar = length(Cargs),
+    {#k_bif{anno=A,op=#k_internal{name=N,arity=Ar},args=Kargs},Ap,St1};
+expr(#c_try{anno=A,arg=Ca,vars=Cvs,body=Cb,evars=Evs,handler=Ch}, Sub0, St0) ->
+    %% The normal try expression. The body and exception handler
+    %% variables behave as let variables.
+    {Ka,Pa,St1} = body(Ca, Sub0, St0),
+    {Kcvs,Sub1,St2} = pattern_list(Cvs, Sub0, St1),
+    {Kb,Pb,St3} = body(Cb, Sub1, St2),
+    {Kevs,Sub2,St4} = pattern_list(Evs, Sub0, St3),
+    {Kh,Ph,St5} = body(Ch, Sub2, St4),
+    {#k_try{anno=A,arg=pre_seq(Pa, Ka),
+	    vars=Kcvs,body=pre_seq(Pb, Kb),
+	    evars=Kevs,handler=pre_seq(Ph, Kh)},[],St5};
+expr(#c_catch{anno=A,body=Cb}, Sub, St0) ->
+    {Kb,Pb,St1} = body(Cb, Sub, St0),
+    {#k_catch{anno=A,body=pre_seq(Pb, Kb)},[],St1};
+%% Handle internal expressions.
+expr(#ireceive_accept{anno=A}, _Sub, St) -> {#k_receive_accept{anno=A},[],St};
+%%Search
+expr(#isearch_accept{anno=A}, _Sub, St) -> {#k_search_accept{anno=A},[],St}.
+
+%% Translate a function_clause to case_clause if it has been moved into
+%% another function.
+translate_match_fail([#c_tuple{es=[#c_literal{anno=A,val=function_clause}|As]}]=Args,
+		      #kern{ff=FF}) ->
+    case {A,FF} of
+	{[{name,Same}],Same} ->
+	    %% Still in the correct function.
+	    Args;
+	{[{name,{F,_}}],F} ->
+	    %% Still in the correct function.
+	    Args;
+	_ ->
+	    %% Inlining has probably moved the function_clause into another
+	    %% function (where it will not work correctly).
+	    %% Rewrite to a case_clause.
+	    [#c_tuple{es=[#c_literal{val=case_clause},#c_tuple{es=As}]}]
+    end;
+translate_match_fail(Args, _) -> Args.
+
+%% expr_list([Cexpr], Sub, State) -> {[Kexpr],[PreKexpr],State}.
+
+% expr_list(Ces, Sub, St) ->
+%     foldr(fun (Ce, {Kes,Esp,St0}) ->
+% 		  {Ke,Ep,St1} = expr(Ce, Sub, St0),
+% 		  {[Ke|Kes],Ep ++ Esp,St1}
+% 	  end, {[],[],St}, Ces).
+
+%% call_type(Module, Function, Arity) -> call | bif | apply | error.
+%%  Classify the call.
+call_type(#c_literal{val=M}, #c_literal{val=F}, Ar) when is_atom(M), is_atom(F) ->
+    case is_remote_bif(M, F, Ar) of
+	false -> call;
+	true -> bif
+    end;
+call_type(#c_var{}, #c_literal{val=A}, _) when is_atom(A) -> apply;
+call_type(#c_literal{val=A}, #c_var{}, _) when is_atom(A) -> apply;
+call_type(#c_var{}, #c_var{}, _) -> apply;
+call_type(_, _, _) -> error.
+
+%% match_vars(Kexpr, State) -> {[Kvar],[PreKexpr],State}.
+%%  Force return from body into a list of variables.
+
+match_vars(#ivalues{args=As}, St) ->
+    foldr(fun (Ka, {Vs,Vsp,St0}) ->
+		  {V,Vp,St1} = force_variable(Ka, St0),
+		  {[V|Vs],Vp ++ Vsp,St1}
+	  end, {[],[],St}, As);
+match_vars(Ka, St0) ->
+    {V,Vp,St1} = force_variable(Ka, St0),
+    {[V],Vp,St1}.
+
+%% c_apply(A, Op, [Carg], Sub, State) -> {Kexpr,[PreKexpr],State}.
+%%  Transform application, detect which are guaranteed to be bifs.
+
+c_apply(A, #c_fname{anno=Ra,id=F0,arity=Ar}, Cargs, Sub, St0) ->
+    {Kargs,Ap,St1} = atomic_list(Cargs, Sub, St0),
+    F1 = get_fsub(F0, Ar, Sub),			%Has it been rewritten
+    {#k_call{anno=A,op=#k_local{anno=Ra,name=F1,arity=Ar},args=Kargs},
+     Ap,St1};
+c_apply(A, Cop, Cargs, Sub, St0) ->
+    {Kop,Op,St1} = variable(Cop, Sub, St0),
+    {Kargs,Ap,St2} = atomic_list(Cargs, Sub, St1),
+    {#k_call{anno=A,op=Kop,args=Kargs},Op ++ Ap,St2}.
+
+flatten_seq(#iset{anno=A,vars=Vs,arg=Arg,body=B}) ->
+    [#iset{anno=A,vars=Vs,arg=Arg}|flatten_seq(B)];
+flatten_seq(Ke) -> [Ke].
+
+pre_seq([#iset{anno=A,vars=Vs,arg=Arg,body=B}|Ps], K) ->
+    B = undefined,				%Assertion.
+    #iset{anno=A,vars=Vs,arg=Arg,body=pre_seq(Ps, K)};
+pre_seq([P|Ps], K) ->
+    #iset{vars=[],arg=P,body=pre_seq(Ps, K)};
+pre_seq([], K) -> K.
+
+%% atomic(Cexpr, Sub, State) -> {Katomic,[PreKexpr],State}.
+%%  Convert a Core expression making sure the result is an atomic
+%%  literal.
+
+atomic(Ce, Sub, St0) ->
+    {Ke,Kp,St1} = expr(Ce, Sub, St0),
+    {Ka,Ap,St2} = force_atomic(Ke, St1),
+    {Ka,Kp ++ Ap,St2}.
+
+force_atomic(Ke, St0) ->
+    case is_atomic(Ke) of
+	true -> {Ke,[],St0}; 
+	false ->
+	    {V,St1} = new_var(St0),
+	    {V,[#iset{vars=[V],arg=Ke}],St1}
+    end.
+
+% force_atomic_list(Kes, St) ->
+%     foldr(fun (Ka, {As,Asp,St0}) ->
+% 		  {A,Ap,St1} = force_atomic(Ka, St0),
+% 		  {[A|As],Ap ++ Asp,St1}
+% 	  end, {[],[],St}, Kes).
+
+atomic_bin([#c_bitstr{anno=A,val=E0,size=S0,unit=U0,type=T,flags=Fs0}|Es0],
+	   Sub, St0) ->
+    {E,Ap1,St1} = atomic(E0, Sub, St0),
+    {S1,Ap2,St2} = atomic(S0, Sub, St1),
+    validate_bin_element_size(S1),
+    U1 = core_lib:literal_value(U0),
+    Fs1 = core_lib:literal_value(Fs0),
+    {Es,Ap3,St3} = atomic_bin(Es0, Sub, St2),
+    {#k_bin_seg{anno=A,size=S1,
+		unit=U1,
+		type=core_lib:literal_value(T),
+		flags=Fs1,
+		seg=E,next=Es},
+     Ap1++Ap2++Ap3,St3};
+atomic_bin([], _Sub, St) -> {#k_bin_end{},[],St}.
+
+validate_bin_element_size(#k_var{}) -> ok;
+validate_bin_element_size(#k_int{val=V}) when V >= 0 -> ok;
+validate_bin_element_size(#k_atom{val=all}) -> ok;
+validate_bin_element_size(#k_atom{val=undefined}) -> ok;
+validate_bin_element_size(_) -> throw(bad_element_size).
+    
+%% atomic_list([Cexpr], Sub, State) -> {[Kexpr],[PreKexpr],State}.
+
+atomic_list(Ces, Sub, St) ->
+    foldr(fun (Ce, {Kes,Esp,St0}) ->
+		  {Ke,Ep,St1} = atomic(Ce, Sub, St0),
+		  {[Ke|Kes],Ep ++ Esp,St1}
+	  end, {[],[],St}, Ces).
+
+%% is_atomic(Kexpr) -> bool().
+%%  Is a Kexpr atomic?  Strings are NOT considered atomic!
+
+is_atomic(#k_literal{}) -> true;
+is_atomic(#k_int{}) -> true;
+is_atomic(#k_float{}) -> true;
+is_atomic(#k_atom{}) -> true;
+%%is_atomic(#k_char{}) -> true;			%No characters
+%%is_atomic(#k_string{}) -> true;
+is_atomic(#k_nil{}) -> true;
+is_atomic(#k_var{}) -> true;
+is_atomic(_) -> false.
+
+%% variable(Cexpr, Sub, State) -> {Kvar,[PreKexpr],State}.
+%%  Convert a Core expression making sure the result is a variable.
+
+variable(Ce, Sub, St0) ->
+    {Ke,Kp,St1} = expr(Ce, Sub, St0),
+    {Kv,Vp,St2} = force_variable(Ke, St1),
+    {Kv,Kp ++ Vp,St2}.
+
+force_variable(#k_var{}=Ke, St) -> {Ke,[],St};
+force_variable(Ke, St0) ->
+    {V,St1} = new_var(St0),
+    {V,[#iset{vars=[V],arg=Ke}],St1}.
+
+%% pattern(Cpat, Isub, Osub, State) -> {Kpat,Sub,State}.
+%%  Convert patterns.  Variables shadow so rename variables that are
+%%  already defined.
+%%
+%%  Patterns are complicated by sizes in binaries.  These are pure
+%%  input variables which create no bindings.  We, therefore, need to
+%%  carry around the original substitutions to get the correct
+%%  handling.
+
+pattern(#c_var{anno=A,name=V}, _Isub, Osub, St0) ->
+    case sets:is_element(V, St0#kern.ds) of
+	true ->
+	    {New,St1} = new_var_name(St0),
+	    {#k_var{anno=A,name=New},
+	     set_vsub(V, New, Osub),
+	     St1#kern{ds=sets:add_element(New, St1#kern.ds)}};
+	false ->
+	    {#k_var{anno=A,name=V},Osub,
+	     St0#kern{ds=sets:add_element(V, St0#kern.ds)}}
+    end;
+pattern(#c_literal{anno=A,val=V}, _Isub, Osub, St) ->
+    {expand_pat_literal(V, A),Osub,St};
+pattern(#c_cons{anno=A,hd=Ch,tl=Ct}, Isub, Osub0, St0) ->
+    {Kh,Osub1,St1} = pattern(Ch, Isub, Osub0, St0),
+    {Kt,Osub2,St2} = pattern(Ct, Isub, Osub1, St1),
+    {#k_cons{anno=A,hd=Kh,tl=Kt},Osub2,St2};
+pattern(#c_tuple{anno=A,es=Ces}, Isub, Osub0, St0) ->
+    {Kes,Osub1,St1} = pattern_list(Ces, Isub, Osub0, St0),
+    {#k_tuple{anno=A,es=Kes},Osub1,St1};
+pattern(#c_binary{anno=A,segments=Cv}, Isub, Osub0, St0) ->
+    {Kv,Osub1,St1} = pattern_bin(Cv, Isub, Osub0, St0),
+    {#k_binary{anno=A,segs=Kv},Osub1,St1};
+pattern(#c_alias{anno=A,var=Cv,pat=Cp}, Isub, Osub0, St0) ->
+    {Cvs,Cpat} = flatten_alias(Cp),
+    {Kvs,Osub1,St1} = pattern_list([Cv|Cvs], Isub, Osub0, St0),
+    {Kpat,Osub2,St2} = pattern(Cpat, Isub, Osub1, St1),
+    {#ialias{anno=A,vars=Kvs,pat=Kpat},Osub2,St2}.
+
+flatten_alias(#c_alias{var=V,pat=P}) ->
+    {Vs,Pat} = flatten_alias(P),
+    {[V|Vs],Pat};
+flatten_alias(Pat) -> {[],Pat}.
+
+pattern_bin(Es, Isub, Osub0, St0) ->
+    {Kbin,{_,Osub},St} = pattern_bin_1(Es, Isub, Osub0, St0),
+    {Kbin,Osub,St}.
+
+pattern_bin_1([#c_bitstr{anno=A,val=E0,size=S0,unit=U,type=T,flags=Fs}|Es0], 
+	    Isub0, Osub0, St0) ->
+    {S1,[],St1} = expr(S0, Isub0, St0),
+    U0 = core_lib:literal_value(U),
+    Fs0 = core_lib:literal_value(Fs),
+    %%ok= io:fwrite("~w: ~p~n", [?LINE,{B0,S1,U0,Fs0}]),
+    {E,Osub1,St2} = pattern(E0, Isub0, Osub0, St1),
+    Isub1 = case E0 of
+		#c_var{name=V} ->
+		    set_vsub(V, E#k_var.name, Isub0);
+		_ -> Isub0
+	    end,
+    {Es,{Isub,Osub},St3} = pattern_bin_1(Es0, Isub1, Osub1, St2),
+    {#k_bin_seg{anno=A,size=S1,
+		unit=U0,
+		type=core_lib:literal_value(T),
+		flags=Fs0,
+		seg=E,next=Es},
+     {Isub,Osub},St3};
+pattern_bin_1([], Isub, Osub, St) -> {#k_bin_end{},{Isub,Osub},St}.
+
+%% pattern_list([Cexpr], Sub, State) -> {[Kexpr],Sub,State}.
+
+pattern_list(Ces, Sub, St) ->
+    pattern_list(Ces, Sub, Sub, St).
+
+pattern_list(Ces, Isub, Osub, St) ->
+    foldr(fun (Ce, {Kes,Osub0,St0}) ->
+		  {Ke,Osub1,St1} = pattern(Ce, Isub, Osub0, St0),
+		  {[Ke|Kes],Osub1,St1}
+	  end, {[],Osub,St}, Ces).
+
+%% new_sub() -> Subs.
+%% set_vsub(Name, Sub, Subs) -> Subs.
+%% subst_vsub(Name, Sub, Subs) -> Subs.
+%% get_vsub(Name, Subs) -> SubName.
+%%  Add/get substitute Sub for Name to VarSub.  Use orddict so we know
+%%  the format is a list {Name,Sub} pairs.  When adding a new
+%%  substitute we fold substitute chains so we never have to search
+%%  more than once.
+
+new_sub() -> orddict:new().
+
+get_vsub(V, Vsub) ->
+    case orddict:find(V, Vsub) of
+	{ok,Val} -> Val;
+	error -> V
+    end.
+
+set_vsub(V, S, Vsub) ->
+    orddict:store(V, S, Vsub).
+
+subst_vsub(V, S, Vsub0) ->
+    %% Fold chained substitutions.
+    Vsub1 = orddict:map(fun (_, V1) when V1 =:= V -> S;
+			    (_, V1) -> V1
+			end, Vsub0),
+    orddict:store(V, S, Vsub1).
+
+get_fsub(F, A, Fsub) ->
+    case orddict:find({F,A}, Fsub) of
+	{ok,Val} -> Val;
+	error -> F
+    end.
+
+set_fsub(F, A, S, Fsub) ->
+    orddict:store({F,A}, S, Fsub).
+
+new_fun_name(St) ->
+    new_fun_name("anonymous", St).
+
+%% new_fun_name(Type, State) -> {FunName,State}.
+
+new_fun_name(Type, #kern{func={F,Arity},fcount=C}=St) ->
+    Name = "-" ++ atom_to_list(F) ++ "/" ++ integer_to_list(Arity) ++
+	"-" ++ Type ++ "-" ++ integer_to_list(C) ++ "-",
+    {list_to_atom(Name),St#kern{fcount=C+1}}.
+
+%% new_var_name(State) -> {VarName,State}.
+
+new_var_name(#kern{vcount=C}=St) ->
+    {list_to_atom("ker" ++ integer_to_list(C)),St#kern{vcount=C+1}}.
+
+%% new_var(State) -> {#k_var{},State}.
+
+new_var(St0) ->
+    {New,St1} = new_var_name(St0),
+    {#k_var{name=New},St1}.
+
+%% new_vars(Count, State) -> {[#k_var{}],State}.
+%%  Make Count new variables.
+
+new_vars(N, St) -> new_vars(N, St, []).
+
+new_vars(N, St0, Vs) when N > 0 ->
+    {V,St1} = new_var(St0),
+    new_vars(N-1, St1, [V|Vs]);
+new_vars(0, St, Vs) -> {Vs,St}.
+
+make_vars(Vs) -> [ #k_var{name=V} || V <- Vs ].
+
+add_var_def(V, St) ->
+    St#kern{ds=sets:add_element(V#k_var.name, St#kern.ds)}.
+
+%%add_vars_def(Vs, St) ->
+%%    Ds = foldl(fun (#k_var{name=V}, Ds) -> add_element(V, Ds) end,
+%%	       St#kern.ds, Vs),
+%%    St#kern{ds=Ds}.
+
+%% is_remote_bif(Mod, Name, Arity) -> true | false.
+%%  Test if function is really a BIF.
+
+is_remote_bif(erlang, get, 1) -> true;
+is_remote_bif(erlang, N, A) ->
+    case erl_internal:guard_bif(N, A) of
+	true -> true;
+	false ->
+	    try erl_internal:op_type(N, A) of
+		arith -> true;
+		bool -> true;
+		comp -> true;
+		list -> false;
+		send -> false
+	    catch
+		_:_ -> false		% not an op
+	    end
+    end;
+is_remote_bif(_, _, _) -> false.
+
+%% bif_vals(Name, Arity) -> integer().
+%% bif_vals(Mod, Name, Arity) -> integer().
+%%  Determine how many return values a BIF has.  Provision for BIFs to
+%%  return multiple values.  Only used in bodies where a BIF may be
+%%  called for effect only.
+
+bif_vals(dsetelement, 3) -> 0;
+bif_vals(bs_context_to_binary, 1) -> 0;
+bif_vals(_, _) -> 1.
+
+bif_vals(_, _, _) -> 1.
+
+%% foldr2(Fun, Acc, List1, List2) -> Acc.
+%%  Fold over two lists.
+
+foldr2(Fun, Acc0, [E1|L1], [E2|L2]) ->
+    Acc1 = Fun(E1, E2, Acc0),
+    foldr2(Fun, Acc1, L1, L2);
+foldr2(_, Acc, [], []) -> Acc.
+
+%% first([A]) -> [A].
+%% last([A]) -> A.
+
+last([L]) -> L;
+last([_|T]) -> last(T).
+
+first([_]) -> [];
+first([H|T]) -> [H|first(T)].
+
+%% This code implements the algorithm for an optimizing compiler for
+%% pattern matching given "The Implementation of Functional
+%% Programming Languages" by Simon Peyton Jones. The code is much
+%% longer as the meaning of constructors is different from the book.
+%%
+%% In Erlang many constructors can have different values, e.g. 'atom'
+%% or 'integer', whereas in the original algorithm these would be
+%% different constructors. Our view makes it easier in later passes to
+%% handle indexing over each type.
+%%
+%% Patterns are complicated by having alias variables.  The form of a
+%% pattern is Pat | {alias,Pat,[AliasVar]}.  This is hidden by access
+%% functions to pattern arguments but the code must be aware of it.
+%%
+%% The compilation proceeds in two steps:
+%%
+%% 1. The patterns in the clauses to converted to lists of kernel
+%% patterns.  The Core clause is now hybrid, this is easier to work
+%% with.  Remove clauses with trivially false guards, this simplifies
+%% later passes.  Add locally defined vars and variable subs to each
+%% clause for later use.
+%%
+%% 2. The pattern matching is optimised.  Variable substitutions are
+%% added to the VarSub structure and new variables are made visible.
+%% The guard and body are then converted to Kernel form.
+
+%% kmatch([Var], [Clause], Sub, State) -> {Kexpr,[PreExpr],State}.
+
+kmatch(Us, Ccs, Sub, St0) ->
+    {Cs,St1} = match_pre(Ccs, Sub, St0),	%Convert clauses
+    %%Def = kernel_match_error,              %The strict case
+    %% This should be a kernel expression from the first pass.
+    Def = #k_call{anno=[compiler_generated],
+		  op=#k_remote{mod=#k_atom{val=erlang},
+			       name=#k_atom{val=exit},
+			       arity=1},
+		  args=[#k_atom{val=kernel_match_error}]},
+    {Km,St2} = match(Us, Cs, Def, St1),               %Do the match.
+    {Km,St2}.
+
+%% match_pre([Cclause], Sub, State) -> {[Clause],State}.
+%%  Must be careful not to generate new substitutions here now!
+%%  Remove clauses with trivially false guards which will never
+%%  succeed.
+
+match_pre(Cs, Sub0, St) ->
+    foldr(fun (#c_clause{anno=A,pats=Ps,guard=G,body=B}, {Cs0,St0}) ->
+		  case is_false_guard(G) of
+		      true -> {Cs0,St0};
+		      false ->
+			  {Kps,Osub1,St1} = pattern_list(Ps, Sub0, St0),
+			  {[#iclause{anno=A,isub=Sub0,osub=Osub1,
+				     pats=Kps,guard=G,body=B}|
+			    Cs0],St1}
+		  end
+	  end, {[],St}, Cs).
+
+%% match([Var], [Clause], Default, State) -> {MatchExpr,State}.
+
+match([U|Us], Cs, Def, St0) ->
+    %%ok = io:format("match ~p~n", [Cs]),
+    Pcss = partition(Cs),
+    foldr(fun (Pcs, {D,St}) -> match_varcon([U|Us], Pcs, D, St) end,
+	  {Def,St0}, Pcss);
+match([], Cs, Def, St) ->
+    match_guard(Cs, Def, St).
+
+%% match_guard([Clause], Default, State) -> {IfExpr,State}.
+%%  Build a guard to handle guards. A guard *ALWAYS* fails if no
+%%  clause matches, there will be a surrounding 'alt' to catch the
+%%  failure.  Drop redundant cases, i.e. those after a true guard.
+
+match_guard(Cs0, Def0, St0) ->
+    {Cs1,Def1,St1} = match_guard_1(Cs0, Def0, St0),
+    {build_alt(build_guard(Cs1), Def1),St1}.
+
+match_guard_1([#iclause{anno=A,osub=Osub,guard=G,body=B}|Cs0], Def0, St0) ->
+    case is_true_guard(G) of
+	true ->
+	    %% The true clause body becomes the default.
+	    {Kb,Pb,St1} = body(B, Osub, St0),
+	    Line = get_line(A),
+	    St2 = maybe_add_warning(Cs0, Line, St1),
+	    St = maybe_add_warning(Def0, Line, St2),
+	    {[],pre_seq(Pb, Kb),St};
+	false ->
+	    {Kg,St1} = guard(G, Osub, St0),
+	    {Kb,Pb,St2} = body(B, Osub, St1),
+	    {Cs1,Def1,St3} = match_guard_1(Cs0, Def0, St2),
+	    {[#k_guard_clause{guard=Kg,body=pre_seq(Pb, Kb)}|Cs1],
+	     Def1,St3}
+    end;
+match_guard_1([], Def, St) -> {[],Def,St}. 
+
+maybe_add_warning([C|_], Line, St) ->
+    maybe_add_warning(C, Line, St);
+maybe_add_warning([], _Line, St) -> St;
+maybe_add_warning(fail, _Line, St) -> St;
+maybe_add_warning(Ke, MatchLine, St) ->
+    case get_kanno(Ke) of
+	[compiler_generated|_] -> St;
+	Anno ->
+	    Line = get_line(Anno),
+	    Warn = case MatchLine of
+		       none -> nomatch_shadow;
+		       _ -> {nomatch_shadow,MatchLine}
+		   end,
+	    add_warning(Line, Warn, Anno, St)
+    end.
+    
+get_line([Line|_]) when is_integer(Line) -> Line;
+get_line([_|T]) -> get_line(T);
+get_line([]) -> none.
+    
+get_file([{file,File}|_]) -> File;
+get_file([_|T]) -> get_file(T);
+get_file([]) -> "no_file". % should not happen
+
+%% is_true_guard(Guard) -> bool().
+%% is_false_guard(Guard) -> bool().
+%%  Test if a guard is either trivially true/false.  This has probably
+%%  already been optimised away, but what the heck!
+
+is_true_guard(G) -> guard_value(G) =:= true.
+is_false_guard(G) -> guard_value(G) =:= false.
+
+%% guard_value(Guard) -> true | false | unknown.
+
+guard_value(#c_literal{val=true}) -> true;
+guard_value(#c_literal{val=false}) -> false;
+guard_value(#c_call{module=#c_literal{val=erlang},
+		    name=#c_literal{val='not'},
+		    args=[A]}) ->
+    case guard_value(A) of
+	true -> false;
+	false -> true;
+	unknown -> unknown
+    end;
+guard_value(#c_call{module=#c_literal{val=erlang},
+		    name=#c_literal{val='and'},
+		    args=[Ca,Cb]}) ->
+    case guard_value(Ca) of
+	true -> guard_value(Cb);
+	false -> false;
+	unknown ->
+	    case guard_value(Cb) of
+		false -> false;
+		_Other -> unknown
+	    end
+    end;
+guard_value(#c_call{module=#c_literal{val=erlang},
+		    name=#c_literal{val='or'},
+		    args=[Ca,Cb]}) ->
+    case guard_value(Ca) of
+	true -> true;
+	false -> guard_value(Cb);
+	unknown ->
+	    case guard_value(Cb) of
+		true -> true;
+		_Other -> unknown
+	    end
+    end;
+guard_value(#c_try{arg=E,vars=[#c_var{name=X}],body=#c_var{name=X},
+		   handler=#c_literal{val=false}}) ->
+    guard_value(E);
+guard_value(_) -> unknown.
+
+%% partition([Clause]) -> [[Clause]].
+%%  Partition a list of clauses into groups which either contain
+%%  clauses with a variable first argument, or with a "constructor".
+
+partition([C1|Cs]) ->
+    V1 = is_var_clause(C1),
+    {More,Rest} = splitwith(fun (C) -> is_var_clause(C) =:= V1 end, Cs),
+    [[C1|More]|partition(Rest)];
+partition([]) -> [].
+
+%% match_varcon([Var], [Clause], Def, [Var], Sub, State) ->
+%%        {MatchExpr,State}.
+
+match_varcon(Us, [C|_]=Cs, Def, St) ->
+    case is_var_clause(C) of
+	true -> match_var(Us, Cs, Def, St);
+	false -> match_con(Us, Cs, Def, St)
+    end.
+
+%% match_var([Var], [Clause], Def, State) -> {MatchExpr,State}.
+%%  Build a call to "select" from a list of clauses all containing a
+%%  variable as the first argument.  We must rename the variable in
+%%  each clause to be the match variable as these clause will share
+%%  this variable and may have different names for it.  Rename aliases
+%%  as well.
+
+match_var([U|Us], Cs0, Def, St) ->
+    Cs1 = map(fun (#iclause{isub=Isub0,osub=Osub0,pats=[Arg|As]}=C) ->
+		      Vs = [arg_arg(Arg)|arg_alias(Arg)],
+ 		      Osub1 = foldl(fun (#k_var{name=V}, Acc) ->
+ 					   subst_vsub(V, U#k_var.name, Acc)
+ 				   end, Osub0, Vs),
+ 		      Isub1 = foldl(fun (#k_var{name=V}, Acc) ->
+					    subst_vsub(V, U#k_var.name, Acc)
+				    end, Isub0, Vs),
+		      C#iclause{isub=Isub1,osub=Osub1,pats=As}
+	      end, Cs0),
+    match(Us, Cs1, Def, St).
+
+%% match_con(Variables, [Clause], Default, State) -> {SelectExpr,State}.
+%%  Build call to "select" from a list of clauses all containing a
+%%  constructor/constant as first argument.  Group the constructors
+%%  according to type, the order is really irrelevant but tries to be
+%%  smart.
+
+match_con([U|Us], Cs, Def, St0) ->
+    %% Extract clauses for different constructors (types).
+    %%ok = io:format("match_con ~p~n", [Cs]),
+    Ttcs = select_types([k_binary], Cs) ++ select_bin_con(Cs) ++
+	select_types([k_cons,k_tuple,k_atom,k_float,k_int,k_nil], Cs),
+    %%ok = io:format("ttcs = ~p~n", [Ttcs]),
+    {Scs,St1} =
+	mapfoldl(fun ({T,Tcs}, St) ->
+			 {[S|_]=Sc,S1} = match_value([U|Us], T, Tcs, fail, St),
+			 %%ok = io:format("match_con type2 ~p~n", [T]),
+			 Anno = get_kanno(S),
+			 {#k_type_clause{anno=Anno,type=T,values=Sc},S1} end,
+		 St0, Ttcs),
+    {build_alt_1st_no_fail(build_select(U, Scs), Def),St1}.
+
+select_types(Types, Cs) ->
+    [{T,Tcs} || T <- Types, begin Tcs = select(T, Cs), Tcs =/= [] end].
+    
+
+%% select_bin_con([Clause]) -> [{Type,[Clause]}].
+%%  Extract clauses for the k_bin_seg constructor.  As k_bin_seg
+%%  matching can overlap, the k_bin_seg constructors cannot be
+%%  reordered, only grouped.
+
+select_bin_con(Cs0) ->
+    Cs1 = lists:filter(fun (C) ->
+			       Con = clause_con(C),
+			       (Con =:= k_bin_seg) or (Con =:= k_bin_end)
+		       end, Cs0),
+    select_bin_con_1(Cs1).
+
+select_bin_con_1(Cs) ->
+    try
+	select_bin_int(Cs)
+    catch
+	throw:not_possible ->
+	    select_bin_con_2(Cs)
+    end.
+
+select_bin_con_2([C1|Cs]) ->
+    Con = clause_con(C1),
+    {More,Rest} = splitwith(fun (C) -> clause_con(C) =:= Con end, Cs),
+    [{Con,[C1|More]}|select_bin_con_2(Rest)];
+select_bin_con_2([]) -> [].
+
+%% select_bin_int([Clause]) -> {k_bin_int,[Clause]}
+%%  If the first pattern in each clause selects the same integer,
+%%  rewrite all clauses to use #k_bin_int{} (which will later to
+%%  translated to a bs_match_string/4 instruction).
+%%
+%%  If it is not possible to do this rewrite, a 'not_possible'
+%%  exception is thrown.
+
+select_bin_int([#iclause{pats=[#k_bin_seg{anno=A,type=integer,
+ 					  size=#k_int{val=Bits0}=Sz,unit=U,
+ 					  flags=Fl,seg=#k_int{val=Val},
+					  next=N}|Ps]}=C|Cs0]) ->
+    Bits = U * Bits0,
+    if
+	Bits > 1024 -> throw(not_possible); %Expands the code too much.
+	true -> ok
+    end,
+    select_assert_match_possible(Bits, Val, Fl),
+    P = #k_bin_int{anno=A,size=Sz,unit=U,flags=Fl,val=Val,next=N},
+    select_assert_match_possible(Bits, Val, Fl),
+    case member(native, Fl) of
+	true -> throw(not_possible);
+	false -> ok
+    end,
+    Cs = select_bin_int_1(Cs0, Bits, Fl, Val),
+    [{k_bin_int,[C#iclause{pats=[P|Ps]}|Cs]}];
+select_bin_int([#iclause{pats=[#k_bin_seg{anno=A,type=utf8,
+ 					  flags=[unsigned,big]=Fl,
+					  seg=#k_int{val=Val0},
+					  next=N}|Ps]}=C|Cs0]) ->
+    {Val,Bits} = select_utf8(Val0),
+    P = #k_bin_int{anno=A,size=#k_int{val=Bits},unit=1,
+		   flags=Fl,val=Val,next=N},
+    Cs = select_bin_int_1(Cs0, Bits, Fl, Val),
+    [{k_bin_int,[C#iclause{pats=[P|Ps]}|Cs]}];
+select_bin_int(_) -> throw(not_possible).
+
+select_bin_int_1([#iclause{pats=[#k_bin_seg{anno=A,type=integer,
+					    size=#k_int{val=Bits0}=Sz,unit=U,
+					    flags=Fl,seg=#k_int{val=Val},
+					    next=N}|Ps]}=C|Cs],
+		 Bits, Fl, Val) ->
+    if
+	Bits0*U =:= Bits -> ok;
+	true -> throw(not_possible)
+    end,
+    P = #k_bin_int{anno=A,size=Sz,unit=U,flags=Fl,val=Val,next=N},
+    [C#iclause{pats=[P|Ps]}|select_bin_int_1(Cs, Bits, Fl, Val)];
+select_bin_int_1([#iclause{pats=[#k_bin_seg{anno=A,type=utf8,
+					    flags=Fl,seg=#k_int{val=Val0},
+					    next=N}|Ps]}=C|Cs],
+		 Bits, Fl, Val) ->
+    case select_utf8(Val0) of
+	{Val,Bits} -> ok;
+	{_,_} -> throw(not_possible)
+    end,
+    P = #k_bin_int{anno=A,size=#k_int{val=Bits},unit=1,
+		   flags=[unsigned,big],val=Val,next=N},
+    [C#iclause{pats=[P|Ps]}|select_bin_int_1(Cs, Bits, Fl, Val)];
+select_bin_int_1([], _, _, _) -> [];
+select_bin_int_1(_, _, _, _) -> throw(not_possible).
+
+select_assert_match_possible(Sz, Val, Fs) ->
+    EmptyBindings = erl_eval:new_bindings(),
+    MatchFun = fun({integer,_,_}, NewV, Bs) when NewV =:= Val ->
+		       {match,Bs}
+	       end,
+    EvalFun = fun({integer,_,S}, B) -> {value,S,B} end,
+    Expr = [{bin_element,0,{integer,0,Val},{integer,0,Sz},[{unit,1}|Fs]}],
+    {value,Bin,EmptyBindings} = eval_bits:expr_grp(Expr, EmptyBindings, EvalFun),
+    try
+	{match,_} = eval_bits:match_bits(Expr, Bin,
+					 EmptyBindings,
+					 EmptyBindings,
+					 MatchFun, EvalFun)
+    catch
+	throw:nomatch ->
+	    throw(not_possible)
+    end.
+
+select_utf8(Val0) ->
+    Bin = int_to_utf8(Val0),
+    Size = bit_size(Bin),
+    <<Val:Size>> = Bin,
+    {Val,Size}.
+
+%% XXX Get rid of this function in the release following R12B-5.
+int_to_utf8(I) when 0 =< I, I =< 16#7F ->
+    <<I>>;
+int_to_utf8(I) when 0 =< I, I =< 16#7FF ->
+    B2 = I,
+    B1 = (I bsr 6),
+    <<1:1,1:1,0:1,B1:5,1:1,0:1,B2:6>>;
+int_to_utf8(I) when 0 =< I, I =< 16#FFFF ->
+    if
+	16#D800 =< I, I =< 16#DFFF -> throw(not_possible);
+	true -> ok
+    end,
+    B3 = I,
+    B2 = (I bsr 6),
+    B1 = (I bsr 12),
+    <<1:1,1:1,1:1,0:1,B1:4,1:1,0:1,B2:6,1:1,0:1,B3:6>>;
+int_to_utf8(I) when 0 =< I, I =< 16#10FFFF ->
+    B4 = I,
+    B3 = (I bsr 6),
+    B2 = (I bsr 12),
+    B1 = (I bsr 18),
+    <<1:1,1:1,1:1,1:1,0:1,B1:3,1:1,0:1,B2:6,1:1,0:1,B3:6,1:1,0:1,B4:6>>;
+int_to_utf8(_) ->
+    throw(not_possible).
+
+%% select(Con, [Clause]) -> [Clause].
+
+select(T, Cs) -> [ C || C <- Cs, clause_con(C) =:= T ].
+
+%% match_value([Var], Con, [Clause], Default, State) -> {SelectExpr,State}.
+%%  At this point all the clauses have the same constructor, we must
+%%  now separate them according to value.
+
+match_value(_, _, [], _, St) -> {[],St};
+match_value(Us, T, Cs0, Def, St0) ->
+    Css = group_value(T, Cs0),
+    %%ok = io:format("match_value ~p ~p~n", [T, Css]),
+    {Css1,St1} = mapfoldl(fun (Cs, St) ->
+				  match_clause(Us, Cs, Def, St) end,
+			  St0, Css),
+    {Css1,St1}.
+    %%{#k_select_val{type=T,var=hd(Us),clauses=Css1},St1}.
+
+%% group_value([Clause]) -> [[Clause]].
+%%  Group clauses according to value.  Here we know that
+%%  1. Some types are singled valued
+%%  2. The clauses in bin_segs cannot be reordered only grouped
+%%  3. Other types are disjoint and can be reordered
+
+group_value(k_cons, Cs) -> [Cs];		%These are single valued
+group_value(k_nil, Cs) -> [Cs];
+group_value(k_binary, Cs) -> [Cs];
+group_value(k_bin_end, Cs) -> [Cs];
+group_value(k_bin_seg, Cs) ->
+    group_bin_seg(Cs);
+group_value(k_bin_int, Cs) ->
+    [Cs];
+group_value(_, Cs) ->
+    %% group_value(Cs).
+    Cd = foldl(fun (C, Gcs0) -> dict:append(clause_val(C), C, Gcs0) end,
+	       dict:new(), Cs),
+    dict:fold(fun (_, Vcs, Css) -> [Vcs|Css] end, [], Cd).
+
+group_bin_seg([C1|Cs]) ->
+    V1 = clause_val(C1),
+    {More,Rest} = splitwith(fun (C) -> clause_val(C) == V1 end, Cs),
+    [[C1|More]|group_bin_seg(Rest)];
+group_bin_seg([]) -> [].
+
+%% Profiling shows that this quadratic implementation account for a big amount
+%% of the execution time if there are many values.
+% group_value([C|Cs]) ->
+%     V = clause_val(C),
+%     Same = [ Cv || Cv <- Cs, clause_val(Cv) == V ], %Same value
+%     Rest = [ Cv || Cv <- Cs, clause_val(Cv) /= V ], % and all the rest
+%     [[C|Same]|group_value(Rest)];
+% group_value([]) -> [].
+
+%% match_clause([Var], [Clause], Default, State) -> {Clause,State}.
+%%  At this point all the clauses have the same "value".  Build one
+%%  select clause for this value and continue matching.  Rename
+%%  aliases as well.
+
+match_clause([U|Us], [C|_]=Cs0, Def, St0) ->
+    Anno = get_kanno(C),
+    {Match0,Vs,St1} = get_match(get_con(Cs0), St0),
+    Match = sub_size_var(Match0, Cs0),
+    {Cs1,St2} = new_clauses(Cs0, U, St1),
+    {B,St3} = match(Vs ++ Us, Cs1, Def, St2),
+    {#k_val_clause{anno=Anno,val=Match,body=B},St3}.
+
+sub_size_var(#k_bin_seg{size=#k_var{name=Name}=Kvar}=BinSeg, [#iclause{isub=Sub}|_]) ->
+    BinSeg#k_bin_seg{size=Kvar#k_var{name=get_vsub(Name, Sub)}};
+sub_size_var(#k_bin_int{size=#k_var{name=Name}=Kvar}=BinSeg, [#iclause{isub=Sub}|_]) ->
+    BinSeg#k_bin_int{size=Kvar#k_var{name=get_vsub(Name, Sub)}};
+sub_size_var(K, _) -> K.
+
+get_con([C|_]) -> arg_arg(clause_arg(C)).	%Get the constructor
+
+get_match(#k_cons{}, St0) ->
+    {[H,T],St1} = new_vars(2, St0),
+    {#k_cons{hd=H,tl=T},[H,T],St1};
+get_match(#k_binary{}, St0) ->
+    {[V]=Mes,St1} = new_vars(1, St0),
+    {#k_binary{segs=V},Mes,St1};
+get_match(#k_bin_seg{size=#k_atom{val=all},next={k_bin_end,[]}}=Seg, St0) ->
+    {[S]=Vars,St1} = new_vars(1, St0),
+    {Seg#k_bin_seg{seg=S,next=[]},Vars,St1};
+get_match(#k_bin_seg{}=Seg, St0) ->
+    {[S,N0],St1} = new_vars(2, St0),
+    N = set_kanno(N0, [no_usage]),
+    {Seg#k_bin_seg{seg=S,next=N},[S,N],St1};
+get_match(#k_bin_int{}=BinInt, St0) ->
+    {N0,St1} = new_var(St0),
+    N = set_kanno(N0, [no_usage]),
+    {BinInt#k_bin_int{next=N},[N],St1};
+get_match(#k_tuple{es=Es}, St0) ->
+    {Mes,St1} = new_vars(length(Es), St0),
+    {#k_tuple{es=Mes},Mes,St1};
+get_match(M, St) ->
+    {M,[],St}.
+
+new_clauses(Cs0, U, St) ->
+    Cs1 = map(fun (#iclause{isub=Isub0,osub=Osub0,pats=[Arg|As]}=C) ->
+		      Head = case arg_arg(Arg) of
+				 #k_cons{hd=H,tl=T} -> [H,T|As];
+				 #k_tuple{es=Es} -> Es ++ As;
+				 #k_binary{segs=E}  -> [E|As];
+				 #k_bin_seg{size=#k_atom{val=all},
+					    seg=S,next={k_bin_end,[]}} ->
+				     [S|As];
+				 #k_bin_seg{seg=S,next=N} ->
+				     [S,N|As];
+				 #k_bin_int{next=N} ->
+				     [N|As];
+				 _Other -> As
+			     end,
+		      Vs = arg_alias(Arg),
+		      Osub1 = foldl(fun (#k_var{name=V}, Acc) ->
+					    subst_vsub(V, U#k_var.name, Acc)
+				    end, Osub0, Vs),
+		      Isub1 = foldl(fun (#k_var{name=V}, Acc) ->
+					    subst_vsub(V, U#k_var.name, Acc)
+				    end, Isub0, Vs),
+		      C#iclause{isub=Isub1,osub=Osub1,pats=Head}
+	      end, Cs0),
+    {Cs1,St}.
+
+%% build_guard([GuardClause]) -> GuardExpr.
+
+build_guard([]) -> fail;
+build_guard(Cs) -> #k_guard{clauses=Cs}.
+
+%% build_select(Var, [ConClause]) -> SelectExpr.
+
+build_select(V, [Tc|_]=Tcs) ->
+    copy_anno(#k_select{var=V,types=Tcs}, Tc).
+
+%% build_alt(First, Then) -> AltExpr.
+%%  Build an alt, attempt some simple optimisation.
+
+build_alt(fail, Then) -> Then;
+build_alt(First,Then) -> build_alt_1st_no_fail(First, Then).
+
+build_alt_1st_no_fail(First, fail) -> First;
+build_alt_1st_no_fail(First, Then) ->
+    copy_anno(#k_alt{first=First,then=Then}, First).
+
+%% build_match([MatchVar], MatchExpr) -> Kexpr.
+%%  Build a match expr if there is a match.
+
+build_match(Us, #k_alt{}=Km) -> copy_anno(#k_match{vars=Us,body=Km}, Km);
+build_match(Us, #k_select{}=Km) -> copy_anno(#k_match{vars=Us,body=Km}, Km);
+build_match(Us, #k_guard{}=Km) -> copy_anno(#k_match{vars=Us,body=Km}, Km);
+build_match(_, Km) -> Km.
+
+%% clause_arg(Clause) -> FirstArg.
+%% clause_con(Clause) -> Constructor.
+%% clause_val(Clause) -> Value.
+%% is_var_clause(Clause) -> bool().
+
+clause_arg(#iclause{pats=[Arg|_]}) -> Arg.
+
+clause_con(C) -> arg_con(clause_arg(C)).
+
+clause_val(C) -> arg_val(clause_arg(C)).
+
+is_var_clause(C) -> clause_con(C) =:= k_var.
+
+%% arg_arg(Arg) -> Arg.
+%% arg_alias(Arg) -> Aliases.
+%% arg_con(Arg) -> Constructor.
+%% arg_val(Arg) -> Value.
+%%  These are the basic functions for obtaining fields in an argument.
+
+arg_arg(#ialias{pat=Con}) -> Con;
+arg_arg(Con) -> Con.
+
+arg_alias(#ialias{vars=As}) -> As;
+arg_alias(_Con) -> [].
+
+arg_con(Arg) ->
+    case arg_arg(Arg) of
+	#k_int{} -> k_int;
+	#k_float{} -> k_float;
+	#k_atom{} -> k_atom;
+	#k_nil{} -> k_nil;
+	#k_cons{} -> k_cons; 
+	#k_tuple{} -> k_tuple;
+	#k_binary{} -> k_binary;
+	#k_bin_end{} -> k_bin_end;
+	#k_bin_int{} -> k_bin_int;
+	#k_bin_seg{} -> k_bin_seg;
+	#k_var{} -> k_var
+    end.
+
+arg_val(Arg) ->
+    case arg_arg(Arg) of
+	#k_int{val=I} -> I;
+	#k_float{val=F} -> F;
+	#k_atom{val=A} -> A;
+	#k_nil{} -> 0;
+	#k_cons{} -> 2; 
+	#k_tuple{es=Es} -> length(Es);
+	#k_bin_seg{size=S,unit=U,type=T,flags=Fs} ->
+	    {set_kanno(S, []),U,T,Fs};
+	#k_bin_int{} ->
+	    0;
+	#k_bin_end{} -> 0;
+	#k_binary{} -> 0
+    end.
+
+%% ubody_used_vars(Expr, State) -> [UsedVar]
+%%  Return all used variables for the body sequence. Much more
+%%  efficient than using ubody/3 if the body contains nested letrecs.
+ubody_used_vars(Expr, St) ->
+    {_,Used,_} = ubody(Expr, return, St#kern{funs=ignore}),
+    Used.
+
+%% ubody(Expr, Break, State) -> {Expr,[UsedVar],State}.
+%%  Tag the body sequence with its used variables.  These bodies
+%%  either end with a #k_break{}, or with #k_return{} or an expression
+%%  which itself can return, #k_enter{}, #k_match{} ... .
+
+ubody(#iset{vars=[],arg=#iletrec{}=Let,body=B0}, Br, St0) ->
+    %% An iletrec{} should never be last.
+    St = iletrec_funs(Let, St0),
+    ubody(B0, Br, St);
+ubody(#iset{anno=A,vars=Vs,arg=E0,body=B0}, Br, St0) ->
+    {E1,Eu,St1} = uexpr(E0, {break,Vs}, St0),
+    {B1,Bu,St2} = ubody(B0, Br, St1),
+    Ns = lit_list_vars(Vs),
+    Used = union(Eu, subtract(Bu, Ns)),		%Used external vars
+    {#k_seq{anno=#k{us=Used,ns=Ns,a=A},arg=E1,body=B1},Used,St2};
+ubody(#ivalues{anno=A,args=As}, return, St) ->
+    Au = lit_list_vars(As),
+    {#k_return{anno=#k{us=Au,ns=[],a=A},args=As},Au,St};
+ubody(#ivalues{anno=A,args=As}, {break,_Vbs}, St) ->
+    Au = lit_list_vars(As),
+    {#k_break{anno=#k{us=Au,ns=[],a=A},args=As},Au,St};
+ubody(E, return, St0) ->
+    %% Enterable expressions need no trailing return.
+    case is_enter_expr(E) of
+	true -> uexpr(E, return, St0);
+	false ->
+	    {Ea,Pa,St1} = force_atomic(E, St0),
+	    ubody(pre_seq(Pa, #ivalues{args=[Ea]}), return, St1)
+    end;
+ubody(E, {break,Rs}, St0) ->
+    %%ok = io:fwrite("ubody ~w:~p~n", [?LINE,{E,Br}]),
+    %% Exiting expressions need no trailing break.
+    case is_exit_expr(E) of
+	true -> uexpr(E, return, St0);
+	false ->
+	    {Ea,Pa,St1} = force_atomic(E, St0),
+	    ubody(pre_seq(Pa, #ivalues{args=[Ea]}), {break,Rs}, St1)
+    end.
+
+iletrec_funs(#iletrec{defs=Fs}, St0) ->
+    %% Use union of all free variables.
+    %% First just work out free variables for all functions.
+    Free = foldl(fun ({_,#ifun{vars=Vs,body=Fb0}}, Free0) ->
+			 Fbu = ubody_used_vars(Fb0, St0),
+			 Ns = lit_list_vars(Vs),
+			 Free1 = subtract(Fbu, Ns),
+			 union(Free1, Free0)
+		 end, [], Fs),
+    FreeVs = make_vars(Free),
+    %% Add this free info to State.
+    St1 = foldl(fun ({N,#ifun{vars=Vs}}, Lst) ->
+			store_free(N, length(Vs), FreeVs, Lst)
+		end, St0, Fs),
+    iletrec_funs_gen(Fs, FreeVs, St1).
+
+%% Now regenerate local functions to use free variable information.
+iletrec_funs_gen(_, _, #kern{funs=ignore}=St) ->
+    %% Optimization: The ultimate caller is only interested in the used variables,
+    %% not the updated state. Makes a difference if there are nested letrecs.
+    St;
+iletrec_funs_gen(Fs, FreeVs, St) ->
+    foldl(fun ({N,#ifun{anno=Fa,vars=Vs,body=Fb0}}, Lst0) ->
+		  {Fb1,_,Lst1} = ubody(Fb0, return, Lst0),
+		  Arity = length(Vs) + length(FreeVs),
+		  Fun = #k_fdef{anno=#k{us=[],ns=[],a=Fa},
+				func=N,arity=Arity,
+				vars=Vs ++ FreeVs,body=Fb1},
+		  Lst1#kern{funs=[Fun|Lst1#kern.funs]}
+	  end, St, Fs).
+
+
+%% is_exit_expr(Kexpr) -> bool().
+%%  Test whether Kexpr always exits and never returns.
+
+is_exit_expr(#k_call{op=#k_internal{name=match_fail,arity=1}}) -> true;
+is_exit_expr(#k_call{op=#k_remote{mod=Mod,name=Name,arity=Arity}}) ->
+    erl_bifs:is_exit_bif(Mod, Name, Arity);
+is_exit_expr(#k_receive_next{}) -> true;
+is_exit_expr(_) -> false.
+
+%% is_enter_expr(Kexpr) -> bool().
+%%  Test whether Kexpr is "enterable", i.e. can handle return from
+%%  within itself without extra #k_return{}.
+
+is_enter_expr(#k_try{}) -> true;
+is_enter_expr(#k_call{}) -> true;
+is_enter_expr(#k_match{}) -> true;
+is_enter_expr(#k_receive{}) -> true;
+is_enter_expr(#k_receive_next{}) -> true;
+is_enter_expr(_) -> false.
+
+%% uguard(Expr, State) -> {Expr,[UsedVar],State}.
+%%  Tag the guard sequence with its used variables.
+
+uguard(#k_try{anno=A,arg=B0,vars=[#k_var{name=X}],body=#k_var{name=X},
+	      handler=#k_atom{val=false}}=Try, St0) ->
+    {B1,Bu,St1} = uguard(B0, St0),
+    {Try#k_try{anno=#k{us=Bu,ns=[],a=A},arg=B1},Bu,St1};
+uguard(T, St) ->
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,T]),
+    uguard_test(T, St).
+
+%% uguard_test(Expr, State) -> {Test,[UsedVar],State}.
+%%  At this stage tests are just expressions which don't return any
+%%  values.
+
+uguard_test(T, St) -> uguard_expr(T, [], St).
+
+uguard_expr(#iset{anno=A,vars=Vs,arg=E0,body=B0}, Rs, St0) ->
+    Ns = lit_list_vars(Vs),
+    {E1,Eu,St1} = uguard_expr(E0, Vs, St0),
+    {B1,Bu,St2} = uguard_expr(B0, Rs, St1),
+    Used = union(Eu, subtract(Bu, Ns)),
+    {#k_seq{anno=#k{us=Used,ns=Ns,a=A},arg=E1,body=B1},Used,St2};
+uguard_expr(#k_try{anno=A,arg=B0,vars=[#k_var{name=X}],body=#k_var{name=X},
+		   handler=#k_atom{val=false}}=Try, Rs, St0) ->
+    {B1,Bu,St1} = uguard_expr(B0, Rs, St0),
+    {Try#k_try{anno=#k{us=Bu,ns=lit_list_vars(Rs),a=A},arg=B1,ret=Rs},
+     Bu,St1};
+uguard_expr(#k_test{anno=A,op=Op,args=As}=Test, Rs, St) ->
+    [] = Rs,					%Sanity check
+    Used = union(op_vars(Op), lit_list_vars(As)),
+    {Test#k_test{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A}},
+     Used,St};
+uguard_expr(#k_bif{anno=A,op=Op,args=As}=Bif, Rs, St) ->
+    Used = union(op_vars(Op), lit_list_vars(As)),
+    {Bif#k_bif{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A},ret=Rs},
+     Used,St};
+uguard_expr(#ivalues{anno=A,args=As}, Rs, St) ->
+    Sets = foldr2(fun (V, Arg, Rhs) ->
+			  #iset{anno=A,vars=[V],arg=Arg,body=Rhs}
+		  end, #k_atom{val=true}, Rs, As),
+    uguard_expr(Sets, [], St);
+uguard_expr(#k_match{anno=A,vars=Vs,body=B0}, Rs, St0) ->
+    %% Experimental support for andalso/orelse in guards.
+    Br = case Rs of
+	     [] -> return;
+	     _ -> {break,Rs}
+	 end,
+    {B1,Bu,St1} = umatch(B0, Br, St0),
+    {#k_match{anno=#k{us=Bu,ns=lit_list_vars(Rs),a=A},
+	      vars=Vs,body=B1,ret=Rs},Bu,St1};
+uguard_expr(Lit, Rs, St) ->
+    %% Transform literals to puts here.
+    Used = lit_vars(Lit),
+    {#k_put{anno=#k{us=Used,ns=lit_list_vars(Rs),a=get_kanno(Lit)},
+	    arg=Lit,ret=Rs},Used,St}.
+
+%% uexpr(Expr, Break, State) -> {Expr,[UsedVar],State}.
+%%  Tag an expression with its used variables.
+%%  Break = return | {break,[RetVar]}.
+
+uexpr(#k_call{anno=A,op=#k_local{name=F,arity=Ar}=Op,args=As0}=Call, Br, St) ->
+    Free = get_free(F, Ar, St),
+    As1 = As0 ++ Free,				%Add free variables LAST!
+    Used = lit_list_vars(As1),
+    {case Br of
+	 {break,Rs} ->
+	     Call#k_call{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A},
+			 op=Op#k_local{arity=Ar + length(Free)},
+			 args=As1,ret=Rs};
+	 return ->
+	     #k_enter{anno=#k{us=Used,ns=[],a=A},
+		      op=Op#k_local{arity=Ar + length(Free)},
+		      args=As1}
+     end,Used,St};
+uexpr(#k_call{anno=A,op=Op,args=As}=Call, {break,Rs}, St) ->
+    Used = union(op_vars(Op), lit_list_vars(As)),
+    {Call#k_call{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A},ret=Rs},
+     Used,St};
+uexpr(#k_call{anno=A,op=Op,args=As}, return, St) ->
+    Used = union(op_vars(Op), lit_list_vars(As)),
+    {#k_enter{anno=#k{us=Used,ns=[],a=A},op=Op,args=As},
+     Used,St};
+uexpr(#k_bif{anno=A,op=Op,args=As}=Bif, {break,Rs}, St0) ->
+    Used = union(op_vars(Op), lit_list_vars(As)),
+    {Brs,St1} = bif_returns(Op, Rs, St0),
+    {Bif#k_bif{anno=#k{us=Used,ns=lit_list_vars(Brs),a=A},ret=Brs},
+     Used,St1};
+uexpr(#k_match{anno=A,vars=Vs,body=B0}, Br, St0) ->
+    Rs = break_rets(Br),
+    {B1,Bu,St1} = umatch(B0, Br, St0),
+    {#k_match{anno=#k{us=Bu,ns=lit_list_vars(Rs),a=A},
+	      vars=Vs,body=B1,ret=Rs},Bu,St1};
+uexpr(#k_receive{anno=A,var=V,body=B0,timeout=T,action=A0}, Br, St0) ->
+    Rs = break_rets(Br),
+    Tu = lit_vars(T),				%Timeout is atomic
+    {B1,Bu,St1} = umatch(B0, Br, St0),
+    {A1,Au,St2} = ubody(A0, Br, St1),
+    Used = del_element(V#k_var.name, union(Bu, union(Tu, Au))),
+    {#k_receive{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A},
+		var=V,body=B1,timeout=T,action=A1,ret=Rs},
+     Used,St2};
+uexpr(#k_receive_accept{anno=A}, _, St) ->
+    {#k_receive_accept{anno=#k{us=[],ns=[],a=A}},[],St};
+uexpr(#k_receive_next{anno=A}, _, St) ->
+    {#k_receive_next{anno=#k{us=[],ns=[],a=A}},[],St};
+uexpr(#k_search_accept{anno=A}, _, St) ->
+    {#k_search_accept{anno=#k{us=[],ns=[],a=A}},[],St};
+uexpr(#k_try{anno=A,arg=A0,vars=Vs,body=B0,evars=Evs,handler=H0},
+      {break,Rs0}, St0) ->
+    {Avs,St1} = new_vars(length(Vs), St0),	%Need dummy names here
+    {A1,Au,St2} = ubody(A0, {break,Avs}, St1),	%Must break to clean up here!
+    {B1,Bu,St3} = ubody(B0, {break,Rs0}, St2),
+    {H1,Hu,St4} = ubody(H0, {break,Rs0}, St3),
+    %% Guarantee ONE return variable.
+    NumNew = if
+		 Rs0 =:= [] -> 1;
+		 true -> 0
+	     end,
+    {Ns,St5} = new_vars(NumNew, St4),
+    Rs1 = Rs0 ++ Ns,
+    Used = union([Au,subtract(Bu, lit_list_vars(Vs)),
+		  subtract(Hu, lit_list_vars(Evs))]),
+    {#k_try{anno=#k{us=Used,ns=lit_list_vars(Rs1),a=A},
+	    arg=A1,vars=Vs,body=B1,evars=Evs,handler=H1,ret=Rs1},
+     Used,St5};
+uexpr(#k_try{anno=A,arg=A0,vars=Vs,body=B0,evars=Evs,handler=H0},
+      return, St0) ->
+    {Avs,St1} = new_vars(length(Vs), St0),	%Need dummy names here
+    {A1,Au,St2} = ubody(A0, {break,Avs}, St1),	%Must break to clean up here!
+    {B1,Bu,St3} = ubody(B0, return, St2),
+    {H1,Hu,St4} = ubody(H0, return, St3),
+    NumNew = 1,
+    {Ns,St5} = new_vars(NumNew, St4),
+    Used = union([Au,subtract(Bu, lit_list_vars(Vs)),
+		  subtract(Hu, lit_list_vars(Evs))]),
+    {#k_try_enter{anno=#k{us=Used,ns=Ns,a=A},
+		  arg=A1,vars=Vs,body=B1,evars=Evs,handler=H1},
+     Used,St5};
+uexpr(#k_catch{anno=A,body=B0}, {break,Rs0}, St0) ->
+    {Rb,St1} = new_var(St0),
+    {B1,Bu,St2} = ubody(B0, {break,[Rb]}, St1),
+    %% Guarantee ONE return variable.
+    {Ns,St3} = new_vars(1 - length(Rs0), St2),
+    Rs1 = Rs0 ++ Ns,
+    {#k_catch{anno=#k{us=Bu,ns=lit_list_vars(Rs1),a=A},body=B1,ret=Rs1},Bu,St3};
+uexpr(#ifun{anno=A,vars=Vs,body=B0}=IFun, {break,Rs}, St0) ->
+    {B1,Bu,St1} = ubody(B0, return, St0),	%Return out of new function
+    Ns = lit_list_vars(Vs),
+    Free = subtract(Bu, Ns),			%Free variables in fun
+    Fvs = make_vars(Free),
+    Arity = length(Vs) + length(Free),
+    {{Index,Uniq,Fname}, St3} =
+	case lists:keysearch(id, 1, A) of 
+	    {value,{id,Id}} ->
+		{Id, St1};
+	    false ->
+		%% No id annotation. Must invent one.
+		I = St1#kern.fcount,
+		U = erlang:hash(IFun, (1 bsl 27)-1),
+		{N, St2} = new_fun_name(St1),
+		{{I,U,N}, St2}
+	end,
+    Fun = #k_fdef{anno=#k{us=[],ns=[],a=A},func=Fname,arity=Arity,
+		  vars=Vs ++ Fvs,body=B1},
+    {#k_bif{anno=#k{us=Free,ns=lit_list_vars(Rs),a=A},
+ 	    op=#k_internal{name=make_fun,arity=length(Free)+3},
+ 	    args=[#k_atom{val=Fname},#k_int{val=Arity},
+ 		  #k_int{val=Index},#k_int{val=Uniq}|Fvs],
+ 	    ret=Rs},
+     Free,add_local_function(Fun, St3)};
+uexpr(Lit, {break,Rs}, St) ->
+    %% Transform literals to puts here.
+    %%ok = io:fwrite("uexpr ~w:~p~n", [?LINE,Lit]),
+    Used = lit_vars(Lit),
+    {#k_put{anno=#k{us=Used,ns=lit_list_vars(Rs),a=get_kanno(Lit)},
+	    arg=Lit,ret=Rs},Used,St}.
+
+add_local_function(_, #kern{funs=ignore}=St) -> St;
+add_local_function(F, #kern{funs=Funs}=St) -> St#kern{funs=[F|Funs]}.
+
+
+%% get_free(Name, Arity, State) -> [Free].
+%% store_free(Name, Arity, [Free], State) -> State.
+
+get_free(F, A, St) ->
+    case orddict:find({F,A}, St#kern.free) of
+	{ok,Val} -> Val;
+	error -> []
+    end.
+
+store_free(F, A, Free, St) ->
+    St#kern{free=orddict:store({F,A}, Free, St#kern.free)}.
+
+break_rets({break,Rs}) -> Rs;
+break_rets(return) -> [].
+
+%% bif_returns(Op, [Ret], State) -> {[Ret],State}.
+
+bif_returns(#k_remote{mod=M,name=N,arity=Ar}, Rs, St0) ->
+    %%ok = io:fwrite("uexpr ~w:~p~n", [?LINE,{M,N,Ar,Rs}]),
+    {Ns,St1} = new_vars(bif_vals(M, N, Ar) - length(Rs), St0),
+    {Rs ++ Ns,St1};
+bif_returns(#k_internal{name=N,arity=Ar}, Rs, St0) ->
+    %%ok = io:fwrite("uexpr ~w:~p~n", [?LINE,{N,Ar,Rs}]),
+    {Ns,St1} = new_vars(bif_vals(N, Ar) - length(Rs), St0),
+    {Rs ++ Ns,St1}.
+
+%% umatch(Match, Break, State) -> {Match,[UsedVar],State}.
+%%  Tag a match expression with its used variables.
+
+umatch(#k_alt{anno=A,first=F0,then=T0}, Br, St0) ->
+    {F1,Fu,St1} = umatch(F0, Br, St0),
+    {T1,Tu,St2} = umatch(T0, Br, St1),
+    Used = union(Fu, Tu),
+    {#k_alt{anno=#k{us=Used,ns=[],a=A},first=F1,then=T1},
+     Used,St2};
+umatch(#k_select{anno=A,var=V,types=Ts0}, Br, St0) ->
+    {Ts1,Tus,St1} = umatch_list(Ts0, Br, St0),
+    Used = case member(no_usage, get_kanno(V)) of
+	       true -> Tus;
+	       false -> add_element(V#k_var.name, Tus)
+	   end,
+    {#k_select{anno=#k{us=Used,ns=[],a=A},var=V,types=Ts1},Used,St1};
+umatch(#k_type_clause{anno=A,type=T,values=Vs0}, Br, St0) ->
+    {Vs1,Vus,St1} = umatch_list(Vs0, Br, St0),
+    {#k_type_clause{anno=#k{us=Vus,ns=[],a=A},type=T,values=Vs1},Vus,St1};
+umatch(#k_val_clause{anno=A,val=P0,body=B0}, Br, St0) ->
+    {U0,Ps} = pat_vars(P0),
+    P = set_kanno(P0, #k{us=U0,ns=Ps,a=get_kanno(P0)}),
+    {B1,Bu,St1} = umatch(B0, Br, St0),
+    Used = union(U0, subtract(Bu, Ps)),
+    {#k_val_clause{anno=#k{us=Used,ns=[],a=A},val=P,body=B1},
+     Used,St1};
+umatch(#k_guard{anno=A,clauses=Gs0}, Br, St0) ->
+    {Gs1,Gus,St1} = umatch_list(Gs0, Br, St0),
+    {#k_guard{anno=#k{us=Gus,ns=[],a=A},clauses=Gs1},Gus,St1};
+umatch(#k_guard_clause{anno=A,guard=G0,body=B0}, Br, St0) ->
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,G0]),
+    {G1,Gu,St1} = uguard(G0, St0),
+    %%ok = io:fwrite("~w: ~p~n", [?LINE,G1]),
+    {B1,Bu,St2} = umatch(B0, Br, St1),
+    Used = union(Gu, Bu),
+    {#k_guard_clause{anno=#k{us=Used,ns=[],a=A},guard=G1,body=B1},Used,St2};
+umatch(B0, Br, St0) -> ubody(B0, Br, St0).
+
+umatch_list(Ms0, Br, St) ->
+    foldr(fun (M0, {Ms1,Us,Sta}) ->
+		  {M1,Mu,Stb} = umatch(M0, Br, Sta),
+		  {[M1|Ms1],union(Mu, Us),Stb}
+	  end, {[],[],St}, Ms0).
+
+%% op_vars(Op) -> [VarName].
+
+op_vars(#k_local{}) -> [];
+op_vars(#k_remote{mod=Mod,name=Name}) ->
+    ordsets:from_list([V || #k_var{name=V} <- [Mod,Name]]);
+op_vars(#k_internal{}) -> [];
+op_vars(Atomic) -> lit_vars(Atomic).
+
+%% lit_vars(Literal) -> [VarName].
+%%  Return the variables in a literal.
+
+lit_vars(#k_var{name=N}) -> [N];
+lit_vars(#k_int{}) -> [];
+lit_vars(#k_float{}) -> [];
+lit_vars(#k_atom{}) -> [];
+%%lit_vars(#k_char{}) -> [];
+lit_vars(#k_string{}) -> [];
+lit_vars(#k_nil{}) -> [];
+lit_vars(#k_cons{hd=H,tl=T}) ->
+    union(lit_vars(H), lit_vars(T));
+lit_vars(#k_binary{segs=V}) -> lit_vars(V);
+lit_vars(#k_bin_end{}) -> [];
+lit_vars(#k_bin_seg{size=Size,seg=S,next=N}) ->
+    union(lit_vars(Size), union(lit_vars(S), lit_vars(N)));
+lit_vars(#k_tuple{es=Es}) ->
+    lit_list_vars(Es);
+lit_vars(#k_literal{}) -> [].
+
+lit_list_vars(Ps) ->
+    foldl(fun (P, Vs) -> union(lit_vars(P), Vs) end, [], Ps).
+
+%% pat_vars(Pattern) -> {[UsedVarName],[NewVarName]}.
+%%  Return variables in a pattern.  All variables are new variables
+%%  except those in the size field of binary segments.
+
+pat_vars(#k_var{name=N}) -> {[],[N]};
+%%pat_vars(#k_char{}) -> {[],[]};
+%%pat_vars(#k_string{}) -> {[],[]};
+pat_vars(#k_int{}) -> {[],[]};
+pat_vars(#k_float{}) -> {[],[]};
+pat_vars(#k_atom{}) -> {[],[]};
+pat_vars(#k_nil{}) -> {[],[]};
+pat_vars(#k_cons{hd=H,tl=T}) ->
+    pat_list_vars([H,T]);
+pat_vars(#k_binary{segs=V}) ->
+    pat_vars(V);
+pat_vars(#k_bin_seg{size=Size,seg=S}) ->
+    {U1,New} = pat_list_vars([S]),
+    {[],U2} = pat_vars(Size),
+    {union(U1, U2),New};
+pat_vars(#k_bin_int{size=Size}) ->
+    {[],U} = pat_vars(Size),
+    {U,[]};
+pat_vars(#k_bin_end{}) -> {[],[]};
+pat_vars(#k_tuple{es=Es}) ->
+    pat_list_vars(Es).
+
+pat_list_vars(Ps) ->
+    foldl(fun (P, {Used0,New0}) ->
+		  {Used,New} = pat_vars(P),
+		  {union(Used0, Used),union(New0, New)} end,
+	  {[],[]}, Ps).
+
+%% handle_literal(Literal, Anno) -> Kernel
+%%  Examine the literal. Complex (heap-based) literals such as lists,
+%%  tuples, and binaries should be kept as literals and put into the constant pool.
+%%
+%%  (If necessary, this function could be extended to go through the literal
+%%  and convert huge binary literals to bit syntax expressions. We don't do that
+%%  because v3_core does not produce huge binary literals, and the optimizations in
+%%  sys_core_fold don't do much optimizations of binaries. IF THAT CHANGE IS MADE,
+%%  ALSO CHANGE sys_core_dsetel.)
+
+handle_literal(#c_literal{anno=A,val=V}) ->
+    case V of
+	[_|_] ->
+	    #k_literal{anno=A,val=V};
+	V when is_tuple(V) ->
+	    #k_literal{anno=A,val=V};
+	V when is_bitstring(V) ->
+	    #k_literal{anno=A,val=V};
+	_ ->
+	    expand_literal(V, A)
+    end.
+
+%% expand_literal(Literal, Anno) -> CoreTerm | KernelTerm
+%%  Fully expand the literal. Atomic terms such as integers are directly
+%%  translated to the Kernel Erlang format, while complex terms are kept
+%%  in the Core Erlang format (but the content is recursively processed).
+
+expand_literal([H|T]=V, A) when is_integer(H), 0 =< H, H =< 255 ->
+    case is_print_char_list(T) of
+	false ->
+	    #c_cons{anno=A,hd=#k_int{anno=A,val=H},tl=expand_literal(T, A)};
+	true ->
+	    #k_string{anno=A,val=V}
+    end;
+expand_literal([H|T], A) ->
+    #c_cons{anno=A,hd=expand_literal(H, A),tl=expand_literal(T, A)};
+expand_literal([], A) ->
+    #k_nil{anno=A};
+expand_literal(V, A) when is_tuple(V) ->
+    #c_tuple{anno=A,es=expand_literal_list(tuple_to_list(V), A)};
+expand_literal(V, A) when is_integer(V) ->
+    #k_int{anno=A,val=V};
+expand_literal(V, A) when is_float(V) ->
+    #k_float{anno=A,val=V};
+expand_literal(V, A) when is_atom(V) ->
+    #k_atom{anno=A,val=V}.
+
+expand_literal_list([H|T], A) ->
+    [expand_literal(H, A)|expand_literal_list(T, A)];
+expand_literal_list([], _) -> [].
+
+is_print_char_list([H|T]) when is_integer(H), 0 =< H, H =< 255 ->
+    is_print_char_list(T);
+is_print_char_list([]) -> true;
+is_print_char_list(_) -> false.
+
+%% expand_pat_literal(Literal, Anno) -> Kernel
+%%  Expand a literal used as a pattern (the result will not contain #k_string{}).
+
+expand_pat_literal([H|T], A) ->
+    #k_cons{anno=A,hd=expand_pat_literal(H, A),tl=expand_pat_literal(T, A)};
+expand_pat_literal([], A) ->
+    #k_nil{anno=A};
+expand_pat_literal(V, A) when is_tuple(V) ->
+    #k_tuple{anno=A,es=expand_pat_literal_list(tuple_to_list(V), A)};
+expand_pat_literal(V, A) when is_integer(V) ->
+    #k_int{anno=A,val=V};
+expand_pat_literal(V, A) when is_float(V) ->
+    #k_float{anno=A,val=V};
+expand_pat_literal(V, A) when is_atom(V) ->
+    #k_atom{anno=A,val=V}.
+
+expand_pat_literal_list([H|T], A) ->
+    [expand_pat_literal(H, A)|expand_pat_literal_list(T, A)];
+expand_pat_literal_list([], _) -> [].
+
+make_list(Es) ->
+    foldr(fun(E, Acc) ->
+ 		  #c_cons{hd=E,tl=Acc}
+ 	  end, #c_literal{val=[]}, Es).
+
+%% List of integers in interval [N,M]. Empty list if N > M.
+
+integers(N, M) when N =< M ->
+    [N|integers(N + 1, M)];
+integers(_, _) -> [].
+
+%%%
+%%% Handling of warnings.
+%%%
+
+format_error({nomatch_shadow,Line}) ->
+    M = io_lib:format("this clause cannot match because a previous clause at line ~p "
+		      "always matches", [Line]),
+    lists:flatten(M);
+format_error(nomatch_shadow) ->
+    "this clause cannot match because a previous clause always matches";
+format_error(bad_call) ->
+    "invalid module and/or function name; this call will always fail".
+
+add_warning(none, Term, Anno, #kern{ws=Ws}=St) ->
+    File = get_file(Anno),
+    St#kern{ws=[{File,[{?MODULE,Term}]}|Ws]};
+add_warning(Line, Term, Anno, #kern{ws=Ws}=St) when Line >= 0 ->
+    File = get_file(Anno),
+    St#kern{ws=[{File,[{Line,?MODULE,Term}]}|Ws]};
+add_warning(_, _, _, St) -> St.
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl
--- otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl	2007-11-26 18:58:03.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl	2009-06-23 20:40:10.000000000 +0100
@@ -59,8 +59,11 @@
 -record(k_call, {anno=[],op,args,ret=[]}).
 -record(k_enter, {anno=[],op,args}).
 -record(k_receive, {anno=[],var,body,timeout,action,ret=[]}).
+-record(k_search, {anno=[],var, body,timeout,action,ret=[]}).
 -record(k_receive_accept, {anno=[]}).
+-record(k_search_accept, {anno=[]}).
 -record(k_receive_next, {anno=[]}).
+-record(k_search_next, {anno=[]}).
 -record(k_try, {anno=[],arg,vars,body,evars,handler,ret=[]}).
 -record(k_try_enter, {anno=[],arg,vars,body,evars,handler}).
 -record(k_catch, {anno=[],body,ret=[]}).
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl~ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl~
--- otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel.hrl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,82 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+
+%% Purpose : Kernel Erlang as records.
+
+%% It would be nice to incorporate some generic functions as well but
+%% this could make including this file difficult.
+%% N.B. the annotation field is ALWAYS the first field!
+
+%% Kernel annotation record.
+-record(k, {us,					%Used variables
+	    ns,					%New variables
+	    a}).				%Core annotation
+
+%% Literals
+%% NO CHARACTERS YET.
+%%-record(k_char, {anno=[],val}).
+-record(k_literal, {anno=[],val}).		%Only used for complex literals.
+-record(k_int, {anno=[],val}).
+-record(k_float, {anno=[],val}).
+-record(k_atom, {anno=[],val}).
+-record(k_string, {anno=[],val}).
+-record(k_nil, {anno=[]}).
+
+-record(k_tuple, {anno=[],es}).
+-record(k_cons, {anno=[],hd,tl}).
+-record(k_binary, {anno=[],segs}).
+-record(k_bin_seg, {anno=[],size,unit,type,flags,seg,next}).
+-record(k_bin_int, {anno=[],size,unit,flags,val,next}).
+-record(k_bin_end, {anno=[]}).
+-record(k_var, {anno=[],name}).
+
+-record(k_local, {anno=[],name,arity}).
+-record(k_remote, {anno=[],mod,name,arity}).
+-record(k_internal, {anno=[],name,arity}).
+
+-record(k_mdef, {anno=[],name,exports,attributes,body}).
+-record(k_fdef, {anno=[],func,arity,vars,body}).
+
+-record(k_seq, {anno=[],arg,body}).
+-record(k_put, {anno=[],arg,ret=[]}).
+-record(k_bif, {anno=[],op,args,ret=[]}).
+-record(k_test, {anno=[],op,args}).
+-record(k_call, {anno=[],op,args,ret=[]}).
+-record(k_enter, {anno=[],op,args}).
+-record(k_receive, {anno=[],var,body,timeout,action,ret=[]}).
+-record(k_search, {anno=[],var, body,timeout,action,ret=[]}).
+-record(k_receive_accept, {anno=[]}).
+-record(k_search_accept, {anno=[]}).
+-record(k_receive_next, {anno=[]}).
+-record(k_try, {anno=[],arg,vars,body,evars,handler,ret=[]}).
+-record(k_try_enter, {anno=[],arg,vars,body,evars,handler}).
+-record(k_catch, {anno=[],body,ret=[]}).
+
+-record(k_match, {anno=[],vars,body,ret=[]}).
+-record(k_alt, {anno=[],first,then}).
+-record(k_select, {anno=[],var,types}).
+-record(k_type_clause, {anno=[],type,values}).
+-record(k_val_clause, {anno=[],val,body}).
+-record(k_guard, {anno=[],clauses}).
+-record(k_guard_clause, {anno=[],guard,body}).
+
+-record(k_break, {anno=[],args=[]}).
+-record(k_return, {anno=[],args=[]}).
+
+%%k_get_anno(Thing) -> element(2, Thing).
+%%k_set_anno(Thing, Anno) -> setelement(2, Thing, Anno).
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl
--- otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl	2008-02-05 13:37:38.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl	2009-06-23 20:40:10.000000000 +0100
@@ -258,8 +258,11 @@ format_1(#k_receive{var=V,body=B,timeout
      "end",
      format_ret(Rs, Ctxt1)
     ];
-format_1(#k_receive_accept{}, _Ctxt) -> "receive_accept";
-format_1(#k_receive_next{}, _Ctxt) -> "receive_next";
+format_1(#k_search{var=V,body=B,timeout=T,action=A,ret=Rs}, Ctxt) ->
+    [Name | Rest] =
+	format_1(#k_receive{var=V,body=B,timeout=T,action=A,ret=Rs}, Ctxt),
+    ["search" | Rest];
+format_1(#k_search_accept{}, _Ctxt) -> "search_accept";
 format_1(#k_break{args=As}, Ctxt) ->
     ["<",
      format_hseq(As, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl~ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl~
--- otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_kernel_pp.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,490 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Kernel Erlang (naive) prettyprinter
+
+-module(v3_kernel_pp).
+
+-include("v3_kernel.hrl").
+
+-export([format/1]).
+
+%% These are "internal" structures in sys_kernel which are here for
+%% debugging purposes.
+-record(iset, {anno=[],vars,arg,body}).
+-record(ifun, {anno=[],vars,body}).
+
+%% ====================================================================== %%
+%% format(Node) -> Text
+%%	Node = coreErlang()
+%%	Text = string() | [Text]
+%%
+%%	Prettyprint-formats (naively) an abstract Core Erlang syntax
+%%	tree.
+
+-record(ctxt, {indent = 0,
+	       item_indent = 2,
+	       body_indent = 2,
+	       tab_width = 8}).
+
+canno(Cthing) -> element(2, Cthing).
+
+format(Node) -> format(Node, #ctxt{}).
+
+format(Node, Ctxt) ->
+    case canno(Node) of
+%% 	[] ->
+%% 	    format_1(Node, Ctxt);
+%% 	[L,{file,_}] when is_integer(L) ->
+%% 	    format_1(Node, Ctxt);
+%% 	#k{a=Anno}=K when Anno =/= [] ->
+%% 	    format(setelement(2, Node, K#k{a=[]}), Ctxt);
+%% 	List ->
+%% 	    format_anno(List, Ctxt, fun (Ctxt1) ->
+%% 					    format_1(Node, Ctxt1)
+%% 				    end);
+	_ ->
+	    format_1(Node, Ctxt)
+    end.
+
+%% format_anno(Anno, Ctxt0, ObjFun) ->
+%%     Ctxt1 = ctxt_bump_indent(Ctxt0, 1),
+%%     ["( ",
+%%      ObjFun(Ctxt0),
+%%      nl_indent(Ctxt1),
+%%      "-| ",io_lib:write(Anno),
+%%      " )"].
+    
+
+%% format_1(Kexpr, Context) -> string().
+
+format_1(#k_atom{val=A}, _Ctxt) -> core_atom(A);
+%%format_1(#k_char{val=C}, _Ctxt) -> io_lib:write_char(C);
+format_1(#k_float{val=F}, _Ctxt) -> float_to_list(F);
+format_1(#k_int{val=I}, _Ctxt) -> integer_to_list(I);
+format_1(#k_nil{}, _Ctxt) -> "[]";
+format_1(#k_string{val=S}, _Ctxt) -> io_lib:write_string(S);
+format_1(#k_var{name=V}, _Ctxt) ->
+    if is_atom(V) ->
+	    case atom_to_list(V) of
+		[$_|Cs] -> "_X" ++ Cs;
+		[C|Cs] when C >= $A, C =< $Z -> [C|Cs];
+		Cs -> [$_|Cs]
+	    end;
+       is_integer(V) -> [$_|integer_to_list(V)]
+    end;
+format_1(#k_cons{hd=H,tl=T}, Ctxt) ->
+    Txt = ["["|format(H, ctxt_bump_indent(Ctxt, 1))],
+    [Txt|format_list_tail(T, ctxt_bump_indent(Ctxt, width(Txt, Ctxt)))];
+format_1(#k_tuple{es=Es}, Ctxt) ->
+    [${,
+     format_hseq(Es, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
+     $}
+    ];
+format_1(#k_binary{segs=S}, Ctxt) ->
+    ["#<",format(S, ctxt_bump_indent(Ctxt, 2)),">#"];
+format_1(#k_bin_seg{}=S, Ctxt) ->
+    [format_bin_seg_1(S, Ctxt),
+     format_bin_seg(S#k_bin_seg.next, ctxt_bump_indent(Ctxt, 2))];
+format_1(#k_bin_int{size=Sz,unit=U,flags=Fs,val=Val,next=Next}, Ctxt) ->
+    S = #k_bin_seg{size=Sz,unit=U,type=integer,flags=Fs,seg=#k_int{val=Val},next=Next},
+    [format_bin_seg_1(S, Ctxt),
+     format_bin_seg(S#k_bin_seg.next, ctxt_bump_indent(Ctxt, 2))];
+format_1(#k_bin_end{}, _Ctxt) -> "#<>#";
+format_1(#k_local{name=N,arity=A}, Ctxt) ->
+    "local " ++ format_fa_pair({N,A}, Ctxt);
+format_1(#k_remote{mod=M,name=N,arity=A}, _Ctxt) ->
+    %% This is for our internal translator.
+    io_lib:format("remote ~s:~s/~w", [format(M),format(N),A]);
+format_1(#k_internal{name=N,arity=A}, Ctxt) ->
+    "internal " ++ format_fa_pair({N,A}, Ctxt);
+format_1(#k_seq{arg=A,body=B}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, 2),
+    ["do",
+     nl_indent(Ctxt1),
+     format(A, Ctxt1),
+     nl_indent(Ctxt),
+     "then",
+     nl_indent(Ctxt)
+     | format(B, Ctxt)
+    ];
+format_1(#k_match{vars=Vs,body=Bs,ret=Rs}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.item_indent),
+    ["match ",
+     format_hseq(Vs, ",", ctxt_bump_indent(Ctxt, 6), fun format/2),
+     nl_indent(Ctxt1),
+     format(Bs, Ctxt1),
+     nl_indent(Ctxt),
+     "end",
+     format_ret(Rs, Ctxt1)
+    ];
+format_1(#k_alt{first=O,then=T}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.item_indent),
+    ["alt",
+     nl_indent(Ctxt1),
+     format(O, Ctxt1),
+     nl_indent(Ctxt1),
+     format(T, Ctxt1)];
+format_1(#k_select{var=V,types=Cs}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, 2),
+    ["select ",
+     format(V, Ctxt),
+     nl_indent(Ctxt1),
+     format_vseq(Cs, "", "", Ctxt1, fun format/2)
+    ];
+format_1(#k_type_clause{type=T,values=Cs}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    ["type ",
+     io_lib:write(T),
+     nl_indent(Ctxt1),
+     format_vseq(Cs, "", "", Ctxt1, fun format/2)
+    ];
+format_1(#k_val_clause{val=Val,body=B}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    [format(Val, Ctxt),
+     " ->",
+     nl_indent(Ctxt1)
+     | format(B, Ctxt1)
+    ];
+format_1(#k_guard{clauses=Gs}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, 5),
+    ["when ",
+     nl_indent(Ctxt1),
+     format_vseq(Gs, "", "", Ctxt1, fun format/2)];
+format_1(#k_guard_clause{guard=G,body=B}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    [format(G, Ctxt),
+     nl_indent(Ctxt),
+     "->",
+     nl_indent(Ctxt1)
+     | format(B, Ctxt1)
+    ];
+format_1(#k_call{op=Op,args=As,ret=Rs}, Ctxt) ->
+    Txt = ["call (",format(Op, ctxt_bump_indent(Ctxt, 6)),$)],
+    Ctxt1 = ctxt_bump_indent(Ctxt, 2),
+    [Txt,format_args(As, Ctxt1),
+     format_ret(Rs, Ctxt1)
+    ];
+format_1(#k_enter{op=Op,args=As}, Ctxt) ->
+    Txt = ["enter (",format(Op, ctxt_bump_indent(Ctxt, 7)),$)],
+    Ctxt1 = ctxt_bump_indent(Ctxt, 2),
+    [Txt,format_args(As, Ctxt1)];
+format_1(#k_bif{op=Op,args=As,ret=Rs}, Ctxt) ->
+    Txt = ["bif (",format(Op, ctxt_bump_indent(Ctxt, 5)),$)],
+    Ctxt1 = ctxt_bump_indent(Ctxt, 2),
+    [Txt,format_args(As, Ctxt1),
+     format_ret(Rs, Ctxt1)
+    ];
+format_1(#k_test{op=Op,args=As}, Ctxt) ->
+    Txt = ["test (",format(Op, ctxt_bump_indent(Ctxt, 6)),$)],
+    Ctxt1 = ctxt_bump_indent(Ctxt, 2),
+    [Txt,format_args(As, Ctxt1)];
+format_1(#k_put{arg=A,ret=Rs}, Ctxt) ->
+    [format(A, Ctxt),
+     format_ret(Rs, ctxt_bump_indent(Ctxt, 1))
+    ];
+format_1(#k_try{arg=A,vars=Vs,body=B,evars=Evs,handler=H}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    ["try",
+     nl_indent(Ctxt1),
+     format(A, Ctxt1),
+     nl_indent(Ctxt),
+     "of ",
+     format_hseq(Vs, ", ", ctxt_bump_indent(Ctxt, 3), fun format/2),
+     nl_indent(Ctxt1),
+     format(B, Ctxt1),
+     nl_indent(Ctxt),
+     "catch ",
+     format_hseq(Evs, ", ", ctxt_bump_indent(Ctxt, 6), fun format/2),
+     nl_indent(Ctxt1),
+     format(H, Ctxt1),
+     nl_indent(Ctxt),
+     "end"
+    ];
+format_1(#k_try_enter{arg=A,vars=Vs,body=B,evars=Evs,handler=H}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    ["try_enter",
+     nl_indent(Ctxt1),
+     format(A, Ctxt1),
+     nl_indent(Ctxt),
+     "of ",
+     format_hseq(Vs, ", ", ctxt_bump_indent(Ctxt, 3), fun format/2),
+     nl_indent(Ctxt1),
+     format(B, Ctxt1),
+     nl_indent(Ctxt),
+     "catch ",
+     format_hseq(Evs, ", ", ctxt_bump_indent(Ctxt, 6), fun format/2),
+     nl_indent(Ctxt1),
+     format(H, Ctxt1),
+     nl_indent(Ctxt),
+     "end"
+    ];
+format_1(#k_catch{body=B,ret=Rs}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    ["catch",
+     nl_indent(Ctxt1),
+     format(B, Ctxt1),
+     nl_indent(Ctxt),
+     "end",
+     format_ret(Rs, Ctxt1)
+    ];
+format_1(#k_receive{var=V,body=B,timeout=T,action=A,ret=Rs}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.item_indent),
+    ["receive ",
+     format(V, Ctxt),
+     nl_indent(Ctxt1),
+     format(B, Ctxt1),
+     nl_indent(Ctxt),
+     "after ",
+     format(T, ctxt_bump_indent(Ctxt, 6)),
+     " ->",
+     nl_indent(Ctxt1),
+     format(A, Ctxt1),
+     nl_indent(Ctxt),
+     "end",
+     format_ret(Rs, Ctxt1)
+    ];
+format_1(#k_search{var=V,body=B,timeout=T,action=A,ret=Rs}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.item_indent),
+    ["search ",
+     format(V, Ctxt),
+     nl_indent(Ctxt1),
+     format(B, Ctxt1),
+     nl_indent(Ctxt),
+     "after ",
+     format(T, ctxt_bump_indent(Ctxt, 6)),
+     " ->",
+     nl_indent(Ctxt1),
+     format(A, Ctxt1),
+     nl_indent(Ctxt),
+     "end",
+     format_ret(Rs, Ctxt1)
+    ];
+format_1(#k_search_accept{}, _Ctxt) -> "search_accept";
+format_1(#k_break{args=As}, Ctxt) ->
+    ["<",
+     format_hseq(As, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
+     ">"
+    ];
+format_1(#k_return{args=As}, Ctxt) ->
+    ["<<",
+     format_hseq(As, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
+     ">>"
+    ];
+format_1(#k_fdef{func=F,arity=A,vars=Vs,body=B}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    ["fdef ",
+     format_fa_pair({F,A}, ctxt_bump_indent(Ctxt, 5)),
+     format_args(Vs, ctxt_bump_indent(Ctxt, 14)),
+     " =",
+     nl_indent(Ctxt1),
+     format(B, Ctxt1)
+    ];
+format_1(#k_mdef{name=N,exports=Es,attributes=As,body=B}, Ctxt) ->
+    ["module ",
+     format(#k_atom{val=N}, ctxt_bump_indent(Ctxt, 7)),
+     nl_indent(Ctxt),
+     "export [",
+     format_vseq(Es,
+		 "", ",",
+		 ctxt_bump_indent(Ctxt, 8),
+		 fun format_fa_pair/2),
+     "]",
+     nl_indent(Ctxt),
+     "attributes [",
+     format_vseq(As,
+		 "", ",",
+		 ctxt_bump_indent(Ctxt, 12),
+		 fun format_attribute/2),
+     "]",
+     nl_indent(Ctxt),
+     format_vseq(B,
+		 "", "",
+		 Ctxt,
+		 fun format/2),
+     nl_indent(Ctxt)
+     | "end"
+    ];
+%% Internal sys_kernel structures.
+format_1(#iset{vars=Vs,arg=A,body=B}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    ["set <",
+     format_hseq(Vs, ", ", ctxt_bump_indent(Ctxt, 5), fun format/2),
+     "> =",
+     nl_indent(Ctxt1),
+     format(A, Ctxt1),
+     nl_indent(Ctxt),
+     "in  "
+     | format(B, ctxt_bump_indent(Ctxt, 2))
+    ];
+format_1(#ifun{vars=Vs,body=B}, Ctxt) ->
+    Ctxt1 = ctxt_bump_indent(Ctxt, Ctxt#ctxt.body_indent),
+    ["fun ",
+     format_args(Vs, ctxt_bump_indent(Ctxt, 4)),
+     " ->",
+     nl_indent(Ctxt1)
+     | format(B, Ctxt1)
+    ];
+format_1(Type, _Ctxt) ->
+    ["** Unsupported type: ",
+     io_lib:write(Type)
+     | " **"
+    ].
+
+%% format_ret([RetVar], Context) -> Txt.
+%%  Format the return vars of kexpr.
+
+format_ret(Rs, Ctxt) ->
+    [" >> ",
+     "<",
+     format_hseq(Rs, ",", ctxt_bump_indent(Ctxt, 5), fun format/2),
+     ">"].
+
+%% format_args([Arg], Context) -> Txt.
+%%  Format arguments.
+
+format_args(As, Ctxt) ->
+  [$(,format_hseq(As, ", ", ctxt_bump_indent(Ctxt, 1), fun format/2),$)].
+
+%% format_hseq([Thing], Separator, Context, Fun) -> Txt.
+%%  Format a sequence horizontally.
+
+format_hseq([H], _Sep, Ctxt, Fun) ->
+    Fun(H, Ctxt);
+format_hseq([H|T], Sep, Ctxt, Fun) ->
+    Txt = [Fun(H, Ctxt)|Sep],
+    Ctxt1 = ctxt_bump_indent(Ctxt, width(Txt, Ctxt)),
+    [Txt|format_hseq(T, Sep, Ctxt1, Fun)];
+format_hseq([], _, _, _) -> "".
+
+%% format_vseq([Thing], LinePrefix, LineSuffix, Context, Fun) -> Txt.
+%%  Format a sequence vertically.
+
+format_vseq([H], _Pre, _Suf, Ctxt, Fun) ->
+    Fun(H, Ctxt);
+format_vseq([H|T], Pre, Suf, Ctxt, Fun) ->
+    [Fun(H, Ctxt),Suf,nl_indent(Ctxt),Pre|
+     format_vseq(T, Pre, Suf, Ctxt, Fun)];
+format_vseq([], _, _, _, _) -> "".
+
+format_fa_pair({F,A}, _Ctxt) -> [core_atom(F),$/,integer_to_list(A)].
+
+%% format_attribute({Name,Val}, Context) -> Txt.
+
+format_attribute({Name,Val}, Ctxt) when is_list(Val) ->
+    Txt = format(#k_atom{val=Name}, Ctxt),
+    Ctxt1 = ctxt_bump_indent(Ctxt, width(Txt,Ctxt)+4),
+    [Txt," = ",
+     $[,format_vseq(Val, "", ",", Ctxt1,
+		    fun (A, _C) -> io_lib:write(A) end),$]
+    ];
+format_attribute({Name,Val}, Ctxt) ->
+    Txt = format(#k_atom{val=Name}, Ctxt),
+    [Txt," = ",io_lib:write(Val)].
+
+format_list_tail(#k_nil{anno=[]}, _Ctxt) -> "]";
+format_list_tail(#k_cons{anno=[],hd=H,tl=T}, Ctxt) ->
+    Txt = [$,|format(H, Ctxt)],
+    Ctxt1 = ctxt_bump_indent(Ctxt, width(Txt, Ctxt)),
+    [Txt|format_list_tail(T, Ctxt1)];
+format_list_tail(Tail, Ctxt) ->
+    ["|",format(Tail, ctxt_bump_indent(Ctxt, 1)), "]"].
+
+format_bin_seg([], _Ctx) -> "";
+format_bin_seg(#k_bin_end{anno=[]}, _Ctxt) -> "";
+format_bin_seg(#k_bin_seg{anno=[],next=N}=Seg, Ctxt) ->
+    Txt = [$,|format_bin_seg_1(Seg, Ctxt)],
+    [Txt|format_bin_seg(N, ctxt_bump_indent(Ctxt, width(Txt, Ctxt)))];
+format_bin_seg(Seg, Ctxt) ->
+    ["|",format(Seg, ctxt_bump_indent(Ctxt, 2))].
+
+format_bin_seg_1(#k_bin_seg{size=S,unit=U,type=T,flags=Fs,seg=Seg}, Ctxt) ->
+    [format(Seg, Ctxt),
+     ":",format(S, Ctxt),"*",io_lib:write(U),
+     ":",io_lib:write(T),
+     lists:map(fun (F) -> [$-,io_lib:write(F)] end, Fs)
+    ].
+
+% format_bin_elements(#k_binary_cons{hd=H,tl=T,size=S,info=I}, Ctxt) ->
+%     A = canno(T),
+%     Fe = fun (Eh, Es, Ei, Ct) ->
+% 		 [format(Eh, Ct),":",format(Es, Ct),"/",io_lib:write(Ei)]
+% 	 end,
+%     case T of
+% 	#k_zero_binary{} when A == [] ->
+% 	    Fe(H, S, I, Ctxt);
+% 	#k_binary_cons{} when A == [] ->
+% 	    Txt = [Fe(H, S, I, Ctxt)|","],
+% 	    Ctxt1 = ctxt_bump_indent(Ctxt, width(Txt, Ctxt)),
+% 	    [Txt|format_bin_elements(T, Ctxt1)];
+% 	_ ->
+% 	    Txt = [Fe(H, S, I, Ctxt)|"|"],
+% 	    [Txt|format(T, ctxt_bump_indent(Ctxt, width(Txt, Ctxt)))]
+%     end.
+
+indent(Ctxt) -> indent(Ctxt#ctxt.indent, Ctxt).
+
+indent(N, _Ctxt) when N =< 0 -> "";
+indent(N, Ctxt) ->
+    T = Ctxt#ctxt.tab_width,
+    string:chars($\t, N div T, string:chars($\s, N rem T)).
+
+nl_indent(Ctxt) -> [$\n|indent(Ctxt)].
+
+
+unindent(T, Ctxt) ->
+    unindent(T, Ctxt#ctxt.indent, Ctxt, []).
+
+unindent(T, N, _Ctxt, C) when N =< 0 ->
+    [T|C];
+unindent([$\s|T], N, Ctxt, C) ->
+    unindent(T, N - 1, Ctxt, C);
+unindent([$\t|T], N, Ctxt, C) ->
+    Tab = Ctxt#ctxt.tab_width,
+    if N >= Tab ->
+	    unindent(T, N - Tab, Ctxt, C);
+       true ->
+	    unindent([string:chars($\s, Tab - N)|T], 0, Ctxt, C)
+    end;
+unindent([L|T], N, Ctxt, C) when is_list(L) ->
+    unindent(L, N, Ctxt, [T|C]);
+unindent([H|T], _N, _Ctxt, C) ->
+    [H|[T|C]];
+unindent([], N, Ctxt, [H|T]) ->
+    unindent(H, N, Ctxt, T);
+unindent([], _, _, []) -> [].
+
+
+width(Txt, Ctxt) ->
+    width(Txt, 0, Ctxt, []).
+
+width([$\t|T], A, Ctxt, C) ->
+    width(T, A + Ctxt#ctxt.tab_width, Ctxt, C);
+width([$\n|T], _A, Ctxt, C) ->
+    width(unindent([T|C], Ctxt), Ctxt);
+width([H|T], A, Ctxt, C) when is_list(H) ->
+    width(H, A, Ctxt, [T|C]);
+width([_|T], A, Ctxt, C) ->
+    width(T, A + 1, Ctxt, C);
+width([], A, Ctxt, [H|T]) ->
+    width(H, A, Ctxt, T);
+width([], A, _, []) -> A.
+
+ctxt_bump_indent(Ctxt, Dx) ->
+    Ctxt#ctxt{indent=Ctxt#ctxt.indent + Dx}.
+
+core_atom(A) -> io_lib:write_string(atom_to_list(A), $').
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_life.erl minimal_otp_src_R12B-5/lib/compiler/src/v3_life.erl
--- otp_src_R12B-5/lib/compiler/src/v3_life.erl	2008-11-04 10:51:33.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_life.erl	2009-06-23 20:40:10.000000000 +0100
@@ -228,10 +228,21 @@ expr(#k_receive{anno=A,var=V,body=Kb,tim
     #l{ke={receive_loop,atomic(T),variable(V),M,
 	   #l{ke=Tes,i=I+1,vdb=Adb,a=[]},var_list(Rs)},
        i=I,vdb=use_vars(A#k.us, I+1, Vdb),a=A#k.a};
+expr(#k_search{anno=A,var=V,body=Kb,timeout=T,action=Ka,ret=Rs}, I, Vdb) ->
+    Result =
+	expr(
+	  #k_receive{anno=A, var=V, body=Kb, timeout=T, action=Ka, ret=Rs},
+	  I, Vdb),
+    #l{ke={receive_loop,Atomic,Variable,M,L,VarList}} = Result,
+    Result#l{ke={search_loop, Atomic, Variable, M, L, VarList}};
 expr(#k_receive_accept{anno=A}, I, _Vdb) ->
     #l{ke=receive_accept,i=I,a=A#k.a};
+expr(#k_search_accept{anno=A}, I, _Vdb) ->
+    #l{ke=search_accept,i=I,a=A#k.a};
 expr(#k_receive_next{anno=A}, I, _Vdb) ->
     #l{ke=receive_next,i=I,a=A#k.a};
+expr(#k_search_next{anno=A}, I, _Vdb) ->
+    #l{ke=search_next,i=I,a=A#k.a};
 expr(#k_put{anno=A,arg=Arg,ret=Rs}, I, _Vdb) ->
     #l{ke={set,var_list(Rs),literal(Arg, [])},i=I,a=A#k.a};
 expr(#k_break{anno=A,args=As}, I, _Vdb) ->
diff -urNp otp_src_R12B-5/lib/compiler/src/v3_life.erl~ minimal_otp_src_R12B-5/lib/compiler/src/v3_life.erl~
--- otp_src_R12B-5/lib/compiler/src/v3_life.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/compiler/src/v3_life.erl~	2009-06-23 20:40:10.000000000 +0100
@@ -0,0 +1,566 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+%% Purpose : Convert annotated kernel expressions to annotated beam format.
+
+%% This module creates beam format annotated with variable lifetime
+%% information.  Each thing is given an index and for each variable we
+%% store the first and last index for its occurrence.  The variable
+%% database, VDB, attached to each thing is only relevant internally
+%% for that thing.
+%%
+%% For nested things like matches the numbering continues locally and
+%% the VDB for that thing refers to the variable usage within that
+%% thing.  Variables which live through a such a thing are internally
+%% given a very large last index.  Internally the indexes continue
+%% after the index of that thing.  This creates no problems as the
+%% internal variable info never escapes and externally we only see
+%% variable which are alive both before or after.
+%%
+%% This means that variables never "escape" from a thing and the only
+%% way to get values from a thing is to "return" them, with 'break' or
+%% 'return'.  Externally these values become the return values of the
+%% thing.  This is no real limitation as most nested things have
+%% multiple threads so working out a common best variable usage is
+%% difficult.
+
+-module(v3_life).
+
+-export([module/2]).
+
+-export([vdb_find/2]).
+
+-import(lists, [member/2,map/2,foldl/3,reverse/1,sort/1]).
+-import(ordsets, [add_element/2,intersection/2,union/2]).
+
+-include("v3_kernel.hrl").
+-include("v3_life.hrl").
+
+%% These are not defined in v3_kernel.hrl.
+get_kanno(Kthing) -> element(2, Kthing).
+%%set_kanno(Kthing, Anno) -> setelement(2, Kthing, Anno).
+
+module(#k_mdef{name=M,exports=Es,attributes=As,body=Fs0}, Opts) ->
+    put(?MODULE, Opts),
+    Fs1 = functions(Fs0, []),
+    erase(?MODULE),
+    {ok,{M,Es,As,Fs1}}.
+
+functions([F|Fs], Acc) ->
+    functions(Fs, [function(F)|Acc]);
+functions([], Acc) -> reverse(Acc).
+
+%% function(Kfunc) -> Func.
+
+function(#k_fdef{func=F,arity=Ar,vars=Vs,body=Kb}) ->
+    %ok = io:fwrite("life ~w: ~p~n~p~n", [?LINE,{F,Ar},Kb]),
+    As = var_list(Vs),
+    Vdb0 = foldl(fun ({var,N}, Vdb) -> new_var(N, 0, Vdb) end, [], As),
+    %% Force a top-level match!
+    B0 = case Kb of
+	     #k_match{} -> Kb;
+	     _ ->
+		 Ka = get_kanno(Kb),
+		 #k_match{anno=#k{us=Ka#k.us,ns=[],a=Ka#k.a},
+			  vars=Vs,body=Kb,ret=[]}
+	 end,
+    {B1,_,Vdb1} = body(B0, 1, Vdb0),
+    {function,F,Ar,As,B1,Vdb1}.
+
+%% body(Kbody, I, Vdb) -> {[Expr],MaxI,Vdb}.
+%%  Handle a body, need special cases for transforming match_fails.
+%%  We KNOW that they only occur last in a body.
+
+body(#k_seq{arg=#k_put{anno=Pa,arg=Arg,ret=[R]},
+	    body=#k_enter{anno=Ea,op=#k_internal{name=match_fail,arity=1},
+			  args=[R]}},
+      I, Vdb0) ->
+    Vdb1 = use_vars(Pa#k.us, I, Vdb0),		%All used here
+    {[match_fail(Arg, I, Pa#k.a ++ Ea#k.a)],I,Vdb1};
+body(#k_enter{anno=Ea,op=#k_internal{name=match_fail,arity=1},args=[Arg]},
+      I, Vdb0) ->
+    Vdb1 = use_vars(Ea#k.us, I, Vdb0),
+    {[match_fail(Arg, I, Ea#k.a)],I,Vdb1};
+body(#k_seq{arg=Ke,body=Kb}, I, Vdb0) ->
+    %%ok = io:fwrite("life ~w:~p~n", [?LINE,{Ke,I,Vdb0}]),
+    A = get_kanno(Ke),
+    Vdb1 = use_vars(A#k.us, I, new_vars(A#k.ns, I, Vdb0)),
+    {Es,MaxI,Vdb2} = body(Kb, I+1, Vdb1),
+    E = expr(Ke, I, Vdb2),
+    {[E|Es],MaxI,Vdb2};
+body(Ke, I, Vdb0) ->
+    %%ok = io:fwrite("life ~w:~p~n", [?LINE,{Ke,I,Vdb0}]),
+    A = get_kanno(Ke),
+    Vdb1 = use_vars(A#k.us, I, new_vars(A#k.ns, I, Vdb0)),
+    E = expr(Ke, I, Vdb1),
+    {[E],I,Vdb1}.
+
+%% guard(Kguard, I, Vdb) -> Guard.
+
+guard(#k_try{anno=A,arg=Ts,vars=[#k_var{name=X}],body=#k_var{name=X},
+	     handler=#k_atom{val=false},ret=Rs}, I, Vdb) ->
+    %% Lock variables that are alive before try and used afterwards.
+    %% Don't lock variables that are only used inside the try expression.
+    Pdb0 = vdb_sub(I, I+1, Vdb),
+    {T,MaxI,Pdb1} = guard_body(Ts, I+1, Pdb0),
+    Pdb2 = use_vars(A#k.ns, MaxI+1, Pdb1),	%Save "return" values
+    #l{ke={protected,T,var_list(Rs)},i=I,a=A#k.a,vdb=Pdb2};
+guard(#k_seq{}=G, I, Vdb0) ->
+    {Es,_,Vdb1} = guard_body(G, I, Vdb0),
+    #l{ke={block,Es},i=I,vdb=Vdb1,a=[]};
+guard(G, I, Vdb) -> guard_expr(G, I, Vdb).
+
+%% guard_body(Kbody, I, Vdb) -> {[Expr],MaxI,Vdb}.
+
+guard_body(#k_seq{arg=Ke,body=Kb}, I, Vdb0) ->
+    A = get_kanno(Ke),
+    Vdb1 = use_vars(A#k.us, I, new_vars(A#k.ns, I, Vdb0)),
+    {Es,MaxI,Vdb2} = guard_body(Kb, I+1, Vdb1), 
+    E = guard_expr(Ke, I, Vdb2),
+    {[E|Es],MaxI,Vdb2};
+guard_body(Ke, I, Vdb0) ->
+    A = get_kanno(Ke),
+    Vdb1 = use_vars(A#k.us, I, new_vars(A#k.ns, I, Vdb0)),
+    E = guard_expr(Ke, I, Vdb1),
+    {[E],I,Vdb1}.
+
+%% guard_expr(Call, I, Vdb) -> Expr
+
+guard_expr(#k_test{anno=A,op=Op,args=As}, I, _Vdb) ->
+    #l{ke={test,test_op(Op),atomic_list(As)},i=I,a=A#k.a};
+guard_expr(#k_bif{anno=A,op=Op,args=As,ret=Rs}, I, _Vdb) ->
+    Name = bif_op(Op),
+    Ar = length(As),
+    case is_gc_bif(Name, Ar) of
+	false ->
+	    #l{ke={bif,Name,atomic_list(As),var_list(Rs)},i=I,a=A#k.a};
+	true ->
+	    #l{ke={gc_bif,Name,atomic_list(As),var_list(Rs)},i=I,a=A#k.a}
+    end;
+guard_expr(#k_put{anno=A,arg=Arg,ret=Rs}, I, _Vdb) ->
+    #l{ke={set,var_list(Rs),literal(Arg, [])},i=I,a=A#k.a};
+guard_expr(#k_match{anno=A,body=Kb,ret=Rs}, I, Vdb) ->
+    %% Support for andalso/orelse in guards.
+    %% Work out imported variables which need to be locked.
+    Mdb = vdb_sub(I, I+1, Vdb),
+    M = match(Kb, A#k.us, I+1, [], Mdb),
+    #l{ke={match,M,var_list(Rs)},i=I,vdb=use_vars(A#k.us, I+1, Mdb),a=A#k.a};
+guard_expr(G, I, Vdb) -> guard(G, I, Vdb).
+
+%% expr(Kexpr, I, Vdb) -> Expr.
+
+expr(#k_call{anno=A,op=Op,args=As,ret=Rs}, I, _Vdb) ->
+    #l{ke={call,call_op(Op),atomic_list(As),var_list(Rs)},i=I,a=A#k.a};
+expr(#k_enter{anno=A,op=Op,args=As}, I, _Vdb) ->
+    #l{ke={enter,call_op(Op),atomic_list(As)},i=I,a=A#k.a};
+expr(#k_bif{anno=A,op=Op,args=As,ret=Rs}, I, _Vdb) ->
+    Bif = k_bif(A, Op, As, Rs),
+    #l{ke=Bif,i=I,a=A#k.a};
+expr(#k_match{anno=A,body=Kb,ret=Rs}, I, Vdb) ->
+    %% Work out imported variables which need to be locked.
+    Mdb = vdb_sub(I, I+1, Vdb),
+    M = match(Kb, A#k.us, I+1, [], Mdb),
+    #l{ke={match,M,var_list(Rs)},i=I,vdb=use_vars(A#k.us, I+1, Mdb),a=A#k.a};
+expr(#k_try{anno=A,arg=Ka,vars=Vs,body=Kb,evars=Evs,handler=Kh,ret=Rs}, I, Vdb) ->
+    %% Lock variables that are alive before the catch and used afterwards.
+    %% Don't lock variables that are only used inside the try.
+    Tdb0 = vdb_sub(I, I+1, Vdb),
+    %% This is the tricky bit. Lock variables in Arg that are used in
+    %% the body and handler. Add try tag 'variable'.
+    Ab = get_kanno(Kb),
+    Ah = get_kanno(Kh),
+    Tdb1 = use_vars(Ab#k.us, I+3, use_vars(Ah#k.us, I+3, Tdb0)),
+    Tdb2 = vdb_sub(I, I+2, Tdb1),
+    Vnames = fun (Kvar) -> Kvar#k_var.name end,	%Get the variable names
+    {Aes,_,Adb} = body(Ka, I+2, add_var({catch_tag,I+1}, I+1, locked, Tdb2)),
+    {Bes,_,Bdb} = body(Kb, I+4, new_vars(map(Vnames, Vs), I+3, Tdb2)),
+    {Hes,_,Hdb} = body(Kh, I+4, new_vars(map(Vnames, Evs), I+3, Tdb2)),
+    #l{ke={'try',#l{ke={block,Aes},i=I+1,vdb=Adb,a=[]},
+	   var_list(Vs),#l{ke={block,Bes},i=I+3,vdb=Bdb,a=[]},
+	   var_list(Evs),#l{ke={block,Hes},i=I+3,vdb=Hdb,a=[]},
+	   var_list(Rs)},
+       i=I,vdb=Tdb1,a=A#k.a};
+expr(#k_try_enter{anno=A,arg=Ka,vars=Vs,body=Kb,evars=Evs,handler=Kh}, I, Vdb) ->
+    %% Lock variables that are alive before the catch and used afterwards.
+    %% Don't lock variables that are only used inside the try.
+    Tdb0 = vdb_sub(I, I+1, Vdb),
+    %% This is the tricky bit. Lock variables in Arg that are used in
+    %% the body and handler. Add try tag 'variable'.
+    Ab = get_kanno(Kb),
+    Ah = get_kanno(Kh),
+    Tdb1 = use_vars(Ab#k.us, I+3, use_vars(Ah#k.us, I+3, Tdb0)),
+    Tdb2 = vdb_sub(I, I+2, Tdb1),
+    Vnames = fun (Kvar) -> Kvar#k_var.name end,	%Get the variable names
+    {Aes,_,Adb} = body(Ka, I+2, add_var({catch_tag,I+1}, I+1, 1000000, Tdb2)),
+    {Bes,_,Bdb} = body(Kb, I+4, new_vars(map(Vnames, Vs), I+3, Tdb2)),
+    {Hes,_,Hdb} = body(Kh, I+4, new_vars(map(Vnames, Evs), I+3, Tdb2)),
+    #l{ke={try_enter,#l{ke={block,Aes},i=I+1,vdb=Adb,a=[]},
+	   var_list(Vs),#l{ke={block,Bes},i=I+3,vdb=Bdb,a=[]},
+	   var_list(Evs),#l{ke={block,Hes},i=I+3,vdb=Hdb,a=[]}},
+       i=I,vdb=Tdb1,a=A#k.a};
+expr(#k_catch{anno=A,body=Kb,ret=[R]}, I, Vdb) ->
+    %% Lock variables that are alive before the catch and used afterwards.
+    %% Don't lock variables that are only used inside the catch.
+    %% Add catch tag 'variable'.
+    Cdb0 = vdb_sub(I, I+1, Vdb),
+    {Es,_,Cdb1} = body(Kb, I+1, add_var({catch_tag,I}, I, locked, Cdb0)),
+    #l{ke={'catch',Es,variable(R)},i=I,vdb=Cdb1,a=A#k.a};
+expr(#k_receive{anno=A,var=V,body=Kb,timeout=T,action=Ka,ret=Rs}, I, Vdb) ->
+    %% Work out imported variables which need to be locked.
+    Rdb = vdb_sub(I, I+1, Vdb),
+    M = match(Kb, add_element(V#k_var.name, A#k.us), I+1, [],
+ 	      new_var(V#k_var.name, I, Rdb)),
+    {Tes,_,Adb} = body(Ka, I+1, Rdb),
+    #l{ke={receive_loop,atomic(T),variable(V),M,
+	   #l{ke=Tes,i=I+1,vdb=Adb,a=[]},var_list(Rs)},
+       i=I,vdb=use_vars(A#k.us, I+1, Vdb),a=A#k.a};
+expr(#k_receive_accept{anno=A}, I, _Vdb) ->
+    #l{ke=receive_accept,i=I,a=A#k.a};
+expr(#k_search_accept{anno=A}, I, _Vdb) ->
+    #l{ke=search_accept,i=I,a=A#k.a};
+expr(#k_receive_next{anno=A}, I, _Vdb) ->
+    #l{ke=receive_next,i=I,a=A#k.a};
+expr(#k_put{anno=A,arg=Arg,ret=Rs}, I, _Vdb) ->
+    #l{ke={set,var_list(Rs),literal(Arg, [])},i=I,a=A#k.a};
+expr(#k_break{anno=A,args=As}, I, _Vdb) ->
+    #l{ke={break,atomic_list(As)},i=I,a=A#k.a};
+expr(#k_return{anno=A,args=As}, I, _Vdb) ->
+    #l{ke={return,atomic_list(As)},i=I,a=A#k.a}.
+
+%% call_op(Op) -> Op.
+%% bif_op(Op) -> Op.
+%% test_op(Op) -> Op.
+%%  Do any necessary name translations here to munge into beam format.
+
+call_op(#k_local{name=N}) -> N; 
+call_op(#k_remote{mod=M,name=N}) -> {remote,atomic(M),atomic(N)};
+call_op(Other) -> variable(Other).
+
+bif_op(#k_remote{mod=#k_atom{val=erlang},name=#k_atom{val=N}}) -> N;
+bif_op(#k_internal{name=N}) -> N.
+
+test_op(#k_remote{mod=#k_atom{val=erlang},name=#k_atom{val=N}}) -> N.
+
+%% k_bif(Anno, Op, [Arg], [Ret]) -> Expr.
+%%  Build bifs, do special handling of internal some calls.
+
+k_bif(_A, #k_internal{name=dsetelement,arity=3}, As, []) ->
+    {bif,dsetelement,atomic_list(As),[]};
+k_bif(_A, #k_internal{name=bs_context_to_binary=Op,arity=1}, As, []) ->
+    {bif,Op,atomic_list(As),[]};
+k_bif(_A, #k_internal{name=bs_init_writable=Op,arity=1}, As, Rs) ->
+    {bif,Op,atomic_list(As),var_list(Rs)};
+k_bif(_A, #k_internal{name=make_fun},
+      [#k_atom{val=Fun},#k_int{val=Arity},
+       #k_int{val=Index},#k_int{val=Uniq}|Free],
+      Rs) ->
+    {bif,{make_fun,Fun,Arity,Index,Uniq},var_list(Free),var_list(Rs)};
+k_bif(_A, Op, As, Rs) ->
+    %% The general case.
+    Name = bif_op(Op),
+    Ar = length(As),
+    case is_gc_bif(Name, Ar) of
+	false ->
+	    {bif,Name,atomic_list(As),var_list(Rs)};
+	true ->
+	    {gc_bif,Name,atomic_list(As),var_list(Rs)}
+    end.
+
+%% match(Kexpr, [LockVar], I, Vdb) -> Expr.
+%%  Convert match tree to old format.
+
+match(#k_alt{anno=A,first=Kf,then=Kt}, Ls, I, Ctxt, Vdb0) ->
+    Vdb1 = use_vars(union(A#k.us, Ls), I, Vdb0),
+    F = match(Kf, Ls, I+1, Ctxt, Vdb1),
+    T = match(Kt, Ls, I+1, Ctxt, Vdb1),
+    #l{ke={alt,F,T},i=I,vdb=Vdb1,a=A#k.a};
+match(#k_select{anno=A,var=V,types=Kts}, Ls0, I, Ctxt, Vdb0) ->
+    Vanno = get_kanno(V),
+    Ls1 = case member(no_usage, Vanno) of
+	      false -> add_element(V#k_var.name, Ls0);
+	      true -> Ls0
+	  end,
+    Anno = case member(reuse_for_context, Vanno) of
+	       true -> [reuse_for_context|A#k.a];
+	       false -> A#k.a
+	   end,
+    Vdb1 = use_vars(union(A#k.us, Ls1), I, Vdb0),
+    Ts = [type_clause(Tc, Ls1, I+1, Ctxt, Vdb1) || Tc <- Kts],
+    #l{ke={select,literal2(V, Ctxt),Ts},i=I,vdb=Vdb1,a=Anno};
+match(#k_guard{anno=A,clauses=Kcs}, Ls, I, Ctxt, Vdb0) ->
+    Vdb1 = use_vars(union(A#k.us, Ls), I, Vdb0),
+    Cs = [guard_clause(G, Ls, I+1, Ctxt, Vdb1) || G <- Kcs],
+    #l{ke={guard,Cs},i=I,vdb=Vdb1,a=A#k.a};
+match(Other, Ls, I, _Ctxt, Vdb0) ->
+    Vdb1 = use_vars(Ls, I, Vdb0),
+    {B,_,Vdb2} = body(Other, I+1, Vdb1),
+    #l{ke={block,B},i=I,vdb=Vdb2,a=[]}.
+
+type_clause(#k_type_clause{anno=A,type=T,values=Kvs}, Ls, I, Ctxt, Vdb0) ->
+    %%ok = io:format("life ~w: ~p~n", [?LINE,{T,Kvs}]),
+    Vdb1 = use_vars(union(A#k.us, Ls), I+1, Vdb0),
+    Vs = [val_clause(Vc, Ls, I+1, Ctxt, Vdb1) || Vc <- Kvs],
+    #l{ke={type_clause,type(T),Vs},i=I,vdb=Vdb1,a=A#k.a}.
+
+val_clause(#k_val_clause{anno=A,val=V,body=Kb}, Ls0, I, Ctxt0, Vdb0) ->
+    New = (get_kanno(V))#k.ns,
+    Bus = (get_kanno(Kb))#k.us,
+    %%ok = io:format("Ls0 = ~p, Used=~p\n  New=~p, Bus=~p\n", [Ls0,Used,New,Bus]),
+    Ls1 = union(intersection(New, Bus), Ls0),	%Lock for safety
+    Vdb1 = use_vars(union(A#k.us, Ls1), I+1, new_vars(New, I, Vdb0)),
+    Ctxt = case V of
+	       #k_binary{segs=#k_var{name=C0}} -> C0;
+	       _ -> Ctxt0
+	   end,
+    B = match(Kb, Ls1, I+1, Ctxt, Vdb1),
+    #l{ke={val_clause,literal2(V, Ctxt),B},i=I,vdb=use_vars(Bus, I+1, Vdb1),a=A#k.a}.
+
+guard_clause(#k_guard_clause{anno=A,guard=Kg,body=Kb}, Ls, I, Ctxt, Vdb0) ->
+    Vdb1 = use_vars(union(A#k.us, Ls), I+2, Vdb0),
+    Gdb = vdb_sub(I+1, I+2, Vdb1),
+    G = guard(Kg, I+1, Gdb),
+    B = match(Kb, Ls, I+2, Ctxt, Vdb1),
+    #l{ke={guard_clause,G,B},
+       i=I,vdb=use_vars((get_kanno(Kg))#k.us, I+2, Vdb1),
+       a=A#k.a}.
+
+%% match_fail(FailValue, I, Anno) -> Expr.
+%%  Generate the correct match_fail instruction.  N.B. there is no
+%%  generic case for when the fail value has been created elsewhere.
+
+match_fail(#k_literal{anno=Anno,val={Atom,Val}}, I, A) when is_atom(Atom) ->
+    match_fail(#k_tuple{anno=Anno,es=[#k_atom{val=Atom},#k_literal{val=Val}]}, I, A);
+match_fail(#k_literal{anno=Anno,val={Atom}}, I, A) when is_atom(Atom) ->
+    match_fail(#k_tuple{anno=Anno,es=[#k_atom{val=Atom}]}, I, A);
+match_fail(#k_literal{anno=Anno,val=Atom}, I, A) when is_atom(Atom) ->
+    match_fail(#k_atom{anno=Anno,val=Atom}, I, A);
+match_fail(#k_tuple{es=[#k_atom{val=function_clause}|As]}, I, A) ->
+    #l{ke={match_fail,{function_clause,literal_list(As, [])}},i=I,a=A};
+match_fail(#k_tuple{es=[#k_atom{val=badmatch},Val]}, I, A) ->
+    #l{ke={match_fail,{badmatch,literal(Val, [])}},i=I,a=A};
+match_fail(#k_tuple{es=[#k_atom{val=case_clause},Val]}, I, A) ->
+    #l{ke={match_fail,{case_clause,literal(Val, [])}},i=I,a=A};
+match_fail(#k_atom{val=if_clause}, I, A) ->
+    #l{ke={match_fail,if_clause},i=I,a=A};
+match_fail(#k_tuple{es=[#k_atom{val=try_clause},Val]}, I, A) ->
+    #l{ke={match_fail,{try_clause,literal(Val, [])}},i=I,a=A}.
+
+%% type(Ktype) -> Type.
+
+type(k_int) -> integer;
+%%type(k_char) -> integer;			%Hhhmmm???
+type(k_float) -> float;
+type(k_atom) -> atom;
+type(k_nil) -> nil;
+type(k_cons) -> cons;
+type(k_tuple) -> tuple;
+type(k_binary) -> binary;
+type(k_bin_seg) -> bin_seg;
+type(k_bin_int) -> bin_int;
+type(k_bin_end) -> bin_end.
+
+%% variable(Klit) -> Lit.
+%% var_list([Klit]) -> [Lit].
+
+variable(#k_var{name=N}) -> {var,N}.
+
+var_list(Ks) -> [variable(K) || K <- Ks].
+
+%% atomic(Klit) -> Lit.
+%% atomic_list([Klit]) -> [Lit].
+
+atomic(#k_literal{val=V}) -> {literal,V};
+atomic(#k_var{name=N}) -> {var,N};
+atomic(#k_int{val=I}) -> {integer,I};
+atomic(#k_float{val=F}) -> {float,F};
+atomic(#k_atom{val=N}) -> {atom,N};
+%%atomic(#k_char{val=C}) -> {char,C};
+%%atomic(#k_string{val=S}) -> {string,S};
+atomic(#k_nil{}) -> nil.
+
+atomic_list(Ks) -> [atomic(K) || K <- Ks].
+
+%% literal(Klit) -> Lit.
+%% literal_list([Klit]) -> [Lit].
+
+literal(#k_var{name=N}, _) -> {var,N};
+literal(#k_int{val=I}, _) -> {integer,I};
+literal(#k_float{val=F}, _) -> {float,F};
+literal(#k_atom{val=N}, _) -> {atom,N};
+%%literal(#k_char{val=C}, _) -> {char,C};
+literal(#k_string{val=S}, _) -> {string,S};
+literal(#k_nil{}, _) -> nil;
+literal(#k_cons{hd=H,tl=T}, Ctxt) ->
+    {cons,[literal(H, Ctxt),literal(T, Ctxt)]};
+literal(#k_binary{segs=V}, Ctxt) ->
+	    {binary,literal(V, Ctxt)};
+literal(#k_bin_seg{size=S,unit=U,type=T,flags=Fs,seg=Seg,next=N}, Ctxt) ->
+    {bin_seg,Ctxt,literal(S, Ctxt),U,T,Fs,
+     [literal(Seg, Ctxt),literal(N, Ctxt)]};
+literal(#k_bin_end{}, Ctxt) ->
+    {bin_end,Ctxt};
+literal(#k_tuple{es=Es}, Ctxt) ->
+    {tuple,literal_list(Es, Ctxt)};
+literal(#k_literal{val=V}, _Ctxt) ->
+    {literal,V}.
+
+literal_list(Ks, Ctxt) ->
+    [literal(K, Ctxt) || K <- Ks].
+
+literal2(#k_var{name=N}, _) -> {var,N};
+literal2(#k_int{val=I}, _) -> {integer,I};
+literal2(#k_float{val=F}, _) -> {float,F};
+literal2(#k_atom{val=N}, _) -> {atom,N};
+%%literal2(#k_char{val=C}, _) -> {char,C};
+literal2(#k_string{val=S}, _) -> {string,S};
+literal2(#k_nil{}, _) -> nil;
+literal2(#k_cons{hd=H,tl=T}, Ctxt) ->
+    {cons,[literal2(H, Ctxt),literal2(T, Ctxt)]};
+literal2(#k_binary{segs=V}, Ctxt) ->
+    {binary,literal2(V, Ctxt)};
+literal2(#k_bin_seg{size=S,unit=U,type=T,flags=Fs,seg=Seg,next=[]}, Ctxt) ->
+    {bin_seg,Ctxt,literal2(S, Ctxt),U,T,Fs,[literal2(Seg, Ctxt)]};
+literal2(#k_bin_seg{size=S,unit=U,type=T,flags=Fs,seg=Seg,next=N}, Ctxt) ->
+    {bin_seg,Ctxt,literal2(S, Ctxt),U,T,Fs,
+     [literal2(Seg, Ctxt),literal2(N, Ctxt)]};
+literal2(#k_bin_int{size=S,unit=U,flags=Fs,val=Int,next=N}, Ctxt) ->
+    {bin_int,Ctxt,literal2(S, Ctxt),U,Fs,Int,
+     [literal2(N, Ctxt)]};
+literal2(#k_bin_end{}, Ctxt) ->
+    {bin_end,Ctxt};
+literal2(#k_tuple{es=Es}, Ctxt) ->
+    {tuple,literal_list2(Es, Ctxt)}.
+
+literal_list2(Ks, Ctxt) ->
+    [literal2(K, Ctxt) || K <- Ks].
+
+%% literal_bin(#k_bin_seg{size=S,unit=U,type=T,flags=Fs,seg=Seg,next=N}) ->
+%%     {bin_seg,literal(S),U,T,Fs,[literal(Seg),literal(N)]}
+
+
+%% is_gc_bif(Name, Arity) -> true|false
+%%  Determines whether the BIF Name/Arity might do a GC.
+
+is_gc_bif(Name, Arity) ->
+    case get_opt(no_gc_bifs) of
+	true -> false;
+	false -> is_gc_bif_1(Name, Arity)
+    end.
+
+is_gc_bif_1(hd, 1) -> false;
+is_gc_bif_1(tl, 1) -> false;
+is_gc_bif_1(self, 0) -> false;
+is_gc_bif_1(node, 0) -> false;
+is_gc_bif_1(node, 1) -> false;
+is_gc_bif_1(element, 2) -> false;
+is_gc_bif_1(get, 1) -> false;
+is_gc_bif_1(raise, 2) -> false;
+is_gc_bif_1(tuple_size, 1) -> false;
+is_gc_bif_1(Bif, Arity) ->
+    not (erl_internal:bool_op(Bif, Arity) orelse
+	 erl_internal:new_type_test(Bif, Arity) orelse
+	 erl_internal:comp_op(Bif, Arity)).
+
+%% get_opt(OptionName) -> true|false
+%%  Test a compiler option.
+get_opt(Opt) ->
+    proplists:get_bool(Opt, get(?MODULE)).
+
+
+%% new_var(VarName, I, Vdb) -> Vdb.
+%% new_vars([VarName], I, Vdb) -> Vdb.
+%% use_var(VarName, I, Vdb) -> Vdb.
+%% use_vars([VarName], I, Vdb) -> Vdb.
+%% add_var(VarName, F, L, Vdb) -> Vdb.
+
+new_var(V, I, Vdb) ->
+    vdb_store_new(V, I, I, Vdb).
+
+new_vars(Vs, I, Vdb0) ->
+    foldl(fun (V, Vdb) -> new_var(V, I, Vdb) end, Vdb0, Vs).
+
+use_var(V, I, Vdb) ->
+    case vdb_find(V, Vdb) of
+	{V,F,L} when I > L -> vdb_update(V, F, I, Vdb);
+	{V,_,_} -> Vdb;
+	error -> vdb_store_new(V, I, I, Vdb)
+    end.
+
+use_vars([], _, Vdb) -> Vdb;
+use_vars([V], I, Vdb) -> use_var(V, I, Vdb);
+use_vars(Vs, I, Vdb) ->
+    Res = use_vars_1(sort(Vs), Vdb, I),
+    %% The following line can be used as an assertion.
+    %%   Res = foldl(fun (V, Vdb) -> use_var(V, I, Vdb) end, Vdb, Vs),
+    Res.
+
+%% Measurements show that it is worthwhile having this special
+%% function that updates/inserts several variables at once.
+
+use_vars_1([V|_]=Vs, [{V1,_,_}=Vd|Vdb], I) when V > V1 ->
+    [Vd|use_vars_1(Vs, Vdb, I)];
+use_vars_1([V|Vs], [{V1,_,_}|_]=Vdb, I) when V < V1 ->
+    %% New variable.
+    [{V,I,I}|use_vars_1(Vs, Vdb, I)];
+use_vars_1([V|Vs], [{_,F,L}=Vd|Vdb], I) ->
+    %% Existing variable.
+    if
+	I > L ->[{V,F,I}|use_vars_1(Vs, Vdb, I)];
+	true -> [Vd|use_vars_1(Vs, Vdb, I)]
+    end;
+use_vars_1([V|Vs], [], I) ->
+    %% New variable.
+    [{V,I,I}|use_vars_1(Vs, [], I)];
+use_vars_1([], Vdb, _) -> Vdb.
+
+add_var(V, F, L, Vdb) ->
+    vdb_store_new(V, F, L, Vdb).
+
+vdb_find(V, Vdb) ->
+    %% Performance note: Profiling shows that this function accounts for
+    %% a lot of the execution time when huge constant terms are built.
+    %% Using the BIF lists:keysearch/3 is a lot faster than the
+    %% original Erlang version.
+    case lists:keysearch(V, 1, Vdb) of
+	{value,Vd} -> Vd;
+	false -> error
+    end.
+
+%vdb_find(V, [{V1,F,L}=Vd|Vdb]) when V < V1 -> error;
+%vdb_find(V, [{V1,F,L}=Vd|Vdb]) when V == V1 -> Vd;
+%vdb_find(V, [{V1,F,L}=Vd|Vdb]) when V > V1 -> vdb_find(V, Vdb);
+%vdb_find(V, []) -> error.
+
+vdb_update(V, F, L, [{V1,_,_}=Vd|Vdb]) when V > V1 ->
+    [Vd|vdb_update(V, F, L, Vdb)];
+vdb_update(V, F, L, [{V1,_,_}|Vdb]) when V == V1 ->
+    [{V,F,L}|Vdb].
+
+vdb_store_new(V, F, L, [{V1,_,_}=Vd|Vdb]) when V > V1 ->
+    [Vd|vdb_store_new(V, F, L, Vdb)];
+vdb_store_new(V, F, L, [{V1,_,_}|_]=Vdb) when V < V1 -> [{V,F,L}|Vdb];
+vdb_store_new(V, F, L, []) -> [{V,F,L}].
+
+%% vdb_sub(Min, Max, Vdb) -> Vdb.
+%%  Extract variables which are used before and after Min.  Lock
+%%  variables alive after Max.
+
+vdb_sub(Min, Max, Vdb) ->
+    [ if L >= Max -> {V,F,locked};
+	 true -> Vd
+      end || {V,F,L}=Vd <- Vdb, F < Min, L >= Min ].
+
diff -urNp otp_src_R12B-5/lib/stdlib/src/epp.erl minimal_otp_src_R12B-5/lib/stdlib/src/epp.erl
--- otp_src_R12B-5/lib/stdlib/src/epp.erl	2008-06-10 13:47:24.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/epp.erl	2009-06-23 20:40:26.000000000 +0100
@@ -841,6 +841,8 @@ macro_arg([{'case',Lc}|Toks], E, Arg) ->
     macro_arg(Toks, ['end'|E], [{'case',Lc}|Arg]);
 macro_arg([{'receive',Lr}|Toks], E, Arg) ->
     macro_arg(Toks, ['end'|E], [{'receive',Lr}|Arg]);
+macro_arg([{'search',Lr}|Toks], E, Arg) ->
+    macro_arg(Toks, ['end'|E], [{'search',Lr}|Arg]);
 macro_arg([{'try',Lr}|Toks], E, Arg) ->
     macro_arg(Toks, ['end'|E], [{'try',Lr}|Arg]);
 macro_arg([{'cond',Lr}|Toks], E, Arg) ->
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_eval.erl minimal_otp_src_R12B-5/lib/stdlib/src/erl_eval.erl
--- otp_src_R12B-5/lib/stdlib/src/erl_eval.erl	2008-02-05 13:37:05.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_eval.erl	2009-06-23 20:40:26.000000000 +0100
@@ -173,6 +173,11 @@ expr({'receive',_,Cs}, Bs, Lf, Ef, RBs) 
 expr({'receive',_, Cs, E, TB}, Bs0, Lf, Ef, RBs) ->
     {value,T,Bs} = expr(E, Bs0, Lf, Ef, none),
     receive_clauses(T, Cs, {TB,Bs}, Bs0, Lf, Ef, [], RBs);
+expr({'search',_,Cs}, Bs, Lf, Ef, RBs) ->
+    search_clauses(Cs, Bs, Lf, Ef, [], RBs);
+expr({'search',_, Cs, E, TB}, Bs0, Lf, Ef, RBs) ->
+    {value,T,Bs} = expr(E, Bs0, Lf, Ef, none),
+    search_clauses(T, Cs, {TB,Bs}, Bs0, Lf, Ef, [], RBs);
 expr({'fun',_Line,{function,Mod,Name,Arity}}, Bs, _Lf, _Ef, RBs) ->
     F = erlang:make_fun(Mod, Name, Arity),
     ret_expr(F, Bs, RBs);    
@@ -749,6 +754,50 @@ receive_clauses(T, Cs, TB, Bs, Lf, Ef, M
 	    exprs(B, Bs1, Lf, Ef, RBs)
     end.
 
+%%
+%% search_clauses(Clauses, Bindings, LocalFuncHnd,ExtFuncHnd, Messages, RBs) 
+%%
+search_clauses(Cs, Bs, Lf, Ef, Ms, RBs) ->
+    receive
+	Val ->
+	    case match_clause(Cs, [Val], Bs, Lf, Ef) of
+		{B, Bs1} ->
+		    merge_queue(Ms),
+		    exprs(B, Bs1, Lf, Ef, RBs);
+		nomatch ->
+		    search_clauses(Cs, Bs, Lf, Ef, [Val|Ms], RBs)
+	    end
+    end.
+%%
+%% search_clauses(TimeOut, Clauses, TimeoutBody, Bindings, 
+%%                 ExternalFuncHandler, LocalFuncHandler, RBs)
+%%
+search_clauses(T, Cs, TB, Bs, Lf, Ef, Ms, RBs) ->
+    {_,_} = statistics(runtime),
+    receive
+	Val ->
+	    case match_clause(Cs, [Val], Bs, Lf, Ef) of
+		{B, Bs1} ->
+		    merge_queue(Ms),
+		    exprs(B, Bs1, Lf, Ef, RBs);
+		nomatch ->
+		    {_,T1} = statistics(runtime),
+		    if
+			T =:= infinity ->
+			    search_clauses(T, Cs, TB,Bs,Lf,Ef,[Val|Ms],RBs);
+			T-T1 =< 0 ->
+			    search_clauses(0, Cs, TB,Bs,Lf,Ef,[Val|Ms],RBs);
+			true ->
+			    search_clauses(T-T1, Cs,TB,Bs,Lf,Ef,[Val|Ms],RBs)
+		    end
+	    end
+    after T ->
+	    merge_queue(Ms),
+	    {B, Bs1} = TB,
+	    exprs(B, Bs1, Lf, Ef, RBs)
+    end.
+
+
 merge_queue(Ms) ->
     send_all(recv_all(Ms), self()).
 
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_expand_records.erl minimal_otp_src_R12B-5/lib/stdlib/src/erl_expand_records.erl
--- otp_src_R12B-5/lib/stdlib/src/erl_expand_records.erl	2008-04-07 14:58:49.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_expand_records.erl	2009-06-23 20:40:26.000000000 +0100
@@ -333,6 +333,14 @@ expr({'receive',Line,Cs0,To0,ToEs0}, St0
     {ToEs,St2} = exprs(ToEs0, St1),
     {Cs,St3} = clauses(Cs0, St2),
     {{'receive',Line,Cs,To,ToEs},St3};
+expr({'search',Line,Cs0}, St0) ->
+    {Cs,St1} = clauses(Cs0, St0),
+    {{'search',Line,Cs},St1};
+expr({'search',Line,Cs0,To0,ToEs0}, St0) ->
+    {To,St1} = expr(To0, St0),
+    {ToEs,St2} = exprs(ToEs0, St1),
+    {Cs,St3} = clauses(Cs0, St2),
+    {{'search',Line,Cs,To,ToEs},St3};
 expr({'fun',_,{function,_F,_A}}=Fun, St) ->
     {Fun,St};
 expr({'fun',_,{function,_M,_F,_A}}=Fun, St) ->
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_internal.erl minimal_otp_src_R12B-5/lib/stdlib/src/erl_internal.erl
--- otp_src_R12B-5/lib/stdlib/src/erl_internal.erl	2008-09-01 13:51:20.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_internal.erl	2009-06-23 20:40:26.000000000 +0100
@@ -323,6 +323,11 @@ bif(put, 2) -> true;
 bif(register, 2) -> true;
 bif(registered, 0) -> true;
 bif(round, 1) -> true;
+bif(search_reset, 0) -> true;
+bif(last_search_index, 0) -> true;
+bif(search_debug, 1) -> true;
+bif(search_index, 1) -> true;
+bif(receive_index, 1) -> true;
 bif(self, 0) -> true;
 bif(setelement, 3) -> true;
 bif(size, 1) -> true;
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_internal.erl~ minimal_otp_src_R12B-5/lib/stdlib/src/erl_internal.erl~
--- otp_src_R12B-5/lib/stdlib/src/erl_internal.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_internal.erl~	2009-06-23 20:40:26.000000000 +0100
@@ -0,0 +1,360 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+-module(erl_internal).
+
+%% Define Erlang bifs, guard tests and other internal stuff.
+%%
+%% NOTE: All guard_bif(), arith_op(), bool_op() and comp_op() must be
+%%       defined in bif.tab as 'ubif', i.e bif without trace wrapper.
+%%       
+%%       Why?
+%%       
+%%       Because the compiler uses an optimized instruction for
+%%       the call to these bifs, which when loaded gets a direct 
+%%       entry pointer inserted into itself by the loader, 
+%%       instead of a bif table index as for regular bifs.
+%%       
+%%       If tracing is enabled on these bifs, when a module is loaded, 
+%%       the direct entry pointer inserted into the call instruction 
+%%       will be pointing to the trace wrapper, so even if tracing is 
+%%       disabled for bifs, the loaded module will call these bifs through 
+%%       the trace wrappers.
+%%       
+%%       The call instruction in question does not give enough information
+%%       to call trace match function {caller} for it to succeed 
+%%       other then by chance, and the 'return_to' trace flag works just
+%%       as bad, so both will mostly say that the caller is 'undefined'. 
+%%       Furthermore the calls to these bifs will still generate
+%%       trace messages from the loaded module even if tracing is disabled 
+%%       for them, and no one knows what else might be messed up.
+%%
+%%       That's why!
+%%
+
+-export([bif/2,bif/3,guard_bif/2,
+	 type_test/2,new_type_test/2,old_type_test/2]).
+-export([arith_op/2,bool_op/2,comp_op/2,list_op/2,send_op/2,op_type/2]).
+
+%%---------------------------------------------------------------------------
+
+-type arity() :: 0..255.
+
+%%---------------------------------------------------------------------------
+
+%%  Erlang builtin functions allowed in guards.
+-spec guard_bif(Name::atom(), Arity::arity()) -> bool().
+
+guard_bif(abs, 1) -> true;
+guard_bif(float, 1) -> true;
+guard_bif(trunc, 1) -> true;
+guard_bif(round, 1) -> true;
+guard_bif(length, 1) -> true;
+guard_bif(hd, 1) -> true;
+guard_bif(tl, 1) -> true;
+guard_bif(size, 1) -> true;
+guard_bif(bit_size, 1) -> true;
+guard_bif(byte_size, 1) -> true;
+guard_bif(element, 2) -> true;
+guard_bif(self, 0) -> true;
+guard_bif(node, 0) -> true;
+guard_bif(node, 1) -> true;
+guard_bif(tuple_size, 1) -> true;
+guard_bif(is_atom, 1) -> true;
+guard_bif(is_binary, 1) -> true;
+guard_bif(is_bitstring, 1) -> true;
+guard_bif(is_boolean, 1) -> true;
+guard_bif(is_constant, 1) -> true;
+guard_bif(is_float, 1) -> true;
+guard_bif(is_function, 1) -> true;
+guard_bif(is_function, 2) -> true;
+guard_bif(is_integer, 1) -> true;
+guard_bif(is_list, 1) -> true;
+guard_bif(is_number, 1) -> true;
+guard_bif(is_pid, 1) -> true;
+guard_bif(is_port, 1) -> true;
+guard_bif(is_reference, 1) -> true;
+guard_bif(is_tuple, 1) -> true;
+guard_bif(is_record, 2) -> true;
+guard_bif(is_record, 3) -> true;
+guard_bif(Name, A) when is_atom(Name), is_integer(A) -> false.
+
+%%  Erlang type tests.
+-spec type_test(Name::atom(), Arity::arity()) -> bool().
+
+type_test(Name, Arity) ->
+    new_type_test(Name, Arity) orelse old_type_test(Name, Arity).
+
+%%  Erlang new-style type tests.
+-spec new_type_test(Name::atom(), Arity::arity()) -> bool().
+
+new_type_test(is_atom, 1) -> true;
+new_type_test(is_boolean, 1) -> true;
+new_type_test(is_binary, 1) -> true;
+new_type_test(is_bitstring, 1) -> true;
+new_type_test(is_constant, 1) -> true;
+new_type_test(is_float, 1) -> true;
+new_type_test(is_function, 1) -> true;
+new_type_test(is_function, 2) -> true;
+new_type_test(is_integer, 1) -> true;
+new_type_test(is_list, 1) -> true;
+new_type_test(is_number, 1) -> true;
+new_type_test(is_pid, 1) -> true;
+new_type_test(is_port, 1) -> true;
+new_type_test(is_reference, 1) -> true;
+new_type_test(is_tuple, 1) -> true;
+new_type_test(is_record, 2) -> true;
+new_type_test(is_record, 3) -> true;
+new_type_test(Name, A) when is_atom(Name), is_integer(A) -> false.
+
+%%  Erlang old-style type tests.
+-spec old_type_test(Name::atom(), Arity::arity()) -> bool().
+
+old_type_test(integer, 1) -> true;
+old_type_test(float, 1) -> true;
+old_type_test(number, 1) -> true;
+old_type_test(atom, 1) -> true;
+old_type_test(constant, 1) -> true;
+old_type_test(list, 1) -> true;
+old_type_test(tuple, 1) -> true;
+old_type_test(pid, 1) -> true;
+old_type_test(reference, 1) -> true;
+old_type_test(port, 1) -> true;
+old_type_test(binary, 1) -> true;
+old_type_test(record, 2) -> true;
+old_type_test(function, 1) -> true;
+old_type_test(Name, A) when is_atom(Name), is_integer(A) -> false.
+
+-spec arith_op(Op::atom(), Arity::arity()) -> bool().
+
+arith_op('+', 1) -> true;
+arith_op('-', 1) -> true;
+arith_op('*', 2) -> true;
+arith_op('/', 2) -> true;
+arith_op('+', 2) -> true;
+arith_op('-', 2) -> true;
+arith_op('bnot', 1) -> true;
+arith_op('div', 2) -> true;
+arith_op('rem', 2) -> true;
+arith_op('band', 2) -> true;
+arith_op('bor', 2) -> true;
+arith_op('bxor', 2) -> true;
+arith_op('bsl', 2) -> true;
+arith_op('bsr', 2) -> true;
+arith_op(Op, A) when is_atom(Op), is_integer(A) -> false.
+
+-spec bool_op(Op::atom(), Arity::arity()) -> bool().
+
+bool_op('not', 1) -> true;
+bool_op('and', 2) -> true;
+bool_op('or', 2) -> true;
+bool_op('xor', 2) -> true;
+bool_op(Op, A) when is_atom(Op), is_integer(A) -> false.
+
+-spec comp_op(Op::atom(), Arity::arity()) -> bool().
+
+comp_op('==', 2) -> true;
+comp_op('/=', 2) -> true;
+comp_op('=<', 2) -> true;
+comp_op('<', 2) -> true;
+comp_op('>=', 2) -> true;
+comp_op('>', 2) -> true;
+comp_op('=:=', 2) -> true;
+comp_op('=/=', 2) -> true;
+comp_op(Op, A) when is_atom(Op), is_integer(A) -> false.
+
+-spec list_op(Op::atom(), Arity::arity()) -> bool().
+
+list_op('++', 2) -> true;
+list_op('--', 2) -> true;
+list_op(Op, A) when is_atom(Op), is_integer(A) -> false.
+
+-spec send_op(Op::atom(), Arity::arity()) -> bool().
+
+send_op('!', 2) -> true;
+send_op(Op, A) when is_atom(Op), is_integer(A) -> false.
+
+-spec op_type(Op::atom(), Arity::arity()) ->
+		'arith' | 'bool' | 'comp' | 'list' | 'send'.
+
+op_type('+', 1) -> arith;
+op_type('-', 1) -> arith;
+op_type('*', 2) -> arith;
+op_type('/', 2) -> arith;
+op_type('+', 2) -> arith;
+op_type('-', 2) -> arith;
+op_type('bnot', 1) -> arith;
+op_type('div', 2) -> arith;
+op_type('rem', 2) -> arith;
+op_type('band', 2) -> arith;
+op_type('bor', 2) -> arith;
+op_type('bxor', 2) -> arith;
+op_type('bsl', 2) -> arith;
+op_type('bsr', 2) -> arith;
+op_type('not', 1) -> bool;
+op_type('and', 2) -> bool;
+op_type('or', 2) -> bool;
+op_type('xor', 2) -> bool;
+op_type('==', 2) -> comp;
+op_type('/=', 2) -> comp;
+op_type('=<', 2) -> comp;
+op_type('<', 2) -> comp;
+op_type('>=', 2) -> comp;
+op_type('>', 2) -> comp;
+op_type('=:=', 2) -> comp;
+op_type('=/=', 2) -> comp;
+op_type('++', 2) -> list;
+op_type('--', 2) -> list;
+op_type('!', 2) -> send.
+
+-spec bif(Mod::atom(), Name::atom(), Arity::arity()) -> bool().
+
+bif(erlang, Name, Arity) -> bif(Name, Arity);
+bif(M, F, A) when is_atom(M), is_atom(F), is_integer(A) -> false.
+
+-spec bif(Name::atom(), Arity::arity()) -> bool().
+%%   Returns true if erlang:Name/Arity is an auto-imported BIF, false otherwise.
+%%   Use erlang:is_bultin(Mod, Name, Arity) to find whether a function is a BIF
+%%   (meaning implemented in C) or not.
+
+bif(abs, 1) -> true;
+bif(apply, 2) -> true;
+bif(apply, 3) -> true;
+bif(atom_to_list, 1) -> true;
+bif(binary_to_list, 1) -> true;
+bif(binary_to_list, 3) -> true;
+bif(binary_to_term, 1) -> true;
+bif(bitsize, 1) -> true;
+bif(bit_size, 1) -> true;
+bif(bitstring_to_list, 1) -> true;
+bif(byte_size, 1) -> true;
+bif(check_process_code, 2) -> true;
+bif(concat_binary, 1) -> true;
+bif(date, 0) -> true;
+bif(delete_module, 1) -> true;
+bif(disconnect_node, 1) -> true;
+bif(element, 2) -> true;
+bif(erase, 0) -> true;
+bif(erase, 1) -> true;
+bif(exit, 1) -> true;
+bif(exit, 2) -> true;
+bif(float, 1) -> true;
+bif(float_to_list, 1) -> true;
+bif(garbage_collect, 0) -> true;
+bif(garbage_collect, 1) -> true;
+bif(get, 0) -> true;
+bif(get, 1) -> true;
+bif(get_keys, 1) -> true;
+bif(group_leader, 0) -> true;
+bif(group_leader, 2) -> true;
+bif(halt, 0) -> true;
+bif(halt, 1) -> true;
+bif(hd, 1) -> true;
+bif(integer_to_list, 1) -> true;
+bif(iolist_size, 1) -> true;
+bif(iolist_to_binary, 1) -> true;
+bif(is_alive, 0) -> true;
+bif(is_process_alive, 1) -> true;
+bif(is_atom, 1) -> true;
+bif(is_boolean, 1) -> true;
+bif(is_binary, 1) -> true;
+bif(is_bitstr, 1) -> true;
+bif(is_bitstring, 1) -> true;
+bif(is_constant, 1) -> true;
+bif(is_float, 1) -> true;
+bif(is_function, 1) -> true;
+bif(is_function, 2) -> true;
+bif(is_integer, 1) -> true;
+bif(is_list, 1) -> true;
+bif(is_number, 1) -> true;
+bif(is_pid, 1) -> true;
+bif(is_port, 1) -> true;
+bif(is_reference, 1) -> true;
+bif(is_tuple, 1) -> true;
+bif(is_record, 2) -> true;
+bif(is_record, 3) -> true;
+bif(length, 1) -> true;
+bif(link, 1) -> true;
+bif(list_to_atom, 1) -> true;
+bif(list_to_binary, 1) -> true;
+bif(list_to_bitstring, 1) -> true;
+bif(list_to_existing_atom, 1) -> true;
+bif(list_to_float, 1) -> true;
+bif(list_to_integer, 1) -> true;
+bif(list_to_pid, 1) -> true;
+bif(list_to_tuple, 1) -> true;
+bif(load_module, 2) -> true;
+bif(make_ref, 0) -> true;
+bif(module_loaded, 1) -> true;
+bif(monitor_node, 2) -> true;
+bif(node, 0) -> true;
+bif(node, 1) -> true;
+bif(nodes, 0) -> true;
+bif(nodes, 1) -> true;
+bif(now, 0) -> true;
+bif(open_port, 2) -> true;
+bif(pid_to_list, 1) -> true;
+bif(port_close, 1) -> true;
+bif(port_command, 2) -> true;
+bif(port_connect, 2) -> true;
+bif(port_control, 3) -> true;
+bif(pre_loaded, 0) -> true;
+bif(process_flag, 2) -> true;
+bif(process_flag, 3) -> true;
+bif(process_info, 1) -> true;
+bif(process_info, 2) -> true;
+bif(processes, 0) -> true;
+bif(purge_module, 1) -> true;
+bif(put, 2) -> true;
+bif(register, 2) -> true;
+bif(registered, 0) -> true;
+bif(round, 1) -> true;
+bif(search_reset, 0) -> true;
+bif(search_debug, 1) -> true;
+bif(search_index, 1) -> true;
+bif(receive_index, 1) -> true;
+bif(self, 0) -> true;
+bif(setelement, 3) -> true;
+bif(size, 1) -> true;
+bif(spawn, 1) -> true;
+bif(spawn, 2) -> true;
+bif(spawn, 3) -> true;
+bif(spawn, 4) -> true;
+bif(spawn_link, 1) -> true;
+bif(spawn_link, 2) -> true;
+bif(spawn_link, 3) -> true;
+bif(spawn_link, 4) -> true;
+bif(spawn_monitor, 1) -> true;
+bif(spawn_monitor, 3) -> true;
+bif(spawn_opt, 2) -> true;
+bif(spawn_opt, 3) -> true;
+bif(spawn_opt, 4) -> true;
+bif(spawn_opt, 5) -> true;
+bif(split_binary, 2) -> true;
+bif(statistics, 1) -> true;
+bif(term_to_binary, 1) -> true;
+bif(term_to_binary, 2) -> true;
+bif(throw, 1) -> true;
+bif(time, 0) -> true;
+bif(tl, 1) -> true;
+bif(trunc, 1) -> true;
+bif(tuple_size, 1) -> true;
+bif(tuple_to_list, 1) -> true;
+bif(unlink, 1) -> true;
+bif(unregister, 1) -> true;
+bif(whereis, 1) -> true;
+bif(Name, A) when is_atom(Name), is_integer(A) -> false.
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_lint.erl minimal_otp_src_R12B-5/lib/stdlib/src/erl_lint.erl
--- otp_src_R12B-5/lib/stdlib/src/erl_lint.erl	2008-11-04 10:51:13.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_lint.erl	2009-06-23 20:40:26.000000000 +0100
@@ -1,3 +1,4 @@
+
 %% -*- erlang-indent-level: 4 -*-
 %%=======================================================================
 %% ``The contents of this file are subject to the Erlang Public License,
@@ -1885,6 +1886,17 @@ expr({'receive',Line,Cs,To,ToEs}, Vt, St
     Csvts = [Tevt|Cvt],
     {Rvt,St4} = icrt_export(Csvts, Vt, {'receive',Line}, St3),
     {vtmerge([Tvt,Tevt,Rvt]),St4};
+expr({'search',Line,Cs}, Vt, St) ->
+    icrt_clauses(Cs, {'search',Line}, Vt, St);
+expr({'search',Line,Cs,To,ToEs}, Vt, St0) ->
+    %% Are variables from the timeout expression visible in the clauses? NO!
+    {Tvt,St1} = expr(To, Vt, St0),
+    {Tevt,St2} = exprs(ToEs, Vt, St1),
+    {Cvt,St3} = icrt_clauses(Cs, Vt, St2),
+    %% Csvts = [vtnew(Tevt, Vt)|Cvt],           %This is just NEW variables!
+    Csvts = [Tevt|Cvt],
+    {Rvt,St4} = icrt_export(Csvts, Vt, {'search',Line}, St3),
+    {vtmerge([Tvt,Tevt,Rvt]),St4};
 expr({'fun',Line,Body}, Vt, St) ->
     %%No one can think funs export!
     case Body of
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_parse.erl minimal_otp_src_R12B-5/lib/stdlib/src/erl_parse.erl
--- otp_src_R12B-5/lib/stdlib/src/erl_parse.erl	2008-11-05 11:40:18.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_parse.erl	2009-06-23 20:40:26.000000000 +0100
@@ -1,6 +1,6 @@
 -module(erl_parse).
 -export([parse/1, parse_and_scan/1, format_error/1]).
--file("erl_parse.yrl", 498).
+-file("erl_parse.yrl", 508).
 
 %% ``The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -514,7 +514,7 @@ func_prec() -> {800,700}.
 
 max_prec() -> 1000.
 
--file("/ldisk/daily_build/otp_prebuild_r12b.2008-11-05_12/otp_src_R12B-5/bootstrap/lib/parsetools/include/yeccpre.hrl", 0).
+-file("/home/hubert/libs/otp_src_joins_R12B-5/bootstrap/lib/parsetools/include/yeccpre.hrl", 0).
 %% ``The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
 %% compliance with the License. You should have received a copy of the
@@ -1011,38 +1011,38 @@ yeccpars2(138=S, Cat, Ss, Stack, T, Ts, 
 %%  yeccpars2_170(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(171=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_171(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(172=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(172=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_172(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(173=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(174=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(175=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_175(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(176=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_176(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(177=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_177(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(178=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_178(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(179=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_179(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(180=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_180(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(181=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_181(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(182=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(183=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_183(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(184=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_184(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(185=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_185(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(186=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_186(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(187=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_187(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(188=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_188(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(189=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -1052,109 +1052,109 @@ yeccpars2(190=S, Cat, Ss, Stack, T, Ts, 
 yeccpars2(191=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(192=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(193=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(194=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_194(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(195=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(196=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_196(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(197=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(198=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_198(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(199=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_199(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(195=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(196=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_196(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(197=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_197(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(198=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_198(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(199=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(200=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_200(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(201=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(202=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_202(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(201=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_201(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(202=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_202(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(203=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_203(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(204=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_204(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(205=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_205(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(206=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(207=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_207(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(205=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_205(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(206=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_206(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(207=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_207(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(208=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(209=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_209(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(210=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_210(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(209=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_209(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(210=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(211=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_211(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(212=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(212=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_212(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(213=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_213(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(214=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_214(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(214=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(215=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(216=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(216=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_216(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(217=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(218=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_218(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(219=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(218=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(219=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_219(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(220=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_220(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(221=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_221(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(222=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(221=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(222=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_222(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(223=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_223(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(224=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_224(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(224=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(225=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_225(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(226=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_226(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(227=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_227(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(228=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_228(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(229=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(230=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_230(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(231=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(228=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_228(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(229=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_229(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(230=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_230(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(231=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(232=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_232(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(233=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(233=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(234=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_234(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(235=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(235=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(236=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_236(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(237=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(238=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_238(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(239=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_207(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(239=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(240=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_240(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(241=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(242=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_242(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(243=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_243(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_209(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(242=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_242(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(243=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(244=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_244(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(245=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -1163,174 +1163,174 @@ yeccpars2(246=S, Cat, Ss, Stack, T, Ts, 
  yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(247=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_247(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(248=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(249=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(248=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(249=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_249(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(250=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(251=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_251(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(252=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_252(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(253=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_250(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(251=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(252=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(253=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_253(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(254=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_254(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(255=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(256=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_256(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(257=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_257(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(255=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(256=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_256(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(257=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(258=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_258(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(259=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_259(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(260=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_260(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(261=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(262=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_262(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(263=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_263(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(264=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(265=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_265(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(264=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(265=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(266=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_266(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(267=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_267(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(268=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(269=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_269(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(270=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(271=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_271(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(272=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_272(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(268=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_268(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(269=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_269(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(270=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_270(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(271=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(272=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_272(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(273=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_273(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(274=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_274(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(275=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_275(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(276=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_276(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(277=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_277(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(278=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(279=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_279(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(280=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_280(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(281=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_281(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(282=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_282(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(282=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(283=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(284=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_284(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(284=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_284(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(285=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_285(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(286=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_286(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(287=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_287(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(288=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_288(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(287=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_287(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(288=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(289=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(290=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_290(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(291=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_291(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_289(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(290=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(291=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_291(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(292=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_292(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(293=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_293(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(294=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_294(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(295=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_295(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(296=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_296(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(294=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_294(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(295=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_295(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(296=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_296(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(297=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_297(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(298=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_298(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(299=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_299(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(300=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_300(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(300=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_300(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(301=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_301(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(302=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(303=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_303(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(302=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_302(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(303=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_303(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(304=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_304(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(305=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_305(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(306=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_306(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(307=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_307(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(307=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_307(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(308=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_308(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(309=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_309(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(310=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(309=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(310=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_310(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(311=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_311(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(312=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(312=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_312(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(313=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_313(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(314=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_314(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(315=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_315(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(316=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_316(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(316=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_316(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(317=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_317(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(318=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_318(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(318=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_318(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(319=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_319(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(320=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_320(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(320=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_320(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(321=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_321(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(322=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_322(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(322=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(323=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_323(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(324=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_324(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(325=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_325(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(326=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_326(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(327=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(327=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_327(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(328=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_328(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(329=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_329(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(329=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_329(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(330=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_330(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(331=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_317(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(331=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_331(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(332=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_332(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(333=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -1338,23 +1338,23 @@ yeccpars2(331=S, Cat, Ss, Stack, T, Ts, 
 %% yeccpars2(334=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_334(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(335=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(336=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_336(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_335(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(336=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_336(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(337=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_337(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(338=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_338(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(338=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_338(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(339=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_339(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(340=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_340(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(340=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_340(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(341=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_341(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(342=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_342(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(343=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_343(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(343=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_329(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(344=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_344(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(345=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -1362,123 +1362,123 @@ yeccpars2(341=S, Cat, Ss, Stack, T, Ts, 
 %% yeccpars2(346=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_346(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(347=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_347(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(348=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_32(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(348=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_348(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(349=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_349(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(350=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_350(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(351=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_351(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(351=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_351(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(352=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_194(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(353=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_353(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_352(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(353=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(354=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_354(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(355=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_355(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(356=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(357=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_32(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(356=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_356(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(357=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_357(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(358=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_358(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(359=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_359(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(359=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_359(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(360=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_32(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(361=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_361(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(362=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_362(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(363=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_363(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(363=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_363(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(364=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_364(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(365=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_365(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_196(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(365=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_365(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(366=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_366(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(367=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_367(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(368=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(369=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_369(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_32(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(370=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_370(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(371=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_371(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(372=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_372(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(373=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_373(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(374=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_374(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(372=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(373=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_373(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(374=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_374(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(375=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(376=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_376(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_375(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(376=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_376(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(377=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_377(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(378=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_378(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(379=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_379(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(380=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_380(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(379=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_379(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(380=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(381=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_381(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(382=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_382(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(383=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_347(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(383=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_383(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(384=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_384(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(385=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(386=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(387=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_387(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_386(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(387=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(388=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_388(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(389=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(390=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_390(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(391=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_391(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(392=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_392(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(393=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(394=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_394(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(393=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_393(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(394=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_394(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(395=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_395(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(396=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_396(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_359(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(396=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_396(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(397=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(398=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_398(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(399=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_399(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(400=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_400(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(399=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_399(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(400=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_400(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(401=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_401(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(402=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_402(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(403=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(403=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(404=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(405=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_405(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_404(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(405=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(406=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_406(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(407=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -1495,12 +1495,12 @@ yeccpars2(412=S, Cat, Ss, Stack, T, Ts, 
  yeccpars2_412(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(413=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_413(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(414=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_414(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(414=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_414(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(415=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_415(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(416=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(417=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_417(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(418=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -1513,72 +1513,96 @@ yeccpars2(421=S, Cat, Ss, Stack, T, Ts, 
  yeccpars2_421(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(422=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_422(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(423=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_423(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(424=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_424(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(425=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_425(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(423=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_423(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(424=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_424(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(425=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_425(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(426=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(427=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_317(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_426(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(427=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_427(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(428=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_428(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(429=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_429(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(429=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_429(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(430=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(431=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_431(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(432=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_432(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_430(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(431=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_431(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(432=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_432(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(433=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(434=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_434(S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_433(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(434=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_434(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(435=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_435(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(436=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_436(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(437=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_437(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(438=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_438(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(439=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_439(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(438=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(439=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_329(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(440=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_440(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(441=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(442=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_442(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(443=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_443(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(444=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_444(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(441=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_441(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(442=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(443=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_443(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(444=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_444(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(445=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(446=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_446(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(447=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_447(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(448=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_448(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(449=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_215(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(450=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_450(S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccpars2(451=S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+%%  yeccpars2_449(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(450=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_450(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(451=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_451(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(452=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_452(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(453=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(453=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(454=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 %%  yeccpars2_454(S, Cat, Ss, Stack, T, Ts, Tzr);
-%% yeccpars2(455=S, Cat, Ss, Stack, T, Ts, Tzr) ->
-%%  yeccpars2_455(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(455=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_455(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(456=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_456(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(457=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(458=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_458(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(459=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(460=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_460(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(461=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_217(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(462=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_462(S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccpars2(463=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(464=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_464(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(465=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(466=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_466(S, Cat, Ss, Stack, T, Ts, Tzr);
+%% yeccpars2(467=S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%%  yeccpars2_467(S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccpars2(Other, _, _, _, _, _, _) ->
  erlang:error({yecc_bug,"1.3",{missing_state_in_action_table, Other}}).
 
@@ -1592,35 +1616,35 @@ yeccpars2_1(_S, Cat, Ss, Stack, T, Ts, T
  yeccgoto_rule(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_2(S, ';', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 451, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 463, Ss, Stack, T, Ts, Tzr);
 yeccpars2_2(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_2_(Stack),
  yeccgoto_rule_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_3(S, dot, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 450, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 462, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_4_(Stack),
  yeccgoto_function(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_5(S, ';', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 445, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 457, Ss, Stack, T, Ts, Tzr);
 yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_5_(Stack),
  yeccgoto_function_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_6(S, dot, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 444, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 456, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_7(_S, '$end', _Ss, Stack,  _T, _Ts, _Tzr) ->
  {ok, hd(Stack)}.
 
 yeccpars2_8(S, dot, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 443, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 455, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_9(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 285, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_10(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 13, Ss, Stack, T, Ts, Tzr);
@@ -1635,58 +1659,60 @@ yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, 
  yeccgoto_atom1(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_13(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_13(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
-yeccpars2_13(S, '+', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_13(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_13(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_13(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_13(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_13(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
+yeccpars2_13(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
 yeccpars2_13(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_cont_13(S, '<<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, '[', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, 'begin', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_13(S, '[', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 179, Ss, Stack, T, Ts, Tzr);
+yeccpars2_cont_13(S, 'begin', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
 yeccpars2_cont_13(S, 'case', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
 yeccpars2_cont_13(S, char, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, float, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 184, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_13(S, float, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, 'if', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_13(S, 'fun', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, integer, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_13(S, 'if', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr);
+yeccpars2_cont_13(S, integer, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
 yeccpars2_cont_13(S, 'query', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, 'receive', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 190, Ss, Stack, T, Ts, Tzr);
-yeccpars2_cont_13(S, string, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_cont_13(S, 'receive', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 191, Ss, Stack, T, Ts, Tzr);
+yeccpars2_cont_13(S, search, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 192, Ss, Stack, T, Ts, Tzr);
+yeccpars2_cont_13(S, string, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
 yeccpars2_cont_13(S, 'try', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 192, Ss, Stack, T, Ts, Tzr).
+ yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_14(S, '(', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 18, Ss, Stack, T, Ts, Tzr);
@@ -2301,34 +2327,34 @@ yeccpars2_143(_S, Cat, Ss, Stack, T, Ts,
  yeccgoto_atomic(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_700(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_700(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_147(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_147(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_147(S, '.', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_147(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_148(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_148(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_148(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_148(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_147(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_148(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_147(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_147(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_147(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_148(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_148(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_148(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
-
 yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
@@ -2336,121 +2362,121 @@ yeccpars2_150(_S, Cat, Ss, Stack, T, Ts,
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_700(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_700(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_153(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 430, Ss, Stack, T, Ts, Tzr);
 yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_900(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_154(S, '.', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 426, Ss, Stack, T, Ts, Tzr);
-yeccpars2_154(S, ':', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 427, Ss, Stack, T, Ts, Tzr);
+yeccpars2_154(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 442, Ss, Stack, T, Ts, Tzr);
 yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_800(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_900(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_155(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 285, Ss, Stack, T, Ts, Tzr);
+yeccpars2_155(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 438, Ss, Stack, T, Ts, Tzr);
+yeccpars2_155(S, ':', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 439, Ss, Stack, T, Ts, Tzr);
 yeccpars2_155(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_700(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_800(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
+yeccpars2_156(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr);
 yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_600(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_700(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_expr_600(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_500(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_158(S, '*', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_159(S, '*', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 429, Ss, Stack, T, Ts, Tzr);
+yeccpars2_159(S, '/', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 430, Ss, Stack, T, Ts, Tzr);
+yeccpars2_159(S, 'and', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 431, Ss, Stack, T, Ts, Tzr);
+yeccpars2_159(S, 'band', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 432, Ss, Stack, T, Ts, Tzr);
+yeccpars2_159(S, 'div', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 433, Ss, Stack, T, Ts, Tzr);
+yeccpars2_159(S, 'rem', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 434, Ss, Stack, T, Ts, Tzr);
+yeccpars2_159(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_expr_400(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_160(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 417, Ss, Stack, T, Ts, Tzr);
-yeccpars2_158(S, '/', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_160(S, '++', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 418, Ss, Stack, T, Ts, Tzr);
-yeccpars2_158(S, 'and', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_160(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 419, Ss, Stack, T, Ts, Tzr);
-yeccpars2_158(S, 'band', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_160(S, '--', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 420, Ss, Stack, T, Ts, Tzr);
-yeccpars2_158(S, 'div', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_160(S, 'bor', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 421, Ss, Stack, T, Ts, Tzr);
-yeccpars2_158(S, 'rem', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_160(S, 'bsl', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 422, Ss, Stack, T, Ts, Tzr);
-yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_400(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+yeccpars2_160(S, 'bsr', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 423, Ss, Stack, T, Ts, Tzr);
+yeccpars2_160(S, 'bxor', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 424, Ss, Stack, T, Ts, Tzr);
+yeccpars2_160(S, 'or', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 425, Ss, Stack, T, Ts, Tzr);
+yeccpars2_160(S, 'xor', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 426, Ss, Stack, T, Ts, Tzr);
+yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_expr_300(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_159(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 405, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, '++', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '/=', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 406, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '<', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 407, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, '--', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '=/=', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 408, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, 'bor', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '=:=', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 409, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, 'bsl', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '=<', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 410, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, 'bsr', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '==', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 411, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, 'bxor', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '>', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 412, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, 'or', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_161(S, '>=', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 413, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(S, 'xor', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 414, Ss, Stack, T, Ts, Tzr);
-yeccpars2_159(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_300(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_160(S, '/=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 394, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(S, '<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 395, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(S, '=/=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 396, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(S, '=:=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 397, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(S, '=<', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 398, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(S, '==', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 399, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(S, '>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 400, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(S, '>=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 401, Ss, Stack, T, Ts, Tzr);
-yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_200(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_161(S, 'andalso', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 391, Ss, Stack, T, Ts, Tzr);
 yeccpars2_161(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_160(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_200(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_162(S, 'orelse', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 389, Ss, Stack, T, Ts, Tzr);
+yeccpars2_162(S, 'andalso', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 403, Ss, Stack, T, Ts, Tzr);
 yeccpars2_162(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_150(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_160(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_163(S, '!', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 385, Ss, Stack, T, Ts, Tzr);
-yeccpars2_163(S, '=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 386, Ss, Stack, T, Ts, Tzr);
+yeccpars2_163(S, 'orelse', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 401, Ss, Stack, T, Ts, Tzr);
 yeccpars2_163(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_100(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_150(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
+yeccpars2_164(S, '!', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 397, Ss, Stack, T, Ts, Tzr);
+yeccpars2_164(S, '=', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 398, Ss, Stack, T, Ts, Tzr);
 yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ yeccgoto_expr_100(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_165(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 383, Ss, Stack, T, Ts, Tzr);
-yeccpars2_165(S, '::', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 348, Ss, Stack, T, Ts, Tzr);
 yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_165_(Stack),
- yeccgoto_attr_val(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_expr(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
+yeccpars2_166(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 395, Ss, Stack, T, Ts, Tzr);
+yeccpars2_166(S, '::', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 360, Ss, Stack, T, Ts, Tzr);
 yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ NewStack = yeccpars2_166_(Stack),
+ yeccgoto_attr_val(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
@@ -2459,428 +2485,452 @@ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts,
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_169_(Stack),
+ NewStack = yeccpars2_170_(Stack),
  yeccgoto_attribute(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_atomic(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_172: see yeccpars2_18
+%% yeccpars2_173: see yeccpars2_18
 
-yeccpars2_173(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_174(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_174(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_174(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_174(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_174(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_174(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_prefix_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
-
 yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_prefix_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_176: see yeccpars2_18
+yeccpars2_176(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_prefix_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_177(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '-', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '>>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 323, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, atom, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_177(S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
+%% yeccpars2_177: see yeccpars2_18
 
-yeccpars2_178(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_178(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_178(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_178(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_178(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 308, Ss, Stack, T, Ts, Tzr);
+yeccpars2_178(S, '>>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 335, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_178(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
 yeccpars2_178(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_179: see yeccpars2_173
+yeccpars2_179(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, '+', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, '-', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 320, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, atom, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_179(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
+
+%% yeccpars2_180: see yeccpars2_174
 
-yeccpars2_180(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_181(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_prefix_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_181: see yeccpars2_173
+%% yeccpars2_182: see yeccpars2_174
 
-%% yeccpars2_182: see yeccpars2_173
+%% yeccpars2_183: see yeccpars2_174
 
-yeccpars2_183(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_atomic(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_185(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_atomic(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_185(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 285, Ss, Stack, T, Ts, Tzr);
-yeccpars2_185(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_186(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr);
+yeccpars2_186(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_186: see yeccpars2_173
+%% yeccpars2_187: see yeccpars2_174
 
-yeccpars2_187(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_188(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_atomic(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_188(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_189(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_prefix_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_189(S, '[', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 259, Ss, Stack, T, Ts, Tzr).
+yeccpars2_190(S, '[', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 271, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_190(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_191(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_191(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, 'after', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 249, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_191(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 261, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_191(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_190(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_191(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_191(S, string, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 191, Ss, Stack, T, Ts, Tzr);
-yeccpars2_191(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_192(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, '+', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, '-', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 251, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, atom, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_193(S, string, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
+yeccpars2_193(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_strings(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_192: see yeccpars2_173
+%% yeccpars2_194: see yeccpars2_174
 
-yeccpars2_193(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_195(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_194(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_196(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_196(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_196(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_196(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 198, Ss, Stack, T, Ts, Tzr);
-yeccpars2_194(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_196(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 200, Ss, Stack, T, Ts, Tzr);
+yeccpars2_196(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_195(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 203, Ss, Stack, T, Ts, Tzr).
+yeccpars2_197(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 205, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_196(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr);
-yeccpars2_196(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_196_(Stack),
+yeccpars2_198(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 203, Ss, Stack, T, Ts, Tzr);
+yeccpars2_198(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_198_(Stack),
  yeccgoto_exprs(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_197: see yeccpars2_173
+%% yeccpars2_199: see yeccpars2_174
 
-yeccpars2_198(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_200(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_198_(Stack),
+ NewStack = yeccpars2_200_(Stack),
  yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_199(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 200, Ss, Stack, T, Ts, Tzr).
+yeccpars2_201(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 202, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_200(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_200_(Stack),
+ NewStack = yeccpars2_202_(Stack),
  yeccgoto_expr_max(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_201: see yeccpars2_173
+%% yeccpars2_203: see yeccpars2_174
 
-yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_204(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_202_(Stack),
+ NewStack = yeccpars2_204_(Stack),
  yeccgoto_exprs(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_203(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_205(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_203_(Stack),
+ NewStack = yeccpars2_205_(Stack),
  yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_204(S, 'of', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 208, Ss, Stack, T, Ts, Tzr);
-yeccpars2_204(S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_210(S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccpars2_206(S, 'of', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 210, Ss, Stack, T, Ts, Tzr);
+yeccpars2_206(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_212(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_205(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_207(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_205_(Stack),
+ NewStack = yeccpars2_207_(Stack),
  yeccgoto_try_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_206: see yeccpars2_173
+%% yeccpars2_208: see yeccpars2_174
 
-yeccpars2_207(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_209(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_209(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_209(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_209(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 228, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_207(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_209(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 230, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_209(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_208: see yeccpars2_173
+%% yeccpars2_210: see yeccpars2_174
 
-yeccpars2_209(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
-yeccpars2_209(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_209_(Stack),
- yeccpars2_215(215, Cat, [209 | Ss], NewStack, T, Ts, Tzr).
-
-yeccpars2_210(S, 'after', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 206, Ss, Stack, T, Ts, Tzr);
-yeccpars2_210(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 207, Ss, Stack, T, Ts, Tzr).
-
-yeccpars2_211(S, ';', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 212, Ss, Stack, T, Ts, Tzr);
+yeccpars2_211(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
 yeccpars2_211(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_211_(Stack),
- yeccgoto_cr_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccpars2_217(217, Cat, [211 | Ss], NewStack, T, Ts, Tzr).
 
-%% yeccpars2_212: see yeccpars2_173
+yeccpars2_212(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 208, Ss, Stack, T, Ts, Tzr);
+yeccpars2_212(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 209, Ss, Stack, T, Ts, Tzr).
 
+yeccpars2_213(S, ';', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 214, Ss, Stack, T, Ts, Tzr);
 yeccpars2_213(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_|Nss] = Ss,
  NewStack = yeccpars2_213_(Stack),
+ yeccgoto_cr_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+
+%% yeccpars2_214: see yeccpars2_174
+
+yeccpars2_215(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_,_|Nss] = Ss,
+ NewStack = yeccpars2_215_(Stack),
  yeccgoto_cr_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_214(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_216(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_214_(Stack),
+ NewStack = yeccpars2_216_(Stack),
  yeccgoto_try_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_215(S, '->', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 222, Ss, Stack, T, Ts, Tzr).
+yeccpars2_217(S, '->', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 224, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_216: see yeccpars2_173
+%% yeccpars2_218: see yeccpars2_174
 
-yeccpars2_217(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_219(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_217_(Stack),
+ NewStack = yeccpars2_219_(Stack),
  yeccgoto_clause_guard(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_218(S, ';', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 219, Ss, Stack, T, Ts, Tzr);
-yeccpars2_218(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_218_(Stack),
+yeccpars2_220(S, ';', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 221, Ss, Stack, T, Ts, Tzr);
+yeccpars2_220(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_220_(Stack),
  yeccgoto_guard(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_219: see yeccpars2_173
+%% yeccpars2_221: see yeccpars2_174
 
-yeccpars2_220(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_222(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_220_(Stack),
+ NewStack = yeccpars2_222_(Stack),
  yeccgoto_guard(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_221(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_|Nss] = Ss,
- NewStack = yeccpars2_221_(Stack),
- yeccgoto_cr_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
-
-%% yeccpars2_222: see yeccpars2_173
-
 yeccpars2_223(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_|Nss] = Ss,
+ [_,_|Nss] = Ss,
  NewStack = yeccpars2_223_(Stack),
- yeccgoto_clause_body(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ yeccgoto_cr_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_224(S, 'after', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 241, Ss, Stack, T, Ts, Tzr);
-yeccpars2_224(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 242, Ss, Stack, T, Ts, Tzr).
+%% yeccpars2_224: see yeccpars2_174
 
-yeccpars2_225(S, ';', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 239, Ss, Stack, T, Ts, Tzr);
 yeccpars2_225(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_|Nss] = Ss,
  NewStack = yeccpars2_225_(Stack),
- yeccgoto_try_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_clause_body(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_226(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
-yeccpars2_226(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_226_(Stack),
- yeccpars2_215(237, Cat, [226 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_226(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 243, Ss, Stack, T, Ts, Tzr);
+yeccpars2_226(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 244, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_227(S, ':', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 233, Ss, Stack, T, Ts, Tzr);
+yeccpars2_227(S, ';', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 241, Ss, Stack, T, Ts, Tzr);
 yeccpars2_227(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_atomic(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ NewStack = yeccpars2_227_(Stack),
+ yeccgoto_try_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_228(S, ':', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 229, Ss, Stack, T, Ts, Tzr);
+yeccpars2_228(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
 yeccpars2_228(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
+ NewStack = yeccpars2_228_(Stack),
+ yeccpars2_217(239, Cat, [228 | Ss], NewStack, T, Ts, Tzr).
 
-%% yeccpars2_229: see yeccpars2_173
+yeccpars2_229(S, ':', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 235, Ss, Stack, T, Ts, Tzr);
+yeccpars2_229(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccgoto_atomic(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_230(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
+yeccpars2_230(S, ':', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 231, Ss, Stack, T, Ts, Tzr);
 yeccpars2_230(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_230_(Stack),
- yeccpars2_215(231, Cat, [230 | Ss], NewStack, T, Ts, Tzr).
+ yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_231: see yeccpars2_215
+%% yeccpars2_231: see yeccpars2_174
 
+yeccpars2_232(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
 yeccpars2_232(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_,_,_|Nss] = Ss,
  NewStack = yeccpars2_232_(Stack),
- yeccgoto_try_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ yeccpars2_217(233, Cat, [232 | Ss], NewStack, T, Ts, Tzr).
 
-%% yeccpars2_233: see yeccpars2_173
+%% yeccpars2_233: see yeccpars2_217
 
-yeccpars2_234(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
 yeccpars2_234(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_,_,_,_|Nss] = Ss,
  NewStack = yeccpars2_234_(Stack),
- yeccpars2_215(235, Cat, [234 | Ss], NewStack, T, Ts, Tzr).
+ yeccgoto_try_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_235: see yeccpars2_215
+%% yeccpars2_235: see yeccpars2_174
 
+yeccpars2_236(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
 yeccpars2_236(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_,_,_|Nss] = Ss,
  NewStack = yeccpars2_236_(Stack),
- yeccgoto_try_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ yeccpars2_217(237, Cat, [236 | Ss], NewStack, T, Ts, Tzr).
 
-%% yeccpars2_237: see yeccpars2_215
+%% yeccpars2_237: see yeccpars2_217
 
 yeccpars2_238(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_|Nss] = Ss,
+ [_,_,_,_|Nss] = Ss,
  NewStack = yeccpars2_238_(Stack),
  yeccgoto_try_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_239: see yeccpars2_207
+%% yeccpars2_239: see yeccpars2_217
 
 yeccpars2_240(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
  NewStack = yeccpars2_240_(Stack),
- yeccgoto_try_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ yeccgoto_try_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_241: see yeccpars2_173
+%% yeccpars2_241: see yeccpars2_209
 
 yeccpars2_242(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
  NewStack = yeccpars2_242_(Stack),
- yeccgoto_try_catch(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+ yeccgoto_try_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_243(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 244, Ss, Stack, T, Ts, Tzr).
+%% yeccpars2_243: see yeccpars2_174
 
 yeccpars2_244(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_,_,_|Nss] = Ss,
+ [_,_|Nss] = Ss,
  NewStack = yeccpars2_244_(Stack),
  yeccgoto_try_catch(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
@@ -2888,955 +2938,997 @@ yeccpars2_245(S, 'end', Ss, Stack, T, Ts
  yeccpars1(S, 246, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_246(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- [_,_|Nss] = Ss,
+ [_,_,_,_|Nss] = Ss,
  NewStack = yeccpars2_246_(Stack),
  yeccgoto_try_catch(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_247(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_247(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 248, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_248(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_,_|Nss] = Ss,
+ NewStack = yeccpars2_248_(Stack),
+ yeccgoto_try_catch(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+
+yeccpars2_249(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_247_(Stack),
+ NewStack = yeccpars2_249_(Stack),
  yeccgoto_strings(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_248(S, 'after', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 253, Ss, Stack, T, Ts, Tzr);
-yeccpars2_248(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_250(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 255, Ss, Stack, T, Ts, Tzr);
+yeccpars2_250(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 256, Ss, Stack, T, Ts, Tzr).
+
+%% yeccpars2_251: see yeccpars2_174
+
+%% yeccpars2_252: see yeccpars2_217
+
+yeccpars2_253(S, 'end', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 254, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_249: see yeccpars2_173
+yeccpars2_254(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_,_,_,_|Nss] = Ss,
+ NewStack = yeccpars2_254_(Stack),
+ yeccgoto_search_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+
+%% yeccpars2_255: see yeccpars2_174
+
+yeccpars2_256(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_,_|Nss] = Ss,
+ NewStack = yeccpars2_256_(Stack),
+ yeccgoto_search_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
+
+%% yeccpars2_257: see yeccpars2_217
 
-%% yeccpars2_250: see yeccpars2_215
+yeccpars2_258(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 259, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_259(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ [_,_,_,_,_|Nss] = Ss,
+ NewStack = yeccpars2_259_(Stack),
+ yeccgoto_search_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_251(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 252, Ss, Stack, T, Ts, Tzr).
+yeccpars2_260(S, 'after', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 265, Ss, Stack, T, Ts, Tzr);
+yeccpars2_260(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 266, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_252(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+%% yeccpars2_261: see yeccpars2_174
+
+%% yeccpars2_262: see yeccpars2_217
+
+yeccpars2_263(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 264, Ss, Stack, T, Ts, Tzr).
+
+yeccpars2_264(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_252_(Stack),
+ NewStack = yeccpars2_264_(Stack),
  yeccgoto_receive_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_253: see yeccpars2_173
+%% yeccpars2_265: see yeccpars2_174
 
-yeccpars2_254(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_266(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_254_(Stack),
+ NewStack = yeccpars2_266_(Stack),
  yeccgoto_receive_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_255: see yeccpars2_215
+%% yeccpars2_267: see yeccpars2_217
 
-yeccpars2_256(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 257, Ss, Stack, T, Ts, Tzr).
+yeccpars2_268(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 269, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_257(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_257_(Stack),
+ NewStack = yeccpars2_269_(Stack),
  yeccgoto_receive_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_258(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 273, Ss, Stack, T, Ts, Tzr).
+yeccpars2_270(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 285, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_259: see yeccpars2_173
+%% yeccpars2_271: see yeccpars2_174
 
-yeccpars2_260(S, '||', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 261, Ss, Stack, T, Ts, Tzr).
+yeccpars2_272(S, '||', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 273, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_261: see yeccpars2_173
+%% yeccpars2_273: see yeccpars2_174
 
-yeccpars2_262(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr).
+yeccpars2_274(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 284, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_263(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr);
-yeccpars2_263(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_263_(Stack),
+yeccpars2_275(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 282, Ss, Stack, T, Ts, Tzr);
+yeccpars2_275(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_275_(Stack),
  yeccgoto_lc_exprs(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_264(S, '<-', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 268, Ss, Stack, T, Ts, Tzr);
-yeccpars2_264(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_276(S, '<-', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 280, Ss, Stack, T, Ts, Tzr);
+yeccpars2_276(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_lc_expr(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_265(S, '<=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 266, Ss, Stack, T, Ts, Tzr);
-yeccpars2_265(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_277(S, '<=', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 278, Ss, Stack, T, Ts, Tzr);
+yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_266: see yeccpars2_173
+%% yeccpars2_278: see yeccpars2_174
 
-yeccpars2_267(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_267_(Stack),
+ NewStack = yeccpars2_279_(Stack),
  yeccgoto_lc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_268: see yeccpars2_173
+%% yeccpars2_280: see yeccpars2_174
 
-yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_281(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_269_(Stack),
+ NewStack = yeccpars2_281_(Stack),
  yeccgoto_lc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_270: see yeccpars2_173
+%% yeccpars2_282: see yeccpars2_174
 
-yeccpars2_271(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_283(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_271_(Stack),
+ NewStack = yeccpars2_283_(Stack),
  yeccgoto_lc_exprs(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_272(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_272_(Stack),
+ NewStack = yeccpars2_284_(Stack),
  yeccgoto_list_comprehension(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_273(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_285(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_273_(Stack),
+ NewStack = yeccpars2_285_(Stack),
  yeccgoto_query_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_274(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 280, Ss, Stack, T, Ts, Tzr).
+yeccpars2_286(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 292, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_275(S, ';', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 278, Ss, Stack, T, Ts, Tzr);
-yeccpars2_275(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_275_(Stack),
+yeccpars2_287(S, ';', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 290, Ss, Stack, T, Ts, Tzr);
+yeccpars2_287(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_287_(Stack),
  yeccgoto_if_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_276: see yeccpars2_215
+%% yeccpars2_288: see yeccpars2_217
 
-yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_289(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_277_(Stack),
+ NewStack = yeccpars2_289_(Stack),
  yeccgoto_if_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_278: see yeccpars2_173
+%% yeccpars2_290: see yeccpars2_174
 
-yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_291(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_279_(Stack),
+ NewStack = yeccpars2_291_(Stack),
  yeccgoto_if_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_280(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_292(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_280_(Stack),
+ NewStack = yeccpars2_292_(Stack),
  yeccgoto_if_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_281(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 299, Ss, Stack, T, Ts, Tzr).
+yeccpars2_293(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 311, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_282(S, ';', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr);
-yeccpars2_282(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_282_(Stack),
+yeccpars2_294(S, ';', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 309, Ss, Stack, T, Ts, Tzr);
+yeccpars2_294(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_294_(Stack),
  yeccgoto_fun_clauses(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_283(S, '/', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 291, Ss, Stack, T, Ts, Tzr);
-yeccpars2_283(S, ':', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 292, Ss, Stack, T, Ts, Tzr).
+yeccpars2_295(S, '/', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 303, Ss, Stack, T, Ts, Tzr);
+yeccpars2_295(S, ':', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 304, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_284(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
-yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_284_(Stack),
- yeccpars2_215(289, Cat, [284 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_296(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
+yeccpars2_296(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_296_(Stack),
+ yeccpars2_217(301, Cat, [296 | Ss], NewStack, T, Ts, Tzr).
 
-yeccpars2_285(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 287, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_297(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 299, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_297(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_297(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_297(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_285(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_297(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_297(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_286(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 288, Ss, Stack, T, Ts, Tzr).
+yeccpars2_298(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 300, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_287(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_299(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_287_(Stack),
+ NewStack = yeccpars2_299_(Stack),
  yeccgoto_argument_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_288(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_300(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_288_(Stack),
+ NewStack = yeccpars2_300_(Stack),
  yeccgoto_argument_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_289: see yeccpars2_215
+%% yeccpars2_301: see yeccpars2_217
 
-yeccpars2_290(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_302(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_290_(Stack),
+ NewStack = yeccpars2_302_(Stack),
  yeccgoto_fun_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_291(S, integer, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 296, Ss, Stack, T, Ts, Tzr).
+yeccpars2_303(S, integer, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 308, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_292: see yeccpars2_18
+%% yeccpars2_304: see yeccpars2_18
 
-yeccpars2_293(S, '/', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 294, Ss, Stack, T, Ts, Tzr).
+yeccpars2_305(S, '/', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 306, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_294(S, integer, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 295, Ss, Stack, T, Ts, Tzr).
+yeccpars2_306(S, integer, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 307, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_295(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_307(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_295_(Stack),
+ NewStack = yeccpars2_307_(Stack),
  yeccgoto_fun_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_296(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_308(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_296_(Stack),
+ NewStack = yeccpars2_308_(Stack),
  yeccgoto_fun_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_297: see yeccpars2_9
+%% yeccpars2_309: see yeccpars2_9
 
-yeccpars2_298(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_310(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_298_(Stack),
+ NewStack = yeccpars2_310_(Stack),
  yeccgoto_fun_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_299(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_311(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_299_(Stack),
+ NewStack = yeccpars2_311_(Stack),
  yeccgoto_fun_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_300(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_312(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_300_(Stack),
+ NewStack = yeccpars2_312_(Stack),
  yeccgoto_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_301(S, 'of', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 302, Ss, Stack, T, Ts, Tzr).
+yeccpars2_313(S, 'of', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 314, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_302: see yeccpars2_173
+%% yeccpars2_314: see yeccpars2_174
 
-yeccpars2_303(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 304, Ss, Stack, T, Ts, Tzr).
+yeccpars2_315(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 316, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_304(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_316(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_304_(Stack),
+ NewStack = yeccpars2_316_(Stack),
  yeccgoto_case_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_305(S, 'end', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 306, Ss, Stack, T, Ts, Tzr).
+yeccpars2_317(S, 'end', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 318, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_306(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_306_(Stack),
+ NewStack = yeccpars2_318_(Stack),
  yeccgoto_expr_max(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_307(S, '||', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 261, Ss, Stack, T, Ts, Tzr);
-yeccpars2_307(S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_315(S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccpars2_319(S, '||', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 273, Ss, Stack, T, Ts, Tzr);
+yeccpars2_319(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_327(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_308(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_320(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_308_(Stack),
+ NewStack = yeccpars2_320_(Stack),
  yeccgoto_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_309(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_321(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_309_(Stack),
+ NewStack = yeccpars2_321_(Stack),
  yeccgoto_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_310: see yeccpars2_173
+%% yeccpars2_322: see yeccpars2_174
 
-yeccpars2_311(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_311_(Stack),
+yeccpars2_323(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_323_(Stack),
  yeccgoto_tail(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_312: see yeccpars2_173
+%% yeccpars2_324: see yeccpars2_174
 
-yeccpars2_313(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 314, Ss, Stack, T, Ts, Tzr).
+yeccpars2_325(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 326, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_314(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_314_(Stack),
+ NewStack = yeccpars2_326_(Stack),
  yeccgoto_tail(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_315(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 310, Ss, Stack, T, Ts, Tzr);
-yeccpars2_315(S, ']', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 311, Ss, Stack, T, Ts, Tzr);
-yeccpars2_315(S, '|', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 312, Ss, Stack, T, Ts, Tzr).
+yeccpars2_327(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 322, Ss, Stack, T, Ts, Tzr);
+yeccpars2_327(S, ']', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 323, Ss, Stack, T, Ts, Tzr);
+yeccpars2_327(S, '|', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 324, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_316(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_316_(Stack),
+ NewStack = yeccpars2_328_(Stack),
  yeccgoto_tail(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_317(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_317(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_329(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_329(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_317(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_329(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_317(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_317(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_317(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_329(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_329(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_329(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_bit_expr(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_319(S, ':', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 331, Ss, Stack, T, Ts, Tzr);
-yeccpars2_319(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_319_(Stack),
- yeccpars2_330(330, Cat, [319 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_331(S, ':', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 343, Ss, Stack, T, Ts, Tzr);
+yeccpars2_331(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_331_(Stack),
+ yeccpars2_342(342, Cat, [331 | Ss], NewStack, T, Ts, Tzr).
 
-yeccpars2_320(S, '||', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 327, Ss, Stack, T, Ts, Tzr);
-yeccpars2_320(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_332(S, '||', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 339, Ss, Stack, T, Ts, Tzr);
+yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_expr_max(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_321(S, '>>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 326, Ss, Stack, T, Ts, Tzr).
+yeccpars2_333(S, '>>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 338, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_322(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 324, Ss, Stack, T, Ts, Tzr);
-yeccpars2_322(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_322_(Stack),
+yeccpars2_334(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 336, Ss, Stack, T, Ts, Tzr);
+yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_334_(Stack),
  yeccgoto_bin_elements(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_323(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_335(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_323_(Stack),
+ NewStack = yeccpars2_335_(Stack),
  yeccgoto_binary(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_324(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_336(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_336(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_336(S, '-', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
+yeccpars2_336(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_336(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_336(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_336(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_324(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_336(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_336(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_336(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_325(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_337(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_325_(Stack),
+ NewStack = yeccpars2_337_(Stack),
  yeccgoto_bin_elements(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_326_(Stack),
+ NewStack = yeccpars2_338_(Stack),
  yeccgoto_binary(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_327: see yeccpars2_173
+%% yeccpars2_339: see yeccpars2_174
 
-yeccpars2_328(S, '>>', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 329, Ss, Stack, T, Ts, Tzr).
+yeccpars2_340(S, '>>', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 341, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_329(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_341(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_329_(Stack),
+ NewStack = yeccpars2_341_(Stack),
  yeccgoto_binary_comprehension(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_330(S, '/', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 335, Ss, Stack, T, Ts, Tzr);
-yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_330_(Stack),
- yeccpars2_334(_S, Cat, [330 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_342(S, '/', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 347, Ss, Stack, T, Ts, Tzr);
+yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_342_(Stack),
+ yeccpars2_346(_S, Cat, [342 | Ss], NewStack, T, Ts, Tzr).
 
-%% yeccpars2_331: see yeccpars2_317
+%% yeccpars2_343: see yeccpars2_329
 
-yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_bit_size_expr(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_333(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_345(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_333_(Stack),
+ NewStack = yeccpars2_345_(Stack),
  yeccgoto_opt_bit_size_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_334_(Stack),
+ NewStack = yeccpars2_346_(Stack),
  yeccgoto_bin_element(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_335: see yeccpars2_18
+%% yeccpars2_347: see yeccpars2_18
 
-yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_336_(Stack),
+ NewStack = yeccpars2_348_(Stack),
  yeccgoto_opt_bit_type_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_337(S, '-', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 341, Ss, Stack, T, Ts, Tzr);
-yeccpars2_337(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_337_(Stack),
+yeccpars2_349(S, '-', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 353, Ss, Stack, T, Ts, Tzr);
+yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_349_(Stack),
  yeccgoto_bit_type_list(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_338(S, ':', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 339, Ss, Stack, T, Ts, Tzr);
-yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_338_(Stack),
+yeccpars2_350(S, ':', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 351, Ss, Stack, T, Ts, Tzr);
+yeccpars2_350(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_350_(Stack),
  yeccgoto_bit_type(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_339(S, integer, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 340, Ss, Stack, T, Ts, Tzr).
+yeccpars2_351(S, integer, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 352, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_340(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_352(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_340_(Stack),
+ NewStack = yeccpars2_352_(Stack),
  yeccgoto_bit_type(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_341: see yeccpars2_18
+%% yeccpars2_353: see yeccpars2_18
 
-yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_354(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_342_(Stack),
+ NewStack = yeccpars2_354_(Stack),
  yeccgoto_bit_type_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_343(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_355(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_343_(Stack),
+ NewStack = yeccpars2_355_(Stack),
  yeccgoto_bit_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_344_(Stack),
+ NewStack = yeccpars2_356_(Stack),
  yeccgoto_expr_900(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_345(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 365, Ss, Stack, T, Ts, Tzr).
+yeccpars2_357(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 377, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_346(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 200, Ss, Stack, T, Ts, Tzr);
-yeccpars2_346(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 347, Ss, Stack, T, Ts, Tzr);
-yeccpars2_346(S, '::', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 348, Ss, Stack, T, Ts, Tzr).
+yeccpars2_358(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 202, Ss, Stack, T, Ts, Tzr);
+yeccpars2_358(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 359, Ss, Stack, T, Ts, Tzr);
+yeccpars2_358(S, '::', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 360, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_347(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_359(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_359(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_359(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 182, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_359(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, 'catch', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 183, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 352, Ss, Stack, T, Ts, Tzr);
-yeccpars2_347(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_359(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 364, Ss, Stack, T, Ts, Tzr);
+yeccpars2_359(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_348: see yeccpars2_32
+%% yeccpars2_360: see yeccpars2_32
 
-yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_349_(Stack),
+ NewStack = yeccpars2_361_(Stack),
  yeccgoto_typed_attr_val(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_350(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_362(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_350_(Stack),
+ NewStack = yeccpars2_362_(Stack),
  yeccgoto_typed_attr_val(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_351(S, ')', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 364, Ss, Stack, T, Ts, Tzr).
+yeccpars2_363(S, ')', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 376, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_352: see yeccpars2_194
+%% yeccpars2_364: see yeccpars2_196
 
-yeccpars2_353(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 363, Ss, Stack, T, Ts, Tzr).
+yeccpars2_365(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 375, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_354(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 360, Ss, Stack, T, Ts, Tzr);
-yeccpars2_354(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_354_(Stack),
+yeccpars2_366(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 372, Ss, Stack, T, Ts, Tzr);
+yeccpars2_366(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_366_(Stack),
  yeccgoto_typed_exprs(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_355(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 356, Ss, Stack, T, Ts, Tzr);
-yeccpars2_355(S, '::', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 357, Ss, Stack, T, Ts, Tzr);
-yeccpars2_355(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_355_(Stack),
+yeccpars2_367(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 368, Ss, Stack, T, Ts, Tzr);
+yeccpars2_367(S, '::', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 369, Ss, Stack, T, Ts, Tzr);
+yeccpars2_367(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_367_(Stack),
  yeccgoto_exprs(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_356: see yeccpars2_173
+%% yeccpars2_368: see yeccpars2_174
 
-%% yeccpars2_357: see yeccpars2_32
+%% yeccpars2_369: see yeccpars2_32
 
-yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_370(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_358_(Stack),
+ NewStack = yeccpars2_370_(Stack),
  yeccgoto_typed_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_359_(Stack),
+ NewStack = yeccpars2_371_(Stack),
  yeccgoto_typed_exprs(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_360: see yeccpars2_173
+%% yeccpars2_372: see yeccpars2_174
 
-yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_361_(Stack),
+ NewStack = yeccpars2_373_(Stack),
  yeccgoto_typed_exprs(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_362(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_374(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_362_(Stack),
+ NewStack = yeccpars2_374_(Stack),
  yeccgoto_typed_exprs(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_363(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_375(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_363_(Stack),
+ NewStack = yeccpars2_375_(Stack),
  yeccgoto_typed_record_fields(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_364(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_376(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_364_(Stack),
+ NewStack = yeccpars2_376_(Stack),
  yeccgoto_attr_val(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_365(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_365_(Stack),
+ NewStack = yeccpars2_377_(Stack),
  yeccgoto_attribute(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_366(S, '.', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 368, Ss, Stack, T, Ts, Tzr);
-yeccpars2_366(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 369, Ss, Stack, T, Ts, Tzr).
+yeccpars2_378(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 380, Ss, Stack, T, Ts, Tzr);
+yeccpars2_378(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 381, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_367(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_367_(Stack),
+ NewStack = yeccpars2_379_(Stack),
  yeccgoto_record_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_368: see yeccpars2_18
+%% yeccpars2_380: see yeccpars2_18
 
-yeccpars2_369(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 373, Ss, Stack, T, Ts, Tzr);
-yeccpars2_369(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 374, Ss, Stack, T, Ts, Tzr);
-yeccpars2_369(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_381(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 385, Ss, Stack, T, Ts, Tzr);
+yeccpars2_381(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 386, Ss, Stack, T, Ts, Tzr);
+yeccpars2_381(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_370(S, '}', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 381, Ss, Stack, T, Ts, Tzr).
+yeccpars2_382(S, '}', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 393, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_371(S, ',', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 379, Ss, Stack, T, Ts, Tzr);
-yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_371_(Stack),
+yeccpars2_383(S, ',', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 391, Ss, Stack, T, Ts, Tzr);
+yeccpars2_383(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_383_(Stack),
  yeccgoto_record_fields(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_372(S, '=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 377, Ss, Stack, T, Ts, Tzr).
+yeccpars2_384(S, '=', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 389, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_373(S, '=', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 375, Ss, Stack, T, Ts, Tzr).
+yeccpars2_385(S, '=', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 387, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_374(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_386(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_374_(Stack),
+ NewStack = yeccpars2_386_(Stack),
  yeccgoto_record_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_375: see yeccpars2_173
+%% yeccpars2_387: see yeccpars2_174
 
-yeccpars2_376(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_388(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_376_(Stack),
+ NewStack = yeccpars2_388_(Stack),
  yeccgoto_record_field(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_377: see yeccpars2_173
+%% yeccpars2_389: see yeccpars2_174
 
-yeccpars2_378(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_390(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_378_(Stack),
+ NewStack = yeccpars2_390_(Stack),
  yeccgoto_record_field(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_379(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 373, Ss, Stack, T, Ts, Tzr);
-yeccpars2_379(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_391(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 385, Ss, Stack, T, Ts, Tzr);
+yeccpars2_391(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_380(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_380_(Stack),
+ NewStack = yeccpars2_392_(Stack),
  yeccgoto_record_fields(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_393(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_381_(Stack),
+ NewStack = yeccpars2_393_(Stack),
  yeccgoto_record_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_382(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_394(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_382_(Stack),
+ NewStack = yeccpars2_394_(Stack),
  yeccgoto_record_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_383: see yeccpars2_347
+%% yeccpars2_395: see yeccpars2_359
 
-yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_396(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_384_(Stack),
+ NewStack = yeccpars2_396_(Stack),
  yeccgoto_attr_val(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_385(S, '#', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 172, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, '(', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 197, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, '+', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 174, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, '-', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_397(S, '#', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 173, Ss, Stack, T, Ts, Tzr);
+yeccpars2_397(S, '(', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 199, Ss, Stack, T, Ts, Tzr);
+yeccpars2_397(S, '+', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, '.', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_397(S, '-', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 176, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, atom, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_397(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr);
+yeccpars2_397(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 11, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, 'not', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_397(S, 'bnot', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 181, Ss, Stack, T, Ts, Tzr);
+yeccpars2_397(S, 'not', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr);
+yeccpars2_397(S, 'spec', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 12, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, var, Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 193, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 194, Ss, Stack, T, Ts, Tzr);
-yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_397(S, var, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 195, Ss, Stack, T, Ts, Tzr);
+yeccpars2_397(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 196, Ss, Stack, T, Ts, Tzr);
+yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_cont_13(S, Cat, Ss, Stack, T, Ts, Tzr).
 
-%% yeccpars2_386: see yeccpars2_385
+%% yeccpars2_398: see yeccpars2_397
 
-yeccpars2_387(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_399(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_387_(Stack),
+ NewStack = yeccpars2_399_(Stack),
  yeccgoto_expr_100(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_388(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_400(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_388_(Stack),
+ NewStack = yeccpars2_400_(Stack),
  yeccgoto_expr_100(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_389: see yeccpars2_385
+%% yeccpars2_401: see yeccpars2_397
 
-yeccpars2_390(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_402(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_390_(Stack),
+ NewStack = yeccpars2_402_(Stack),
  yeccgoto_expr_150(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_391: see yeccpars2_385
+%% yeccpars2_403: see yeccpars2_397
 
-yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_404(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_392_(Stack),
+ NewStack = yeccpars2_404_(Stack),
  yeccgoto_expr_160(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_393: see yeccpars2_385
+%% yeccpars2_405: see yeccpars2_397
 
-yeccpars2_394(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_406(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_395(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_407(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_396(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_408(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_397(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_409(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_398(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_410(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_399(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_411(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_400(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_412(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_401(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_comp_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_402(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_402_(Stack),
+ NewStack = yeccpars2_414_(Stack),
  yeccgoto_expr_200(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_403: see yeccpars2_385
+%% yeccpars2_415: see yeccpars2_397
 
-%% yeccpars2_404: see yeccpars2_385
+%% yeccpars2_416: see yeccpars2_397
 
-yeccpars2_405(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_417(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_406(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_418(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_list_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_407(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_419(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_408(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_420(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_list_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_409(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_421(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_410(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_422(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_411(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_423(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_412(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_424(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_425(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_426(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_add_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_415(S, '*', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 417, Ss, Stack, T, Ts, Tzr);
-yeccpars2_415(S, '/', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 418, Ss, Stack, T, Ts, Tzr);
-yeccpars2_415(S, 'and', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 419, Ss, Stack, T, Ts, Tzr);
-yeccpars2_415(S, 'band', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 420, Ss, Stack, T, Ts, Tzr);
-yeccpars2_415(S, 'div', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 421, Ss, Stack, T, Ts, Tzr);
-yeccpars2_415(S, 'rem', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 422, Ss, Stack, T, Ts, Tzr);
-yeccpars2_415(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_427(S, '*', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 429, Ss, Stack, T, Ts, Tzr);
+yeccpars2_427(S, '/', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 430, Ss, Stack, T, Ts, Tzr);
+yeccpars2_427(S, 'and', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 431, Ss, Stack, T, Ts, Tzr);
+yeccpars2_427(S, 'band', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 432, Ss, Stack, T, Ts, Tzr);
+yeccpars2_427(S, 'div', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 433, Ss, Stack, T, Ts, Tzr);
+yeccpars2_427(S, 'rem', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 434, Ss, Stack, T, Ts, Tzr);
+yeccpars2_427(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_415_(Stack),
+ NewStack = yeccpars2_427_(Stack),
  yeccgoto_expr_400(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_416: see yeccpars2_385
+%% yeccpars2_428: see yeccpars2_397
 
-yeccpars2_417(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_429(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_mult_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_418(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_430(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_mult_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_419(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_431(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_mult_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_420(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_432(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_mult_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_421(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_433(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_mult_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_422(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_434(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_mult_op(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_423(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_423_(Stack),
+ NewStack = yeccpars2_435_(Stack),
  yeccgoto_expr_500(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_424(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_436(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_424_(Stack),
+ NewStack = yeccpars2_436_(Stack),
  yeccgoto_expr_300(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_425(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_437(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_425_(Stack),
+ NewStack = yeccpars2_437_(Stack),
  yeccgoto_function_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_426: see yeccpars2_18
+%% yeccpars2_438: see yeccpars2_18
 
-%% yeccpars2_427: see yeccpars2_317
+%% yeccpars2_439: see yeccpars2_329
 
-yeccpars2_428(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_440(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_428_(Stack),
+ NewStack = yeccpars2_440_(Stack),
  yeccgoto_expr_800(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_429(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_441(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_429_(Stack),
+ NewStack = yeccpars2_441_(Stack),
  yeccgoto_expr_900(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_430: see yeccpars2_18
+%% yeccpars2_442: see yeccpars2_18
 
-yeccpars2_431(S, '.', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 433, Ss, Stack, T, Ts, Tzr);
-yeccpars2_431(S, '{', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 369, Ss, Stack, T, Ts, Tzr).
+yeccpars2_443(S, '.', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 445, Ss, Stack, T, Ts, Tzr);
+yeccpars2_443(S, '{', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 381, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_432(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_444(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_432_(Stack),
+ NewStack = yeccpars2_444_(Stack),
  yeccgoto_record_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_433: see yeccpars2_18
+%% yeccpars2_445: see yeccpars2_18
 
-yeccpars2_434(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_446(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_,_|Nss] = Ss,
- NewStack = yeccpars2_434_(Stack),
+ NewStack = yeccpars2_446_(Stack),
  yeccgoto_record_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_447(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_435_(Stack),
+ NewStack = yeccpars2_447_(Stack),
  yeccgoto_expr_600(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_436(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
-yeccpars2_436(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_436_(Stack),
- yeccpars2_438(438, Cat, [436 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_448(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
+yeccpars2_448(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_448_(Stack),
+ yeccpars2_450(450, Cat, [448 | Ss], NewStack, T, Ts, Tzr).
 
-yeccpars2_437(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_437_(Stack),
+yeccpars2_449(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_449_(Stack),
  yeccgoto_clause_args(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
-yeccpars2_438(S, '->', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 222, Ss, Stack, T, Ts, Tzr);
-yeccpars2_438(S, ':-', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 441, Ss, Stack, T, Ts, Tzr).
+yeccpars2_450(S, '->', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 224, Ss, Stack, T, Ts, Tzr);
+yeccpars2_450(S, ':-', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 453, Ss, Stack, T, Ts, Tzr).
 
-yeccpars2_439(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_451(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_439_(Stack),
+ NewStack = yeccpars2_451_(Stack),
  yeccgoto_rule_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_440(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_452(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_,_|Nss] = Ss,
- NewStack = yeccpars2_440_(Stack),
+ NewStack = yeccpars2_452_(Stack),
  yeccgoto_function_clause(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_441: see yeccpars2_173
+%% yeccpars2_453: see yeccpars2_174
 
-yeccpars2_442(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_454(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_442_(Stack),
+ NewStack = yeccpars2_454_(Stack),
  yeccgoto_rule_body(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_443(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_455(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_443_(Stack),
+ NewStack = yeccpars2_455_(Stack),
  yeccgoto_form(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-yeccpars2_444(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_456(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_444_(Stack),
+ NewStack = yeccpars2_456_(Stack),
  yeccgoto_form(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_445: see yeccpars2_18
+%% yeccpars2_457: see yeccpars2_18
 
-yeccpars2_446(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_446_(Stack),
+ NewStack = yeccpars2_458_(Stack),
  yeccgoto_function_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_447: see yeccpars2_9
+%% yeccpars2_459: see yeccpars2_9
 
-yeccpars2_448(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
-yeccpars2_448(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_448_(Stack),
- yeccpars2_215(449, Cat, [448 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_460(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
+yeccpars2_460(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_460_(Stack),
+ yeccpars2_217(461, Cat, [460 | Ss], NewStack, T, Ts, Tzr).
 
-%% yeccpars2_449: see yeccpars2_215
+%% yeccpars2_461: see yeccpars2_217
 
-yeccpars2_450(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_462(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
- NewStack = yeccpars2_450_(Stack),
+ NewStack = yeccpars2_462_(Stack),
  yeccgoto_form(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_451: see yeccpars2_18
+%% yeccpars2_463: see yeccpars2_18
 
-yeccpars2_452(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_,_|Nss] = Ss,
- NewStack = yeccpars2_452_(Stack),
+ NewStack = yeccpars2_464_(Stack),
  yeccgoto_rule_clauses(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
-%% yeccpars2_453: see yeccpars2_9
+%% yeccpars2_465: see yeccpars2_9
 
-yeccpars2_454(S, 'when', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 216, Ss, Stack, T, Ts, Tzr);
-yeccpars2_454(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_454_(Stack),
- yeccpars2_455(455, Cat, [454 | Ss], NewStack, T, Ts, Tzr).
+yeccpars2_466(S, 'when', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 218, Ss, Stack, T, Ts, Tzr);
+yeccpars2_466(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ NewStack = yeccpars2_466_(Stack),
+ yeccpars2_467(467, Cat, [466 | Ss], NewStack, T, Ts, Tzr).
 
-yeccpars2_455(S, ':-', Ss, Stack, T, Ts, Tzr) ->
- yeccpars1(S, 441, Ss, Stack, T, Ts, Tzr).
+yeccpars2_467(S, ':-', Ss, Stack, T, Ts, Tzr) ->
+ yeccpars1(S, 453, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_add_op(159, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(404, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_add_op(160, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_397(416, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_argument_list(9=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_449(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_argument_list(156=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_437(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_argument_list(155=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_425(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_argument_list(185, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_284(284, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_argument_list(297, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_284(284, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_argument_list(447=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_437(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_argument_list(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_437(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_argument_list(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_296(296, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_argument_list(309, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_296(296, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_argument_list(459=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_449(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_argument_list(465=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_449(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_atom1(0, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atom1(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atom1(14, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_17(17, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atom1(18, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -3885,272 +3977,284 @@ yeccgoto_atom1(126, Cat, Ss, Stack, T, T
  yeccpars2_122(122, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atom1(132, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_133(133, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atom1(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_295(295, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_229(229, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_229(229, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(304, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_305(305, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_350(350, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(353, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_350(350, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(369, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(380=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_394(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(381, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_384(384, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(391, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_384(384, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(438=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_441(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(442, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_443(443, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(445=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_446(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(457, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_9(459, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atom1(463, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_9(465, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_atomic(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(172, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_366(366, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(176=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(185, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_227(227, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(239, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_227(227, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(292, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_293(293, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(335, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_338(338, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(341, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_338(338, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(348, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(357, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_382(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(369, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(379, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_atomic(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(426=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_429(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(430, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_431(431, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(433=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_434(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(445, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_9(447, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atom1(451, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_9(453, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_atomic(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_atomic(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_atomic(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_atomic(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_attr_val(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_attribute(0, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr).
@@ -4158,15 +4262,15 @@ yeccgoto_attribute(0, Cat, Ss, Stack, T,
 yeccgoto_bin_base_type(35, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_68(68, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_bin_element(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_322(322, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_bin_element(324, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_322(322, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_bin_elements(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_321(321, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_bin_elements(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_325(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_bin_element(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_334(334, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_bin_element(336, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_334(334, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_bin_elements(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_333(333, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_bin_elements(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_337(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_bin_unit_type(35, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_67(67, Cat, Ss, Stack, T, Ts, Tzr);
@@ -4174,1828 +4278,1932 @@ yeccgoto_bin_unit_type(76, Cat, Ss, Stac
  yeccpars2_78(78, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_binary(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_332(332, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(273, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_277(277, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(282, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_277(277, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(339, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_277(277, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary(453, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_277(277, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_binary_comprehension(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_320(320, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(261, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(270, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(327, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_comprehension(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_comprehension(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_comprehension(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_comprehension(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_comprehension(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_comprehension(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_binary_comprehension(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_comprehension(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_comprehension(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_binary_comprehension(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_binary_type(23=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(32=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(36=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(40=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(44=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(50=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(56=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(84=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(94=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(99=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(102=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(112=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(115=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(117=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(123=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_binary_type(369=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_bit_expr(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_331(331, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_bit_expr(336, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_331(331, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_bit_size_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_345(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_bit_type(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_349(349, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_bit_type(353, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_349(349, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_bit_type_list(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_bit_type_list(353=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_354(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_case_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_case_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_comprehension(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_binary_type(23=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(32=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(36=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(40=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(44=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(50=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(56=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(84=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(94=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(99=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(102=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(112=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(115=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(117=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(123=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(348=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_binary_type(357=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_bit_expr(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_319(319, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_bit_expr(324, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_319(319, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_bit_size_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_333(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_bit_type(335, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_337(337, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_bit_type(341, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_337(337, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_bit_type_list(335=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_bit_type_list(341=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_case_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_case_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_case_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_case_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_case_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_case_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_clause_args(9, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_436(436, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_args(447, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_448(448, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_args(453, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_454(454, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_clause_args(459, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_460(460, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_args(465, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_466(466, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_clause_body(215=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_221(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_232(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_236(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(217=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_223(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_234(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_clause_body(237=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_238(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(250, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_251(251, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(255, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_256(256, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(276=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(289=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_290(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(438=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_440(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_body(449=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_440(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_clause_body(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_240(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(252, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_253(253, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(257, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(262, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(267, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_268(268, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(288=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_289(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(301=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_302(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(450=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_452(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_body(461=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_452(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_clause_guard(209, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(215, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_guard(226, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(237, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_guard(230, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(231, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_guard(234, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(235, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_guard(284, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(289, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_guard(436, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_438(438, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_guard(211, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(217, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_guard(228, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(239, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_guard(232, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(233, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_guard(236, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(237, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_guard(296, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(301, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_clause_guard(448, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(449, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_clause_guard(454, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_455(455, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_450(450, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_guard(460, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(461, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_clause_guard(466, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_467(467, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_comp_op(161, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_397(405, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_cr_clause(191, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_213(213, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clause(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_213(213, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clause(210, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_213(213, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clause(214, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_213(213, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clause(314, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_213(213, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_comp_op(160, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(393, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_cr_clause(190, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cr_clause(208, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cr_clause(212, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cr_clause(302, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_cr_clauses(190, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_248(248, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cr_clauses(208, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_210(210, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cr_clauses(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_213(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_cr_clauses(302, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_303(303, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_cr_clauses(191, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_260(260, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clauses(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_250(250, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clauses(210, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_212(212, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clauses(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_215(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_cr_clauses(314, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_315(315, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_expr(13, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_165(165, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(173, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_346(346, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(178, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_307(307, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_166(166, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(174, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_358(358, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(181, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_301(301, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_300(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(190, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_209(209, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_319(319, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(180, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_313(313, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_312(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(191, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr(192, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr(194, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(197, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_199(199, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(201, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(206, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_226(226, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(196, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(199, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_201(201, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(203, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr(208, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_209(209, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(212, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_209(209, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(216, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(219, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(222, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(229, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_230(230, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(233, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_234(234, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(239, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_226(226, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_228(228, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(210, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(214, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(218, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(221, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(224, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(231, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_232(232, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(235, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_236(236, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr(241, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(249, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(250, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(253, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(255, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(259, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_260(260, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_228(228, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(243, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(251, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(252, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(255, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(257, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr(261, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_264(264, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_267(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(270, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_264(264, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(278, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(285, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(302, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_209(209, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(310, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_315(315, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(312, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_313(313, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(327, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_264(264, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(347, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(352, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_355(355, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(356, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_355(355, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(360, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_355(355, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_376(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_378(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(383, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_264(264, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_217(262, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(265, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(267, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(271, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_272(272, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(273, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_276(276, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_281(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(282, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_276(276, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(290, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(297, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(314, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_211(211, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(322, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_327(327, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(324, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_325(325, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(339, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_276(276, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(359, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(364, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_367(367, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(368, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_367(367, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(372, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_367(367, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_388(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_390(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(395, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_198(198, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr(453, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_276(276, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_expr_100(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_100(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_388(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_387(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_100(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_400(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_399(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_100(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_expr_150(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(174, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(180, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(183, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(191, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(196, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(199, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(203, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(210, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(214, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(218, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(221, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(224, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(231, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(235, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(243, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(251, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(255, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(265, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(271, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(273, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(280, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(282, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(290, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(297, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(314, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(322, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(324, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(339, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(359, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(364, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(368, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(372, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(387, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(395, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(397, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(398, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_402(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_150(453, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_164(164, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_expr_160(13, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(174, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(179, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(180, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(182, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(183, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(187, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(191, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(192, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(194, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(197, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(196, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(199, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(203, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(207, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(208, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(209, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(212, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(210, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(216, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(214, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(219, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(218, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(222, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(221, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(229, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(224, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(231, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(239, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(235, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(241, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(249, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(253, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(251, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(255, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(261, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(266, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(265, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(268, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(271, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(270, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_160(280, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(285, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(282, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(302, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(290, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(310, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(297, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(312, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(314, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(327, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(322, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(324, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(352, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(356, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(359, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(364, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(375, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(368, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(377, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(372, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(383, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(387, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(385, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(389, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(386, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(395, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_390(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_150(441, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_160(397, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_160(398, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_160(401, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_160(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_404(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_160(453, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_163(163, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_expr_160(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(13, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(174, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(179, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(180, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(182, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(183, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(187, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(191, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(192, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(194, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(197, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(196, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(199, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(203, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(207, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(208, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(209, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(212, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(210, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(216, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(214, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(219, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(218, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(222, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(221, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(229, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(224, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(231, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(239, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(235, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(241, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(249, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(253, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(251, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(255, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(261, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(266, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(265, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(268, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(271, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(270, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(278, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(285, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(280, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(302, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(282, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(310, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(290, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(312, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(297, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(327, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(314, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(322, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(352, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(324, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(356, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(359, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(375, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(364, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(377, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(368, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(383, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(372, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(385, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(387, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(386, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(389, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(395, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_200(397, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_200(398, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_200(401, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_160(441, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_200(403, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_200(453, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_expr_200(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_300(174, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(179, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(180, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(182, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(183, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(187, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(191, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(192, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(194, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(196, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(197, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(199, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(203, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(208, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(207, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(209, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(210, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(212, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(214, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(216, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(218, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(219, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(221, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(222, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(224, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(229, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(231, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(235, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(239, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(241, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(249, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(251, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(253, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(255, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(261, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(265, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(266, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(271, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(268, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(270, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(278, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(280, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_300(282, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(285, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(290, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(302, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(297, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(310, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(314, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(312, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(322, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(327, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(324, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(352, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(359, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(356, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(364, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(368, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(375, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(372, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(377, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(387, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(383, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(389, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(385, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(395, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(386, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(397, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(398, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(391, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(401, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_200(441, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_300(403, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_300(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_300(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_436(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_300(453, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_expr_300(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(13, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(174, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(179, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(180, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(182, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(183, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(187, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(191, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(192, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(194, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(197, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(196, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(199, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(203, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(207, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(208, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_400(210, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_400(214, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_400(218, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_400(221, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_400(224, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(212, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(231, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(216, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(235, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(219, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(241, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(222, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(229, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(251, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(255, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(239, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(261, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(265, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(249, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(271, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(253, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(278, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(280, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(266, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(282, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(268, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(290, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(270, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(297, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(314, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(285, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(322, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(302, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(324, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(310, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(312, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(359, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(327, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(364, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(368, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(352, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(372, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(356, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(387, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(389, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(375, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(395, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(377, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(397, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(383, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(398, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(385, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(401, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(386, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(403, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(405, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(391, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(415, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_402(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_424(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_300(441, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_400(453, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_160(160, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_expr_400(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(13, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(174, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(179, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(180, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(182, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(183, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(187, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(191, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(192, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(194, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(197, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(196, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(199, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(203, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(207, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(208, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(209, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(212, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(210, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(216, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(214, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(219, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(218, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(222, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(221, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(229, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(224, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(231, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(239, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(235, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(241, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(249, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(253, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(251, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(255, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(261, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(266, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(265, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(268, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(271, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(270, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(278, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(285, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(280, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(302, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(282, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(310, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(290, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(312, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(297, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(327, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(314, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(322, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(352, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(324, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(356, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(359, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(375, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(364, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(377, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(368, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(383, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(372, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(385, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(387, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(386, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(389, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(395, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(391, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(397, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(393, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(398, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(403, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_500(401, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_400(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_expr_500(13, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(173, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(178, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(181, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(182, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(190, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(192, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(194, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(197, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(201, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(206, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(208, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(212, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(216, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(219, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(222, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(229, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(233, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(239, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(241, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(249, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(253, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(259, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(261, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(266, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(268, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(270, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(278, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(285, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(302, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(310, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(312, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(327, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(347, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(352, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(356, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(360, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(375, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(377, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(383, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(385, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(386, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(389, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(391, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(393, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_500(403, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(404, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_415(415, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_500(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_500(405, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_500(415, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_500(416, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_427(427, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_500(453, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_expr_600(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_600(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_expr_700(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_447(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_700(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_700(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_423(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_600(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_expr_700(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_700(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_700(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_700(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_700(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_700(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_700(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_700(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_expr_800(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(148, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(174, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(180, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(183, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(191, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(196, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(199, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(203, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(210, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(214, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(218, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(221, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(224, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(231, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(235, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(243, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(251, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(255, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(265, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(271, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(273, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(280, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(282, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(290, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(297, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(314, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(322, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(324, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(339, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(359, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(364, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(368, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(372, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(387, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(395, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(397, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(398, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(401, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(403, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(405, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(415, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(416, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(428, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_800(453, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_expr_900(13, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(147, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(148, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(174, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(179, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(180, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(182, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(183, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(187, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(191, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(192, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(194, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(197, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(196, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(199, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(203, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(207, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(208, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(209, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(212, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(210, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(216, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(214, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(219, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(218, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(222, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(221, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(229, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(224, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(231, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(239, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(235, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(241, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(249, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(253, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(251, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(255, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(261, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(266, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(265, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(268, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(271, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(270, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(278, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(285, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(280, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(302, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(282, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(310, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(290, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(312, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(297, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(327, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(314, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(322, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(352, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(324, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(356, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(359, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(375, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(364, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(377, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(368, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(383, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(372, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(385, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(387, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(386, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(389, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(395, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(391, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(397, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(393, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(398, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(403, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(401, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_900(403, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(404, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(405, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(416, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(415, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_800(441, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_900(416, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_900(428, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_900(453, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_expr_900(13, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(13, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(147, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(148, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(173, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(174, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(178, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(179, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(179, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(180, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(181, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(182, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(182, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(183, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(187, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(191, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(192, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(192, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(194, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(194, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(197, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(196, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(201, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(199, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(203, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(207, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(208, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(209, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(212, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(210, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(216, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(214, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(219, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(218, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(222, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(221, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(229, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(224, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(233, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(231, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(239, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(235, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(241, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(249, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(253, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(251, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(259, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(255, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(261, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(261, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(266, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(265, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(268, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(271, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(270, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(278, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(285, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(280, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(302, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(282, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(310, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(290, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(312, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(297, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(327, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(314, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(347, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(322, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(352, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(324, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(356, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_355(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(359, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(375, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(364, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(377, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(368, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(383, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(372, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(385, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(387, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(386, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(389, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(389, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(395, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(391, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(397, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(393, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(398, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(403, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(401, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(404, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(403, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(416, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_expr_max(405, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(415, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_900(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_expr_max(13, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(147, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(173, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(178, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(181, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(182, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(190, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(192, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(194, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(197, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(201, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(206, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(208, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(212, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(216, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(219, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(222, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(229, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(233, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(239, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(241, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(249, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(253, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(259, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(261, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(266, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(268, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(270, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(278, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(285, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(302, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(310, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(312, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_343(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(327, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(347, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(352, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(356, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(360, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(375, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(377, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(383, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(385, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(386, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(389, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(391, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(393, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(403, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(404, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_expr_max(416, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_428(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_expr_max(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_153(153, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(428, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_440(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_expr_max(453, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_154(154, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_exprs(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_305(305, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_218(218, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(192, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_204(204, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(180, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_317(317, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_220(220, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_exprs(194, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(206, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_206(206, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(196, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_197(197, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_204(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(208, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_247(247, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(218, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_220(220, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(221, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_220(220, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_225(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(243, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_245(245, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(216, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_218(218, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(219, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_218(218, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_223(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(241, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_243(243, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(278, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_218(218, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(285, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_286(286, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(347, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_351(351, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(352, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_362(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_exprs(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_exprs(290, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_220(220, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(297, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_298(298, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(359, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_363(363, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(364, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_197(197, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_204(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_374(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_exprs(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_396(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_field_type(89, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_91(91, Cat, Ss, Stack, T, Ts, Tzr);
@@ -6010,1189 +6218,1366 @@ yeccgoto_field_types(96=_S, Cat, Ss, Sta
 yeccgoto_form(0, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_fun_clause(185, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_282(282, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_clause(297, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_282(282, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_fun_clauses(185, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_281(281, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_clauses(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_298(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_fun_clause(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_clause(309, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_fun_clauses(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_293(293, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_clauses(309=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_310(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_fun_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_fun_type(16, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_22(22, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_type(19, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_22(22, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_type(47=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_49(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_fun_type(128, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_22(22, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_fun_type_100(47, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_48(48, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_function(0, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_function_call(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_function_call(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_fun_type(16, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_22(22, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_type(19, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_22(22, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_type(47=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_49(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_fun_type(128, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_22(22, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_function_clause(0, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_5(5, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_clause(457, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_5(5, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_function_clauses(0=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_function_clauses(457=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_fun_type_100(47, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_48(48, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_guard(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(288, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_guard(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_219(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_guard(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_222(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_guard(290, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_217(288, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_if_clause(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_287(287, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_clause(290, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_287(287, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_function(0, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_if_clauses(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_286(286, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_clauses(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_291(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_function_call(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_call(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_if_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_if_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_function_clause(0, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_5(5, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_clause(445, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_5(5, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_function_clauses(0=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_function_clauses(445=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_446(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_guard(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(276, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_guard(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_217(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_guard(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_220(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_guard(278, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_215(276, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_int_type(23, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(32, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(36, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(40, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(44, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(50, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(56, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(84, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(94, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(99, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(102, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(110=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(112, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(115, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(117, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(123, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(360, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_int_type(369, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_if_clause(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_lc_expr(273, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_275(275, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_lc_expr(282, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_275(275, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_lc_expr(339, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_275(275, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_clause(278, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_lc_expr(453, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_275(275, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_if_clauses(186, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_lc_exprs(273, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_274(274, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_clauses(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_lc_exprs(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_283(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_lc_exprs(339, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_340(340, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_lc_exprs(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_454(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_if_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_list(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_list(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_if_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_list(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_int_type(23, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(32, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(36, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(40, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(44, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(50, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(56, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(84, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(94, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(99, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(102, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(110=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(112, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(115, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(117, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(123, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(348, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_int_type(357, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_lc_expr(261, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_lc_expr(270, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_lc_expr(327, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_lc_expr(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_lc_exprs(261, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_262(262, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_lc_exprs(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_271(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_lc_exprs(327, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_328(328, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_lc_exprs(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_442(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_list(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(190, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_270(270, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_list_comprehension(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_list_comprehension(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_list_comprehension(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_list_comprehension(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_list_comprehension(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_list_comprehension(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(189, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_list_comprehension(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_list_op(159, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(403, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_mult_op(158, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(416, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_mult_op(415, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_385(416, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_list_op(160, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_397(415, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_mult_op(159, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_397(428, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_mult_op(427, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_397(428, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_opt_bit_size_expr(319, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_330(330, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_opt_bit_size_expr(331, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_342(342, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_opt_bit_type_list(330=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_opt_bit_type_list(342=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_prefix_op(13, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(173, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(177, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_317(317, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(174, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(178, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_329(329, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(179, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(181, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(180, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(182, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(186, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(190, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(183, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(187, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(191, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(192, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(194, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(197, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(201, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(206, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(196, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(199, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(203, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(208, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(212, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(216, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(219, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(222, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(229, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(233, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(239, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(210, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(214, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(218, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(221, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(224, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(231, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(235, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(241, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(249, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(253, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(259, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(243, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(251, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(255, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(261, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(266, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(268, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(270, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(265, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(271, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(273, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(278, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(285, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(302, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(310, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(312, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(280, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(282, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(290, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(297, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(314, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(322, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(324, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_317(317, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(327, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(347, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(352, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(356, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(360, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(375, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(377, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(383, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(385, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(386, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(336, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_329(329, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(339, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(359, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(364, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(368, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(372, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(387, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(389, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(391, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(393, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(395, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(397, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(398, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(401, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(403, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(404, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(405, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(415, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_prefix_op(416, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_prefix_op(441, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_147(147, Cat, Ss, Stack, T, Ts, Tzr).
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(428, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_prefix_op(453, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_query_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_query_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_receive_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_receive_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_receive_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_receive_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_query_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_receive_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_receive_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_receive_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_record_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_record_field(381, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_383(383, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_record_field(391, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_383(383, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_record_fields(381, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_382(382, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_record_fields(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_record_tuple(378=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_record_tuple(443=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_444(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_rule(0, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_3(3, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_rule_body(450=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_451(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_rule_body(467=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_451(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_rule_clause(0, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_rule_clause(463, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_rule_clauses(0=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_1(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_rule_clauses(463=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_search_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_search_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_search_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_record_field(369, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_371(371, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_field(379, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_371(371, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_record_fields(369, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_fields(379=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_380(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_record_tuple(366=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_367(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_record_tuple(431=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_432(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_rule(0, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_3(3, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_rule_body(438=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_439(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_rule_body(455=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_439(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_rule_clause(0, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_rule_clause(451, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_rule_clauses(0=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_1(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_rule_clauses(451=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_452(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
 yeccgoto_spec_fun(14, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_spec_fun(18, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -7200,127 +7585,133 @@ yeccgoto_spec_fun(18, Cat, Ss, Stack, T,
 
 yeccgoto_strings(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_247(_S, Cat, Ss, Stack, T, Ts, Tzr);
+ yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_strings(193=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_249(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_strings(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_strings(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_strings(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_strings(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_strings(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_strings(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_tail(307=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_309(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tail(315=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_316(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_tail(319=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_321(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tail(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_top_type(23, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr);
@@ -7348,10 +7739,10 @@ yeccgoto_top_type(115=_S, Cat, Ss, Stack
  yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_top_type(123, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_top_type(348=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_top_type(357=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_top_type(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_top_type(369=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_370(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_top_type_100(23=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
@@ -7383,9 +7774,9 @@ yeccgoto_top_type_100(117=_S, Cat, Ss, S
  yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_top_type_100(123=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_top_type_100(348=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_top_type_100(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_top_type_100(357=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_top_type_100(369=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_top_types(23, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -7403,253 +7794,265 @@ yeccgoto_top_types(112=_S, Cat, Ss, Stac
 yeccgoto_top_types(123, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_124(124, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_try_catch(204=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_205(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_catch(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_214(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_try_clause(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_225(225, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_clause(239, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_225(225, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_try_clauses(207, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_224(224, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_clauses(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_240(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_try_catch(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_207(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_catch(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_216(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_try_clause(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_227(227, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_clause(241, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_227(227, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_try_clauses(209, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_226(226, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_clauses(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_242(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_try_expr(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_expr(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_expr(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_expr(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_try_expr(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_try_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_try_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_try_expr(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_tuple(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(147=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(173=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(148=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(177=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(174=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(178=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(179=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(181=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(180=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(182=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(186=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(183=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(190=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(187=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple(191=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(192=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(194=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(197=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(201=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(196=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(206=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(199=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(207=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(203=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(208=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(212=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(209=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(216=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(210=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(219=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(214=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(222=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(218=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(229=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(221=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(233=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(224=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(239=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(231=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple(235=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(241=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(249=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(243=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(253=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(251=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(259=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(255=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(261=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(266=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(265=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(268=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(271=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(270=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(273=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(278=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(285=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(280=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple(282=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(302=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(290=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(310=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(297=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(312=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(314=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(317=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(322=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(324=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(327=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(329=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(331=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(336=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(339=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(352=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(343=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(364=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(375=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(377=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(387=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(385=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(386=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(389=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(397=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(391=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(398=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(393=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(401=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(403=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(404=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(405=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple(415=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tuple(416=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(427=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(428=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_tuple(439=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_tuple(441=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_tuple(453=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_type(23, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -7682,9 +8085,9 @@ yeccgoto_type(117, Cat, Ss, Stack, T, Ts
  yeccpars2_24(24, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_type(123, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_24(24, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_type(348, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_type(360, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_24(24, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_type(357, Cat, Ss, Stack, T, Ts, Tzr) ->
+yeccgoto_type(369, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_24(24, Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccgoto_type_guard(119, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -7716,30 +8119,30 @@ yeccgoto_type_spec(14=_S, Cat, Ss, Stack
 
 yeccgoto_typed_attr_val(13=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_140(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_typed_attr_val(173, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_345(345, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_typed_attr_val(174, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr).
 
-yeccgoto_typed_expr(352, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_354(354, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_typed_expr(356, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_354(354, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_typed_expr(360, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_354(354, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_typed_exprs(352, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_353(353, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_typed_exprs(356=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_typed_exprs(360=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr).
-
-yeccgoto_typed_record_fields(347=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_350(_S, Cat, Ss, Stack, T, Ts, Tzr);
-yeccgoto_typed_record_fields(383=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- yeccpars2_350(_S, Cat, Ss, Stack, T, Ts, Tzr).
+yeccgoto_typed_expr(364, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_366(366, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_typed_expr(368, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_366(366, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_typed_expr(372, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_366(366, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_typed_exprs(364, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_365(365, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_typed_exprs(368=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_typed_exprs(372=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr).
+
+yeccgoto_typed_record_fields(359=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_362(_S, Cat, Ss, Stack, T, Ts, Tzr);
+yeccgoto_typed_record_fields(395=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
+ yeccpars2_362(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 -compile({inline,{yeccpars2_1_,1}}).
--file("erl_parse.yrl", 483).
+-file("erl_parse.yrl", 493).
 yeccpars2_1_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -7747,7 +8150,7 @@ yeccpars2_1_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_2_,1}}).
--file("erl_parse.yrl", 485).
+-file("erl_parse.yrl", 495).
 yeccpars2_2_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -7755,7 +8158,7 @@ yeccpars2_2_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_4_,1}}).
--file("erl_parse.yrl", 188).
+-file("erl_parse.yrl", 190).
 yeccpars2_4_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -7763,16 +8166,16 @@ yeccpars2_4_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_5_,1}}).
--file("erl_parse.yrl", 190).
+-file("erl_parse.yrl", 192).
 yeccpars2_5_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 7773).
+-file("./erl_parse.erl", 8176).
 -compile({inline,{yeccpars2_12_,1}}).
--file("erl_parse.yrl", 78).
+-file("erl_parse.yrl", 80).
 yeccpars2_12_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -7780,7 +8183,7 @@ yeccpars2_12_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_15_,1}}).
--file("erl_parse.yrl", 76).
+-file("erl_parse.yrl", 78).
 yeccpars2_15_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7788,7 +8191,7 @@ yeccpars2_15_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_21_,1}}).
--file("erl_parse.yrl", 101).
+-file("erl_parse.yrl", 103).
 yeccpars2_21_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -7796,52 +8199,52 @@ yeccpars2_21_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_27_,1}}).
--file("erl_parse.yrl", 114).
+-file("erl_parse.yrl", 116).
 yeccpars2_27_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 7806).
+-file("./erl_parse.erl", 8209).
 -compile({inline,{yeccpars2_42_,1}}).
--file("erl_parse.yrl", 137).
+-file("erl_parse.yrl", 139).
 yeccpars2_42_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { type , ? line ( __1 ) , tuple , [ ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7815).
+-file("./erl_parse.erl", 8218).
 -compile({inline,{yeccpars2_43_,1}}).
--file("erl_parse.yrl", 138).
+-file("erl_parse.yrl", 140).
 yeccpars2_43_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { type , ? line ( __1 ) , tuple , __2 }
   end | __Stack].
 
--file("./erl_parse.erl", 7824).
+-file("./erl_parse.erl", 8227).
 -compile({inline,{yeccpars2_45_,1}}).
--file("erl_parse.yrl", 117).
+-file("erl_parse.yrl", 119).
 yeccpars2_45_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { ann_type , ? line ( __1 ) , [ __1 , __3 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7833).
+-file("./erl_parse.erl", 8236).
 -compile({inline,{yeccpars2_51_,1}}).
--file("erl_parse.yrl", 146).
+-file("erl_parse.yrl", 148).
 yeccpars2_51_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { type , ? line ( __1 ) , 'fun' , [ ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7842).
+-file("./erl_parse.erl", 8245).
 -compile({inline,{yeccpars2_57_,1}}).
--file("erl_parse.yrl", 154).
+-file("erl_parse.yrl", 156).
 yeccpars2_57_(__Stack0) ->
  [__7,__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7850,34 +8253,34 @@ yeccpars2_57_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_58_,1}}).
--file("erl_parse.yrl", 147).
+-file("erl_parse.yrl", 149).
 yeccpars2_58_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __3
   end | __Stack].
 
--file("./erl_parse.erl", 7860).
+-file("./erl_parse.erl", 8263).
 -compile({inline,{yeccpars2_60_,1}}).
--file("erl_parse.yrl", 133).
+-file("erl_parse.yrl", 135).
 yeccpars2_60_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { type , ? line ( __1 ) , nil , [ ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7869).
+-file("./erl_parse.erl", 8272).
 -compile({inline,{yeccpars2_62_,1}}).
--file("erl_parse.yrl", 134).
+-file("erl_parse.yrl", 136).
 yeccpars2_62_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { type , ? line ( __1 ) , list , [ __2 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7878).
+-file("./erl_parse.erl", 8281).
 -compile({inline,{yeccpars2_66_,1}}).
--file("erl_parse.yrl", 135).
+-file("erl_parse.yrl", 137).
 yeccpars2_66_(__Stack0) ->
  [__7,__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7885,9 +8288,9 @@ yeccpars2_66_(__Stack0) ->
     nonempty_list , [ __2 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7888).
+-file("./erl_parse.erl", 8291).
 -compile({inline,{yeccpars2_69_,1}}).
--file("erl_parse.yrl", 170).
+-file("erl_parse.yrl", 172).
 yeccpars2_69_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7897,7 +8300,7 @@ yeccpars2_69_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_72_,1}}).
--file("erl_parse.yrl", 180).
+-file("erl_parse.yrl", 182).
 yeccpars2_72_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7905,16 +8308,16 @@ yeccpars2_72_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_75_,1}}).
--file("erl_parse.yrl", 182).
+-file("erl_parse.yrl", 184).
 yeccpars2_75_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_bin_type ( [ __1 , __3 ] , __5 )
   end | __Stack].
 
--file("./erl_parse.erl", 7915).
+-file("./erl_parse.erl", 8318).
 -compile({inline,{yeccpars2_77_,1}}).
--file("erl_parse.yrl", 173).
+-file("erl_parse.yrl", 175).
 yeccpars2_77_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7922,18 +8325,18 @@ yeccpars2_77_(__Stack0) ->
     [ __2 , abstract ( 0 , ? line ( __1 ) ) ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7925).
+-file("./erl_parse.erl", 8328).
 -compile({inline,{yeccpars2_81_,1}}).
--file("erl_parse.yrl", 178).
+-file("erl_parse.yrl", 180).
 yeccpars2_81_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { type , ? line ( __1 ) , binary , [ __2 , __4 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7934).
+-file("./erl_parse.erl", 8337).
 -compile({inline,{yeccpars2_82_,1}}).
--file("erl_parse.yrl", 175).
+-file("erl_parse.yrl", 177).
 yeccpars2_82_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7941,9 +8344,9 @@ yeccpars2_82_(__Stack0) ->
     [ abstract ( 0 , ? line ( __1 ) ) , __2 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7944).
+-file("./erl_parse.erl", 8347).
 -compile({inline,{yeccpars2_83_,1}}).
--file("erl_parse.yrl", 150).
+-file("erl_parse.yrl", 152).
 yeccpars2_83_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7951,9 +8354,9 @@ yeccpars2_83_(__Stack0) ->
     ? line ( __2 ) )
   end | __Stack].
 
--file("./erl_parse.erl", 7954).
+-file("./erl_parse.erl", 8357).
 -compile({inline,{yeccpars2_85_,1}}).
--file("erl_parse.yrl", 158).
+-file("erl_parse.yrl", 160).
 yeccpars2_85_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7961,9 +8364,9 @@ yeccpars2_85_(__Stack0) ->
     [ { type , ? line ( __1 ) , product , [ ] } , __4 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7964).
+-file("./erl_parse.erl", 8367).
 -compile({inline,{yeccpars2_87_,1}}).
--file("erl_parse.yrl", 123).
+-file("erl_parse.yrl", 125).
 yeccpars2_87_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7971,25 +8374,25 @@ yeccpars2_87_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_91_,1}}).
--file("erl_parse.yrl", 164).
+-file("erl_parse.yrl", 166).
 yeccpars2_91_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 7981).
+-file("./erl_parse.erl", 8384).
 -compile({inline,{yeccpars2_93_,1}}).
--file("erl_parse.yrl", 139).
+-file("erl_parse.yrl", 141).
 yeccpars2_93_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { type , ? line ( __1 ) , record , [ __2 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 7990).
+-file("./erl_parse.erl", 8393).
 -compile({inline,{yeccpars2_95_,1}}).
--file("erl_parse.yrl", 167).
+-file("erl_parse.yrl", 169).
 yeccpars2_95_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -7998,16 +8401,16 @@ yeccpars2_95_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_97_,1}}).
--file("erl_parse.yrl", 165).
+-file("erl_parse.yrl", 167).
 yeccpars2_97_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8008).
+-file("./erl_parse.erl", 8411).
 -compile({inline,{yeccpars2_98_,1}}).
--file("erl_parse.yrl", 140).
+-file("erl_parse.yrl", 142).
 yeccpars2_98_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8015,9 +8418,9 @@ yeccpars2_98_(__Stack0) ->
     record , [ __2 | __4 ] }
   end | __Stack].
 
--file("./erl_parse.erl", 8018).
+-file("./erl_parse.erl", 8421).
 -compile({inline,{yeccpars2_104_,1}}).
--file("erl_parse.yrl", 129).
+-file("erl_parse.yrl", 131).
 yeccpars2_104_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8025,9 +8428,9 @@ yeccpars2_104_(__Stack0) ->
     [ __1 , __3 , [ ] ] }
   end | __Stack].
 
--file("./erl_parse.erl", 8028).
+-file("./erl_parse.erl", 8431).
 -compile({inline,{yeccpars2_105_,1}}).
--file("erl_parse.yrl", 131).
+-file("erl_parse.yrl", 133).
 yeccpars2_105_(__Stack0) ->
  [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8036,16 +8439,16 @@ yeccpars2_105_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_107_,1}}).
--file("erl_parse.yrl", 126).
+-file("erl_parse.yrl", 128).
 yeccpars2_107_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_gen_type ( __1 )
   end | __Stack].
 
--file("./erl_parse.erl", 8046).
+-file("./erl_parse.erl", 8449).
 -compile({inline,{yeccpars2_108_,1}}).
--file("erl_parse.yrl", 127).
+-file("erl_parse.yrl", 129).
 yeccpars2_108_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8053,9 +8456,9 @@ yeccpars2_108_(__Stack0) ->
     normalise ( __1 ) , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 8056).
+-file("./erl_parse.erl", 8459).
 -compile({inline,{yeccpars2_111_,1}}).
--file("erl_parse.yrl", 144).
+-file("erl_parse.yrl", 146).
 yeccpars2_111_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8064,16 +8467,16 @@ yeccpars2_111_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_113_,1}}).
--file("erl_parse.yrl", 115).
+-file("erl_parse.yrl", 117).
 yeccpars2_113_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8074).
+-file("./erl_parse.erl", 8477).
 -compile({inline,{yeccpars2_116_,1}}).
--file("erl_parse.yrl", 161).
+-file("erl_parse.yrl", 163).
 yeccpars2_116_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8082,16 +8485,16 @@ yeccpars2_116_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_118_,1}}).
--file("erl_parse.yrl", 121).
+-file("erl_parse.yrl", 123).
 yeccpars2_118_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    lift_unions ( __1 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 8092).
+-file("./erl_parse.erl", 8495).
 -compile({inline,{yeccpars2_120_,1}}).
--file("erl_parse.yrl", 105).
+-file("erl_parse.yrl", 107).
 yeccpars2_120_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8100,16 +8503,16 @@ yeccpars2_120_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_121_,1}}).
--file("erl_parse.yrl", 108).
+-file("erl_parse.yrl", 110).
 yeccpars2_121_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8110).
+-file("./erl_parse.erl", 8513).
 -compile({inline,{yeccpars2_125_,1}}).
--file("erl_parse.yrl", 111).
+-file("erl_parse.yrl", 113).
 yeccpars2_125_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8118,7 +8521,7 @@ yeccpars2_125_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_127_,1}}).
--file("erl_parse.yrl", 109).
+-file("erl_parse.yrl", 111).
 yeccpars2_127_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8126,7 +8529,7 @@ yeccpars2_127_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_129_,1}}).
--file("erl_parse.yrl", 102).
+-file("erl_parse.yrl", 104).
 yeccpars2_129_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8134,7 +8537,7 @@ yeccpars2_129_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_130_,1}}).
--file("erl_parse.yrl", 82).
+-file("erl_parse.yrl", 84).
 yeccpars2_130_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8142,7 +8545,7 @@ yeccpars2_130_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_133_,1}}).
--file("erl_parse.yrl", 85).
+-file("erl_parse.yrl", 87).
 yeccpars2_133_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8150,7 +8553,7 @@ yeccpars2_133_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_136_,1}}).
--file("erl_parse.yrl", 87).
+-file("erl_parse.yrl", 89).
 yeccpars2_136_(__Stack0) ->
  [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8158,7 +8561,7 @@ yeccpars2_136_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_138_,1}}).
--file("erl_parse.yrl", 86).
+-file("erl_parse.yrl", 88).
 yeccpars2_138_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8166,7 +8569,7 @@ yeccpars2_138_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_139_,1}}).
--file("erl_parse.yrl", 81).
+-file("erl_parse.yrl", 83).
 yeccpars2_139_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -8174,1031 +8577,1058 @@ yeccpars2_139_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,{yeccpars2_140_,1}}).
--file("erl_parse.yrl", 74).
+-file("erl_parse.yrl", 76).
 yeccpars2_140_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_typed_attribute ( __2 , __3 )
   end | __Stack].
 
--compile({inline,{yeccpars2_165_,1}}).
--file("erl_parse.yrl", 184).
-yeccpars2_165_(__Stack0) ->
+-compile({inline,{yeccpars2_166_,1}}).
+-file("erl_parse.yrl", 186).
+yeccpars2_166_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_169_,1}}).
--file("erl_parse.yrl", 73).
-yeccpars2_169_(__Stack0) ->
+-compile({inline,{yeccpars2_170_,1}}).
+-file("erl_parse.yrl", 75).
+yeccpars2_170_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_attribute ( __2 , __3 )
   end | __Stack].
 
--compile({inline,{yeccpars2_196_,1}}).
--file("erl_parse.yrl", 434).
-yeccpars2_196_(__Stack0) ->
+-compile({inline,{yeccpars2_198_,1}}).
+-file("erl_parse.yrl", 444).
+yeccpars2_198_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8208).
--compile({inline,{yeccpars2_198_,1}}).
--file("erl_parse.yrl", 317).
-yeccpars2_198_(__Stack0) ->
+-file("./erl_parse.erl", 8611).
+-compile({inline,{yeccpars2_200_,1}}).
+-file("erl_parse.yrl", 320).
+yeccpars2_200_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { tuple , ? line ( __1 ) , [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_200_,1}}).
--file("erl_parse.yrl", 260).
-yeccpars2_200_(__Stack0) ->
+-compile({inline,{yeccpars2_202_,1}}).
+-file("erl_parse.yrl", 262).
+yeccpars2_202_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_202_,1}}).
--file("erl_parse.yrl", 435).
-yeccpars2_202_(__Stack0) ->
+-compile({inline,{yeccpars2_204_,1}}).
+-file("erl_parse.yrl", 445).
+yeccpars2_204_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8233).
--compile({inline,{yeccpars2_203_,1}}).
--file("erl_parse.yrl", 318).
-yeccpars2_203_(__Stack0) ->
+-file("./erl_parse.erl", 8636).
+-compile({inline,{yeccpars2_205_,1}}).
+-file("erl_parse.yrl", 321).
+yeccpars2_205_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { tuple , ? line ( __1 ) , __2 }
   end | __Stack].
 
--file("./erl_parse.erl", 8242).
--compile({inline,{yeccpars2_205_,1}}).
--file("erl_parse.yrl", 396).
-yeccpars2_205_(__Stack0) ->
+-file("./erl_parse.erl", 8645).
+-compile({inline,{yeccpars2_207_,1}}).
+-file("erl_parse.yrl", 406).
+yeccpars2_207_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_try ( ? line ( __1 ) , __2 , [ ] , __3 )
   end | __Stack].
 
--compile({inline,{yeccpars2_209_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_209_(__Stack0) ->
+-compile({inline,{yeccpars2_211_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_211_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--compile({inline,{yeccpars2_211_,1}}).
--file("erl_parse.yrl", 365).
-yeccpars2_211_(__Stack0) ->
+-compile({inline,{yeccpars2_213_,1}}).
+-file("erl_parse.yrl", 368).
+yeccpars2_213_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_213_,1}}).
--file("erl_parse.yrl", 366).
-yeccpars2_213_(__Stack0) ->
+-compile({inline,{yeccpars2_215_,1}}).
+-file("erl_parse.yrl", 369).
+yeccpars2_215_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8274).
--compile({inline,{yeccpars2_214_,1}}).
--file("erl_parse.yrl", 394).
-yeccpars2_214_(__Stack0) ->
+-file("./erl_parse.erl", 8677).
+-compile({inline,{yeccpars2_216_,1}}).
+-file("erl_parse.yrl", 404).
+yeccpars2_216_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_try ( ? line ( __1 ) , __2 , __4 , __5 )
   end | __Stack].
 
--compile({inline,{yeccpars2_217_,1}}).
--file("erl_parse.yrl", 199).
-yeccpars2_217_(__Stack0) ->
+-compile({inline,{yeccpars2_219_,1}}).
+-file("erl_parse.yrl", 201).
+yeccpars2_219_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_218_,1}}).
--file("erl_parse.yrl", 437).
-yeccpars2_218_(__Stack0) ->
+-compile({inline,{yeccpars2_220_,1}}).
+-file("erl_parse.yrl", 447).
+yeccpars2_220_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_220_,1}}).
--file("erl_parse.yrl", 438).
-yeccpars2_220_(__Stack0) ->
+-compile({inline,{yeccpars2_222_,1}}).
+-file("erl_parse.yrl", 448).
+yeccpars2_222_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8307).
--compile({inline,{yeccpars2_221_,1}}).
--file("erl_parse.yrl", 369).
-yeccpars2_221_(__Stack0) ->
+-file("./erl_parse.erl", 8710).
+-compile({inline,{yeccpars2_223_,1}}).
+-file("erl_parse.yrl", 372).
+yeccpars2_223_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { clause , ? line ( __1 ) , [ __1 ] , __2 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_223_,1}}).
--file("erl_parse.yrl", 202).
-yeccpars2_223_(__Stack0) ->
+-compile({inline,{yeccpars2_225_,1}}).
+-file("erl_parse.yrl", 204).
+yeccpars2_225_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_225_,1}}).
--file("erl_parse.yrl", 405).
-yeccpars2_225_(__Stack0) ->
+-compile({inline,{yeccpars2_227_,1}}).
+-file("erl_parse.yrl", 415).
+yeccpars2_227_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_226_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_226_(__Stack0) ->
+-compile({inline,{yeccpars2_228_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_228_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--compile({inline,{yeccpars2_230_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_230_(__Stack0) ->
+-compile({inline,{yeccpars2_232_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_232_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--file("./erl_parse.erl", 8346).
--compile({inline,{yeccpars2_232_,1}}).
--file("erl_parse.yrl", 415).
-yeccpars2_232_(__Stack0) ->
+-file("./erl_parse.erl", 8749).
+-compile({inline,{yeccpars2_234_,1}}).
+-file("erl_parse.yrl", 425).
+yeccpars2_234_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    L = ? line ( __1 ) ,
     { clause , L , [ { tuple , L , [ __1 , __3 , { var , L , '_' } ] } ] , __4 , __5 }
   end | __Stack].
 
--compile({inline,{yeccpars2_234_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_234_(__Stack0) ->
+-compile({inline,{yeccpars2_236_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_236_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--file("./erl_parse.erl", 8363).
--compile({inline,{yeccpars2_236_,1}}).
--file("erl_parse.yrl", 412).
-yeccpars2_236_(__Stack0) ->
+-file("./erl_parse.erl", 8766).
+-compile({inline,{yeccpars2_238_,1}}).
+-file("erl_parse.yrl", 422).
+yeccpars2_238_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    L = ? line ( __1 ) ,
     { clause , L , [ { tuple , L , [ __1 , __3 , { var , L , '_' } ] } ] , __4 , __5 }
   end | __Stack].
 
--file("./erl_parse.erl", 8373).
--compile({inline,{yeccpars2_238_,1}}).
--file("erl_parse.yrl", 409).
-yeccpars2_238_(__Stack0) ->
+-file("./erl_parse.erl", 8776).
+-compile({inline,{yeccpars2_240_,1}}).
+-file("erl_parse.yrl", 419).
+yeccpars2_240_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    L = ? line ( __1 ) ,
     { clause , L , [ { tuple , L , [ { atom , L , throw } , __1 , { var , L , '_' } ] } ] , __2 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_240_,1}}).
--file("erl_parse.yrl", 406).
-yeccpars2_240_(__Stack0) ->
+-compile({inline,{yeccpars2_242_,1}}).
+-file("erl_parse.yrl", 416).
+yeccpars2_242_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_242_,1}}).
--file("erl_parse.yrl", 399).
-yeccpars2_242_(__Stack0) ->
+-compile({inline,{yeccpars2_244_,1}}).
+-file("erl_parse.yrl", 409).
+yeccpars2_244_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { __2 , [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_244_,1}}).
--file("erl_parse.yrl", 401).
-yeccpars2_244_(__Stack0) ->
+-compile({inline,{yeccpars2_246_,1}}).
+-file("erl_parse.yrl", 411).
+yeccpars2_246_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { __2 , __4 }
   end | __Stack].
 
--compile({inline,{yeccpars2_246_,1}}).
--file("erl_parse.yrl", 403).
-yeccpars2_246_(__Stack0) ->
+-compile({inline,{yeccpars2_248_,1}}).
+-file("erl_parse.yrl", 413).
+yeccpars2_248_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { [ ] , __2 }
   end | __Stack].
 
--file("./erl_parse.erl", 8415).
--compile({inline,{yeccpars2_247_,1}}).
--file("erl_parse.yrl", 448).
-yeccpars2_247_(__Stack0) ->
+-file("./erl_parse.erl", 8818).
+-compile({inline,{yeccpars2_249_,1}}).
+-file("erl_parse.yrl", 458).
+yeccpars2_249_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
-   { string , ? line ( __1 ) , element ( 3 , __1 ) ++ element ( 3 , __2 ) }
+   { string , ? line ( __1 ) , element ( 3 , __1 ) ++ element ( 3 , __2 ) }
+  end | __Stack].
+
+-file("./erl_parse.erl", 8827).
+-compile({inline,{yeccpars2_254_,1}}).
+-file("erl_parse.yrl", 384).
+yeccpars2_254_(__Stack0) ->
+ [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
+ [begin
+   { search , ? line ( __1 ) , [ ] , __3 , __4 }
+  end | __Stack].
+
+-file("./erl_parse.erl", 8836).
+-compile({inline,{yeccpars2_256_,1}}).
+-file("erl_parse.yrl", 382).
+yeccpars2_256_(__Stack0) ->
+ [__3,__2,__1 | __Stack] = __Stack0,
+ [begin
+   { search , ? line ( __1 ) , __2 }
+  end | __Stack].
+
+-file("./erl_parse.erl", 8845).
+-compile({inline,{yeccpars2_259_,1}}).
+-file("erl_parse.yrl", 386).
+yeccpars2_259_(__Stack0) ->
+ [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
+ [begin
+   { search , ? line ( __1 ) , __2 , __4 , __5 }
   end | __Stack].
 
--file("./erl_parse.erl", 8424).
--compile({inline,{yeccpars2_252_,1}}).
--file("erl_parse.yrl", 374).
-yeccpars2_252_(__Stack0) ->
+-file("./erl_parse.erl", 8854).
+-compile({inline,{yeccpars2_264_,1}}).
+-file("erl_parse.yrl", 377).
+yeccpars2_264_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'receive' , ? line ( __1 ) , [ ] , __3 , __4 }
   end | __Stack].
 
--file("./erl_parse.erl", 8433).
--compile({inline,{yeccpars2_254_,1}}).
--file("erl_parse.yrl", 372).
-yeccpars2_254_(__Stack0) ->
+-file("./erl_parse.erl", 8863).
+-compile({inline,{yeccpars2_266_,1}}).
+-file("erl_parse.yrl", 375).
+yeccpars2_266_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'receive' , ? line ( __1 ) , __2 }
   end | __Stack].
 
--file("./erl_parse.erl", 8442).
--compile({inline,{yeccpars2_257_,1}}).
--file("erl_parse.yrl", 376).
-yeccpars2_257_(__Stack0) ->
+-file("./erl_parse.erl", 8872).
+-compile({inline,{yeccpars2_269_,1}}).
+-file("erl_parse.yrl", 379).
+yeccpars2_269_(__Stack0) ->
  [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'receive' , ? line ( __1 ) , __2 , __4 , __5 }
   end | __Stack].
 
--compile({inline,{yeccpars2_263_,1}}).
--file("erl_parse.yrl", 310).
-yeccpars2_263_(__Stack0) ->
+-compile({inline,{yeccpars2_275_,1}}).
+-file("erl_parse.yrl", 313).
+yeccpars2_275_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8459).
--compile({inline,{yeccpars2_267_,1}}).
--file("erl_parse.yrl", 315).
-yeccpars2_267_(__Stack0) ->
+-file("./erl_parse.erl", 8889).
+-compile({inline,{yeccpars2_279_,1}}).
+-file("erl_parse.yrl", 318).
+yeccpars2_279_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { b_generate , ? line ( __2 ) , __1 , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 8468).
--compile({inline,{yeccpars2_269_,1}}).
--file("erl_parse.yrl", 314).
-yeccpars2_269_(__Stack0) ->
+-file("./erl_parse.erl", 8898).
+-compile({inline,{yeccpars2_281_,1}}).
+-file("erl_parse.yrl", 317).
+yeccpars2_281_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { generate , ? line ( __2 ) , __1 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_271_,1}}).
--file("erl_parse.yrl", 311).
-yeccpars2_271_(__Stack0) ->
+-compile({inline,{yeccpars2_283_,1}}).
+-file("erl_parse.yrl", 314).
+yeccpars2_283_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8485).
--compile({inline,{yeccpars2_272_,1}}).
--file("erl_parse.yrl", 307).
-yeccpars2_272_(__Stack0) ->
+-file("./erl_parse.erl", 8915).
+-compile({inline,{yeccpars2_284_,1}}).
+-file("erl_parse.yrl", 310).
+yeccpars2_284_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { lc , ? line ( __1 ) , __2 , __4 }
   end | __Stack].
 
--file("./erl_parse.erl", 8494).
--compile({inline,{yeccpars2_273_,1}}).
--file("erl_parse.yrl", 427).
-yeccpars2_273_(__Stack0) ->
+-file("./erl_parse.erl", 8924).
+-compile({inline,{yeccpars2_285_,1}}).
+-file("erl_parse.yrl", 437).
+yeccpars2_285_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'query' , ? line ( __1 ) , __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_275_,1}}).
--file("erl_parse.yrl", 355).
-yeccpars2_275_(__Stack0) ->
+-compile({inline,{yeccpars2_287_,1}}).
+-file("erl_parse.yrl", 358).
+yeccpars2_287_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8511).
--compile({inline,{yeccpars2_277_,1}}).
--file("erl_parse.yrl", 359).
-yeccpars2_277_(__Stack0) ->
+-file("./erl_parse.erl", 8941).
+-compile({inline,{yeccpars2_289_,1}}).
+-file("erl_parse.yrl", 362).
+yeccpars2_289_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { clause , ? line ( hd ( hd ( __1 ) ) ) , [ ] , __1 , __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_279_,1}}).
--file("erl_parse.yrl", 356).
-yeccpars2_279_(__Stack0) ->
+-compile({inline,{yeccpars2_291_,1}}).
+-file("erl_parse.yrl", 359).
+yeccpars2_291_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8528).
--compile({inline,{yeccpars2_280_,1}}).
--file("erl_parse.yrl", 353).
-yeccpars2_280_(__Stack0) ->
+-file("./erl_parse.erl", 8958).
+-compile({inline,{yeccpars2_292_,1}}).
+-file("erl_parse.yrl", 356).
+yeccpars2_292_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'if' , ? line ( __1 ) , __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_282_,1}}).
--file("erl_parse.yrl", 386).
-yeccpars2_282_(__Stack0) ->
+-compile({inline,{yeccpars2_294_,1}}).
+-file("erl_parse.yrl", 396).
+yeccpars2_294_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_284_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_284_(__Stack0) ->
+-compile({inline,{yeccpars2_296_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_296_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--file("./erl_parse.erl", 8552).
--compile({inline,{yeccpars2_287_,1}}).
--file("erl_parse.yrl", 430).
-yeccpars2_287_(__Stack0) ->
+-file("./erl_parse.erl", 8982).
+-compile({inline,{yeccpars2_299_,1}}).
+-file("erl_parse.yrl", 440).
+yeccpars2_299_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { [ ] , ? line ( __1 ) }
   end | __Stack].
 
--file("./erl_parse.erl", 8561).
--compile({inline,{yeccpars2_288_,1}}).
--file("erl_parse.yrl", 431).
-yeccpars2_288_(__Stack0) ->
+-file("./erl_parse.erl", 8991).
+-compile({inline,{yeccpars2_300_,1}}).
+-file("erl_parse.yrl", 441).
+yeccpars2_300_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { __2 , ? line ( __1 ) }
   end | __Stack].
 
--compile({inline,{yeccpars2_290_,1}}).
--file("erl_parse.yrl", 390).
-yeccpars2_290_(__Stack0) ->
+-compile({inline,{yeccpars2_302_,1}}).
+-file("erl_parse.yrl", 400).
+yeccpars2_302_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { Args , Pos } = __1 ,
     { clause , Pos , 'fun' , Args , __2 , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 8579).
--compile({inline,{yeccpars2_295_,1}}).
--file("erl_parse.yrl", 382).
-yeccpars2_295_(__Stack0) ->
+-file("./erl_parse.erl", 9009).
+-compile({inline,{yeccpars2_307_,1}}).
+-file("erl_parse.yrl", 392).
+yeccpars2_307_(__Stack0) ->
  [__6,__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'fun' , ? line ( __1 ) , { function , element ( 3 , __2 ) , element ( 3 , __4 ) , element ( 3 , __6 ) } }
   end | __Stack].
 
--file("./erl_parse.erl", 8588).
--compile({inline,{yeccpars2_296_,1}}).
--file("erl_parse.yrl", 380).
-yeccpars2_296_(__Stack0) ->
+-file("./erl_parse.erl", 9018).
+-compile({inline,{yeccpars2_308_,1}}).
+-file("erl_parse.yrl", 390).
+yeccpars2_308_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'fun' , ? line ( __1 ) , { function , element ( 3 , __2 ) , element ( 3 , __4 ) } }
   end | __Stack].
 
--compile({inline,{yeccpars2_298_,1}}).
--file("erl_parse.yrl", 387).
-yeccpars2_298_(__Stack0) ->
+-compile({inline,{yeccpars2_310_,1}}).
+-file("erl_parse.yrl", 397).
+yeccpars2_310_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8605).
--compile({inline,{yeccpars2_299_,1}}).
--file("erl_parse.yrl", 384).
-yeccpars2_299_(__Stack0) ->
+-file("./erl_parse.erl", 9035).
+-compile({inline,{yeccpars2_311_,1}}).
+-file("erl_parse.yrl", 394).
+yeccpars2_311_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_fun ( ? line ( __1 ) , __2 )
   end | __Stack].
 
--file("./erl_parse.erl", 8614).
--compile({inline,{yeccpars2_300_,1}}).
--file("erl_parse.yrl", 205).
-yeccpars2_300_(__Stack0) ->
+-file("./erl_parse.erl", 9044).
+-compile({inline,{yeccpars2_312_,1}}).
+-file("erl_parse.yrl", 207).
+yeccpars2_312_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { 'catch' , ? line ( __1 ) , __2 }
   end | __Stack].
 
--file("./erl_parse.erl", 8623).
--compile({inline,{yeccpars2_304_,1}}).
--file("erl_parse.yrl", 363).
-yeccpars2_304_(__Stack0) ->
+-file("./erl_parse.erl", 9053).
+-compile({inline,{yeccpars2_316_,1}}).
+-file("erl_parse.yrl", 366).
+yeccpars2_316_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { 'case' , ? line ( __1 ) , __2 , __4 }
   end | __Stack].
 
--file("./erl_parse.erl", 8632).
--compile({inline,{yeccpars2_306_,1}}).
--file("erl_parse.yrl", 261).
-yeccpars2_306_(__Stack0) ->
+-file("./erl_parse.erl", 9062).
+-compile({inline,{yeccpars2_318_,1}}).
+-file("erl_parse.yrl", 263).
+yeccpars2_318_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { block , ? line ( __1 ) , __2 }
   end | __Stack].
 
--file("./erl_parse.erl", 8641).
--compile({inline,{yeccpars2_308_,1}}).
--file("erl_parse.yrl", 271).
-yeccpars2_308_(__Stack0) ->
+-file("./erl_parse.erl", 9071).
+-compile({inline,{yeccpars2_320_,1}}).
+-file("erl_parse.yrl", 274).
+yeccpars2_320_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { nil , ? line ( __1 ) }
   end | __Stack].
 
--file("./erl_parse.erl", 8650).
--compile({inline,{yeccpars2_309_,1}}).
--file("erl_parse.yrl", 272).
-yeccpars2_309_(__Stack0) ->
+-file("./erl_parse.erl", 9080).
+-compile({inline,{yeccpars2_321_,1}}).
+-file("erl_parse.yrl", 275).
+yeccpars2_321_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { cons , ? line ( __1 ) , __2 , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 8659).
--compile({inline,{yeccpars2_311_,1}}).
--file("erl_parse.yrl", 274).
-yeccpars2_311_(__Stack0) ->
+-file("./erl_parse.erl", 9089).
+-compile({inline,{yeccpars2_323_,1}}).
+-file("erl_parse.yrl", 277).
+yeccpars2_323_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    { nil , ? line ( __1 ) }
   end | __Stack].
 
--compile({inline,{yeccpars2_314_,1}}).
--file("erl_parse.yrl", 275).
-yeccpars2_314_(__Stack0) ->
+-compile({inline,{yeccpars2_326_,1}}).
+-file("erl_parse.yrl", 278).
+yeccpars2_326_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--file("./erl_parse.erl", 8676).
--compile({inline,{yeccpars2_316_,1}}).
--file("erl_parse.yrl", 276).
-yeccpars2_316_(__Stack0) ->
+-file("./erl_parse.erl", 9106).
+-compile({inline,{yeccpars2_328_,1}}).
+-file("erl_parse.yrl", 279).
+yeccpars2_328_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { cons , ? line ( __2 ) , __2 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_319_,1}}).
--file("erl_parse.yrl", 292).
-yeccpars2_319_(__Stack0) ->
+-compile({inline,{yeccpars2_331_,1}}).
+-file("erl_parse.yrl", 295).
+yeccpars2_331_(__Stack0) ->
  [begin
    default
   end | __Stack0].
 
--compile({inline,{yeccpars2_322_,1}}).
--file("erl_parse.yrl", 282).
-yeccpars2_322_(__Stack0) ->
+-compile({inline,{yeccpars2_334_,1}}).
+-file("erl_parse.yrl", 285).
+yeccpars2_334_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8700).
--compile({inline,{yeccpars2_323_,1}}).
--file("erl_parse.yrl", 279).
-yeccpars2_323_(__Stack0) ->
+-file("./erl_parse.erl", 9130).
+-compile({inline,{yeccpars2_335_,1}}).
+-file("erl_parse.yrl", 282).
+yeccpars2_335_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { bin , ? line ( __1 ) , [ ] }
   end | __Stack].
 
--compile({inline,{yeccpars2_325_,1}}).
--file("erl_parse.yrl", 283).
-yeccpars2_325_(__Stack0) ->
+-compile({inline,{yeccpars2_337_,1}}).
+-file("erl_parse.yrl", 286).
+yeccpars2_337_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8717).
--compile({inline,{yeccpars2_326_,1}}).
--file("erl_parse.yrl", 280).
-yeccpars2_326_(__Stack0) ->
+-file("./erl_parse.erl", 9147).
+-compile({inline,{yeccpars2_338_,1}}).
+-file("erl_parse.yrl", 283).
+yeccpars2_338_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { bin , ? line ( __1 ) , __2 }
   end | __Stack].
 
--file("./erl_parse.erl", 8726).
--compile({inline,{yeccpars2_329_,1}}).
--file("erl_parse.yrl", 309).
-yeccpars2_329_(__Stack0) ->
+-file("./erl_parse.erl", 9156).
+-compile({inline,{yeccpars2_341_,1}}).
+-file("erl_parse.yrl", 312).
+yeccpars2_341_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { bc , ? line ( __1 ) , __2 , __4 }
   end | __Stack].
 
--compile({inline,{yeccpars2_330_,1}}).
--file("erl_parse.yrl", 295).
-yeccpars2_330_(__Stack0) ->
+-compile({inline,{yeccpars2_342_,1}}).
+-file("erl_parse.yrl", 298).
+yeccpars2_342_(__Stack0) ->
  [begin
    default
   end | __Stack0].
 
--compile({inline,{yeccpars2_333_,1}}).
--file("erl_parse.yrl", 291).
-yeccpars2_333_(__Stack0) ->
+-compile({inline,{yeccpars2_345_,1}}).
+-file("erl_parse.yrl", 294).
+yeccpars2_345_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--file("./erl_parse.erl", 8750).
--compile({inline,{yeccpars2_334_,1}}).
--file("erl_parse.yrl", 286).
-yeccpars2_334_(__Stack0) ->
+-file("./erl_parse.erl", 9180).
+-compile({inline,{yeccpars2_346_,1}}).
+-file("erl_parse.yrl", 289).
+yeccpars2_346_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { bin_element , ? line ( __1 ) , __1 , __2 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_336_,1}}).
--file("erl_parse.yrl", 294).
-yeccpars2_336_(__Stack0) ->
+-compile({inline,{yeccpars2_348_,1}}).
+-file("erl_parse.yrl", 297).
+yeccpars2_348_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_337_,1}}).
--file("erl_parse.yrl", 298).
-yeccpars2_337_(__Stack0) ->
+-compile({inline,{yeccpars2_349_,1}}).
+-file("erl_parse.yrl", 301).
+yeccpars2_349_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_338_,1}}).
--file("erl_parse.yrl", 300).
-yeccpars2_338_(__Stack0) ->
+-compile({inline,{yeccpars2_350_,1}}).
+-file("erl_parse.yrl", 303).
+yeccpars2_350_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    element ( 3 , __1 )
   end | __Stack].
 
--compile({inline,{yeccpars2_340_,1}}).
--file("erl_parse.yrl", 301).
-yeccpars2_340_(__Stack0) ->
+-compile({inline,{yeccpars2_352_,1}}).
+-file("erl_parse.yrl", 304).
+yeccpars2_352_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { element ( 3 , __1 ) , element ( 3 , __3 ) }
   end | __Stack].
 
--compile({inline,{yeccpars2_342_,1}}).
--file("erl_parse.yrl", 297).
-yeccpars2_342_(__Stack0) ->
+-compile({inline,{yeccpars2_354_,1}}).
+-file("erl_parse.yrl", 300).
+yeccpars2_354_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8799).
--compile({inline,{yeccpars2_343_,1}}).
--file("erl_parse.yrl", 288).
-yeccpars2_343_(__Stack0) ->
+-file("./erl_parse.erl", 9229).
+-compile({inline,{yeccpars2_355_,1}}).
+-file("erl_parse.yrl", 291).
+yeccpars2_355_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop1 ( __1 , __2 )
   end | __Stack].
 
--file("./erl_parse.erl", 8808).
--compile({inline,{yeccpars2_344_,1}}).
--file("erl_parse.yrl", 247).
-yeccpars2_344_(__Stack0) ->
+-file("./erl_parse.erl", 9238).
+-compile({inline,{yeccpars2_356_,1}}).
+-file("erl_parse.yrl", 249).
+yeccpars2_356_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { record_field , ? line ( __1 ) , { atom , ? line ( __1 ) , '' } , __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_349_,1}}).
--file("erl_parse.yrl", 90).
-yeccpars2_349_(__Stack0) ->
+-compile({inline,{yeccpars2_361_,1}}).
+-file("erl_parse.yrl", 92).
+yeccpars2_361_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { type_def , __1 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_350_,1}}).
--file("erl_parse.yrl", 89).
-yeccpars2_350_(__Stack0) ->
+-compile({inline,{yeccpars2_362_,1}}).
+-file("erl_parse.yrl", 91).
+yeccpars2_362_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { typed_record , __1 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_354_,1}}).
--file("erl_parse.yrl", 94).
-yeccpars2_354_(__Stack0) ->
+-compile({inline,{yeccpars2_366_,1}}).
+-file("erl_parse.yrl", 96).
+yeccpars2_366_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_355_,1}}).
--file("erl_parse.yrl", 434).
-yeccpars2_355_(__Stack0) ->
+-compile({inline,{yeccpars2_367_,1}}).
+-file("erl_parse.yrl", 444).
+yeccpars2_367_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_358_,1}}).
--file("erl_parse.yrl", 99).
-yeccpars2_358_(__Stack0) ->
+-compile({inline,{yeccpars2_370_,1}}).
+-file("erl_parse.yrl", 101).
+yeccpars2_370_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { typed , __1 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_359_,1}}).
--file("erl_parse.yrl", 96).
-yeccpars2_359_(__Stack0) ->
+-compile({inline,{yeccpars2_371_,1}}).
+-file("erl_parse.yrl", 98).
+yeccpars2_371_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_361_,1}}).
--file("erl_parse.yrl", 95).
-yeccpars2_361_(__Stack0) ->
+-compile({inline,{yeccpars2_373_,1}}).
+-file("erl_parse.yrl", 97).
+yeccpars2_373_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_362_,1}}).
--file("erl_parse.yrl", 97).
-yeccpars2_362_(__Stack0) ->
+-compile({inline,{yeccpars2_374_,1}}).
+-file("erl_parse.yrl", 99).
+yeccpars2_374_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8881).
--compile({inline,{yeccpars2_363_,1}}).
--file("erl_parse.yrl", 92).
-yeccpars2_363_(__Stack0) ->
+-file("./erl_parse.erl", 9311).
+-compile({inline,{yeccpars2_375_,1}}).
+-file("erl_parse.yrl", 94).
+yeccpars2_375_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { tuple , ? line ( __1 ) , __2 }
   end | __Stack].
 
--compile({inline,{yeccpars2_364_,1}}).
--file("erl_parse.yrl", 186).
-yeccpars2_364_(__Stack0) ->
+-compile({inline,{yeccpars2_376_,1}}).
+-file("erl_parse.yrl", 188).
+yeccpars2_376_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __2 | __4 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_365_,1}}).
--file("erl_parse.yrl", 75).
-yeccpars2_365_(__Stack0) ->
+-compile({inline,{yeccpars2_377_,1}}).
+-file("erl_parse.yrl", 77).
+yeccpars2_377_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    build_typed_attribute ( __2 , __4 )
   end | __Stack].
 
--file("./erl_parse.erl", 8906).
--compile({inline,{yeccpars2_367_,1}}).
--file("erl_parse.yrl", 332).
-yeccpars2_367_(__Stack0) ->
+-file("./erl_parse.erl", 9336).
+-compile({inline,{yeccpars2_379_,1}}).
+-file("erl_parse.yrl", 335).
+yeccpars2_379_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { record , ? line ( __1 ) , element ( 3 , __2 ) , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_371_,1}}).
--file("erl_parse.yrl", 341).
-yeccpars2_371_(__Stack0) ->
+-compile({inline,{yeccpars2_383_,1}}).
+-file("erl_parse.yrl", 344).
+yeccpars2_383_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    [ __1 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_374_,1}}).
--file("erl_parse.yrl", 338).
-yeccpars2_374_(__Stack0) ->
+-compile({inline,{yeccpars2_386_,1}}).
+-file("erl_parse.yrl", 341).
+yeccpars2_386_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    [ ]
   end | __Stack].
 
--file("./erl_parse.erl", 8931).
--compile({inline,{yeccpars2_376_,1}}).
--file("erl_parse.yrl", 344).
-yeccpars2_376_(__Stack0) ->
+-file("./erl_parse.erl", 9361).
+-compile({inline,{yeccpars2_388_,1}}).
+-file("erl_parse.yrl", 347).
+yeccpars2_388_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { record_field , ? line ( __1 ) , __1 , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 8940).
--compile({inline,{yeccpars2_378_,1}}).
--file("erl_parse.yrl", 345).
-yeccpars2_378_(__Stack0) ->
+-file("./erl_parse.erl", 9370).
+-compile({inline,{yeccpars2_390_,1}}).
+-file("erl_parse.yrl", 348).
+yeccpars2_390_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { record_field , ? line ( __1 ) , __1 , __3 }
   end | __Stack].
 
--compile({inline,{yeccpars2_380_,1}}).
--file("erl_parse.yrl", 342).
-yeccpars2_380_(__Stack0) ->
+-compile({inline,{yeccpars2_392_,1}}).
+-file("erl_parse.yrl", 345).
+yeccpars2_392_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_381_,1}}).
--file("erl_parse.yrl", 339).
-yeccpars2_381_(__Stack0) ->
+-compile({inline,{yeccpars2_393_,1}}).
+-file("erl_parse.yrl", 342).
+yeccpars2_393_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--file("./erl_parse.erl", 8965).
--compile({inline,{yeccpars2_382_,1}}).
--file("erl_parse.yrl", 330).
-yeccpars2_382_(__Stack0) ->
+-file("./erl_parse.erl", 9395).
+-compile({inline,{yeccpars2_394_,1}}).
+-file("erl_parse.yrl", 333).
+yeccpars2_394_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { record_index , ? line ( __1 ) , element ( 3 , __2 ) , __4 }
   end | __Stack].
 
--compile({inline,{yeccpars2_384_,1}}).
--file("erl_parse.yrl", 185).
-yeccpars2_384_(__Stack0) ->
+-compile({inline,{yeccpars2_396_,1}}).
+-file("erl_parse.yrl", 187).
+yeccpars2_396_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--file("./erl_parse.erl", 8982).
--compile({inline,{yeccpars2_387_,1}}).
--file("erl_parse.yrl", 208).
-yeccpars2_387_(__Stack0) ->
+-file("./erl_parse.erl", 9412).
+-compile({inline,{yeccpars2_399_,1}}).
+-file("erl_parse.yrl", 210).
+yeccpars2_399_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { match , ? line ( __2 ) , __1 , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 8991).
--compile({inline,{yeccpars2_388_,1}}).
--file("erl_parse.yrl", 209).
-yeccpars2_388_(__Stack0) ->
+-file("./erl_parse.erl", 9421).
+-compile({inline,{yeccpars2_400_,1}}).
+-file("erl_parse.yrl", 211).
+yeccpars2_400_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop2 ( __1 , __2 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 9000).
--compile({inline,{yeccpars2_390_,1}}).
--file("erl_parse.yrl", 212).
-yeccpars2_390_(__Stack0) ->
+-file("./erl_parse.erl", 9430).
+-compile({inline,{yeccpars2_402_,1}}).
+-file("erl_parse.yrl", 214).
+yeccpars2_402_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop2 ( __1 , __2 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 9009).
--compile({inline,{yeccpars2_392_,1}}).
--file("erl_parse.yrl", 215).
-yeccpars2_392_(__Stack0) ->
+-file("./erl_parse.erl", 9439).
+-compile({inline,{yeccpars2_404_,1}}).
+-file("erl_parse.yrl", 217).
+yeccpars2_404_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop2 ( __1 , __2 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 9018).
--compile({inline,{yeccpars2_402_,1}}).
--file("erl_parse.yrl", 219).
-yeccpars2_402_(__Stack0) ->
+-file("./erl_parse.erl", 9448).
+-compile({inline,{yeccpars2_414_,1}}).
+-file("erl_parse.yrl", 221).
+yeccpars2_414_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop2 ( __1 , __2 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 9027).
--compile({inline,{yeccpars2_415_,1}}).
--file("erl_parse.yrl", 227).
-yeccpars2_415_(__Stack0) ->
+-file("./erl_parse.erl", 9457).
+-compile({inline,{yeccpars2_427_,1}}).
+-file("erl_parse.yrl", 229).
+yeccpars2_427_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop2 ( __1 , __2 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 9036).
--compile({inline,{yeccpars2_423_,1}}).
--file("erl_parse.yrl", 231).
-yeccpars2_423_(__Stack0) ->
+-file("./erl_parse.erl", 9466).
+-compile({inline,{yeccpars2_435_,1}}).
+-file("erl_parse.yrl", 233).
+yeccpars2_435_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop2 ( __1 , __2 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 9045).
--compile({inline,{yeccpars2_424_,1}}).
--file("erl_parse.yrl", 223).
-yeccpars2_424_(__Stack0) ->
+-file("./erl_parse.erl", 9475).
+-compile({inline,{yeccpars2_436_,1}}).
+-file("erl_parse.yrl", 225).
+yeccpars2_436_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop2 ( __1 , __2 , __3 )
   end | __Stack].
 
--file("./erl_parse.erl", 9054).
--compile({inline,{yeccpars2_425_,1}}).
--file("erl_parse.yrl", 350).
-yeccpars2_425_(__Stack0) ->
+-file("./erl_parse.erl", 9484).
+-compile({inline,{yeccpars2_437_,1}}).
+-file("erl_parse.yrl", 353).
+yeccpars2_437_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    { call , ? line ( __1 ) , __1 , element ( 1 , __2 ) }
   end | __Stack].
 
--file("./erl_parse.erl", 9063).
--compile({inline,{yeccpars2_428_,1}}).
--file("erl_parse.yrl", 243).
-yeccpars2_428_(__Stack0) ->
+-file("./erl_parse.erl", 9493).
+-compile({inline,{yeccpars2_440_,1}}).
+-file("erl_parse.yrl", 245).
+yeccpars2_440_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { remote , ? line ( __2 ) , __1 , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 9072).
--compile({inline,{yeccpars2_429_,1}}).
--file("erl_parse.yrl", 249).
-yeccpars2_429_(__Stack0) ->
+-file("./erl_parse.erl", 9502).
+-compile({inline,{yeccpars2_441_,1}}).
+-file("erl_parse.yrl", 251).
+yeccpars2_441_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { record_field , ? line ( __2 ) , __1 , __3 }
   end | __Stack].
 
--file("./erl_parse.erl", 9081).
--compile({inline,{yeccpars2_432_,1}}).
--file("erl_parse.yrl", 336).
-yeccpars2_432_(__Stack0) ->
+-file("./erl_parse.erl", 9511).
+-compile({inline,{yeccpars2_444_,1}}).
+-file("erl_parse.yrl", 339).
+yeccpars2_444_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { record , ? line ( __2 ) , __1 , element ( 3 , __3 ) , __4 }
   end | __Stack].
 
--file("./erl_parse.erl", 9090).
--compile({inline,{yeccpars2_434_,1}}).
--file("erl_parse.yrl", 334).
-yeccpars2_434_(__Stack0) ->
+-file("./erl_parse.erl", 9520).
+-compile({inline,{yeccpars2_446_,1}}).
+-file("erl_parse.yrl", 337).
+yeccpars2_446_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { record_field , ? line ( __2 ) , __1 , element ( 3 , __3 ) , __5 }
   end | __Stack].
 
--file("./erl_parse.erl", 9099).
--compile({inline,{yeccpars2_435_,1}}).
--file("erl_parse.yrl", 235).
-yeccpars2_435_(__Stack0) ->
+-file("./erl_parse.erl", 9529).
+-compile({inline,{yeccpars2_447_,1}}).
+-file("erl_parse.yrl", 237).
+yeccpars2_447_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    ? mkop1 ( __1 , __2 )
   end | __Stack].
 
--compile({inline,{yeccpars2_436_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_436_(__Stack0) ->
+-compile({inline,{yeccpars2_448_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_448_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--compile({inline,{yeccpars2_437_,1}}).
--file("erl_parse.yrl", 197).
-yeccpars2_437_(__Stack0) ->
+-compile({inline,{yeccpars2_449_,1}}).
+-file("erl_parse.yrl", 199).
+yeccpars2_449_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
    element ( 1 , __1 )
   end | __Stack].
 
--file("./erl_parse.erl", 9123).
--compile({inline,{yeccpars2_439_,1}}).
--file("erl_parse.yrl", 489).
-yeccpars2_439_(__Stack0) ->
+-file("./erl_parse.erl", 9553).
+-compile({inline,{yeccpars2_451_,1}}).
+-file("erl_parse.yrl", 499).
+yeccpars2_451_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { clause , ? line ( __1 ) , element ( 3 , __1 ) , __2 , __3 , __4 }
   end | __Stack].
 
--file("./erl_parse.erl", 9132).
--compile({inline,{yeccpars2_440_,1}}).
--file("erl_parse.yrl", 194).
-yeccpars2_440_(__Stack0) ->
+-file("./erl_parse.erl", 9562).
+-compile({inline,{yeccpars2_452_,1}}).
+-file("erl_parse.yrl", 196).
+yeccpars2_452_(__Stack0) ->
  [__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
    { clause , ? line ( __1 ) , element ( 3 , __1 ) , __2 , __3 , __4 }
   end | __Stack].
 
--compile({inline,{yeccpars2_442_,1}}).
--file("erl_parse.yrl", 491).
-yeccpars2_442_(__Stack0) ->
+-compile({inline,{yeccpars2_454_,1}}).
+-file("erl_parse.yrl", 501).
+yeccpars2_454_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __2
   end | __Stack].
 
--compile({inline,{yeccpars2_443_,1}}).
--file("erl_parse.yrl", 69).
-yeccpars2_443_(__Stack0) ->
+-compile({inline,{yeccpars2_455_,1}}).
+-file("erl_parse.yrl", 71).
+yeccpars2_455_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __1
   end | __Stack].
 
--compile({inline,{yeccpars2_444_,1}}).
--file("erl_parse.yrl", 70).
-yeccpars2_444_(__Stack0) ->
+-compile({inline,{yeccpars2_456_,1}}).
+-file("erl_parse.yrl", 72).
+yeccpars2_456_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __1
   end | __Stack].
 
--compile({inline,{yeccpars2_446_,1}}).
--file("erl_parse.yrl", 191).
-yeccpars2_446_(__Stack0) ->
+-compile({inline,{yeccpars2_458_,1}}).
+-file("erl_parse.yrl", 193).
+yeccpars2_458_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_448_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_448_(__Stack0) ->
+-compile({inline,{yeccpars2_460_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_460_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
--compile({inline,{yeccpars2_450_,1}}).
--file("erl_parse.yrl", 71).
-yeccpars2_450_(__Stack0) ->
+-compile({inline,{yeccpars2_462_,1}}).
+-file("erl_parse.yrl", 73).
+yeccpars2_462_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
    __1
   end | __Stack].
 
--compile({inline,{yeccpars2_452_,1}}).
--file("erl_parse.yrl", 486).
-yeccpars2_452_(__Stack0) ->
+-compile({inline,{yeccpars2_464_,1}}).
+-file("erl_parse.yrl", 496).
+yeccpars2_464_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
    [ __1 | __3 ]
   end | __Stack].
 
--compile({inline,{yeccpars2_454_,1}}).
--file("erl_parse.yrl", 200).
-yeccpars2_454_(__Stack0) ->
+-compile({inline,{yeccpars2_466_,1}}).
+-file("erl_parse.yrl", 202).
+yeccpars2_466_(__Stack0) ->
  [begin
    [ ]
   end | __Stack0].
 
 
--file("erl_parse.yrl", 1011).
+-file("erl_parse.yrl", 1021).
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_parse.yrl minimal_otp_src_R12B-5/lib/stdlib/src/erl_parse.yrl
--- otp_src_R12B-5/lib/stdlib/src/erl_parse.yrl	2008-11-04 10:51:19.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_parse.yrl	2009-06-23 20:40:26.000000000 +0100
@@ -34,7 +34,8 @@ tuple
 atom1
 %struct
 record_expr record_tuple record_field record_fields
-if_expr if_clause if_clauses case_expr cr_clause cr_clauses receive_expr
+if_expr if_clause if_clauses case_expr cr_clause cr_clauses
+receive_expr search_expr
 fun_expr fun_clause fun_clauses
 %% cond_expr cond_clause cond_clauses
 try_expr try_catch try_clause try_clauses query_expr
@@ -54,7 +55,8 @@ Terminals
 char integer float atom string var
 
 '(' ')' ',' '->' ':-' '{' '}' '[' ']' '|' '||' '<-' ';' ':' '#' '.'
-'after' 'begin' 'case' 'try' 'catch' 'end' 'fun' 'if' 'of' 'receive' 'when'
+'after' 'begin' 'case' 'try' 'catch' 'end' 'fun' 'if' 'of'
+'receive' 'search' 'when'
 'andalso' 'orelse' 'query' 'spec'
 %% 'cond'
 'bnot' 'not'
@@ -266,6 +268,7 @@ expr_max -> 'begin' exprs 'end' : {block
 expr_max -> if_expr : '$1'.
 expr_max -> case_expr : '$1'.
 expr_max -> receive_expr : '$1'.
+expr_max -> search_expr : '$1'.
 expr_max -> fun_expr : '$1'.
 %%expr_max -> cond_expr : '$1'.
 expr_max -> try_expr : '$1'.
@@ -379,6 +382,13 @@ receive_expr -> 'receive' 'after' expr c
 receive_expr -> 'receive' cr_clauses 'after' expr clause_body 'end' :
 	{'receive',?line('$1'),'$2','$4','$5'}.
 
+search_expr -> 'search' cr_clauses 'end' :
+	{'search',?line('$1'),'$2'}.
+search_expr -> 'search' 'after' expr clause_body 'end' :
+	{'search',?line('$1'),[],'$3','$4'}.
+search_expr -> 'search' cr_clauses 'after' expr clause_body 'end' :
+	{'search',?line('$1'),'$2','$4','$5'}.
+
 
 fun_expr -> 'fun' atom1 '/' integer :
 	{'fun',?line('$1'),{function,element(3, '$2'),element(3, '$4')}}.
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_pp.erl minimal_otp_src_R12B-5/lib/stdlib/src/erl_pp.erl
--- otp_src_R12B-5/lib/stdlib/src/erl_pp.erl	2007-11-26 18:55:32.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_pp.erl	2009-06-23 20:40:26.000000000 +0100
@@ -261,6 +261,13 @@ lexpr({'receive',_,Cs,To,ToOpt}, _, Hook
     {list,[{step,'receive',cr_clauses(Cs, Hook)},
            {step,'after',Al},
            'end']};
+lexpr({'search',_,Cs}, _, Hook) ->
+    {list,[{step,'search',cr_clauses(Cs, Hook)},'end']};
+lexpr({'search',_,Cs,To,ToOpt}, _, Hook) ->
+    Al = {list,[{step,[lexpr(To, Hook),' ->'],body(ToOpt, Hook)}]},
+    {list,[{step,'search',cr_clauses(Cs, Hook)},
+           {step,'after',Al},
+           'end']};
 lexpr({'fun',_,{function,F,A}}, _Prec, _Hook) ->
     leaf(format("fun ~w/~w", [F,A]));
 lexpr({'fun',_,{function,F,A},Extra}, _Prec, _Hook) ->
@@ -826,7 +833,7 @@ spaces(N, T) ->
 wordtable() ->
     L = [begin {leaf,Sz,S} = leaf(W), {S,Sz} end || 
             W <- [" ->"," =","<<",">>","[]","after","begin","case","catch",
-                  "end","fun","if","of","receive","try","when"]],
+                  "end","fun","if","of","receive","try","when","search"]],
     list_to_tuple(L).
 
 word(' ->', WT) -> element(1, WT);
@@ -844,4 +851,5 @@ word('if', WT) -> element(12, WT);
 word('of', WT) -> element(13, WT);
 word('receive', WT) -> element(14, WT);
 word('try', WT) -> element(15, WT);
-word('when', WT) -> element(16, WT).
+word('when', WT) -> element(16, WT);
+word('search', WT) -> element(17, WT).
diff -urNp otp_src_R12B-5/lib/stdlib/src/erl_scan.erl minimal_otp_src_R12B-5/lib/stdlib/src/erl_scan.erl
--- otp_src_R12B-5/lib/stdlib/src/erl_scan.erl	2008-06-10 13:47:24.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/erl_scan.erl	2009-06-23 20:40:26.000000000 +0100
@@ -602,6 +602,7 @@ reserved_word('let') -> true;
 reserved_word('of') -> true;
 reserved_word('query') -> true;
 reserved_word('receive') -> true;
+reserved_word('search') -> true;
 reserved_word('when') -> true;
 reserved_word('bnot') -> true;
 reserved_word('not') -> true;
diff -urNp otp_src_R12B-5/lib/stdlib/src/gen_event.erl minimal_otp_src_R12B-5/lib/stdlib/src/gen_event.erl
--- otp_src_R12B-5/lib/stdlib/src/gen_event.erl	2008-02-05 13:37:06.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/stdlib/src/gen_event.erl	2009-06-23 20:40:26.000000000 +0100
@@ -511,7 +511,7 @@ split(_, [], _) ->
 %%    {Reply, MSL1}
 
 server_call(Handler, Query, MSL, SName) ->
-    case search(Handler, MSL) of
+    case search_handler(Handler, MSL) of
 	{ok, Ha} ->
 	    case server_call_update(Ha, Query, SName) of
 		{no, Reply} ->
@@ -525,15 +525,15 @@ server_call(Handler, Query, MSL, SName) 
 	    {false, {error, bad_module}, MSL}
     end.
 
-search({Mod, Id}, [Ha|_MSL]) when Ha#handler.module =:= Mod,
+search_handler({Mod, Id}, [Ha|_MSL]) when Ha#handler.module =:= Mod,
 				  Ha#handler.id =:= Id ->
     {ok, Ha};
-search(Mod, [Ha|_MSL]) when Ha#handler.module =:= Mod,
+search_handler(Mod, [Ha|_MSL]) when Ha#handler.module =:= Mod,
 			    not Ha#handler.id ->
     {ok, Ha};
-search(Handler, [_|MSL]) ->
-    search(Handler, MSL);
-search(_, []) ->
+search_handler(Handler, [_|MSL]) ->
+    search_handler(Handler, MSL);
+search_handler(_, []) ->
     false.
 
 delete({Mod, Id}, [Ha|MSL]) when Ha#handler.module =:= Mod,
diff -urNp otp_src_R12B-5/lib/stdlib/src/gen_event.erl~ minimal_otp_src_R12B-5/lib/stdlib/src/gen_event.erl~
--- otp_src_R12B-5/lib/stdlib/src/gen_event.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/gen_event.erl~	2009-06-23 20:40:26.000000000 +0100
@@ -0,0 +1,681 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+-module(gen_event).
+
+%%% 
+%%% A general event handler.
+%%% Several handlers (functions) can be added.
+%%% Each handler holds a state and will be called
+%%% for every event received of the handler.
+%%% 
+
+%%% Modified by Magnus.
+%%%       Take care of fault situations and made notify asynchronous.
+%%% Re-written by Joe with new functional interface !
+%%% Modified by Martin - uses proc_lib, sys and gen!
+
+
+-export([start/0, start/1, start_link/0, start_link/1, stop/1, notify/2, 
+	 sync_notify/2,
+	 add_handler/3, add_sup_handler/3, delete_handler/3, swap_handler/3,
+	 swap_sup_handler/3, which_handlers/1, call/3, call/4, wake_hib/4]).
+
+-export([behaviour_info/1]).
+
+-export([init_it/6,
+	 system_continue/3,
+	 system_terminate/4,
+	 system_code_change/4,
+	 print_event/3,
+	 format_status/2]).
+
+-import(error_logger, [error_msg/2]).
+
+-define(reply(X), From ! {element(2,Tag), X}).
+
+-record(handler, {module,
+		  id = false,
+		  state,
+		  supervised = false}).
+
+behaviour_info(callbacks) ->
+    [{init,1},{handle_event,2},{handle_call,2},{handle_info,2},
+     {terminate,2},{code_change,3}];
+behaviour_info(_Other) ->
+    undefined.
+
+%% gen_event:start(Handler) -> ok | {error, What}
+%%   gen_event:add_handler(Handler, Mod, Args) -> ok | Other
+%%      gen_event:notify(Handler, Event) -> ok
+%%      gen_event:call(Handler, Mod, Query) -> {ok, Val} | {error, Why}
+%%      gen_event:call(Handler, Mod, Query, Timeout) -> {ok, Val} | {error, Why}
+%%   gen_event:delete_handler(Handler, Mod, Args) -> Val
+%%   gen_event:swap_handler(Handler, {OldMod, Args1}, {NewMod, Args2}) -> ok
+%%   gen_event:which_handler(Handler) ->  [Mod]
+%% gen_event:stop(Handler)  -> ok 
+
+
+%% handlers must export
+%% Mod:init(Args) -> {ok, State} | Other
+%% Mod:handle_event(Event, State) -> 
+%%    {ok, State'} | remove_handler | {swap_handler,Args1,State1,Mod2,Args2}
+%% Mod:handle_info(Info, State) ->
+%%    {ok, State'} | remove_handler | {swap_handler,Args1,State1,Mod2,Args2}
+%% Mod:handle_call(Query, State) -> 
+%%    {ok, Reply, State'} | {remove_handler, Reply} | 
+%%    {swap_handler, Reply, Args1,State1,Mod2,Args2}
+%% Mod:terminate(Args, State) -> Val
+
+
+%% add_handler(H, Mod, Args) -> ok | Other
+%%    Mod:init(Args) -> {ok, State} | Other
+
+%% delete_handler(H, Mod, Args) -> Val
+%%    Mod:terminate(Args, State) -> Val
+
+%% notify(H, Event) 
+%%    Mod:handle_event(Event, State) ->
+%%         {ok, State1}
+%%         remove_handler
+%%               Mod:terminate(remove_handler, State) is called
+%%               the return value is ignored
+%%         {swap_handler, Args1, State1, Mod2, Args2}
+%%               State2 = Mod:terminate(Args1, State1) is called
+%%               the return value is chained into the new module and
+%%               Mod2:init({Args2, State2}) is called
+%%         Other
+%%               Mod:terminate({error, Other}, State) is called
+%%               The return value is ignored
+%% call(H, Mod, Query) -> Val
+%% call(H, Mod, Query, Timeout) -> Val
+%%      Mod:handle_call(Query, State) -> as above
+
+
+start() ->
+    gen:start(gen_event, nolink, [], [], []).
+
+start(Name) ->
+    gen:start(gen_event, nolink, Name, [], [], []).
+
+start_link() ->
+    gen:start(gen_event, link, [], [], []).
+
+start_link(Name) ->
+    gen:start(gen_event, link, Name, [], [], []).
+
+init_it(Starter, self, Name, Mod, Args, Options) ->
+    init_it(Starter, self(), Name, Mod, Args, Options);
+init_it(Starter, Parent, Name, _, _, Options) ->
+    process_flag(trap_exit, true),
+    Debug = gen:debug_options(Options),
+    proc_lib:init_ack(Starter, {ok, self()}),
+    loop(Parent, Name, [], Debug, false).
+
+add_handler(M, Handler, Args)      -> rpc (M, {add_handler, Handler, Args}).
+add_sup_handler(M, Handler, Args)  ->
+    rpc (M, {add_sup_handler, Handler, Args, self()}).
+notify(M, Event)                   -> send(M, {notify, Event}). 
+sync_notify(M, Event)              -> rpc (M, {sync_notify, Event}).
+call(M, Handler, Query)            -> call1(M, Handler, Query).
+call(M, Handler, Query, Timeout)   -> call1(M, Handler, Query, Timeout).
+delete_handler(M, Handler, Args)   -> rpc (M, {delete_handler, Handler, Args}).
+swap_handler(M, {H1, A1},{H2, A2}) -> rpc (M, {swap_handler, H1, A1, H2, A2}).
+swap_sup_handler(M, {H1, A1},{H2, A2}) ->
+    rpc (M, {swap_sup_handler, H1, A1, H2, A2, self()}).
+which_handlers(M)                  -> rpc (M, which_handlers).
+stop(M)                            -> rpc (M, stop).
+
+rpc(M, Cmd) -> 
+    {ok,Reply} = gen:call(M, self(), Cmd, infinity),
+    Reply.
+
+call1(M, Handler, Query) ->
+    Cmd = {call, Handler, Query},
+    case catch gen:call(M, self(), Cmd) of
+	{ok,Res} ->
+	    Res;
+	{'EXIT', Reason} ->
+	    exit({Reason, {gen_event, call, [M, Handler, Query]}})
+    end.
+
+call1(M, Handler, Query, Timeout) ->
+    Cmd = {call, Handler, Query},
+    case catch gen:call(M, self(), Cmd, Timeout) of
+	{ok,Res} ->
+	    Res;
+	{'EXIT', Reason} ->
+	    exit({Reason, {gen_event, call, [M, Handler, Query, Timeout]}})
+    end.
+
+send({global, Name}, Cmd) ->
+    catch global:send(Name, Cmd),
+    ok;
+send(M, Cmd) ->
+    M ! Cmd,
+    ok.
+loop(Parent, ServerName, MSL, Debug, true) ->
+     proc_lib:hibernate(?MODULE,wake_hib,[Parent, ServerName, MSL, Debug]);
+loop(Parent, ServerName, MSL, Debug, _) ->
+    fetch_msg(Parent, ServerName, MSL, Debug, false).
+
+wake_hib(Parent, ServerName, MSL, Debug) ->
+    fetch_msg(Parent, ServerName, MSL, Debug, true).
+
+fetch_msg(Parent, ServerName, MSL, Debug, Hib) ->
+    receive
+	{system, From, Req} ->
+	    sys:handle_system_msg(Req, From, Parent, gen_event, Debug,
+				  [ServerName, MSL, Hib],Hib);
+	{'EXIT', Parent, Reason} ->
+	    terminate_server(Reason, Parent, MSL, ServerName);
+	Msg when Debug =:= [] ->
+	    handle_msg(Msg, Parent, ServerName, MSL, []);
+	Msg ->
+	    Debug1 = sys:handle_debug(Debug, {gen_event, print_event}, 
+				      ServerName, {in, Msg}),
+	    handle_msg(Msg, Parent, ServerName, MSL, Debug1)
+    end.
+
+handle_msg(Msg, Parent, ServerName, MSL, Debug) ->
+    case Msg of
+	{notify, Event} ->
+	    {Hib,MSL1} = server_notify(Event, handle_event, MSL, ServerName),
+	    loop(Parent, ServerName, MSL1, Debug, Hib);
+	{From, Tag, {sync_notify, Event}} ->
+	    {Hib, MSL1} = server_notify(Event, handle_event, MSL, ServerName),
+	    ?reply(ok),
+	    loop(Parent, ServerName, MSL1, Debug, Hib);
+	{'EXIT', From, Reason} ->
+	    MSL1 = handle_exit(From, Reason, MSL, ServerName),
+	    loop(Parent, ServerName, MSL1, Debug, false);
+	{From, Tag, {call, Handler, Query}} ->
+	    {Hib, Reply, MSL1} = server_call(Handler, Query, MSL, ServerName),
+	    ?reply(Reply),
+	    loop(Parent, ServerName, MSL1, Debug, Hib);
+	{From, Tag, {add_handler, Handler, Args}} ->
+	    {Hib, Reply, MSL1} = server_add_handler(Handler, Args, MSL),
+	    ?reply(Reply),
+	    loop(Parent, ServerName, MSL1, Debug, Hib);
+	{From, Tag, {add_sup_handler, Handler, Args, SupP}} ->
+	    {Hib, Reply, MSL1} = server_add_sup_handler(Handler, Args, MSL, SupP),
+	    ?reply(Reply),
+	    loop(Parent, ServerName, MSL1, Debug, Hib);
+	{From, Tag, {delete_handler, Handler, Args}} ->
+	    {Reply, MSL1} = server_delete_handler(Handler, Args, MSL,
+						  ServerName),
+	    ?reply(Reply),
+	    loop(Parent, ServerName, MSL1, Debug, false);
+	{From, Tag, {swap_handler, Handler1, Args1, Handler2, Args2}} ->
+	    {Hib, Reply, MSL1} = server_swap_handler(Handler1, Args1, Handler2,
+						Args2, MSL, ServerName),
+	    ?reply(Reply),
+	    loop(Parent, ServerName, MSL1, Debug, Hib);
+	{From, Tag, {swap_sup_handler, Handler1, Args1, Handler2, Args2,
+		     Sup}} ->
+	    {Hib, Reply, MSL1} = server_swap_handler(Handler1, Args1, Handler2,
+						Args2, MSL, Sup, ServerName),
+	    ?reply(Reply),
+	    loop(Parent, ServerName, MSL1, Debug, Hib);
+	{From, Tag, stop} ->
+	    catch terminate_server(normal, Parent, MSL, ServerName),
+	    ?reply(ok);
+	{From, Tag, which_handlers} ->
+	    ?reply(the_handlers(MSL)),
+	    loop(Parent, ServerName, MSL, Debug, false);
+	{From, Tag, get_modules} ->
+	    ?reply(get_modules(MSL)),
+	    loop(Parent, ServerName, MSL, Debug, false);
+	Other  ->
+	    {Hib, MSL1} = server_notify(Other, handle_info, MSL, ServerName),
+	    loop(Parent, ServerName, MSL1, Debug, Hib)
+    end.
+
+terminate_server(Reason, Parent, MSL, ServerName) ->
+    stop_handlers(MSL, ServerName),
+    do_unlink(Parent, MSL),
+    exit(Reason).
+
+%% unlink the supervisor process of all supervised handlers.
+%% We do not want a handler supervisor to EXIT due to the
+%% termination of the event manager (server).
+%% Do not unlink Parent !
+do_unlink(Parent, MSL) ->
+    lists:foreach(fun(Handler) when Handler#handler.supervised =:= Parent ->
+			  true;
+		     (Handler) when is_pid(Handler#handler.supervised) ->
+			  unlink(Handler#handler.supervised),
+			  true;
+		     (_) ->
+			  true
+		  end,
+		  MSL).
+
+%% First terminate the supervised (if exists) handlers and
+%% then inform other handlers.
+%% We do not know if any handler really is interested but it
+%% may be so !
+handle_exit(From, Reason, MSL, SName) ->
+    MSL1 = terminate_supervised(From, Reason, MSL, SName),
+    {_,MSL2}=server_notify({'EXIT', From, Reason}, handle_info, MSL1, SName),
+    MSL2.
+
+terminate_supervised(Pid, Reason, MSL, SName) ->
+    F = fun(Ha) when Ha#handler.supervised =:= Pid ->
+		do_terminate(Ha#handler.module,
+			     Ha,
+			     {stop,Reason},
+			     Ha#handler.state,
+			     {parent_terminated, {Pid,Reason}},
+			     SName,
+			     shutdown),
+		false;
+	   (_) ->
+		true
+	end,
+    lists:filter(F, MSL).
+
+%%-----------------------------------------------------------------
+%% Callback functions for system messages handling.
+%%-----------------------------------------------------------------
+system_continue(Parent, Debug, [ServerName, MSL, Hib]) ->
+    loop(Parent, ServerName, MSL, Debug, Hib).
+
+-spec(system_terminate/4 :: (_, _, _, [_]) -> no_return()).
+
+system_terminate(Reason, Parent, _Debug, [ServerName, MSL, _Hib]) ->
+    terminate_server(Reason, Parent, MSL, ServerName).
+
+%%-----------------------------------------------------------------
+%% Module here is sent in the system msg change_code.  It specifies
+%% which module should be changed.
+%%-----------------------------------------------------------------
+system_code_change([ServerName, MSL, Hib], Module, OldVsn, Extra) ->
+    MSL1 = lists:zf(fun(H) when H#handler.module =:= Module ->
+			    {ok, NewState} =
+				Module:code_change(OldVsn,
+						   H#handler.state, Extra),
+			    {true, H#handler{state = NewState}};
+		       (_) -> true
+		    end,
+		    MSL),
+    {ok, [ServerName, MSL1, Hib]}.
+
+%%-----------------------------------------------------------------
+%% Format debug messages.  Print them as the call-back module sees
+%% them, not as the real erlang messages.  Use trace for that.
+%%-----------------------------------------------------------------
+print_event(Dev, {in, Msg}, Name) ->
+    case Msg of
+	{notify, Event} ->
+	    io:format(Dev, "*DBG* ~p got event ~p~n", [Name, Event]);
+	{_,_,{call, Handler, Query}} ->
+	    io:format(Dev, "*DBG* ~p(~p) got call ~p~n",
+		      [Name, Handler, Query]);
+	_ ->
+	    io:format(Dev, "*DBG* ~p got ~p~n", [Name, Msg])
+    end;
+print_event(Dev, Dbg, Name) ->
+    io:format(Dev, "*DBG* ~p : ~p~n", [Name, Dbg]).
+
+
+%% server_add_handler(Handler, Args, MSL) -> {Ret, MSL'}.
+%%   where MSL = [#handler]
+%%   Ret goes to the top level MSL' is the new internal state of the
+%%   event handler
+
+server_add_handler({Mod,Id}, Args, MSL) ->
+    Handler = #handler{module = Mod,
+		       id = Id},
+    server_add_handler(Mod, Handler, Args, MSL);
+server_add_handler(Mod, Args, MSL) -> 
+    Handler = #handler{module = Mod},
+    server_add_handler(Mod, Handler, Args, MSL).
+
+server_add_handler(Mod, Handler, Args, MSL) ->
+    case catch Mod:init(Args) of
+        {ok, State} ->
+	    {false, ok, [Handler#handler{state = State}|MSL]};
+        {ok, State, hibernate} ->
+	    {true, ok, [Handler#handler{state = State}|MSL]};
+        Other ->
+            {false, Other, MSL}
+    end.
+
+%% Set up a link to the supervising process.
+%% (Ought to be unidirected links here, Erl5.0 !!)
+%% NOTE: This link will not be removed then the
+%% handler is removed in case another handler has
+%% own link to this process.
+server_add_sup_handler({Mod,Id}, Args, MSL, Parent) ->
+    link(Parent),
+    Handler = #handler{module = Mod,
+		       id = Id,
+		       supervised = Parent},
+    server_add_handler(Mod, Handler, Args, MSL);
+server_add_sup_handler(Mod, Args, MSL, Parent) -> 
+    link(Parent),
+    Handler = #handler{module = Mod,
+		       supervised = Parent},
+    server_add_handler(Mod, Handler, Args, MSL).
+
+%% server_delete_handler(HandlerId, Args, MSL) -> {Ret, MSL'}
+
+server_delete_handler(HandlerId, Args, MSL, SName) -> 
+    case split(HandlerId, MSL) of
+	{Mod, Handler, MSL1} ->
+	    {do_terminate(Mod, Handler, Args,
+			  Handler#handler.state, delete, SName, normal),
+	     MSL1};
+	error ->
+	    {{error, module_not_found}, MSL}
+    end.
+
+%% server_swap_handler(Handler1, Args1, Handler2, Args2, MSL, SN)= -> MSL'
+%% server_swap_handler(Handler1, Args1, Handler2, Args2, MSL, Sup, SN)= -> MSL'
+
+server_swap_handler(Handler1, Args1, Handler2, Args2, MSL, SName) ->
+    {State2, Sup, MSL1} = split_and_terminate(Handler1, Args1, MSL,
+					      SName, Handler2, false),
+    case s_s_h(Sup, Handler2, {Args2, State2}, MSL1) of
+	{Hib, ok, MSL2} ->
+	    {Hib, ok, MSL2};
+	{Hib, What, MSL2} ->
+	    {Hib, {error, What}, MSL2}
+    end.
+
+server_swap_handler(Handler1, Args1, Handler2, Args2, MSL, Sup, SName) ->
+    {State2, _, MSL1} = split_and_terminate(Handler1, Args1, MSL,
+					    SName, Handler2, Sup),
+    case s_s_h(Sup, Handler2, {Args2, State2}, MSL1) of
+	{Hib, ok, MSL2} ->
+	    {Hib, ok, MSL2};
+	{Hib, What, MSL2} ->
+	    {Hib, {error, What}, MSL2}
+    end.
+
+s_s_h(false, Handler, Args, MSL) ->
+    server_add_handler(Handler, Args, MSL);
+s_s_h(Pid, Handler, Args, MSL) ->
+    server_add_sup_handler(Handler, Args, MSL, Pid).
+
+split_and_terminate(HandlerId, Args, MSL, SName, Handler2, Sup) ->
+    case split(HandlerId, MSL) of
+	{Mod, Handler, MSL1} ->
+	    OldSup = Handler#handler.supervised,
+	    NewSup = if
+			 not Sup -> OldSup;
+			 true    -> Sup
+		     end,
+	    {do_terminate(Mod, Handler, Args,
+			  Handler#handler.state, swapped, SName,
+			  {swapped, Handler2, NewSup}),
+	     OldSup,
+	     MSL1};
+	error ->
+            {error, false, MSL}
+    end.
+
+%% server_notify(Event, Func, MSL, SName) -> MSL'
+
+server_notify(Event, Func, [Handler|T], SName) -> 
+    case server_update(Handler, Func, Event, SName) of
+	{ok, Handler1} ->
+	    {Hib, NewHandlers} = server_notify(Event, Func, T, SName),
+	    {Hib,[Handler1|NewHandlers]};
+	{hibernate, Handler1} ->
+	    {_Hib, NewHandlers} = server_notify(Event, Func, T, SName),
+	    {true,[Handler1|NewHandlers]};
+	no ->
+	    server_notify(Event, Func, T, SName)
+    end;
+server_notify(_, _, [], _) ->
+    {false,[]}.
+
+%% server_update(Handler, Func, Event, ServerName) -> Handler1 | no
+
+server_update(Handler1, Func, Event, SName) ->
+    Mod1 = Handler1#handler.module,
+    State = Handler1#handler.state,
+    case catch Mod1:Func(Event, State) of
+	{ok, State1} -> 
+	    {ok, Handler1#handler{state = State1}};
+	{ok, State1, hibernate} -> 
+	    {hibernate, Handler1#handler{state = State1}};
+	{swap_handler, Args1, State1, Handler2, Args2} ->
+	    do_swap(Mod1,Handler1,Args1,State1,Handler2,Args2,SName);
+	remove_handler ->
+	    do_terminate(Mod1, Handler1, remove_handler, State,
+			 remove, SName, normal),
+	    no;
+	Other ->
+	    do_terminate(Mod1, Handler1, {error, Other}, State,
+			 Event, SName, crash),
+	    no
+    end.
+
+do_swap(Mod1,Handler1,Args1,State1,Handler2,Args2,SName) ->
+    %% finalise the existing handler
+    State2 = do_terminate(Mod1, Handler1, Args1, State1,
+			  swapped, SName,
+			  {swapped, Handler2, Handler1#handler.supervised}),
+    {Mod2,Handler} = new_handler(Handler2, Handler1),
+    case catch Mod2:init({Args2, State2}) of
+	{ok, State2a} ->
+	    {ok, Handler#handler{state = State2a}};
+	Other ->
+	    report_terminate(Handler2, crash, {error, Other}, SName, false),
+	    no
+    end.
+
+new_handler({Mod,Id}, Handler1) ->
+    {Mod,#handler{module = Mod,
+		  id = Id,
+		  supervised = Handler1#handler.supervised}};
+new_handler(Mod, Handler1) ->
+    {Mod,#handler{module = Mod,
+		  supervised = Handler1#handler.supervised}}.
+
+
+%% split(Handler, [#handler]) ->
+%%   {Mod, #handler, [#handler]} | error
+
+split(Ha, MSL) -> split(Ha, MSL, []).
+
+split({Mod,Id}, [Ha|T], L) when Ha#handler.module =:= Mod,
+                                Ha#handler.id =:= Id ->
+    {Mod, Ha, lists:reverse(L, T)};
+split(Mod, [Ha|T], L) when Ha#handler.module =:= Mod,
+                           not Ha#handler.id ->
+    {Mod, Ha, lists:reverse(L, T)};
+split(Ha, [H|T], L) ->
+    split(Ha, T, [H|L]);
+split(_, [], _) ->
+    error.
+
+%% server_call(Handler, Query, MSL, ServerName) ->
+%%    {Reply, MSL1}
+
+server_call(Handler, Query, MSL, SName) ->
+    case search(Handler, MSL) of
+	{ok, Ha} ->
+	    case server_call_update(Ha, Query, SName) of
+		{no, Reply} ->
+		    {false, Reply, delete(Handler, MSL)};
+		{{ok, Ha1}, Reply} ->
+		    {false, Reply, replace(Handler, MSL, Ha1)};
+		{{hibernate, Ha1}, Reply} ->
+		    {true, Reply, replace(Handler, MSL, Ha1)}
+	    end;
+	false ->
+	    {false, {error, bad_module}, MSL}
+    end.
+
+search({Mod, Id}, [Ha|_MSL]) when Ha#handler.module =:= Mod,
+				  Ha#handler.id =:= Id ->
+    {ok, Ha};
+search(Mod, [Ha|_MSL]) when Ha#handler.module =:= Mod,
+			    not Ha#handler.id ->
+    {ok, Ha};
+search(Handler, [_|MSL]) ->
+    search(Handler, MSL);
+search(_, []) ->
+    false.
+
+delete({Mod, Id}, [Ha|MSL]) when Ha#handler.module =:= Mod,
+                                 Ha#handler.id =:= Id ->
+    MSL;
+delete(Mod, [Ha|MSL]) when Ha#handler.module =:= Mod,
+                           not Ha#handler.id ->
+    MSL;
+delete(Handler, [Ha|MSL]) ->
+    [Ha|delete(Handler, MSL)];
+delete(_, []) ->
+    [].
+
+replace({Mod, Id}, [Ha|MSL], NewHa) when Ha#handler.module =:= Mod,
+                                         Ha#handler.id =:= Id ->
+    [NewHa|MSL];
+replace(Mod, [Ha|MSL], NewHa) when Ha#handler.module =:= Mod,
+                                   not Ha#handler.id ->
+    [NewHa|MSL];
+replace(Handler, [Ha|MSL], NewHa) ->
+    [Ha|replace(Handler, MSL, NewHa)];
+replace(_, [], NewHa) ->
+    [NewHa].
+
+%% server_call_update(Handler, Query, ServerName) ->
+%%    {{Handler1, State1} | no, Reply}
+
+server_call_update(Handler1, Query, SName) ->
+    Mod1 = Handler1#handler.module,
+    State = Handler1#handler.state,
+    case catch Mod1:handle_call(Query, State) of
+	{ok, Reply, State1} -> 
+	    {{ok, Handler1#handler{state = State1}}, Reply};
+	{ok, Reply, State1, hibernate} -> 
+	    {{hibernate, Handler1#handler{state = State1}}, 
+	     Reply};
+	{swap_handler, Reply, Args1, State1, Handler2, Args2} ->
+	    {do_swap(Mod1,Handler1,Args1,State1,Handler2,Args2,SName), Reply};
+	{remove_handler, Reply} -> 
+	    do_terminate(Mod1, Handler1, remove_handler, State,
+			 remove, SName, normal),
+	    {no, Reply};
+	Other ->
+	    do_terminate(Mod1, Handler1, {error, Other}, State,
+			 Query, SName, crash),
+	    {no, {error, Other}}
+end.
+
+do_terminate(Mod, Handler, Args, State, LastIn, SName, Reason) ->
+    Res = (catch Mod:terminate(Args, State)),
+    report_terminate(Handler, Reason, Args, State, LastIn, SName, Res),
+    Res.
+
+report_terminate(Handler, crash, {error, Why}, State, LastIn, SName, _) ->
+    report_terminate(Handler, Why, State, LastIn, SName);
+report_terminate(Handler, How, _, State, LastIn, SName, _) ->
+    %% How == normal | shutdown | {swapped, NewHandler, NewSupervisor}
+    report_terminate(Handler, How, State, LastIn, SName).
+
+report_terminate(Handler, Reason, State, LastIn, SName) ->
+    report_error(Handler, Reason, State, LastIn, SName),
+    case Handler#handler.supervised of
+	false ->
+	    ok;
+	Pid ->
+	    Pid ! {gen_event_EXIT,handler(Handler),Reason},
+	    ok
+    end.
+
+report_error(_Handler, normal, _, _, _)               -> ok;
+report_error(_Handler, shutdown, _, _, _)             -> ok;
+report_error(_Handler, {swapped,_,_}, _, _, _)        -> ok;
+report_error(Handler, Reason, State, LastIn, SName)   ->
+    Reason1 = 
+	case Reason of
+	    {'EXIT',{undef,[{M,F,A}|MFAs]}} ->
+		case code:is_loaded(M) of
+		    false ->
+			{'module could not be loaded',[{M,F,A}|MFAs]};
+		    _ ->
+			case erlang:function_exported(M, F, length(A)) of
+			    true ->
+				{undef,[{M,F,A}|MFAs]};
+			    false ->
+				{'function not exported',[{M,F,A}|MFAs]}
+			end
+		end;
+	    {'EXIT',Why} -> 
+		Why;
+	    _ ->            
+		Reason
+	end,
+    error_msg("** gen_event handler ~p crashed.~n"
+	      "** Was installed in ~p~n"
+	      "** Last event was: ~p~n"
+	      "** When handler state == ~p~n"
+	      "** Reason == ~p~n",
+	      [handler(Handler),SName,LastIn,State,Reason1]).
+
+handler(Handler) when not Handler#handler.id ->
+    Handler#handler.module;
+handler(Handler) ->
+    {Handler#handler.module, Handler#handler.id}.
+
+%% stop_handlers(MSL, ServerName) -> []
+
+stop_handlers([Handler|T], SName) ->
+    Mod = Handler#handler.module,
+    do_terminate(Mod, Handler, stop, Handler#handler.state,
+		 stop, SName, shutdown),
+    stop_handlers(T, SName);
+stop_handlers([], _) ->
+    [].
+
+the_handlers(MSL) ->
+    lists:map(fun(Handler) when not Handler#handler.id ->
+		      Handler#handler.module;
+		 (Handler) ->
+		      {Handler#handler.module, Handler#handler.id}
+	      end,
+	      MSL).
+
+%% Message from the release_handler.
+%% The list of modules got to be a set !
+get_modules(MSL) ->
+    Mods = lists:map(fun(Handler) -> Handler#handler.module end,
+		     MSL),
+    ordsets:to_list(ordsets:from_list(Mods)).
+
+%%-----------------------------------------------------------------
+%% Status information
+%%-----------------------------------------------------------------
+format_status(_Opt, StatusData) ->
+    [_PDict, SysState, Parent, _Debug, [ServerName, MSL, _Hib]] = StatusData,
+    Header = lists:concat(["Status for event handler ", ServerName]),
+    [{header, Header},
+     {data, [{"Status", SysState},
+	     {"Parent", Parent}]},
+     {items, {"Installed handlers", MSL}}].
+
+
+
+
+
+
diff -urNp otp_src_R12B-5/lib/stdlib/src/ms_transform.erl minimal_otp_src_R12B-5/lib/stdlib/src/ms_transform.erl
--- otp_src_R12B-5/lib/stdlib/src/ms_transform.erl	2008-02-05 13:38:01.000000000 +0000
+++ minimal_otp_src_R12B-5/lib/stdlib/src/ms_transform.erl	2009-06-23 20:40:26.000000000 +0100
@@ -769,6 +769,7 @@ translate_language_element(Atom) ->
 		{'if', "if"},
 		{'case', "case"},
 		{'receive', "receive"},
+		{'search', "search"},
 		{'try', "try"},
 		{'catch', "catch"},
 		{'match', "match (=)"},
diff -urNp otp_src_R12B-5/lib/stdlib/src/ms_transform.erl~ minimal_otp_src_R12B-5/lib/stdlib/src/ms_transform.erl~
--- otp_src_R12B-5/lib/stdlib/src/ms_transform.erl~	1970-01-01 01:00:00.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/ms_transform.erl~	2009-06-23 20:40:26.000000000 +0100
@@ -0,0 +1,986 @@
+%% ``The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved via the world wide web at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+%% AB. All Rights Reserved.''
+%% 
+%%     $Id$
+%%
+-module(ms_transform).
+
+-export([format_error/1,transform_from_shell/3,parse_transform/2]).
+
+%% Error codes.
+-define(ERROR_BASE_GUARD,0).
+-define(ERROR_BASE_BODY,100).
+-define(ERR_NOFUN,1).
+-define(ERR_ETS_HEAD,2).
+-define(ERR_DBG_HEAD,3).
+-define(ERR_HEADMATCH,4).
+-define(ERR_SEMI_GUARD,5).
+-define(ERR_UNBOUND_VARIABLE,6).
+-define(ERR_HEADBADREC,7).
+-define(ERR_HEADBADFIELD,8).
+-define(ERR_HEADMULTIFIELD,9).
+-define(ERR_HEADDOLLARATOM,10).
+-define(ERR_HEADBINMATCH,11).
+-define(ERR_GENMATCH,16).
+-define(ERR_GENLOCALCALL,17).
+-define(ERR_GENELEMENT,18).
+-define(ERR_GENBADFIELD,19).
+-define(ERR_GENBADREC,20).
+-define(ERR_GENMULTIFIELD,21).
+-define(ERR_GENREMOTECALL,22).
+-define(ERR_GENBINCONSTRUCT,23).
+-define(ERR_GENDISALLOWEDOP,24).
+-define(ERR_GUARDMATCH,?ERR_GENMATCH+?ERROR_BASE_GUARD).
+-define(ERR_BODYMATCH,?ERR_GENMATCH+?ERROR_BASE_BODY).
+-define(ERR_GUARDLOCALCALL,?ERR_GENLOCALCALL+?ERROR_BASE_GUARD).
+-define(ERR_BODYLOCALCALL,?ERR_GENLOCALCALL+?ERROR_BASE_BODY).
+-define(ERR_GUARDELEMENT,?ERR_GENELEMENT+?ERROR_BASE_GUARD).
+-define(ERR_BODYELEMENT,?ERR_GENELEMENT+?ERROR_BASE_BODY).
+-define(ERR_GUARDBADFIELD,?ERR_GENBADFIELD+?ERROR_BASE_GUARD).
+-define(ERR_BODYBADFIELD,?ERR_GENBADFIELD+?ERROR_BASE_BODY).
+-define(ERR_GUARDBADREC,?ERR_GENBADREC+?ERROR_BASE_GUARD).
+-define(ERR_BODYBADREC,?ERR_GENBADREC+?ERROR_BASE_BODY).
+-define(ERR_GUARDMULTIFIELD,?ERR_GENMULTIFIELD+?ERROR_BASE_GUARD).
+-define(ERR_BODYMULTIFIELD,?ERR_GENMULTIFIELD+?ERROR_BASE_BODY).
+-define(ERR_GUARDREMOTECALL,?ERR_GENREMOTECALL+?ERROR_BASE_GUARD).
+-define(ERR_BODYREMOTECALL,?ERR_GENREMOTECALL+?ERROR_BASE_BODY).
+-define(ERR_GUARDBINCONSTRUCT,?ERR_GENBINCONSTRUCT+?ERROR_BASE_GUARD).
+-define(ERR_BODYBINCONSTRUCT,?ERR_GENBINCONSTRUCT+?ERROR_BASE_BODY).
+-define(ERR_GUARDDISALLOWEDOP,?ERR_GENDISALLOWEDOP+?ERROR_BASE_GUARD).
+-define(ERR_BODYDISALLOWEDOP,?ERR_GENDISALLOWEDOP+?ERROR_BASE_BODY).
+
+%%
+%% Called by compiler or ets/dbg:fun2ms when errors occur
+%%
+format_error(?ERR_NOFUN) ->	    
+    "Parameter of ets/dbg:fun2ms/1 is not a literal fun";
+format_error(?ERR_ETS_HEAD) ->	    
+    "ets:fun2ms requires fun with single variable or tuple parameter";
+format_error(?ERR_DBG_HEAD) ->	    
+    "dbg:fun2ms requires fun with single variable or list parameter";
+format_error(?ERR_HEADMATCH) ->	    
+    "in fun head, only matching (=) on toplevel can be translated into match_spec";
+format_error(?ERR_SEMI_GUARD) ->	    
+    "fun with semicolon (;) in guard cannot be translated into match_spec";
+format_error(?ERR_GUARDMATCH) ->	    
+    "fun with guard matching ('=' in guard) is illegal as match_spec as well";
+format_error({?ERR_GUARDLOCALCALL, Name, Arithy}) ->	    
+    lists:flatten(io_lib:format("fun containing the local function call "
+				"'~w/~w' (called in guard) "
+				"cannot be translated into match_spec",
+				[Name, Arithy]));
+format_error({?ERR_GUARDREMOTECALL, Module, Name, Arithy}) ->	    
+    lists:flatten(io_lib:format("fun containing the remote function call "
+				"'~w:~w/~w' (called in guard) "
+				"cannot be translated into match_spec",
+				[Module,Name,Arithy]));
+format_error({?ERR_GUARDELEMENT, Str}) ->
+    lists:flatten(
+      io_lib:format("the language element ~s (in guard) cannot be translated "
+		    "into match_spec", [Str]));
+format_error({?ERR_GUARDBINCONSTRUCT, Var}) ->
+    lists:flatten(
+      io_lib:format("bit syntax construction with variable ~w (in guard) "
+		    "cannot be translated "
+		    "into match_spec", [Var]));
+format_error({?ERR_GUARDDISALLOWEDOP, Operator}) ->
+    %% There is presently no operators that are allowed in bodies but
+    %% not in guards.
+    lists:flatten(
+      io_lib:format("the operator ~w is not allowed in guards", [Operator]));
+format_error(?ERR_BODYMATCH) ->	    
+    "fun with body matching ('=' in body) is illegal as match_spec";
+format_error({?ERR_BODYLOCALCALL, Name, Arithy}) ->	    
+    lists:flatten(io_lib:format("fun containing the local function "
+				"call '~w/~w' (called in body) "
+				"cannot be translated into match_spec",
+				[Name,Arithy]));
+format_error({?ERR_BODYREMOTECALL, Module, Name, Arithy}) ->	    
+    lists:flatten(io_lib:format("fun containing the remote function call "
+				"'~w:~w/~w' (called in body) "
+				"cannot be translated into match_spec",
+				[Module,Name,Arithy]));
+format_error({?ERR_BODYELEMENT, Str}) ->
+    lists:flatten(
+      io_lib:format("the language element ~s (in body) cannot be translated "
+		    "into match_spec", [Str]));
+format_error({?ERR_BODYBINCONSTRUCT, Var}) ->
+    lists:flatten(
+      io_lib:format("bit syntax construction with variable ~w (in body) "
+		    "cannot be translated "
+		    "into match_spec", [Var]));
+format_error({?ERR_BODYDISALLOWEDOP, Operator}) -> 
+    %% This will probably never happen, Are there op's that are allowed in 
+    %% guards but not in bodies? Not at time of writing anyway...
+    lists:flatten(
+      io_lib:format("the operator ~w is not allowed in function bodies", 
+		    [Operator]));
+
+format_error({?ERR_UNBOUND_VARIABLE, Str}) ->
+    lists:flatten(
+      io_lib:format("the variable ~s is unbound, cannot translate "
+		    "into match_spec", [Str]));
+format_error({?ERR_HEADBADREC,Name}) ->	    
+    lists:flatten(
+      io_lib:format("fun head contains unknown record type ~w",[Name]));
+format_error({?ERR_HEADBADFIELD,RName,FName}) ->	    
+    lists:flatten(
+      io_lib:format("fun head contains reference to unknown field ~w in "
+		    "record type ~w",[FName, RName]));
+format_error({?ERR_HEADMULTIFIELD,RName,FName}) ->	    
+    lists:flatten(
+      io_lib:format("fun head contains already defined field ~w in "
+		    "record type ~w",[FName, RName]));
+format_error({?ERR_HEADDOLLARATOM,Atom}) ->	    
+    lists:flatten(
+      io_lib:format("fun head contains atom ~w, which conflics with reserved "
+		    "atoms in match_spec heads",[Atom]));
+format_error({?ERR_HEADBINMATCH,Atom}) ->	    
+    lists:flatten(
+      io_lib:format("fun head contains bit syntax matching of variable ~w, "
+		    "which cannot be translated into match_spec", [Atom]));
+format_error({?ERR_GUARDBADREC,Name}) ->	    
+    lists:flatten(
+      io_lib:format("fun guard contains unknown record type ~w",[Name]));
+format_error({?ERR_GUARDBADFIELD,RName,FName}) ->	    
+    lists:flatten(
+      io_lib:format("fun guard contains reference to unknown field ~w in "
+		    "record type ~w",[FName, RName]));
+format_error({?ERR_GUARDMULTIFIELD,RName,FName}) ->	    
+    lists:flatten(
+      io_lib:format("fun guard contains already defined field ~w in "
+		    "record type ~w",[FName, RName]));
+format_error({?ERR_BODYBADREC,Name}) ->	    
+    lists:flatten(
+      io_lib:format("fun body contains unknown record type ~w",[Name]));
+format_error({?ERR_BODYBADFIELD,RName,FName}) ->	    
+    lists:flatten(
+      io_lib:format("fun body contains reference to unknown field ~w in "
+		    "record type ~w",[FName, RName]));
+format_error({?ERR_BODYMULTIFIELD,RName,FName}) ->	    
+    lists:flatten(
+      io_lib:format("fun body contains already defined field ~w in "
+		    "record type ~w",[FName, RName]));
+format_error(Else) ->
+    lists:flatten(io_lib:format("Unknown error code ~w",[Else])).
+
+%%
+%% Called when translating in shell
+%%
+transform_from_shell(Dialect, Clauses, BoundEnvironment) ->
+    SaveFilename = setup_filename(),
+    case catch ms_clause_list(1,Clauses,Dialect) of
+	{'EXIT',Reason} ->
+	    cleanup_filename(SaveFilename),
+	    exit(Reason);
+	{error,Line,R} ->
+	    {error, [{cleanup_filename(SaveFilename),
+		      [{Line, ?MODULE, R}]}], []};
+	Else ->
+            case (catch fixup_environment(Else,BoundEnvironment)) of
+                {error,Line1,R1} ->
+                    {error, [{cleanup_filename(SaveFilename),
+                             [{Line1, ?MODULE, R1}]}], []}; 
+                Else1 ->
+		    Ret = normalise(Else1),
+                    cleanup_filename(SaveFilename),
+		    Ret
+            end
+    end.
+    
+
+%%
+%% Called when translating during compiling
+%%
+parse_transform(Forms, _Options) ->
+    SaveFilename = setup_filename(),
+    case catch forms(Forms) of
+	{'EXIT',Reason} ->
+	    cleanup_filename(SaveFilename),
+	    exit(Reason);
+	{error,Line,R} ->
+	    {error, [{cleanup_filename(SaveFilename),
+		      [{Line, ?MODULE, R}]}], []};
+	Else ->
+	    cleanup_filename(SaveFilename),
+	    Else
+    end.
+
+setup_filename() ->
+    {erase(filename),erase(records)}.
+
+put_filename(Name) ->
+    put(filename,Name).
+
+put_records(R) ->
+    put(records,R),
+    ok.
+get_records() ->
+    case get(records) of
+	undefined ->
+	    [];
+	Else ->
+	    Else
+    end.
+cleanup_filename({Old,OldRec}) ->
+    Ret = case erase(filename) of
+	      undefined ->
+		  "TOP_LEVEL";
+	      X ->
+		  X
+	  end,
+    case OldRec of
+	undefined ->
+	    erase(records);
+	Rec ->
+	    put(records,Rec)
+    end,
+    case Old of
+	undefined ->
+	    Ret;
+	Y ->
+	    put(filename,Y),
+	    Ret
+    end.
+
+add_record_definition({Name,FieldList}) ->
+    {KeyList,_} = lists:foldl(
+		    fun({record_field,_,{atom,Line0,FieldName}},{L,C}) ->
+			    {[{FieldName,C,{atom,Line0,undefined}}|L],C+1};
+		       ({record_field,_,{atom,_,FieldName},Def},{L,C}) ->
+			    {[{FieldName,C,Def}|L],C+1}
+		    end,
+		    {[],2},
+		    FieldList),
+    put_records([{Name,KeyList}|get_records()]).
+
+forms([F0|Fs0]) ->
+    F1 = form(F0),
+    Fs1 = forms(Fs0),
+    [F1|Fs1];
+forms([]) -> [].
+
+form({attribute,_,file,{Filename,_}}=Form) ->
+    put_filename(Filename),
+    Form;
+form({attribute,_,record,Definition}=Form) -> 
+    add_record_definition(Definition),
+    Form;
+form({function,Line,Name0,Arity0,Clauses0}) ->
+    {Name,Arity,Clauses} = function(Name0, Arity0, Clauses0),
+    {function,Line,Name,Arity,Clauses};
+form(AnyOther) ->
+    AnyOther.
+function(Name, Arity, Clauses0) ->
+    Clauses1 = clauses(Clauses0),
+    {Name,Arity,Clauses1}.
+clauses([C0|Cs]) ->
+    C1 = clause(C0),
+    [C1|clauses(Cs)];
+clauses([]) -> [].
+clause({clause,Line,H0,G0,B0}) ->
+    B1 = copy(B0),
+    {clause,Line,H0,G0,B1}.
+
+copy({call,Line,{remote,_Line2,{atom,_Line3,ets},{atom,_Line4,fun2ms}},
+      As0}) ->
+    transform_call(ets,Line,As0);
+copy({call,Line,{remote,_Line2,{record_field,_Line3,
+                                {atom,_Line4,''},{atom,_Line5,ets}},
+                 {atom,_Line6,fun2ms}}, As0}) ->
+    %% Packages...
+    transform_call(ets,Line,As0);
+copy({call,Line,{remote,_Line2,{atom,_Line3,dbg},{atom,_Line4,fun2ms}},
+      As0}) ->
+    transform_call(dbg,Line,As0);
+copy(T) when is_tuple(T) ->
+    list_to_tuple(copy_list(tuple_to_list(T)));
+copy(L) when is_list(L) ->
+    copy_list(L);
+copy(AnyOther) ->
+    AnyOther.
+
+copy_list([H|T]) ->
+    [copy(H)|copy_list(T)];
+copy_list([]) ->
+    [].
+
+transform_call(Type,_Line,[{'fun',Line2,{clauses, ClauseList}}]) ->
+    ms_clause_list(Line2, ClauseList,Type);
+transform_call(_Type,Line,_NoAbstractFun) ->
+    throw({error,Line,?ERR_NOFUN}).
+
+% Fixup semicolons in guards
+ms_clause_expand({clause, Line, Parameters, Guard = [_,_|_], Body}) ->
+    [ {clause, Line, Parameters, [X], Body} || X <- Guard ];
+ms_clause_expand(_Other) ->
+    false.
+
+ms_clause_list(Line,[H|T],Type) ->
+    case ms_clause_expand(H) of
+	NewHead when is_list(NewHead) ->
+	    ms_clause_list(Line,NewHead ++ T, Type);
+	false ->
+	    {cons, Line, ms_clause(H,Type), ms_clause_list(Line, T,Type)}
+    end;
+ms_clause_list(Line,[],_) ->
+    {nil,Line}.
+ms_clause({clause, Line, Parameters, Guards, Body},Type) ->
+    check_type(Line,Parameters,Type),
+    {MSHead,Bindings} = transform_head(Parameters),
+    MSGuards = transform_guards(Line, Guards, Bindings),
+    MSBody = transform_body(Line,Body,Bindings),
+    {tuple, Line, [MSHead,MSGuards,MSBody]}.
+
+
+check_type(_,[{var,_,_}],_) ->
+    ok;
+check_type(_,[{tuple,_,_}],ets) ->
+    ok;
+check_type(_,[{record,_,_,_}],ets) ->
+    ok;
+check_type(_,[{cons,_,_,_}],dbg) ->
+    ok;
+check_type(Line0,[{match,_,{var,_,_},X}],Any) ->
+    check_type(Line0,[X],Any);
+check_type(Line0,[{match,_,X,{var,_,_}}],Any) ->
+    check_type(Line0,[X],Any);
+check_type(Line,_Type,ets) ->
+    throw({error,Line,?ERR_ETS_HEAD});
+check_type(Line,_,dbg) ->
+    throw({error,Line,?ERR_DBG_HEAD}).
+
+-record(tgd,{ b, %Bindings 
+	      p, %Part of spec
+	      eb %Error code base, 0 for guards, 100 for bodies
+	     }).
+
+transform_guards(Line,[],_Bindings) ->
+    {nil,Line};
+transform_guards(Line,[G],Bindings) ->
+    B = #tgd{b = Bindings, p = guard, eb = ?ERROR_BASE_GUARD},
+    tg0(Line,G,B);
+transform_guards(Line,_,_) ->
+    throw({error,Line,?ERR_SEMI_GUARD}).
+    
+transform_body(Line,Body,Bindings) ->
+    B = #tgd{b = Bindings, p = body, eb = ?ERROR_BASE_BODY},
+    tg0(Line,Body,B).
+    
+
+guard_top_trans({call,Line0,{atom,Line1,OldTest},Params}) ->
+    case old_bool_test(OldTest,length(Params)) of
+	undefined ->
+	    {call,Line0,{atom,Line1,OldTest},Params};
+	Trans ->
+	    {call,Line0,{atom,Line1,Trans},Params}
+    end;
+guard_top_trans(Else) ->
+    Else.
+
+tg0(Line,[],_) ->
+    {nil,Line};
+tg0(Line,[H0|T],B) when B#tgd.p =:= guard ->
+    H = guard_top_trans(H0),
+    {cons,Line, tg(H,B), tg0(Line,T,B)};
+tg0(Line,[H|T],B) ->
+    {cons,Line, tg(H,B), tg0(Line,T,B)}.
+    
+
+tg({match,Line,_,_},B) -> 
+    throw({error,Line,?ERR_GENMATCH+B#tgd.eb});
+tg({op, Line, Operator, O1, O2}, B) ->
+    {tuple, Line, [{atom, Line, Operator}, tg(O1,B), tg(O2,B)]};
+tg({op, Line, Operator, O1}, B) ->
+    {tuple, Line, [{atom, Line, Operator}, tg(O1,B)]};
+tg({call, _Line, {atom, Line2, bindings},[]},_B) ->
+    	    {atom, Line2, '$*'};
+tg({call, _Line, {atom, Line2, object},[]},_B) ->
+    	    {atom, Line2, '$_'};
+tg({call, Line, {atom, _, is_record}=Call,[Object, {atom,Line3,RName}=R]},B) ->
+    MSObject = tg(Object,B),
+    RDefs = get_records(),
+    case lists:keysearch(RName,1,RDefs) of
+	{value, {RName, FieldList}} ->
+	    RSize = length(FieldList)+1,
+	    {tuple, Line, [Call, MSObject, R, {integer, Line3, RSize}]};
+	_ ->
+	    throw({error,Line3,{?ERR_GENBADREC+B#tgd.eb,RName}})
+    end;
+tg({call, Line, {atom, Line2, FunName},ParaList},B) ->
+    case is_ms_function(FunName,length(ParaList), B#tgd.p) of
+	true ->
+	    {tuple, Line, [{atom, Line2, FunName} | 
+			   lists:map(fun(X) -> tg(X,B) end, ParaList)]};
+	_ ->
+	    throw({error,Line,{?ERR_GENLOCALCALL+B#tgd.eb,
+			       FunName,length(ParaList)}}) 
+    end;
+tg({call, Line, {remote,_,{atom,_,erlang},{atom, Line2, FunName}},ParaList},
+   B) ->
+    L = length(ParaList),
+    case is_imported_from_erlang(FunName,L,B#tgd.p) of
+	true ->
+	    case is_operator(FunName,L,B#tgd.p) of
+		false ->
+		    tg({call, Line, {atom, Line2, FunName},ParaList},B);
+		true ->
+		    tg(list_to_tuple([op,Line2,FunName | ParaList]),B)
+		end;
+	_ ->
+	    throw({error,Line,{?ERR_GENREMOTECALL+B#tgd.eb,erlang,
+			       FunName,length(ParaList)}}) 
+    end;
+tg({call, Line, {remote,_,{atom,_,ModuleName},
+		 {atom, _, FunName}},_ParaList},B) ->
+    throw({error,Line,{?ERR_GENREMOTECALL+B#tgd.eb,ModuleName,FunName}});
+tg({cons,Line, H, T},B) -> 
+    {cons, Line, tg(H,B), tg(T,B)};
+tg({nil, Line},_B) ->
+    {nil, Line};
+tg({tuple,Line,L},B) ->
+    {tuple,Line,[{tuple,Line,lists:map(fun(X) -> tg(X,B) end, L)}]};
+tg({integer,Line,I},_) ->
+    {integer,Line,I};
+tg({char,Line,C},_) ->
+    {char,Line,C};
+tg({float, Line,F},_) ->
+    {float,Line,F};
+tg({atom,Line,A},_) ->
+    case atom_to_list(A) of
+	[$$|_] ->
+	   {tuple, Line,[{atom, Line, 'const'},{atom,Line,A}]};
+	_ ->
+	    {atom,Line,A}
+    end;
+tg({string,Line,S},_) ->
+    {string,Line,S};
+tg({var,Line,VarName},B) ->
+    case lkup_bind(VarName, B#tgd.b) of
+	undefined ->
+	    {tuple, Line,[{atom, Line, 'const'},{var,Line,VarName}]};
+	AtomName ->
+	    {atom, Line, AtomName}
+    end;
+tg({record_field,Line,Object,RName,{atom,_Line1,KeyName}},B) ->
+    RDefs = get_records(),
+    case lists:keysearch(RName,1,RDefs) of
+	{value, {RName, FieldList}} ->
+	    case lists:keysearch(KeyName,1, FieldList) of
+		{value, {KeyName,Position,_}} ->
+		    NewObject = tg(Object,B),
+		    {tuple, Line, [{atom, Line, 'element'}, 
+				   {integer, Line, Position}, NewObject]};
+		_ ->
+		    throw({error,Line,{?ERR_GENBADFIELD+B#tgd.eb, RName, 
+				       KeyName}})
+	    end;
+	_ ->
+	    throw({error,Line,{?ERR_GENBADREC+B#tgd.eb,RName}})
+    end;
+
+tg({record,Line,RName,RFields},B) ->
+    RDefs = get_records(),
+    KeyList0 = lists:foldl(fun({record_field,_,{atom,_,Key},Value},
+				     L) ->
+					 NV = tg(Value,B),
+					 [{Key,NV}|L];
+				    ({record_field,_,{var,_,'_'},Value},
+				     L) ->
+					 NV = tg(Value,B),
+					 [{{default},NV}|L];
+				    (_,_) ->
+					 throw({error,Line,
+						{?ERR_GENBADREC+B#tgd.eb,
+						 RName}})
+				 end,
+				 [],
+				 RFields),
+    DefValue = case lists:keysearch({default},1,KeyList0) of
+		   {value,{{default},OverriddenDefValue}} ->
+		       {true,OverriddenDefValue};
+		   _ ->
+		       false
+	       end,
+    KeyList = lists:keydelete({default},1,KeyList0),
+    case lists:keysearch({default},1,KeyList) of
+	{value,{{default},_}} ->
+	    throw({error,Line,{?ERR_GENMULTIFIELD+B#tgd.eb,RName,'_'}});
+	_ ->
+	    ok
+    end,
+    case lists:keysearch(RName,1,RDefs) of
+	{value, {RName, FieldList0}} ->
+	    FieldList1 = lists:foldl(
+			   fun({FN,_,Def},Acc) ->
+				   El = case lists:keysearch(FN,1,KeyList) of
+					    {value, {FN, X0}} ->
+						X0;
+					    _ ->
+						case DefValue of 
+						    {true,Overridden} ->
+							Overridden;
+						    false ->
+							Def
+						end
+					end,
+				   [El | Acc]
+			   end,
+			   [],
+			   FieldList0),
+	    check_multi_field(RName,Line,KeyList,
+				 ?ERR_GENMULTIFIELD+B#tgd.eb),
+	    check_undef_field(RName,Line,KeyList,FieldList0,
+			      ?ERR_GENBADFIELD+B#tgd.eb),
+	    {tuple,Line,[{tuple,Line,[{atom,Line,RName}|FieldList1]}]};
+	_ ->
+	    throw({error,Line,{?ERR_GENBADREC+B#tgd.eb,RName}})
+    end;
+
+tg({record_index,Line,RName,{atom,Line2,KeyName}},B) ->
+    RDefs = get_records(), 
+    case lists:keysearch(RName,1,RDefs) of
+	{value, {RName, FieldList}} ->
+	    case lists:keysearch(KeyName,1, FieldList) of
+		{value, {KeyName,Position,_}} ->
+		    {integer, Line2, Position};
+		_ ->
+		    throw({error,Line2,{?ERR_GENBADFIELD+B#tgd.eb, RName, 
+				       KeyName}})
+	    end;
+	_ ->
+	    throw({error,Line,{?ERR_GENBADREC+B#tgd.eb,RName}})
+    end;
+
+tg({record,Line,{var,Line2,_VName}=AVName, RName,RFields},B) ->
+    RDefs = get_records(),
+    MSVName = tg(AVName,B),
+    KeyList = lists:foldl(fun({record_field,_,{atom,_,Key},Value},
+				     L) ->
+					 NV = tg(Value,B),
+					 [{Key,NV}|L];
+				    (_,_) ->
+					 throw({error,Line,?ERR_HEADBADREC})
+				 end,
+				 [],
+				 RFields),
+    case lists:keysearch(RName,1,RDefs) of
+	{value, {RName, FieldList0}} ->
+	    FieldList1 = lists:foldl(
+			   fun({FN,Pos,_},Acc) ->
+				   El = case lists:keysearch(FN,1,KeyList) of
+					    {value, {FN, X0}} ->
+						X0;
+					    _ ->
+						{tuple, Line2, 
+						 [{atom, Line2, element},
+						  {integer, Line2, Pos},
+						  MSVName]}
+					end,
+				   [El | Acc]
+			   end,
+			   [],
+			   FieldList0),
+	    check_multi_field(RName,Line,KeyList,
+				 ?ERR_GENMULTIFIELD+B#tgd.eb),
+	    check_undef_field(RName,Line,KeyList,FieldList0,
+			      ?ERR_GENBADFIELD+B#tgd.eb),
+	    {tuple,Line,[{tuple,Line,[{atom,Line,RName}|FieldList1]}]};
+	_ ->
+	    throw({error,Line,{?ERR_GENBADREC+B#tgd.eb,RName}})
+    end;
+
+tg({bin_element,_Line0,{var, Line, A},_,_} = Whole,B) ->
+    case lkup_bind(A, B#tgd.b) of
+	undefined ->
+	    Whole; % exists in environment hopefully
+	_AtomName ->
+	    throw({error,Line,{?ERR_GENBINCONSTRUCT+B#tgd.eb,A}})
+    end;    
+tg(default,_B) ->
+    default;
+tg({bin_element,Line,X,Y,Z},B) ->
+    {bin_element, Line, tg(X,B), tg(Y,B), Z};
+
+tg({bin,Line,List},B) ->
+    {bin,Line,[tg(X,B) || X <- List]};
+    
+tg(T,B) when is_tuple(T), tuple_size(T) >= 2 ->
+    Element = element(1,T),
+    Line = element(2,T),
+    throw({error,Line,{?ERR_GENELEMENT+B#tgd.eb,
+		       translate_language_element(Element)}}); 
+tg(Other,B) ->
+    Element = io_lib:format("unknown element ~w", [Other]),
+    throw({error,unknown,{?ERR_GENELEMENT+B#tgd.eb,Element}}).
+
+transform_head([V]) ->
+    Bind = cre_bind(),
+    {NewV,NewBind} = toplevel_head_match(V,Bind),
+    th(NewV,NewBind).
+
+
+toplevel_head_match({match,_,{var,_,VName},Expr},B) ->
+    {Expr,new_bind({VName,'$_'},B)};
+toplevel_head_match({match,_,Expr,{var,_,VName}},B) ->
+    {Expr,new_bind({VName,'$_'},B)};
+toplevel_head_match(Other,B) ->
+    {Other,B}.
+
+th({record,Line,RName,RFields},B) ->
+    % youch...
+    RDefs = get_records(),
+    {KeyList0,NewB} = lists:foldl(fun({record_field,_,{atom,_,Key},Value},
+				     {L,B0}) ->
+					 {NV,B1} = th(Value,B0),
+					 {[{Key,NV}|L],B1};
+				    ({record_field,_,{var,_,'_'},Value},
+				     {L,B0}) ->
+					 {NV,B1} = th(Value,B0),
+					 {[{{default},NV}|L],B1};
+				    (_,_) ->
+					 throw({error,Line,{?ERR_HEADBADREC,
+							    RName}})
+				 end,
+				 {[],B},
+				 RFields),
+    DefValue = case lists:keysearch({default},1,KeyList0) of
+		   {value,{{default},OverriddenDefValue}} ->
+		       OverriddenDefValue;
+		   _ ->
+		       {atom,Line,'_'}
+	       end,
+    KeyList = lists:keydelete({default},1,KeyList0),
+    case lists:keysearch({default},1,KeyList) of
+	{value,{{default},_}} ->
+	    throw({error,Line,{?ERR_HEADMULTIFIELD,RName,'_'}});
+	_ ->
+	    ok
+    end,
+    case lists:keysearch(RName,1,RDefs) of
+	{value, {RName, FieldList0}} ->
+	    FieldList1 = lists:foldl(
+			   fun({FN,_,_},Acc) ->
+				   El = case lists:keysearch(FN,1,KeyList) of
+					    {value, {FN, X0}} ->
+						X0;
+					    _ ->
+						DefValue
+					end,
+				   [El | Acc]
+			   end,
+			   [],
+			   FieldList0),
+	    check_multi_field(RName,Line,KeyList,
+				 ?ERR_HEADMULTIFIELD),
+	    check_undef_field(RName,Line,KeyList,FieldList0,
+			      ?ERR_HEADBADFIELD),
+	    {{tuple,Line,[{atom,Line,RName}|FieldList1]},NewB};
+	_ ->
+	    throw({error,Line,{?ERR_HEADBADREC,RName}})
+    end;
+
+th({match,Line,_,_},_) -> 
+    throw({error,Line,?ERR_HEADMATCH});
+th({atom,Line,A},B) ->
+    case atom_to_list(A) of
+	[$$|NL] ->
+	    case (catch list_to_integer(NL)) of
+		N when is_integer(N) ->
+		    throw({error,Line,{?ERR_HEADDOLLARATOM,A}});
+		_ ->
+		    {{atom,Line,A},B}
+	    end;
+	_ ->
+	    {{atom,Line,A},B}
+    end;
+th({bin_element,_Line0,{var, Line, A},_,_},_) ->
+    throw({error,Line,{?ERR_HEADBINMATCH,A}});
+
+th({var,Line,Name},B) ->
+    case lkup_bind(Name,B) of
+	undefined ->
+	    NewB = new_bind(Name,B),
+	    {{atom,Line,lkup_bind(Name,NewB)},NewB};
+	Trans ->
+	    {{atom,Line,Trans},B}
+    end;
+th([H|T],B) ->
+    {NH,NB} = th(H,B),
+    {NT,NNB} = th(T,NB),
+    {[NH|NT],NNB};
+th(T,B) when is_tuple(T) ->
+    {L,NB} = th(tuple_to_list(T),B),
+    {list_to_tuple(L),NB};
+th(Nonstruct,B) ->
+    {Nonstruct,B}.
+% Could be more efficient...
+check_multi_field(_,_,[],_) ->
+    ok;
+check_multi_field(RName, Line, [{Key,_}|T], ErrCode) ->
+    case lists:keysearch(Key,1,T) of
+	{value,_} ->
+	    throw({error,Line,{ErrCode,RName,Key}});
+	_ ->
+	    check_multi_field(RName, Line, T, ErrCode)
+    end.
+check_undef_field(_,_,[],_,_) ->
+    ok;
+check_undef_field(RName, Line, [{Key,_}|T], FieldList, ErrCode) ->
+    case lists:keysearch(Key,1,FieldList) of
+	{value,_} ->
+	    check_undef_field(RName, Line, T, FieldList, ErrCode); 
+	_ ->
+	    throw({error,Line,{ErrCode,RName,Key}})
+    end.
+
+cre_bind() ->
+    {1,[{'_','_'}]}.
+lkup_bind(Name,{_,List}) ->
+    case lists:keysearch(Name,1,List) of
+	{value, {Name, Trans}} ->
+	    Trans;
+	_ ->
+	    undefined
+    end.
+new_bind({Name,Trans},{Next,L}) ->
+    {Next,[{Name,Trans}|L]};
+new_bind(Name,{Next,L}) ->
+    Trans = list_to_atom([$$|integer_to_list(Next)]),
+    {Next+1,[{Name,Trans}|L]}.
+
+translate_language_element(Atom) ->
+    Transtab = [
+		{lc,"list comprehension"},
+		{bc,"binary comprehension"},
+		{block, "begin/end block"},
+		{'if', "if"},
+		{'case', "case"},
+		{'receive', "receive"},
+		{'try', "try"},
+		{'catch', "catch"},
+		{'match', "match (=)"},
+		{remote, "external function call"}
+	       ],
+    case lists:keysearch(Atom,1,Transtab) of
+	{value,{Atom, String}} ->
+	    String;
+	_ ->
+	    atom_to_list(Atom)
+    end.
+
+old_bool_test(atom,1) -> is_atom;
+old_bool_test(constant,1) -> is_constant;
+old_bool_test(float,1) -> is_float;
+old_bool_test(integer,1) -> is_integer;
+old_bool_test(list,1) -> is_list;
+old_bool_test(number,1) -> is_number;
+old_bool_test(pid,1) -> is_pid;
+old_bool_test(port,1) -> is_port;
+old_bool_test(reference,1) -> is_reference;
+old_bool_test(tuple,1) -> is_tuple;
+old_bool_test(binary,1) -> is_binary;
+old_bool_test(function,1) -> is_function;
+old_bool_test(record,2) -> is_record;
+old_bool_test(_,_) -> undefined.
+
+bool_test(is_atom,1) -> true;
+bool_test(is_constant,1) -> true;
+bool_test(is_float,1) -> true;
+bool_test(is_integer,1) -> true;
+bool_test(is_list,1) -> true;
+bool_test(is_number,1) -> true;
+bool_test(is_pid,1) -> true;
+bool_test(is_port,1) -> true;
+bool_test(is_reference,1) -> true;
+bool_test(is_tuple,1) -> true;
+bool_test(is_binary,1) -> true;
+bool_test(is_function,1) -> true;
+bool_test(is_record,2) -> true;
+bool_test(is_seq_trace,0) -> true;
+bool_test(_,_) -> false.
+
+real_guard_function(abs,1) -> true;
+real_guard_function(element,2) -> true;
+real_guard_function(hd,1) -> true;
+real_guard_function(length,1) -> true;
+real_guard_function(node,0) -> true;
+real_guard_function(node,1) -> true;
+real_guard_function(round,1) -> true;
+real_guard_function(size,1) -> true;
+real_guard_function(tl,1) -> true;
+real_guard_function(trunc,1) -> true;
+real_guard_function(self,0) -> true;
+real_guard_function(float,1) -> true;
+real_guard_function(_,_) -> false.
+
+pseudo_guard_function(get_tcw,0) -> true;
+pseudo_guard_function(_,_) -> false.
+
+guard_function(X,A) ->
+    real_guard_function(X,A) or pseudo_guard_function(X,A).
+
+action_function(set_seq_token,2) -> true;
+action_function(get_seq_token,0) -> true;
+action_function(message,1) -> true;
+action_function(return_trace,0) -> true;
+action_function(process_dump,0) -> true;
+action_function(enable_trace,1) -> true;
+action_function(enable_trace,2) -> true;
+action_function(disable_trace,1) -> true;
+action_function(disable_trace,2) -> true;
+action_function(display,1) -> true;
+action_function(caller,0) -> true;
+action_function(set_tcw,1) -> true;
+action_function(silent,1) -> true;
+action_function(_,_) -> false.
+
+bool_operator('and',2) ->
+    true;
+bool_operator('or',2) ->
+    true;
+bool_operator('xor',2) ->
+    true;
+bool_operator('not',1) ->
+    true;
+bool_operator('andalso',2) ->
+    true;
+bool_operator('orelse',2) ->
+    true;
+bool_operator(_,_) ->
+    false.
+
+arith_operator('+',1) ->
+    true;
+arith_operator('+',2) ->
+    true;
+arith_operator('-',1) ->
+    true;
+arith_operator('-',2) ->
+    true;
+arith_operator('*',2) ->
+    true;
+arith_operator('/',2) ->
+    true;
+arith_operator('div',2) ->
+    true;
+arith_operator('rem',2) ->
+    true;
+arith_operator('band',2) ->
+    true;
+arith_operator('bor',2) ->
+    true;
+arith_operator('bxor',2) ->
+    true;
+arith_operator('bnot',1) ->
+    true;
+arith_operator('bsl',2) ->
+    true;
+arith_operator('bsr',2) ->
+    true;
+arith_operator(_,_) ->
+    false.
+
+cmp_operator('>',2) ->
+    true;
+cmp_operator('>=',2) ->
+    true;
+cmp_operator('<',2) ->
+    true;
+cmp_operator('=<',2) ->
+    true;
+cmp_operator('==',2) ->
+    true;
+cmp_operator('=:=',2) ->
+    true;
+cmp_operator('/=',2) -> 
+    true;
+cmp_operator('=/=',2) ->
+    true;
+cmp_operator(_,_) ->
+    false.
+
+is_operator(X,A,_) ->
+    bool_operator(X,A) or arith_operator(X,A) or cmp_operator(X,A).
+
+is_imported_from_erlang(X,A,_) ->
+    real_guard_function(X,A) or bool_test(X,A) or bool_operator(X,A) or
+    arith_operator(X,A) or cmp_operator(X,A).
+
+is_ms_function(X,A,body) ->
+    action_function(X,A) or guard_function(X,A) or bool_test(X,A);
+
+is_ms_function(X,A,guard) ->
+    guard_function(X,A) or bool_test(X,A).
+
+fixup_environment(L,B) when is_list(L) ->    
+    lists:map(fun(X) ->
+		      fixup_environment(X,B) 
+	      end,
+	      L);
+fixup_environment({var,Line,Name},B) ->
+    case lists:keysearch(Name,1,B) of
+	{value,{Name,Value}} -> 
+	    freeze(Line,Value);
+	_ ->
+	    throw({error,Line,{?ERR_UNBOUND_VARIABLE,atom_to_list(Name)}})
+    end;
+fixup_environment(T,B) when is_tuple(T) ->
+    list_to_tuple(
+      lists:map(fun(X) ->
+			fixup_environment(X,B) 
+		end,
+		tuple_to_list(T)));
+fixup_environment(Other,_B) ->
+    Other.
+    
+freeze(Line,Term) ->
+    {frozen,Line,Term}.
+
+% Most of this is bluntly stolen from erl_parse.
+
+normalise({frozen,_,Term}) ->
+    Term;
+normalise({char,_,C}) -> C;
+normalise({integer,_,I}) -> I;
+normalise({float,_,F}) -> F;
+normalise({atom,_,A}) -> A;
+normalise({string,_,S}) -> S;
+normalise({nil,_}) -> [];
+normalise({bin,_,Fs}) ->
+    {value, B, _} =
+	eval_bits:expr_grp(Fs, [],
+			   fun(E, _) ->
+				   {value, normalise(E), []}
+			   end, [], true),
+    B;
+normalise({cons,_,Head,Tail}) ->
+    [normalise(Head)|normalise(Tail)];
+normalise({tuple,_,Args}) ->
+    list_to_tuple(normalise_list(Args));
+%% Special case for unary +/-.
+normalise({op,_,'+',{char,_,I}}) -> I;
+normalise({op,_,'+',{integer,_,I}}) -> I;
+normalise({op,_,'+',{float,_,F}}) -> F;
+normalise({op,_,'-',{char,_,I}}) -> -I;		%Weird, but compatible!
+normalise({op,_,'-',{integer,_,I}}) -> -I;
+normalise({op,_,'-',{float,_,F}}) -> -F.
+
+normalise_list([H|T]) ->
+    [normalise(H)|normalise_list(T)];
+normalise_list([]) ->
+    [].
+
+
diff -urNp otp_src_R12B-5/lib/stdlib/src/shell.erl minimal_otp_src_R12B-5/lib/stdlib/src/shell.erl
--- otp_src_R12B-5/lib/stdlib/src/shell.erl	2008-09-01 13:51:11.000000000 +0100
+++ minimal_otp_src_R12B-5/lib/stdlib/src/shell.erl	2009-06-23 20:40:26.000000000 +0100
@@ -334,6 +334,10 @@ expand_expr({'receive',L,Cs}, C) ->
     {'receive',L,expand_cs(Cs, C)};
 expand_expr({'receive',L,Cs,To,ToEs}, C) ->
     {'receive',L,expand_cs(Cs, C), expand_expr(To, C), expand_exprs(ToEs, C)};
+expand_expr({'search',L,Cs}, C) ->
+    {'search',L,expand_cs(Cs, C)};
+expand_expr({'search',L,Cs,To,ToEs}, C) ->
+    {'search',L,expand_cs(Cs, C), expand_expr(To, C), expand_exprs(ToEs, C)};
 expand_expr({call,L,{atom,_,e},[N]}, C) ->
     case get_cmd(N, C) of
         {undefined,_,_} ->
jerlang/Makefile0000644000175000017500000001135511220224120013473 0ustar  huberthubertSOURCE_DIR=src
EBIN_DIR=ebin
INCLUDE_DIR=include
SOURCES=$(wildcard $(SOURCE_DIR)/*.erl)
TARGETS=$(patsubst $(SOURCE_DIR)/%.erl, $(EBIN_DIR)/%.beam,$(SOURCES))

WIDEFINDER_SOURCE=misc/wide_finder_data.ap

ifndef USE_JOINS_VM
USE_JOINS_VM=$(shell if [ $$(erl -smp disable -noshell -eval 'io:format(erlang:system_info(version)), halt().') = "5.6.5-joins" ]; then echo "true"; else echo "false"; fi)
endif

ERLC_OPTS=-pa $(EBIN_DIR) -I $(INCLUDE_DIR) -o $(EBIN_DIR) -Wall -v +debug_info $(shell [ $(USE_JOINS_VM) = "true" ] && echo "-Duse_joins_vm")

ERL_OPTS=-pa $(EBIN_DIR) -sname hubert -noshell


all: $(EBIN_DIR)/jerlang_misc.beam $(EBIN_DIR)/jerlang_gen_joins_order.beam $(EBIN_DIR)/jerlang_parse.beam $(EBIN_DIR)/jerlang_vm_parse.beam $(EBIN_DIR)/jerlang_gen_joins.beam $(EBIN_DIR)/jerlang_gen_joins_parse.beam $(TARGETS)

clean:
	rm -rf $(EBIN_DIR)/*.beam
	rm -rf $(SOURCE_DIR)/*.beam

distclean: clean
	find . -regex '.*\(~\|#\|\.swp\|\.dump\)' -exec rm {} \;

$(EBIN_DIR)/%.beam: $(SOURCE_DIR)/%.erl
	erlc $(ERLC_OPTS) $<

shell: all
	erl -pa $(EBIN_DIR) -sname hubert

test: all
	erl $(ERL_OPTS) -eval "test_suite:test(), halt(0)."

test_single_mailbox: all
	erl $(ERL_OPTS) -eval "jerlang_core:test_raw(), halt(0)."

test_single_mailbox_parsed: all
	erl $(ERL_OPTS) -eval "jerlang_tests:test_suite(), halt(0)."

test_testing_parse: all
	erl $(ERL_OPTS) -eval "testing_parse:test(), halt(0)."

test_santa_claus: all
	erl $(ERL_OPTS) -eval "santa_claus:start(), halt(0)."

test_santa_claus_jerlang: all
	erl $(ERL_OPTS) -eval "jerlang_santa_claus:start(), halt(0)."

test_santa_claus_minimal: all
	erl $(ERL_OPTS) -eval "jerlang_santa_claus_minimal:start()."

test_santa_claus_sad: all
	erl $(ERL_OPTS) -eval "jerlang_santa_claus_sad:start()."

test_santa_claus_common: all
	erl $(ERL_OPTS) -eval "jerlang_santa_claus_common:start()."

test_joe_challenge: all
	erl $(ERL_OPTS) +P 134217727 -eval "joe_challenge:start_timer(), halt(0)."

test_joe_challenge2: all
	erl $(ERL_OPTS) +P 134217727 -eval "joe_challenge:start_timer(), halt(0)."

test_gen_joins_jerlang: all
	erl $(ERL_OPTS) -eval "jerlang_gen_joins_test_main:test_suite(), halt(0)."

test_gen_joins_santa: all
	erl $(ERL_OPTS) -eval "jerlang_gen_joins_test_main:time_santa(), halt(0)."

test_gen_joins_santa_time: all
	erl $(ERL_OPTS) -eval "jerlang_gen_joins_test_main:time_santa_script(${ITER}), halt(0)."


test_wide_finder_jerlang: all
	erl $(ERL_OPTS) -eval "jerlang_wide_finder:start('$(WIDEFINDER_SOURCE)'), halt(0)."

test_philosophers_jerlang: all
	erl $(ERL_OPTS) -eval "jerlang_philosophers:test(), halt(0)."

test_exchange_example: all
	erl $(ERL_OPTS) -eval "nata_test:start(), halt(0)."

test_chat_system_jerlang: all
	erl $(ERL_OPTS) -eval "jerlang_chat_system_test:test(), halt(0)."

############################
## Increased load actions
ifeq "x$(TTIMEOUT)" "x"
test_multi_start: all
	echo "SPECIFY 'TSIZE' and 'TTIMEOUT' and 'TSYNC' variables"
else
test_multi_start: all
	erl $(ERL_OPTS) -eval \
		"multiple_producers_test:start(${TSIZE}, ${TTIMEOUT}, ${TSYNC}), halt(0)."
endif
test_multi_start_gather: all
	erl $(ERL_OPTS) -eval \
		"multiple_producers_test:test_suite(\"testing\"), halt(0)."
############################

ifeq "x$(USE_JOINS_VM)" "xtrue"
test_runtime: $(EBIN_DIR)/jerlang_tests_vm.beam
	erl $(ERL_OPTS) -eval "jerlang_tests_vm:test_suite(), halt(0)."

test_runtime_trace: $(EBIN_DIR)/jerlang_tests_vm.beam
	erl $(ERL_OPTS) 
		-eval "dbg:tracer(), dbg:tpl(vm_tests, '_', '_', dbg:fun2ms(fun(_) -> return_trace() end)), dbg:p(all, [c]),jerlang_tests_vm:test_suite(), halt(0)."

test_single_mailbox_vm: all
	erl $(ERL_OPTS) -eval "jerlang_vm_core:test_raw(), halt(0)."

else
test_runtime:
	echo "OTP/R12B-joins-5 is required..."

test_runtime_trace:
	echo "OTP/R12B-joins-5 is required..."

test_single_mailbox_vm:
	echo "OTP/R12B-joins-5 is required..."
endif

start_reindeer: all
	erl -pa $(EBIN_DIR) -sname test2 -noshell -remsh -eval "jerlang_santa_presentation:start_reindeer(),halt(0)."

start_elves: all
	erl -pa $(EBIN_DIR) -sname test1 -noshell -remsh -eval "jerlang_santa_presentation:start_elves(), halt(0)."

connect_shell: all
	erl -pa $(EBIN_DIR) -sname $(NAME) -remsh hubert@ciapek

start_santa: all
	erl $(ERL_OPTS) -eval "jerlang_santa_presentation:start_santa(),halt(0)."
## Performance compare commands
start_santa_minimal_perf: all
	erl $(ERL_OPTS) -eval "jerlang_santa_claus_minimal:time_santa_script(${TSYNC}),halt(0)."

start_santa_okeefe_perf: all
	erl $(ERL_OPTS) -eval "santa_claus_okeefe:time_santa_script(${TSYNC}),halt(0)."

## Nata exchange start commands
start_nata_exchange: all
	erl $(ERL_OPTS) -eval "nata_test:start_pres_exchange(),halt(0)."
start_nata_consumer: all
	erl -pa $(EBIN_DIR) -sname test1 -noshell -remsh -eval "nata_test:start_pres_consumer(${N_ID}, ${N_KEY}, ${N_TYPE}, [${N_CHANN}]), halt(0)."
jerlang/local.configuration0000644000175000017500000000015411220224120015711 0ustar  huberthubertexport PATH=/home/hubert/libs/otp_joins_R12B-5/bin:$PATH
export OTP_HOME=/home/hubert/libs/otp_joins_R12B-5
jerlang/include/joins.hrl0000644000175000017500000000076711220224120015314 0ustar  huberthubert%% requests represents the list of join records representing
%% joins that can contain many patterns
%% ref - unique reference issued by the original process
%% used as a way of identifying the reply
%% oldmsgs - messages which finally didn't create the joins
%% but which were actually matching the pattern
-record(vector, {list=[], id=1, old=[]}).
-record(status, {qs, requests=none, parent, ref=none, msgs=#vector{}}).
-record(pattern, {id, pid, f, t, msgs=[]}).
-record(join, {patternsEts, joins}).
jerlang/include/jerlang.hrl0000644000175000017500000000230511220224120015602 0ustar  huberthubert-type(status() :: 'final' | 'partial').
-type(dupl() :: any()).
-type(state() :: any()).
-type(id() :: integer()).

-type(methods() :: 'init' | 'init_joins' | 'handle_joins' | 'terminate').
-type(behaviour() :: [{methods(), integer()}]).

-type(erl_term() :: any()).

-type(tree(A) :: A).
-type(jdict(A) :: {tree(A), integer()}).
-type(j2dict(A, B) :: {tree(A), tree(B)}).
-type(msg() :: any()).

-type(fun_beta_test() :: fun(([any()], state()) -> 'true')).
-type(fun_alpha_test() :: fun((msg()) -> 'true' | false)).

-record(pattern_joins, {test :: fun_alpha_test(),
			msgs=[] :: [msg()],
			prop=no :: 'undefined' | 'yes' | 'no'}).

-type(alpha() :: [{id(), #pattern_joins{}}]).
-type(beta()  :: [fun_beta_test()]).
-type(join() :: nonempty_improper_list(alpha(), beta())).

%%  -----------------------------
%%  receive-specific section
%%  -----------------------------

-record(opt, {s_time :: non_neg_integer(),
	      timeout :: timeout(),
	      t_action :: fun(() -> any()),
	      timer :: 'disabled' | 'enabled'}).

-type(receive_fun_test() :: fun(([any()], atom()) -> any())).
-type(receive_fun_param(A) :: fun(([any()], atom()) -> A)).
-type(receive_timeout() :: {'timeout', timeout(), fun(() -> any())}).

jerlang/include/gen_joins.hrl0000644000175000017500000000067111220224120016137 0ustar  huberthubert%% requests represents the list of join records representing
%% joins that can contain many patterns
%% ref - unique reference issued by the original process
%% used as a way of identifying the reply
%% oldmsgs - messages which finally didn't create the joins
%% but which were actually matching the pattern
-include("joins.hrl").
-record(gen_state, {patternsEts, joins, ref, msgs=#vector{}}).
-record(gen_pattern, {num, pid, id, msgs=[]}).
jerlang/include/parse_trans.hrl0000644000175000017500000000024611220224120016503 0ustar  huberthubert-record(pclause, {joins, guards, cont}).
-record(pjoin, {channel, pattern, id}).
-record(pcontext, {module}).

-define(L(Val), io:format("~b ~p~n~n", [?LINE, Val])).
jerlang/include/nata.hrl0000644000175000017500000000012511220224120015101 0ustar  huberthubert-record(msg, {key=none,
	      id=none,
	      value}).
-record(channel_msg, {msg}).
jerlang/src/wide_finder_orig.erl0000644000175000017500000000604211220224120016622 0ustar  huberthubert-module(wide_finder_orig).

-compile([native]).

-export([start/1]).

%% The best Bin Buffer Size is 4096
-define(BUFFER_SIZE, 4096). 

start(FileName) ->
    Start = now(),

    Main = self(),
    Collector = spawn(fun () -> collect_loop(Main) end),

    {ok, File} = file:open(FileName, [raw, binary]),
    read_file(File, Collector),
    
    %% don't terminate, wait here, until all tasks done.
    receive
        stop -> io:format("Time: ~10.2f ms~n", [timer:now_diff(now(), Start) / 1000])
    end.

read_file(File, Collector) -> read_file_1(File, [], 0, Collector).
read_file_1(File, PrevTail, I, Collector) ->
    case file:read(File, ?BUFFER_SIZE) of
        eof ->
            Collector ! {chunk_num, I},
            file:close(File);
        {ok, Bin} -> 
            {Data, NextTail} = split_on_last_newline(PrevTail ++ binary_to_list(Bin)),
            spawn(fun () -> Collector ! {dict, scan_lines(Data)} end),
            read_file_1(File, NextTail, I + 1, Collector)
    end.

split_on_last_newline(List) -> split_on_last_newline_1(lists:reverse(List), []).
split_on_last_newline_1(List, Tail) ->
    case List of
        []         -> {lists:reverse(List), []};
        [$\n|Rest] -> {lists:reverse(Rest), Tail};
        [C|Rest]   -> split_on_last_newline_1(Rest, [C | Tail])
    end.

collect_loop(Main) -> collect_loop_1(Main, dict:new(), undefined, 0).
collect_loop_1(Main, Dict, ChunkNum, ChunkNum) ->
    print_result(Dict),
    Main ! stop;
collect_loop_1(Main, Dict, ChunkNum, ProcessedNum) ->
    receive
        {chunk_num, ChunkNumX} -> 
            collect_loop_1(Main, Dict, ChunkNumX, ProcessedNum);
        {dict, DictX} -> 
            Dict1 = dict:merge(fun (_, V1, V2) -> V1 + V2 end, Dict, DictX),
            collect_loop_1(Main, Dict1, ChunkNum, ProcessedNum + 1)
    end.
    
print_result(Dict) ->
    SortedList = lists:reverse(lists:keysort(2, dict:to_list(Dict))),
    [io:format("~p\t: ~s~n", [V, K]) || {K, V} <- lists:sublist(SortedList, 10)].

scan_lines(List) -> scan_lines_1(List, [], dict:new()).
scan_lines_1(List, Line, Dict) -> 
    case List of
        [] -> match_and_update_dict(lists:reverse(Line), Dict);
        [$\n|Rest] ->
            scan_lines_1(Rest, [], match_and_update_dict(lists:reverse(Line), Dict));
        [C|Rest] ->
            scan_lines_1(Rest, [C | Line], Dict)
    end.

match_and_update_dict(Line, Dict) ->
    case process_match(Line) of
        false -> Dict;
        {true, Word} -> 
            dict:update_counter(Word, 1, Dict)
    end.
    
process_match(Line) ->
    case Line of
        [] -> false;
        "GET /ongoing/When/"++[_,_,_,$x,$/,Y1,Y2,Y3,Y4,$/,M1,M2,$/,D1,D2,$/|Rest] -> 
            case match_until_space(Rest, []) of
                [] -> false;
                Word -> {true, [Y1,Y2,Y3,Y4,$/,M1,M2,$/,D1,D2,$/] ++ Word}
            end;
        [_|Rest] -> 
            process_match(Rest)
    end.
    
match_until_space(List, Word) ->
    case List of
        [] -> [];
        [$.|_] -> [];
        [$ |_] -> lists:reverse(Word);
        [C|Rest] -> match_until_space(Rest, [C | Word])
    end.
jerlang/src/test_counter.erl0000644000175000017500000000170211220224120016037 0ustar  huberthubert-module(test_counter).
-compile({parse_transform, jerlang_gen_joins_parse}).
-behaviour(jerlang_gen_joins).

-export([init/1, handle_join/2, terminate/0]).
-export([start/0, stop/0, count/1, tick/0, wait/0, test/0]).


start() ->
    {ok, _} = gen_joins:start({local, ?MODULE}, ?MODULE, [], []).

stop() ->
     ok.

count(Value) ->
    gen_joins:cast(?MODULE, {count, Value}).

tick() ->
    gen_joins:cast(?MODULE, tick).

wait() ->
    gen_joins:call(?MODULE, wait).

test() ->
    gen_joins:call(?MODULE, test).

terminate() ->
    gen_joins:call(?MODULE, stop).

init(_Args) ->
    2.

handle_join({count, N} and tick, State) ->
    io:format("Handle join, count '~p' in  '~p' from '~p' and state: ~p~n", [N, count, tick, State]),
    count(N - 1),
    {[noreply, noreply], State+10};
handle_join({count, 0} and wait, State) ->
    io:format("Handle join, Count(0) ~p and final state '~p'~n",
	      [finished, State]),
    {[noreply, {reply, ok}], State}.
jerlang/src/simple_receive_parsed.erl0000644000175000017500000000242411220224120017654 0ustar  huberthubert-module(simple_receive_parsed).

-include("jerlang.hrl").

-export([start/0]).

start() ->
    jerlang:loop(
      [
       [{1, #pattern_joins{test=
			   fun(Value1) ->
				   case Value1 of
				       {atomic, _Value} -> true;
				       _ -> false
				   end
			   end, msgs=[]}},
	{2, #pattern_joins{test=
			   fun(Value2) ->
				   case Value2 of
				       {test, _Value} -> true;
				       _ -> false
				   end
			   end}}],
       [{3, #pattern_joins{test=
			   fun(Value3) ->
				   case Value3 of
				       {commit, _TransId} -> true;
				       _ -> false
				   end
			   end, msgs=[]}}]],
      [fun(Res1, Case1) ->
	       [{atomic, Value}, {test, Value}] = Res1,
	       Ret = true,
	       case Case1 of
		   test_entry ->
		       Ret;
		   run_all ->
		       {ok, Value}
	       end
       end,
       fun(Res2, Case2) ->
	       [{commit, TransId}] = Res2,
	       Ret = (TransId > 0),
	       case Case2 of
		   test_entry -> 
		       Ret;
		   run_all ->
		       {ok, {trans, TransId}}
	       end
       end],
      [{timeout, 10000,
	fun() ->
		{error, timeout}
	end}]).

%    receive
%	{atomic, Value} and {test, Value} ->
%	    {ok, Value};
%	{commit, TransId} when (TransId > 0)  ->
%	    {ok, {trans, TransId}}
%    after 10000 ->
%	    {error, timeout}
%    end.
jerlang/src/simple_receive.erl0000644000175000017500000000044311220224120016315 0ustar  huberthubert-module(simple_receive).

-compile({parse_transform, jerlang_parse}).

-export([start/0]).

start() ->
    receive
	{atomic, Value} and {test, Value} ->
	    {ok, Value};
	{commit, TransId} when (TransId > 0)  ->
	    {ok, {trans, TransId}}
    after 10000 ->
	    {error, timeout}
    end.
jerlang/src/santa_claus_okeefe.erl0000644000175000017500000000753311220224120017144 0ustar  huberthubert-module(santa_claus_okeefe).
-author('ok@cs.otago.ac.nz'). % Richard A. O'Keefe
-export([start/1, time_santa_script/1]).

%   This is an Erlang solution to "The Santa Claus problem",
%   as discussed by Simon Peyton Jones (with a Haskell solution using
%   Software Transactional Memory) in "Beautiful code".
%   He quotes J.A.Trono "A new exercise in concurrency", SIGCSE 26:8-10, 1994.
%
%	Santa repeatedly sleeps until wakened by either all of his
%	nine reindeer, back from their holidays, or by a group of three
%	of his ten elves.  If awakened by the reindeer, he harnesses
%	each of them to his sleight, delivers toys with them, and finally
%	unharnesses them (allowing them to go off on holiday).  If
%	awakened by a group of elves, he shows each of the group into
%	his study, consults with them on toy R&D, and finally shows them
%	each out (allowing them to go back to work).  Santa should give
%	priority to the reindeer in the case that there is both a group
%	of elves and a group of reindeer waiting.
%
%   Inspired by an old example of Dijkstra's, I solve this problem by
%   introducing two secretaries: Robin and Edna.  The reindeer ask Robin
%   for appointments.  As soon as she has nine waiting reindeer she sends
%   them as a group to Santa.  The elves as Edna for appointments.  As
%   soon as she has three waiting elves she sends them as a group to Santa.
%
%   The Haskell version is 77 SLOC of complex code.
%   The Erlang  version is 43 SLOC of straightforward code.

%%  This is the modified version of the original version
%%  that allows for limiting the synchronisation numbers.

worker(Secretary, Message) ->
    receive after random:uniform(1000) -> ok end,  % random delay
    Secretary ! self(),			% send my PID to the secretary
    Gate_Keeper = receive X -> X end,	% await permission to enter
%    io:put_chars(Message),		% do my action
    Gate_Keeper ! {leave,self()},	% tell the gate-keeper I'm done
    worker(Secretary, Message).		% do it all again

secretary(Santa, Species, Count) ->
    secretary_loop(Count, [], {Santa,Species,Count}).

secretary_loop(0, Group, {Santa,Species,Count}) ->
    Santa ! {Species,Group},
    secretary(Santa, Species, Count);
secretary_loop(N, Group, State) ->
    receive PID ->
        secretary_loop(N-1, [PID|Group], State)
    end.

santa(Main, Counter, Limit) ->
    {Species,Group} =
	receive				% first pick up a reindeer group
	    {reindeer,G} -> {reindeer,G}% if there is one, otherwise
	after 0 ->
	        receive			% wait for reindeer or elves,
	            {reindeer,G} -> {reindeer,G}
	          ; {elves,G}    -> {elves,G}
	        end			% whichever turns up first.
	end,	        
    case Species
      of reindeer -> ok%io:put_chars("Ho, ho, ho!  Let's deliver toys!\n")
       ; elves    -> ok%io:put_chars("Ho, ho, ho!  Let's meet in the study!\n")
    end,
    [PID ! self() || PID <- Group],	% tell them all to enter
    [receive {leave,PID} -> ok end	% wait for each of them to leave
	|| PID <- Group],
    NCounter = 
	case Counter < Limit of
	    true ->
		Counter + 1;
	    false ->
		Main ! stop,
		exit(normal)
	end,
    santa(Main, NCounter, Limit).

spawn_worker(Secretary, Before, I, After) ->
    Message = Before ++ integer_to_list(I) ++ After,
    spawn(fun () -> worker(Secretary, Message) end).

start(Counter) ->
    Pid = self(),
    Santa = spawn(fun () -> santa(Pid, 0, Counter) end),
    Robin = spawn(fun () -> secretary(Santa, reindeer, 9) end),
    Edna  = spawn(fun () -> secretary(Santa, elves,    10) end),
    [spawn_worker(Robin, "Reindeer ", I, " delivering toys.\n")
     || I <- lists:seq(1, 9)],
    [spawn_worker(Edna,  "Elf ",      I, " meeting in the study.\n")
     || I <- lists:seq(1, 10)],
    receive
	stop ->
	    ok
    end.


time_santa_script(Iter) ->
    {Time, _}
	= timer:tc(?MODULE,
		   start, [Iter]),
    
    io:format("Santa ~p took: ~p seconds~n",
	      [Iter, Time/1000000]).
jerlang/src/santa_claus.erl0000644000175000017500000000774311220224120015631 0ustar  huberthubert-module(santa_claus).
-export([elf/2, reindeer/2, ork/2]).
-export([santa/3]).
-export([start/0, start/2]).
-export([start_timer/0, start_timer/1]).

-import(jerlang_misc, [generate_seed/1]).

%% Santa claus problem that allows for limited number of
%% synchronisations, solved using standard Erlang semantics.
%% Inspired by Richard A. O'Keefe solution at
%% http://www.cs.otago.ac.nz/staffpriv/ok/santa/santa.erl
%% We provide additional information to ensure message
%% correctness. Also the worker processes are not created
%% sequentially in one go, to create more non-determinism.

worker(Santa, Type, Id, String) ->
    receive
    after random:uniform(1000) -> ok end,
    Ref = make_ref(),
    Santa ! {Type, self(), Ref},
    io:format("~p[~p]: ~p~n", [Type, Id, String]),
    receive
	{Ref, done} -> ok
    end,
    receive after random:uniform(100) -> ok end,
    Santa ! {job_done, Type, self(), Ref},
    receive
	{Ref, finished} -> ok
    end,
    worker(Santa, Type, Id, String).

elf(Id, Santa) ->
%    search_debug(on),
    generate_seed(Id),
    worker(Santa, elf, Id, "In the waiting hall").

reindeer(Id, Santa) ->
%    search_debug(on),
    generate_seed(Id),
    worker(Santa, reindeer, Id, "Waiting in the stable for a ride").

ork(Id, Santa) ->
    generate_seed(Id),
    receive after random:uniform(1000) -> ok end,
    Santa ! {ork, self()},
    io:format("Ork [~p] sent an arrow~n", [Id]),
    ork(Id, Santa).

notify_workers([], _) ->
    ok;
notify_workers([{Pid, Ref} | Rest], Message) ->
    Pid ! {Ref, Message},
    notify_workers(Rest, Message).

wait_confirmation([]) ->
    ok;
wait_confirmation([{Pid, Ref} | Rest]) ->
    receive
	{job_done, _Type, Pid, Ref} -> ok
    end,
    wait_confirmation(Rest).    

santa(Reindeers, Elves, Limits) ->
    santa0({[], Reindeers}, {[], Elves}, Limits, {0, 0}).

santa0({Reindeers, RMin}, P2, L, {RN, EN})
  when (length(Reindeers) >= RMin) ->
    {ok, Result} = wakeup_santa(Reindeers, RMin,
			  "Reindeers delivering presents"),
    
    santa_continuation({Result, RMin}, P2, L, {RN+1, EN});
santa0(P1, {Elves, EMin}, L, {RN, EN}) when (length(Elves) >= EMin) ->
    {ok, Result} = wakeup_santa(Elves, EMin,
			  "Elves discussing R&D possibilities"),
    santa_continuation(P1, {Result, EMin}, L, {RN, EN+1});
santa0(P1, P2, L, C) ->
    santa1(P1, P2, L, C).

santa_continuation(_, _, {RLimit, ELimit}, {RN, EN}) 
  when (RLimit =< RN) and (ELimit =< EN) ->
    io:format("Simulation finished [~p | ~p] for [~p | ~p]~n",
	      [RN, EN, RLimit, ELimit]);
santa_continuation(P1, P2, Limits, N) ->
    santa0(P1, P2, Limits, N).

wakeup_santa(All, Min, Text) ->
    {Rest, Group} = lists:split(length(All) - Min, All),
    notify_workers(Group, done),
    io:format("Santa: ~p~n", [Text]),
    wait_confirmation(Group),
    notify_workers(Group, finished),
    io:format("Santa: \"Going to sleep\"~n", []),
    {ok, Rest}.
    
santa1({Reindeers, RMin}, {Elves, EMin}, L, C) ->
%    io:format("Santa: Reindeers = ~p, Elves = ~p~n", [length(Reindeers),
%						      length(Elves)]),
    {RReindeers, RElves} = receive
			       {reindeer, Pid, Ref} ->
				   {[{Pid, Ref} | Reindeers], Elves};
			       {elf, Pid, Ref} ->
				   {Reindeers, [{Pid, Ref} | Elves]};
			       {ork, _Pid} ->
				   {Reindeers, Elves};			       
			       _  ->
				   exit({error, unexpected_message})
			   end,
    santa0({RReindeers, RMin}, {RElves, EMin}, L, C).

start() ->
    start(?MODULE, {infinite, infinite}).

start(Module, Limits) ->
    [ spawn(santa_claus, elf, [X, self()]) || X <- [1,3] ],
    [ spawn(santa_claus, reindeer, [X, self()]) || X <- [1,3,4,7,8,9] ],
    [ spawn(santa_claus, elf, [X, self()]) || X <- [2] ],
    [ spawn(santa_claus, reindeer, [X, self()]) || X <- [2,5,6] ],
    [ spawn(santa_claus, ork, [X, self()]) || X <- [1,2,3,4,5]],

    Module:santa(9, 3, Limits).

start_timer() ->
    start_timer(?MODULE).

start_timer(Module) ->
    {Time, _} = timer:tc(Module, start, [Module, {100, 100}]),
    io:format("Executed in ~p seconds~n", [(Time/1000000)]),
    ok.
jerlang/src/ping_pong_test.erl0000644000175000017500000000161311220224120016341 0ustar  huberthubert-module(ping_pong_test).

-ifdef(use_joins_vm).

-export([ping_init/2, pong/0]).
-export([start/0]).

-compile({parse_transform, jerlang_vm_parse}).

ping_init(Id, Pid) ->
%    search_debug(on),
    {A1, A2, A3} = now(),
    random:seed(A1+Id, A2*Id, A3),
    ping(Id, Pid).

ping(Id, Pid) ->
    timer:sleep(random:uniform(100)),
    Ref = make_ref(),
    Pid ! {ping, Ref, self()},
    io:format("Ping[~p]!~n", [Id]),
    receive
	{pong, Ref} -> 
	    ok
    end,
    ping(Id, Pid).

pong() ->
%    search_debug(on),
    {ok, Id} = receive
	{ping, Ref, Pid} ->
	    Pid ! {pong, Ref},
	    {ok, 1}
    end,
    io:format("Pong!~n", []),
%    io:format("Pong[~p]!~n", [Id]),
    pong().

start() ->
    PidPong = spawn(ping_pong_test, pong, []),
    [ spawn(ping_pong_test, ping_init, [X, PidPong]) || X <- [1,2, 3,4, 5, 6, 7, 8, 9]],
    receive
	nothing -> exit({error, wrong_receive})
    end.

-endif.
jerlang/src/nata_test.erl0000644000175000017500000000246411220224120015311 0ustar  huberthubert-module(nata_test).

-export([start/0, start_pres_exchange/0]).
-export([start_pres_producer/2, start_pres_consumer/4]).

-define(EXCHANGE, nata_exchange).

start() ->
%    Keys = [a, b, c, a, b, c, a, b, c, b],
    Keys = [a,b,c],
    KeysChannels = [{a, 2, [2,3]},
		     {c, 3, [1,2]}],
    {ok, _} = nata_exchange:start(),
%    spawn(nata_subscribe, start, []),
    start_consumers(KeysChannels),
    start_producers(Keys),
    receive
	nothing ->
	    ok
    end.
%    nata_publish:start({nata_exchange, 1300, bb, normal}).

start_consumers(Conf) ->
    Ids = lists:seq(1, length(Conf)),
    IdsKeys = lists:zip(Ids, Conf),
    [spawn(nata_subscribe, start, [{?EXCHANGE, Id, Key, Synchr, Channels}]) 
     || {Id, {Key, Synchr, Channels}} <- IdsKeys],
    ok.

start_producers(Keys) ->
    Ids = lists:seq(1, length(Keys)),
    IdsKeys = lists:zip(Ids, Keys),
    [spawn(nata_publish, start, [{?EXCHANGE, Id, Key, normal}])
     || {Id, Key} <- IdsKeys].

block() ->
    receive
	stop ->
	    ok
    end.

start_pres_exchange() ->
    {ok, _} = nata_exchange:start(),
    block().

start_pres_consumer(Id, Key, Type, Channels) ->
    spawn(nata_subscribe, start, [{?EXCHANGE, Id, Key, Type, Channels}]),
    block().

start_pres_producer(Id, Key) ->
    spawn(nata_publish, start, [{?EXCHANGE, Id, Key, normal}]),
    block().
jerlang/src/nata_subscribe.erl0000644000175000017500000000134411220224120016307 0ustar  huberthubert-module(nata_subscribe).

-include("nata.hrl").

-export([start/1]).

-define(CHANNLE, a).
-define(EXCHANGE, nata_exchange).
-define(CHMODULE, nata_channel).

start(Conf) ->
    NConf = init(Conf),
    consume(NConf).

consume({_, Id, _, _, _}=Conf) ->
    receive
	{channel, Name, Msg} ->
	    io:format("[Subscriber ~p]: Received ~p on [~p]~n",
		      [Id, Msg, Name]),
	    ok;
	stop ->
	    %% Should be synchronous
	    %% should cancell the subscriptins first
	    exit(normal)
    end,
    consume(Conf).

init({Exchange, Id, Key, Synchr, Channels}) ->
    {ok, CHPids} = Exchange:create_route(Key, Synchr, Channels),
    lists:foreach( fun(Ch) -> ?CHMODULE:subscribe(Ch) end, CHPids),
    {Exchange, Id, Key, Synchr, CHPids}.
    
jerlang/src/nata_publish.erl0000644000175000017500000000132511220224120015773 0ustar  huberthubert-module(nata_publish).

-include("nata.hrl").

-define(DELAY, 5000).

-export([start/1]).

start(State) ->
    init(State),
    publish(State).

init({_, Seed, _Key, _Type}) ->
    {A1, A2, A3} = now(),
    random:seed(A1+Seed, A2*Seed, A3*Seed),
    io:format("[Producer ~p]:  Start ~n", [Seed]),
    ok.

publish({Exchange, Seed, Key, normal}=State) ->
    timer:sleep(random:uniform(?DELAY)),
    io:format("[Producer ~p]:  publish message [~p]~n", [Seed, Key]),
    Exchange:publish(#msg{key=Key,
			  id=none,
			  value={test, Seed}}),
    check_proceed(State).

check_proceed({_, Seed, _, _} = State) ->
    receive
	stop ->
	    io:format("[Producer ~p]:  stop~n", [Seed])
    after 0 ->
	    publish(State)
    end.
jerlang/src/nata_exchange.erl0000644000175000017500000000676011220224120016117 0ustar  huberthubert-module(nata_exchange).

-compile({parse_transform, jerlang_gen_joins_parse}).

-include("nata.hrl").

-behaviour(jerlang_gen_joins).

-export([init/1, handle_join/2, start/0, terminate/0]).
-export([create_route/3, delete_route/1]).
-export([publish/1]).

-define(CHMODULE, nata_channel).
-define(SERVER, jerlang_gen_joins).
-define(MAX, 4).

init(_) ->
    {ok, {dict:new(), dict:new()}}.

start() ->
    ?SERVER:start({local, ?MODULE}, ?MODULE, [], []).

terminate() ->
    ?SERVER:call(?MODULE, stop).

create_route(Key, Synchr, Channels) ->
    ?SERVER:call(?MODULE, {route, Key, Synchr, Channels}).

delete_route(Key) ->
    ?SERVER:call(?MODULE, {remove_route, Key}).

publish(Msg) ->
    ?SERVER:cast(?MODULE, Msg).

%% ----------------------- CALLBACKS ----------------------

handle_join({route, Key, Synchr, Channels}, Status)
  when ((Synchr > 0) and (Synchr < ?MAX)) ->
    %% Whenever rout already exists we only update
    %% the number of channels

    io:format("[Ex] Create route ~p~n", [Key]),
    {Reply, NS} = 
	try
	    {Pids, {NewRoute, UpdatedS}} =
	    get_route(Key, Synchr, Channels, Status),
	    ok = set_route(NewRoute, Key, Synchr),
	    {{ok, Pids}, UpdatedS} 
	catch
	    throw:_ ->
		{{error, {invalid_synchr, Synchr}}, Status}
	end,
    {[{reply, Reply}], NS};
handle_join({remove_route, Key} and {route, Key, _}, Status) ->
    NS = remove_route(Key, Status),
    {[{reply, ok}, noreply], NS};
handle_join(#msg{key=none}, Status) ->
    io:format("[Ex] Invalid message. Key required~n", []),
    {[noreply], Status};
handle_join(#msg{key=Key, value=V1} and #msg{key=Key, value=V2}
	    and prop({route, Key, 2}), Status) ->
    route_message(Key, [V1, V2], Status),
    {[noreply || _ <- lists:seq(1, 3)], Status};
handle_join(#msg{key=Key, value=V1} and
	    #msg{key=Key, value=V2} and
	    #msg{key=Key, value=V3} and
	    prop({route, Key, 3}),
	    Status) ->

    route_message(Key, [V1, V2, V3], Status),
    {[noreply || _ <- lists:seq(1,4)], Status}.

%%  --------------------------------------------------
%%  ---- INTERNAL FUNCTIONS --------------------------

get_route(Key, Synchr, ChNames, {S1, S2}) ->
    {Update, NS1} =
	case dict:find(Key, S1) of
	    {ok, {Synchr, Values}} ->
		NChNames = (Values ++ (ChNames -- Values)),
		{no, dict:store(Key, {Synchr, NChNames}, S1)};
	    {ok, _} ->
		throw(invalid_synchr);
	    error ->
		{yes, dict:store(Key, {Synchr, ChNames}, S1)}
	end,
    {ChPids, NS2} =
	start_channels(ChNames, S2),
    {ChPids, {Update, {NS1, NS2}}}.
    

set_route(yes, Key, Synchr) ->
    ?SERVER:cast(?MODULE, {route, Key, Synchr}),
    ok;
set_route(_, _, _) ->
    ok.

route_message(Key, Value, {S1, S2}) ->
    {_, ChNames} = dict:fetch(Key, S1),
    ChPids = lists:map(
		 fun(Name) ->
			 dict:fetch(Name, S2)
		 end, ChNames),
    lists:map(
      fun(Pid) ->
	      ?CHMODULE:route(Pid, Key, Value)
      end, ChPids).

start_channels(Channels, Store) ->
    start_channels(Channels, [], Store).

start_channels([], Result, Store) ->
    {lists:reverse(Result), Store};
start_channels([Ch | Rest], Result, Store) ->
    {Pid, NS} =
	case dict:find(Ch, Store) of
	    {ok, ChPid} ->
		{ChPid, Store};
	    error ->
		{ok, ChPid} = ?CHMODULE:start_link(Ch),
		NStore = dict:store(Ch, ChPid, Store),
		{ChPid, NStore} 
	end,
    start_channels(Rest, [Pid | Result], NS).

remove_route(Key, Status) ->
    %% TODO: we should possibly check if the channels
    %% of the key are attached to any other channel
    %% If not, then maybe we should terminate them?
    dict:erase(Key, Status).
jerlang/src/nata_channel.erl0000644000175000017500000000421111220224120015732 0ustar  huberthubert-module(nata_channel).

-behaviour(gen_server).

%% API
-export([start_link/1]).

-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
	 terminate/2, code_change/3]).

-export([subscribe/1, unsubscribe/1, route/3]).

-record(state, {name, msgs, subs=[]}).
-define(SERVER, gen_server).


start_link(Name) ->
    ?SERVER:start_link(?MODULE, [Name], []).

init([Name]) ->
    {ok, #state{name=Name, msgs=queue:new()}}.

subscribe(ChPid) ->
    ?SERVER:call(ChPid, consume).

unsubscribe(ChPid) ->
    ?SERVER:call(ChPid, not_consume).

%%  -------------------------------------------------------
route(ChPid, Key, Msg) ->
    ?SERVER:cast(ChPid, {msg, Key, Msg}).



%%  -------------------- CALLBACKS ------------------------

handle_cast({msg, Key, Msg}, #state{msgs=Q, subs=[]}=S)  ->
    {noreply, S#state{msgs=queue:in(Q, {Key, Msg})}};
handle_cast({msg, Key, Msg}, #state{name=N, subs=Subs}=S) ->
    io:format("[Channel ~p] Notify of ~p~n", [N, Msg]),
    notify_subscribers(Msg, Key, Subs),
    {noreply, S};
handle_cast(_, State) ->
    {noreply, State}.

handle_call(consume, {From, _}, #state{name=N, msgs=Q, subs=[]}=S) ->
    io:format("[Channel ~p] First consumer ~p~n", [N, From]),
    notify_with_old_messages(Q, From),
    {reply, ok, S#state{msgs=queue:new(), subs=[From]}};
handle_call(consume, {From, _}, #state{name=N, subs=Subs} = S) ->
    io:format("[Channel ~p] Consumer ~p~n", [N, From]),
    {reply, ok, S#state{subs=[From | Subs]}};
handle_call(_, _, State) ->
    {noreply, State}.

handle_info(_Info, State) ->
    {noreply, State}.

terminate(_Reason, _State) ->
    ok.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

%%--------------------------------------------------------------------
%%% Internal functions
%%--------------------------------------------------------------------

notify_subscribers(_, _, []) ->
    ok;
notify_subscribers(Msg, Key, [S | Rest]) ->
    S ! {channel, Key, Msg},
    notify_subscribers(Msg, Key, Rest).

notify_with_old_messages(Q, Subs) ->
    L = queue:to_list(Q),
    notify(L, Subs).

notify([], _) ->
    ok;
notify([{Key, M} | Rest], Subs) ->
    Subs ! {channel, Key, M},
    notify(Rest, Subs).
jerlang/src/multiple_producers_test.erl0000644000175000017500000000755511220224120020315 0ustar  huberthubert-module(multiple_producers_test).

-export([packet_generator/1]).
-export([synchronize/2]).
-export([buy/2, deposit/1, secure/2]).


-define(SERVER, multiple_producers).
-define(RANGE, 1000).
-define(SLEEP, 1000).
-define(RATIO, 2).

%%-record(packet,{id, value}).

-export([start/3, test_suite/1,
	 start_synchro/3, start_buyers/2,
	 start_deposit/1, start_secure/2]).

start(Size, Timeout, SyncProc) ->
    {ok, _} = ?SERVER:start(),
    lists:foreach(
      fun(Id) ->
	      spawn_link(?MODULE, packet_generator, [Id])
      end, lists:seq(1, Size)),
    Rounded = erlang:round(Size/?RATIO),
    TestPid = self(),
    TMiliSec = timer:seconds(Timeout),
    spawn_link(fun() -> start_synchro(SyncProc, TMiliSec, TestPid) end),
    spawn_link(fun() -> start_buyers(Rounded, Size) end),
    spawn_link(fun() -> start_deposit(Rounded) end),
    spawn_link(fun() -> start_secure(Rounded, Size) end),
    Final = collect_data(5, 0),
    io:format("Result: ~p ~p ~p ~p~n", [Timeout, Size, SyncProc, Final]),
    Final.

collect_data(0, Result) ->
    Result;
collect_data(N, Result) ->
    V = 
	receive
	    {partial, A} ->
		A
	end,
    collect_data(N - 1, Result + V).

packet_generator(Id) ->
    random:seed(Id*Id, Id + Id, Id * Id + Id),
    packet_generator0(Id).
    
packet_generator0(Id) ->
    timer:sleep(random:uniform(?SLEEP)),
    Value = random:uniform(?RANGE),
    ?SERVER:sell(Id, Value),
    packet_generator0(Id).

start_general(Size, Fun) ->
    lists:foreach(
      fun(Id) ->
	      Fun(Id)
      end, lists:seq(1, Size)),
    receive
	ok ->
	    ok
    end.

start_synchro(Size, Timeout, Pid) ->
    Start = erlang:now(),
    Fun = fun(A) ->
		  spawn_link(?MODULE, synchronize,
			[A, {Pid, Start, Timeout}])
	  end,
    start_general(Size, Fun).

start_buyers(Size, Range) ->
    Fun = fun(A) -> spawn_link(?MODULE, buy, [A, Range]) end,
    start_general(Size, Fun).

start_deposit(Size) ->
    Fun1 = fun(A) -> spawn_link(?MODULE, deposit, [A]) end,
    start_general(Size, Fun1).

start_secure(Size, Range) ->
    Fun2 = fun(B) -> spawn_link(?MODULE, secure, [B, Range]) end,
    start_general(Size, Fun2).
 
synchronize(Id, Args) ->
    random:seed(Id*1, Id*2, Id*3),
    synchronize0(Id, Args, 0).

synchronize0(Id, {Pid, Start, Timeout}=Args, Res) ->
    timer:sleep(random:uniform(?SLEEP)),
    MiliDiff = erlang:round(
		 timer:now_diff(
		   erlang:now(), Start)/1000), %% Microseconds
    case MiliDiff > Timeout of
	true ->
	    Pid ! {partial, Res};
	_ ->
	    try
		?SERVER:notify(Timeout - MiliDiff),
		synchronize0(Id, Args, Res + 1)
	    catch
		exit:{timeout, _} ->
		    Pid ! {partial, Res}
	    end
    end.

buy(Id, Range) ->
    random:seed(Id*Id, Id*Id, Id*Id),
    buy0(Id, Range).

buy0(Id, Range) ->
    timer:sleep(random:uniform(?SLEEP)),
    Value = random:uniform(?RANGE),
    BId = random:uniform(Range),
    
    ?SERVER:buy(BId, Value, random),
    buy0(Id, Range).
    

deposit(Id) ->
    random:seed(Id*4, Id, Id*4),
    deposit0(Id).

deposit0(Id) ->
    timer:sleep(random:uniform(?SLEEP)),
    Value = random:uniform(?RANGE),
    
    ?SERVER:deposit(Value),
    deposit0(Id).

secure(Id, Range) ->
    random:seed(Id*Id, Id*Id, Id*Id),
    secure0(Id, Range).

secure0(Id, Range) ->
    timer:sleep(random:uniform(?SLEEP)),
    BId = random:uniform(Range),
    
    ?SERVER:credentials(BId, random),
    secure0(Id, Range).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Gather test data

test_suite(_) ->
    Notifiers = 10,
    Timeouts = [10, 20, 40, 80, 160, 320, 540],
    Producers = [2, 4, 8, 16, 32, 64, 128, 256],
    lists:foreach(
      fun(Timeout) ->
	      Result = 
		  lists:map(
		    fun(P) ->
			    start(P, Timeout, Notifiers)
		    end, Producers),
	      io:format("~p", [Timeout]),
	      [io:format(" ~p", [R]) || R<- Result],
	      io:format("~n", [])
      end, Timeouts),
    io:format("Done.", []).
    
    
    

jerlang/src/multiple_producers.erl0000644000175000017500000000253211220224120017244 0ustar  huberthubert-module(multiple_producers).
-compile({parse_transform, jerlang_gen_joins_parse}).

-behaviour(jerlang_gen_joins).

-export([init/1, handle_join/2, terminate/0]).
-export([start/0, stop/0]).
-export([notify/0, notify/1, credentials/2,
	deposit/1, sell/2, buy/3]).

-record(packet,{id, value}).

-define(LIMIT, 250).
-define(GEN_JOINS, jerlang_gen_joins).

start() ->
    ?GEN_JOINS:start({local, ?MODULE}, ?MODULE, [], []).

stop() ->
    ?GEN_JOINS:call(?MODULE, stop).

terminate() ->
    ok.

init(_) ->
    {ok, 0}.

notify() ->
    ?GEN_JOINS:call(?MODULE, notify, infinity).

notify(Timeout) ->
    ?GEN_JOINS:call(?MODULE, notify, Timeout).

sell(Id, Value) ->
    ?GEN_JOINS:cast(?MODULE, #packet{value=Value, id=Id}).

buy(Id, Value, Previous) ->
    ?GEN_JOINS:cast(?MODULE, {buy, Id, Value, Previous}).

credentials(Id, Password) ->
    ?GEN_JOINS:cast(?MODULE, {secure, Id, Password}).

deposit(V) ->
    ?GEN_JOINS:cast(?MODULE, {deposit, V}).

%% JOINS

handle_join(notify and #packet{value=V1, id=Id}
	    and {buy, Id, _, _Previous},
	   Current) ->
    {[{reply, {ok, buy, Id}}, noreply, noreply],
     Current - V1};
handle_join(notify and {deposit, V1}
	    and #packet{value=_, id=Id}
	    and {secure, Id, _},
	    State) ->
    {[{reply, {ok, sell, Id}}, noreply,
      noreply, noreply], State + (V1)};
handle_join(stop, _) ->
    {stop, normal}.
jerlang/src/joe_challenge.erl0000644000175000017500000000532611220224120016106 0ustar  huberthubert-module(joe_challenge).

-import(jerlang_misc, [generate_seed/1, average/1]).

-ifdef(use_joins_vm).
-compile({parse_transform, jerlang_vm_parse}).
-else.
-compile({parse_transform, jerlang_parse}).
-endif.

-export([start/3, start_timer/0, start_timer/1]).

-define(REPEAT, 3).

start(Size, N, Delay) ->
    Main = self(),
    Pids = [ spawn_link(fun() -> worker(Id, N, Main, Delay) end)
	     || Id <- lists:seq(1, Size)],
    setup(add(Pids)),
    receive
	ok ->
	    ok
    end.

add([A,B,C | _Rest]=List) ->
    List ++ [A,B,C].

setup([_, _, _]) ->
    finished;
setup([A, B, C, D | Rest]) ->
    A ! {partners, B, C, D},
    setup([B, C, D | Rest]).

worker(Id, N, MasterPid, Delay) ->
    generate_seed(Id),

    receive
	{partners, Pid1, Pid2, Pid3} ->
	    worker1(Id, Pid1, [Pid2, Pid3], N, Delay)
    end,
    finalise(Id, MasterPid).

worker1(1, _, _, 0,_) ->
    ok;
worker1(1, PidNext, Pids, N, Delay) ->
    Msg = {msg, route, N},
    %% Could use list comprehensions, but want to
    %% leave space for delays
    send_synchr(Delay, {synchr, 1}, Pids),
    

    case Delay of 
	true ->
	    receive after random:uniform(1000) -> ok end;
	_ ->
	    ok
    end,
    PidNext ! Msg,

    %% Proper synchron on the all round
    receive
	{msg, route, N} and {synchr, _} and {synchr, _} ->
	    ok
    end,
    worker1(1, PidNext, Pids, N - 1, Delay);
worker1(_, _, _, 0, _) ->
    ok;
worker1(Id, PidNext, Pids, N, Delay) ->
    Synchr = {synchr, Id},
    %% Could use list comprehensions, but want to
    %% leave space for delays
    send_synchr(Delay, Synchr, Pids),
    Msg = 
	receive
	    {msg, route, Val} and {synchr, _} and {synchr, _} ->
		{msg, route, Val}
	end,
    PidNext ! Msg,
    worker1(Id, PidNext, Pids, N - 1, Delay).

finalise(1, MasterPid) ->
    MasterPid ! ok;
finalise(_, _) ->
    ok.

send_synchr(true, Msg, Pids) ->
    lists:foreach(
      fun(Pid) ->
	      receive after random:uniform(1000) -> ok end,
	      Pid ! Msg
      end, Pids);
send_synchr(false, Msg, Pids) ->
    [Pid ! Msg || Pid <- Pids].

start_timer() ->
    start_timer(false).

start_timer(Delay) ->
    io:format("Measuring modified Joe Armstrong's challenge~n", []),
    Tests = [2000, 4000, 6000, 8000, 10000, 12000, 14000,
	     16000, 18000, 20000, 22000, 24000, 26000, 28000, 30000],
    Rounds = [2, 4, 8, 16, 32, 64, 128],

    lists:foreach(
      fun(Round) ->
	      lists:foreach(
		fun(Processes) ->
			Result = 
			    lists:map(
			      fun(_) ->
				      {Time, _} =
					  timer:tc(?MODULE, start,
						   [Processes, Round, Delay]),
				      Time
			      end, lists:seq(1, ?REPEAT)),
			
			io:format("Procs: ~p Round: ~p Time: ~p seconds~n",
				  [Processes, Round, (average(Result)/1000000)])
		end, Tests)
      end, Rounds),
    ok.
jerlang/src/jerlang_wide_finder.erl0000644000175000017500000000666211220224120017314 0ustar  huberthubert-module(jerlang_wide_finder).

-ifdef(use_joins_vm).
-compile({parse_transform, jerlang_vm_parse}).
-else.
-compile({parse_transform, jerlang_parse}).
-endif.

-export([start/1, slave/2]).

%% The best Bin Buffer Size is 4096
-define(BUFFER_SIZE, 4096).

start(FileName) ->
    divide_problem(FileName),
    self() ! {workers, 0},
    gather_results(dict:new()).

divide_problem(FileName) ->
    {ok, File} = file:open(FileName, [raw, binary]),
    create_chunks(File, [], self(), 0).

create_chunks(File, PrevTail, Master, Num) ->
    case file:read(File, ?BUFFER_SIZE) of
	eof ->
	    Master ! {done, Num},
	    file:close(File);
	{ok, Bin} ->
	    {Data, NextTail} =
		split_on_last_newline(PrevTail ++ binary_to_list(Bin)),
	    spawn(?MODULE, slave, [Data, Master]),
	    Master ! {new_chunk, Num},
	    create_chunks(File, NextTail, Master, Num+1)
    end.

slave(Data, Master) ->
    Result = scan_lines(Data),
    Master ! {result, Result}.

%%  Different version
%%  where there is a limited thread pool
%%  and works continuesly request work.
req_slave(Master) ->
    Data =
	receive
	    {scan, Data} ->
		Data;
	    {finish, Master} ->
		exit(normal)
	end,
    Result = scan_lines(Data),
    Master ! {result, Result},
    req_slave(Master).
	    
    
split_on_last_newline(List) -> split_on_last_newline_1(lists:reverse(List), []).
split_on_last_newline_1(List, Tail) ->
    case List of
        []         -> {lists:reverse(List), []};
        [$\n|Rest] -> {lists:reverse(Rest), Tail};
        [C|Rest]   -> split_on_last_newline_1(Rest, [C | Tail])
    end.

gather_results(Store) ->
    receive
%	{workers, 0} and {done, Num} and nothing->
%	    io:format("Job done. Theoretically done ~p~n", [Num]),
%	    print_result(Store);
	{workers, N} and {new_chunk, _} ->
%	    io:format("New chunk. Id [~p]~n", [Id]),
	    self() ! {workers, N+1},
	    gather_results(Store);
	{workers, N} and {result, PStore} ->
            NStore = dict:merge(fun (_, V1, V2) -> V1 + V2 end, Store, PStore),
	    self() ! {workers, N-1},
	    gather_results(NStore);
	{workers, 0} and {done, Num}->
	    io:format("Job done. Theoretically done ~p~n", [Num]),
	    print_result(Store)
    end.


%%%% --Proper matching

print_result(Dict) ->
    SortedList = lists:reverse(lists:keysort(2, dict:to_list(Dict))),
    [io:format("~p\t: ~s~n", [V, K]) || {K, V} <- lists:sublist(SortedList, 10)].

scan_lines(List) -> scan_lines_1(List, [], dict:new()).
scan_lines_1(List, Line, Dict) -> 
    case List of
        [] -> match_and_update_dict(lists:reverse(Line), Dict);
        [$\n|Rest] ->
            scan_lines_1(Rest, [], match_and_update_dict(lists:reverse(Line), Dict));
        [C|Rest] ->
            scan_lines_1(Rest, [C | Line], Dict)
    end.

match_and_update_dict(Line, Dict) ->
    case process_match(Line) of
        false -> Dict;
        {true, Word} -> 
            dict:update_counter(Word, 1, Dict)
    end.
    
process_match(Line) ->
    case Line of
        [] -> false;
        "GET /ongoing/When/"++[_,_,_,$x,$/,Y1,Y2,Y3,Y4,$/,M1,M2,$/,D1,D2,$/|Rest] -> 
            case match_until_space(Rest, []) of
                [] -> false;
                Word -> {true, [Y1,Y2,Y3,Y4,$/,M1,M2,$/,D1,D2,$/] ++ Word}
            end;
        [_|Rest] -> 
            process_match(Rest)
    end.
    
match_until_space(List, Word) ->
    case List of
        [] -> [];
        [$.|_] -> [];
        [$ |_] -> lists:reverse(Word);
        [C|Rest] -> match_until_space(Rest, [C | Word])
    end.

jerlang/src/jerlang_vm_parse.erl0000644000175000017500000005366211220224120016653 0ustar  huberthubert-module(jerlang_vm_parse).
-export([parse_transform/2]).

-import(jerlang_misc, [parse_list/2,
		       unbounded_var/1,
		       is_unbounded_var/1,
		       unique_atom/1]).


%%  Reserved names:
%%  - pattern_joins record

-define(LOCAL_PATTERN(Id, Line, UniqueVar, CaseTests, Propagation),
	{tuple, Line,[
	{integer,Line,Id},
	{record,Line,pattern_joins,
	 [{record_field,Line,
	   {atom,Line,test},
	   {'fun',Line,
	    {clauses,
	     [{clause,Line,
	       [{var,Line,UniqueVar}],
	       [],
	       [{'case',Line,
		 {var,Line,UniqueVar},
		 CaseTests
		}]
	      }]
	    }}},
	  {record_field,Line,
	   {atom,Line,msgs},
	   {nil,Line}},
	  {record_field,Line,
	   {atom,Line,prop},
	   {atom,Line,Propagation}}
	 ]}]}).

-define(JOIN_ACTION(Line, Pattern, ResArgName,
		    CaseArgName, GuardVarName, Action, GBody),
	{'fun',Line,
               {clauses,
                [{clause,Line,
                  [{var,Line,ResArgName},{var,Line,CaseArgName}],
                  [],
                  [{match, Line, Pattern, {var,Line,ResArgName}},
                   {match, Line, {var, Line, GuardVarName}, GBody},
                   {'case',Line,
                    {var,Line,CaseArgName},
                    [{clause,Line,
		      [{atom,Line,test_entry}],
		      [],
		      [{var,Line,GuardVarName}]},
                     {clause,Line,
                      [{atom,Line,run_all}],
                      [],
                      Action}]}]}]}}).

-define(SEARCH_MESSAGE(TimeoutVar, RefVar, PatternClauses, Line),
	{'fun',Line,
	 {clauses,
	  [{clause, Line,
	    [{var, Line, TimeoutVar}, {var, Line, RefVar}],
	    [],
	    [{'search', Line,
	      PatternClauses,
	      {var, Line, TimeoutVar},
	      [{tuple, Line, [{atom, Line, timeout},{var, Line, RefVar}]}]}]
	    }]}}).


-define(TIMEOUT(Time, Action, Line),
	{cons,Line,
	 {tuple,Line,
	  [{atom,Line,timeout},
	   Time,
	   {'fun',Line,
	    {clauses,
	     [{clause,Line,[],[],
	       Action}]}}]},
	 {nil,Line}}).

-define(HANDLER_MODULE, jerlang_vm_core).
-define(HANDLER_FUNC, loop).
-define(HANDLER_RES_ARG_BASE, "ResArgName").
-define(HANDLER_CASE_ARG_BASE, "CaseArg").
-define(HANDLER_GUARD_BASE, "Guard").
-define(HANDLER_P_ARG_BASE, "Value").
-define(HANDLER_CASE_FREE_BASE, "FreeVar").
-define(HANDLER_STIMEOUT_BASE, "Timeout").
-define(HANDLER_SREFERENCE_BASE, "Ref").
-define(PATTERN_RECORD_NAME, pattern_joins).
-define(RECORD_DEFS, records).

-define(PATTERN_RECORD(PatternName, Line),
	{attribute,Line,record,
           {PatternName,
            [{record_field,Line,{atom,Line,test}},
             {record_field,Line,{atom,Line,msgs},{nil,Line}},
             {record_field,Line,{atom,Line,prop},{atom,Line,no}}]}}).

parse_transform(ASTTree, _Options) ->
    put(?RECORD_DEFS, dict:new()),
    Result = parse_clause(ASTTree, []),
%    io:format("ASTTree: ~p~n", [ASTTree]),
%    io:format("Result: ~p~n", [Result]),
    Result.

parse_clause([], Ast) ->
    lists:reverse(Ast);
parse_clause([{attribute, Line, module, _}=Module | Rest], Ast) ->
    parse_clause(Rest, [?PATTERN_RECORD(pattern_joins, Line)
			| [ Module | Ast]]);
parse_clause([{attribute, _, record, {?PATTERN_RECORD_NAME, _}}
	      | _ ], _) ->
    exit({error, {record_not_allowed, ?PATTERN_RECORD_NAME}});
parse_clause([{attribute, _, record, {Name, Fields}} = E | Rest], Ast) ->
    %% FIXME: check if record wasn't defined already
    Dict = get(?RECORD_DEFS),
    put(?RECORD_DEFS, dict:append(Name, parse_record(Fields), Dict)),
    parse_clause(Rest, [ E | Ast]);
parse_clause([{function, L, Name, Arity, Clauses} | Rest], Ast) ->
    ParsedFunc = parse_functions(L, Name, Arity, Clauses, []),
    parse_clause(Rest, [ParsedFunc | Ast]);
parse_clause([Node | Rest], Ast) ->
    parse_clause(Rest, [Node | Ast]).

parse_record(Fields) ->
    parse_record(Fields, []).

parse_record([], Result) ->
    lists:reverse(Result);
parse_record([{record_field, _, {atom, _, Name}} | Rest], Result) ->
    parse_record(Rest, [{Name, undefined} | Result]);
parse_record([{record_field, _, {atom, _, Name}, Value} | Rest], Result) ->
    parse_record(Rest, [{Name, Value} | Result]).

parse_functions(Line, Name, Arity, [], Result) ->
    {function, Line, Name, Arity, lists:reverse(Result)};
parse_functions(L1, Name, Arity1,
		[{clause, L2, Arity2, Guards, Body} | Rest], Result) ->
    %io:format("Body: ~p~n", [Body]),
    PBody = parse_body0(Body, Arity2),
    parse_functions(L1, Name, Arity1, Rest, [{clause, L2, Arity2, Guards, PBody} | Result]).

parse_body0(Body, Arguments) ->
    %% FIXME: need to analyse the arguments
%%    io:format("Args: ~p~n", [Arguments]),
    {_, ArgLiveVars} = parse_body1(Arguments, sets:new(), [args]),
    {PBody, _} = parse_body1(Body, ArgLiveVars, []),
%%    io:format("Vars: ~p~n", [sets:to_list(NLiveVars)]),
    PBody.

parse_body1(Statements, LiveVars, S) ->
    parse_body(Statements, LiveVars, [], S).

parse_body([], LiveVars, Body, _) ->
    {lists:reverse(Body), LiveVars};
parse_body([Statement | Rest], LiveVars, Body, S) ->
    {C, NLiveVars} = parse_body(Statement, LiveVars, S),
    parse_body(Rest, NLiveVars, [C | Body], S);
parse_body(Statement, LiveVars, _Body, S) ->
    parse_body(Statement, LiveVars, S).

%%  Basic clauses
parse_body({var, _Line, '_'}=Var, LiveVars, _S) ->
    {Var, LiveVars};
%%  TODO: handle also the names that start with '_'
parse_body({var, _Line, Name} = Var, LiveVars, _S) ->
    {Var, sets:add_element(Name, LiveVars)};
parse_body({tuple, Line, PN}, LiveVars, S) ->
    {Parsed, NLiveVars} = expr_list(PN, LiveVars, S),
    {{tuple, Line, Parsed}, NLiveVars};
parse_body({nil, _Line}=Nil, LiveVars, _S) ->
    {Nil, LiveVars};
parse_body({cons, Line, P1, P2}, LiveVars, S) ->
    {Parsed1, NLiveVars1} = parse_body1(P1, LiveVars, S),
    {Parsed2, NLiveVars2} = parse_body1(P2, LiveVars, S),
    {{cons, Line, Parsed1, Parsed2},
     sets:union([NLiveVars1, NLiveVars2])};

%%  More complex constructs
parse_body({'receive', Line, Matches}, LiveVars, S) ->
    Result = parse_receive(Matches, Line, {nil, Line}, LiveVars, S),
%    io:format("Result is ~p~n", [Result]),
    {Result, LiveVars};
parse_body({'receive', Line1, Matches,
	     {_, Line2, _} = Timeout, Action},
	   LiveVars, S) ->
    TimeoutOpt = ?TIMEOUT(Timeout, Action, Line2),
    P = parse_receive(Matches, Line1, TimeoutOpt, LiveVars, S),
    {P, LiveVars};
parse_body({clauses, Clauses}, LiveVars, S) ->
    {C, _NLiveVars} = parse_body1(Clauses, LiveVars, S),
    {{clauses, C}, LiveVars};
parse_body({clause, Line, Patterns, Guards, B}, LiveVars, S) ->
    {C1, NLiveVars1} = parse_body1(Patterns, LiveVars, S),
    {C2, NLiveVars2} = parse_body1(Guards, NLiveVars1, S),
    {C3, _NLiveVars3} = parse_body1(B, NLiveVars2, S),
    {{clause, Line, C1, C2, C3}, LiveVars};
parse_body({call, Line, P0, P}, LiveVars, S) ->
    {C, NLiveVars} = parse_body1(P, LiveVars, S),
    {{call, Line, P0, C}, NLiveVars};
parse_body({record, Line, Name, PM}, LiveVars, S) ->
    {PPM, NLiveVars} = expr_list(PM, LiveVars, S),
    {{record, Line, Name, PPM}, NLiveVars};
parse_body({record_field, Line, P1, P2}, LiveVars, S) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, LiveVars2} = parse_body1(P2, LiveVars1, S),
    {{record_field, Line, C1, C2}, LiveVars2};
parse_body({match, Line, P1, P2}, LiveVars, [args]) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, [args]),
    {C2, LiveVars2} = parse_body1(P2, LiveVars, [args]),
    {{match, Line, C1, C2}, sets:union(LiveVars1, LiveVars2)};
parse_body({match, Line, P1, P2}, LiveVars, S) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, _LiveVars2} = parse_body1(P2, LiveVars, S),
    {{match, Line, C1, C2}, LiveVars1};
parse_body({op, Line, Op, P1, P2}, LiveVars, S) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, LiveVars2} = parse_body1(P2, LiveVars, S),
    {{op, Line, Op, C1, C2}, sets:union(LiveVars1, LiveVars2)};
parse_body({Pattern, Line, P}, LiveVars, S) ->
    {C, _NLiveVars} = parse_body1(P, LiveVars, S),
    {{Pattern, Line, C}, LiveVars};
parse_body({Pattern, Line, P1, P2}, LiveVars, S) ->
    {C1, _NLiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, _NLiveVars2} = parse_body1(P2, LiveVars, S),
    {{Pattern, Line, C1, C2}, LiveVars};
parse_body({Pattern, Line, P1, P2, P3, P4}, LiveVars, S) ->
    {C1, _NLiveVars1} = parse_body1(P1, LiveVars, S),
    {C4, _NLiveVars2} = parse_body1(P4, LiveVars, S),
    {{Pattern, Line, C1, P2, P3, C4}, LiveVars};
parse_body(Clause, LiveVars, _) ->
    {Clause, LiveVars}.


%%  FIXME: this should probably be simple map instead of mapfoldl
expr_list(List, LiveVars, S) ->
    lists:mapfoldl(
      fun(Clause, Acc) ->
	      {ParsedElem, NLiveVars} =
		  parse_body1(Clause, LiveVars, S),
	      {ParsedElem, sets:union(NLiveVars, Acc)}
      end, LiveVars, List).
	      


%%  -------   Specific parsing  ---------

parse_receive(Matches, Line, TimeoutOpt, LiveVars, S) ->
    parse_receive(Matches, Line, 1, TimeoutOpt, LiveVars, S, {[], [], []}).

parse_receive([], Line, _Id, TimeoutOpt, _LiveVars,
	      _S, {Records, Functions, SearchClauses}) ->
    FirstArg = lists:reverse(SearchClauses),
    FirstArg1 = sort_search_clauses(FirstArg),
    
    SecondArg = parse_list(lists:reverse(Records), Line),
    ThirdArg = parse_list(lists:reverse(Functions), Line),
    
    TimeoutVar = unique_atom(?HANDLER_STIMEOUT_BASE),
    RefVar = unique_atom(?HANDLER_SREFERENCE_BASE),
    {call, Line,
     {remote, Line, {atom, Line, ?HANDLER_MODULE}, {atom, Line, ?HANDLER_FUNC}},
     [?SEARCH_MESSAGE(TimeoutVar, RefVar, FirstArg1, Line), SecondArg, ThirdArg, TimeoutOpt]};
parse_receive([{clause, LineC, Patterns, Guards, Action} | Rest],
	      Line, Id, TimeoutOpt, LiveVars,
	      S, {Records, Functions, SearchClauses}) ->

%%  FIXME: need to check if maybe we should match
%%  vars when they are next to each other
    {_, NLiveVars1} = parse_body1(Patterns, LiveVars, S),
    %%  FIXME: is the one below actually needed?
    {_, NLiveVars2} = parse_body1(Guards, NLiveVars1, S),
    {PAction, _NLiveVars3} = parse_body1(Action, NLiveVars2, S),
    {PPatterns, PPatternsRec, SearchPattern, NId} =
	parse_patterns(Patterns, LineC, Id, LiveVars),
    ResUniqueName = unique_atom(?HANDLER_RES_ARG_BASE),
    CaseUniqueName = unique_atom(?HANDLER_CASE_ARG_BASE),
    GuardsVar = unique_atom(?HANDLER_GUARD_BASE),

    PGuardsBody
	= receive_guards(Guards, Line),
    ActGuardsFunc = ?JOIN_ACTION(Line, PPatterns, ResUniqueName,
				 CaseUniqueName, GuardsVar,
				 PAction, PGuardsBody),
    parse_receive(Rest, Line, NId, TimeoutOpt,
		  LiveVars, S,
		  {[PPatternsRec | Records],
		   [ActGuardsFunc | Functions],
		   SearchPattern ++ SearchClauses}).

parse_patterns(Patterns, Line, Id, LiveVars) ->
    parse_patterns(Patterns, Line, Id, {[], [], []}, LiveVars, true).

parse_patterns([], Line, Id, {Patterns, PatternsRecords, Search}, _LiveVars, _) ->
    {parse_list(lists:reverse(Patterns), Line),
     parse_list(lists:reverse(PatternsRecords), Line),
     Search,
     Id};
parse_patterns([Pattern | Rest], Line, Id,
	       {RetPattern0, RetPatternRec0, RetSearch0},
	       LiveVars, Decode) ->
    {PPattern, Rec, Search1, NId} =
	parse_patterns(Pattern, Line, Id,
		       {[], [], []}, LiveVars, Decode),
    parse_patterns(Rest, Line, NId,
		   { PPattern ++ RetPattern0,
		     Rec ++ RetPatternRec0,
		     Search1 ++ RetSearch0},
		   LiveVars, true);

%%  Match is 'wrongly' recognized by the standard compiler
%%  And it brakes things horribly. We need to manually
%%  find joins and pack them together
%%  Later we reply the function again but we know that patterns
%%  are now ok, so we omit this function
parse_patterns({match, Line0, _One, _Two}=Match, Line1,
	       Id, {RetPattern, RetPatternRec, RetSearch},
	       LiveVars, Decode) when (Decode == true)->
    Decoded = decode_match(Match),
    JoinsEncoded = join_patterns(Decoded, Line0),
    parse_patterns(JoinsEncoded, Line1, Id,
		   {RetPattern, RetPatternRec, RetSearch},
		   LiveVars, false);
parse_patterns({op, Line, 'and', LPattern, RPattern},
	       _L, Id,
	       {RetPattern,RetPatternRec, RetSearch},
	       LiveVars, Decode) ->
    {PLPattern, PLPatternRec, Search1, Id2} =
	parse_patterns(LPattern, Line, Id,
		       {[], [], []}, LiveVars, Decode),
    {PRPattern, PRPatternRec, Search2, Id3} = 
	parse_patterns(RPattern, Line, Id2,
		       {[], [], []}, LiveVars, Decode),
    {PRPattern ++ PLPattern ++ RetPattern,
     PRPatternRec ++ PLPatternRec ++ RetPatternRec,
     Search2 ++ Search1 ++ RetSearch,
     Id3};
%%  FIXME: better checking on what Other can actually be
%%  atom, var, tuple, fun?, record, ...
parse_patterns(Other, Line, Id, _, LiveVars, _) ->
    parse_pattern(Other, Line, Id, LiveVars).

parse_pattern({call, _Line1, {atom, _Line2, prop}, [Pattern]},
	     Line, Id, LiveVars) ->
    {_PPattern, _Rec, _Search, _NId} =
	parse_pattern(Pattern, Line, Id, LiveVars, yes);
parse_pattern(Pattern, Line, Id, LiveVars) ->
    {_PPattern, _Rec, _Search, _NId} =
	parse_pattern(Pattern, Line, Id, LiveVars, no).

parse_pattern(Pattern, Line, Id, LiveVars, Propagate) ->
    {NPattern, Case} = unbound_pattern(Pattern, LiveVars, false),
    CaseTests = case_test_clauses(NPattern, Line, Case),
    UniqueVar = unique_atom(?HANDLER_P_ARG_BASE),
    Rec = ?LOCAL_PATTERN(Id, Line, UniqueVar, CaseTests, Propagate),
    {[Pattern], [Rec], [create_case_clause(Line, NPattern)], Id + 1}.

%%  FIXME: tuples. lists, records
unbound_pattern({match, Line, P1, P2}, LiveVars, Case) ->
    {R1, Case1} = unbound_pattern(P1, LiveVars, Case),
    {R2, Case2} = unbound_pattern(P2, LiveVars, Case),
    {{match, Line, R1, R2}, (Case1 or Case2)};
unbound_pattern({tuple, Line, PN}, LiveVars, _Case) ->
    RN = lists:map(
	       fun(Elem) ->
		       {R, _} = unbound_pattern(Elem, LiveVars, true),
		       R
	       end, PN),
    {{tuple, Line, RN}, true};
unbound_pattern({cons, Line, P1, P2}, LiveVars, Case) ->
    {R1, _} = unbound_pattern(P1, LiveVars, Case),
    {R2, _} = unbound_pattern(P2, LiveVars, Case),
    {{cons, Line, R1, R2}, true};
%%  FIXME: what if there if for example there is a variable
%%  Test, we make it to _Test, but such already exists and we
%%  have unexpected behaviour	       
unbound_pattern({var, Line, Name} = Var, LiveVars, Case) ->
    case sets:is_element(Name, LiveVars) of
	true -> {Var, true};
	false -> {{var, Line, unbounded_var(Name)}, Case}
    end;
unbound_pattern({record, Line, Name, PN}, LiveVars, _Case) ->
    RN = lists:map(
	   fun(Elem) ->
		   {R, _} = unbound_pattern(Elem, LiveVars, true),
		   R
	   end, PN),
    {{record, Line, Name, RN}, true};
unbound_pattern({record_field, Line, P1, P2}, LiveVars, _Case) ->
    {R1, _} = unbound_pattern(P1, LiveVars, true),
    {R2, _} = unbound_pattern(P2, LiveVars, true),
    {{record_field, Line, R1, R2}, true};
unbound_pattern({bin, Line, PN}, LiveVars, _Case) ->
    RN = lists:map(
	   fun(Elem) ->
		   {R, _} = unbound_pattern(Elem, LiveVars, true),
		   R
	   end, PN),
    {{bin, Line, RN}, true};
unbound_pattern({bin_element, Line, P1, P2, P3}, LiveVars, _Case) ->
    {R1, _} = unbound_pattern(P1, LiveVars, true),
    %% P2 is the size of the bits that we take
    %% and cannot be unbounded
    %% P3 is the type of the bits we take
    %% and cannot be a variable
    {_, Case2} = unbound_pattern(P2, LiveVars, false),
    {_, Case3} = unbound_pattern(P3, LiveVars, false),
    R2 = case Case2 of
	     true -> P2;
	     false -> default
	 end,
    R3 = case Case3 of
	     true -> P3;
	     false -> default
	 end,
    {{bin_element, Line, R1, R2, R3}, true};
unbound_pattern(P, _LiveVars, _Case) ->    
    {P, true}.

%%  We assume that all unbounded vars are '_'
create_case_clause(Line, Clause) ->
    MatchVar = unique_atom(?HANDLER_CASE_FREE_BASE),
    {clause, Line,
     [{match, Line, Clause, {var, Line, MatchVar}}],
     [],
     [{var, Line, MatchVar}]}.

sort_search_clauses(List) ->
    Result = sort(List),
    final_order_pass(Result).

sort([]) -> [];
sort([L]) -> [L];
sort(List) ->
    Middle = length(List) div 2,
    {Left, Right} = lists:split(Middle, List),
    merge(sort(Left),sort(Right)).
 
merge(Left, Right) -> merge(Left, Right, []).
 
merge([L|Left], [R|Right], Acc) ->
    case order_search_clauses(L, R) of
	0  -> merge(Left, [R|Right], [L | Acc]);
	1  -> merge([L|Left], Right, [R | Acc]);
	-1 -> merge(Left, Right, [R | Acc])
    end;
merge([L|Left], [], Acc) ->
    merge(Left, [], [L|Acc]);
merge([], [R|Right], Acc) ->
    merge([], Right, [R|Acc]);
merge([], [], Acc) -> lists:reverse(Acc).


order_search_clauses({clause, _,
		       [{match, _, Msg1, _}], [], _},
		     {clause, _,
		       [{match, _, Msg2, _}], [], _}) ->
    order_search_clauses0(Msg1, Msg2).

%% -1 remove the first one
%% 0  leave the order unchanged
%% 1  reverse the order

order_search_clauses0([], []) ->
    -1;
order_search_clauses0(_, []) ->
    1;
order_search_clauses0([H1 | Rest1], [H2 | Rest2]) ->
    case order_search_clauses0(H1, H2) of
	-1  -> order_search_clauses0(Rest1, Rest2);
	V -> V
    end;
order_search_clauses0({tuple, _, List1},
		      {tuple, _, List2}) ->
    order_search_clauses0(List1, List2);
order_search_clauses0({tuple, _, _},
		      {var, _, _}) ->
    0;
order_search_clauses0({tuple, _, _}, _) ->
    1;
order_search_clauses0({var, _, Name},
		      {var, _, Name}) ->
    -1;
%% FIXME: this case should be removed, once we start
%%        substituting by real '_'
order_search_clauses0({var, _, Name1},
		      {var, _, Name2}) ->
    case is_unbounded_var(Name1) of
	true ->
	    case is_unbounded_var(Name2) of
		true -> -1;
		false -> 1
	    end;
	false -> 0
    end;
order_search_clauses0({var, _, Name}, _) ->
    case is_unbounded_var(Name) of
	true -> 1;
	false -> 0
    end;
order_search_clauses0({atom, _, Name},
		      {atom, _, Name}) ->
    -1;
order_search_clauses0({integer, _, Num},
		      {integer, _, Num}) ->
    -1;
order_search_clauses0({nil, _},
		      {nil, _}) ->
    -1;
order_search_clauses0({record, _, Name, Fields1},
		      {record, _, Name, Fields2}) ->
    compare_record_fields(Name, Fields1, Fields2);
order_search_clauses0({record, _, _, _},
		      {record, _, _, _}) ->
    0;
order_search_clauses0({record, _, _, _}, _) ->
    1;
order_search_clauses0(_, _) ->
    0.


compare_record_fields(Name, F1, F2) ->
    Dict = get(?RECORD_DEFS),
    Fields = case dict:find(Name, Dict) of
		 {ok, [Values]} -> Values;
		 error -> exit({error, {record_undefined, Name}})
	     end,
    compare_record_fields(Fields, {F1, F2}).

compare_record_fields([], {_, _}) ->
    0;
compare_record_fields([FieldVal | Rest], {F1, F2}) ->
    V1 = find_field(F1, FieldVal),
    V2 = find_field(F2, FieldVal),
    case order_record_field(V1, V2) of
	1 -> 1;
	0 -> compare_record_fields(Rest, {F1, F2})
    end.
order_record_field(undefined, undefined) ->
    0;
%% FIXME: is that enough checking?
%% Possibly we should check more if more advanced
%% expression also evaluates no everything
order_record_field(undefined, {var, _, VarName}) ->
    case is_unbounded_var(VarName) of
	true ->
	    0;
	false ->
	    1
    end;
order_record_field(undefined, _Other) ->
    1;
order_record_field(_, _) ->
    0.

find_field([], {_, _}) ->
    undefined;
find_field([{record_field, _, {atom, _, Name}} | _], {Name, Value}) ->
    Value;
find_field([{record_field, _, {atom, _, Name}, Value} | _], {Name, _}) ->
    Value;
find_field([_ | Rest], Name) ->
    find_field(Rest, Name).
    

%%  Check for duplicates as describing sorting
%%  patterns in above way is seriously inefficient
final_order_pass(List) ->
    final_order_pass(List, []).

final_order_pass([], Acc) ->
    lists:reverse(Acc);
final_order_pass([H|Rest], Acc) ->
    Result = final_order_pass(H, Rest, []),
    final_order_pass(Result, [H|Acc]).

final_order_pass(_, [], Acc) ->
    lists:reverse(Acc);
final_order_pass(E, [R|Rest], Acc) ->
    case order_search_clauses(E, R) of
	-1 -> final_order_pass(E, Rest, Acc);
	_  -> final_order_pass(E, Rest, [R|Acc])
    end.
    

case_test_clauses(Pattern, Line, false) ->
    [{clause, Line,
      [Pattern],
      [],
      [{atom, Line, true}]}];
case_test_clauses(Pattern, Line, true) ->
    [{clause, Line,
      [Pattern],
      [],
      [{atom, Line, true}]},
     {clause, Line,
      [{var, Line, '_'}],
      [],
      [{atom, Line, false}]}].

receive_guards([], Line) ->
    {atom, Line, true};
receive_guards([[Guards]], _) ->
    Guards.

decode_match({match, Line0, Left0, {match, _Line, _Left1, _Right1}=Right0}) ->
    %%  Since the code is fine we are sure that first
    %%  element is definitely not the match itself
    %% But it can be an 'and' op.

    {Pattern, Rest0} = match_r_most(Left0),
    [Head | Rest2] = decode_match(Right0),
    {MatchedPattern, Rest1} = match_l_most(Head),
    Rest0 ++ [{match, Line0, Pattern, MatchedPattern} | Rest1] ++ Rest2;
decode_match({match, Line0, Left0, {op, _, 'and', _, _}=Right0}) ->
    {Pattern, Rest0} = match_r_most(Left0),
    {MatchedPattern, Rest1} = match_l_most(Right0),
    Rest0 ++ [{match, Line0, Pattern, MatchedPattern} | Rest1];
decode_match({match, _Line0, _, {op, _, _Other, _, _}}) ->
    exit({error, invalid_join_operator});
decode_match({match, Line0, Left0, Right0}) ->
    {Pattern, Rest} = match_r_most(Left0),
    Rest ++ [{match, Line0, Pattern, Right0}].

match_r_most({op, _, 'and', Left0, Right0}) ->
    {Pattern, RestJoins} = match_r_most(Right0),
    {Pattern, [Left0 | RestJoins]};
match_r_most({op, _, Other, _, _}) ->
    exit({error, {invalid_join_operator, Other}});
match_r_most(Pattern) ->
    {Pattern, []}.

match_l_most({match, _, _, _}) ->
    exit({error, invalid_match_l_most});
match_l_most({op, _, 'and', Left0, Right0}) ->
    {Pattern, RestJoins} = match_l_most(Left0),
    {Pattern,  RestJoins ++ [Right0]};
match_l_most({op, _, Other, _, _}) ->
    exit({error, {invalid_join_operator, Other}});
match_l_most(Pattern) ->
    {Pattern, []}.

join_patterns(Patterns, Line) ->
    join_patterns1(lists:reverse(Patterns), Line).

join_patterns1([], _) ->
    [];
join_patterns1([Elem], _) ->
    Elem;
join_patterns1([Right, Left], Line) ->
    {op, Line, 'and', Left, Right};
join_patterns1([Head | Rest], Line) ->
    Result = join_patterns1(Rest, Line),
    {op, Line, 'and', Result, Head}.

%% -------------- Utilities ------------------

    
    
jerlang/src/jerlang_vm_gen_joins.erl0000644000175000017500000005225111220224120017505 0ustar  huberthubert-module(jerlang_vm_gen_joins).

-ifdef(use_joins_vm).

-export([start/3, start/4, start_link/3, start_link/4]).
-export([call/2, call/3, cast/2]).

%% Internal exports
-export([init_it/6, behaviour_info/1]).

-import(error_logger, [format/2]).
-import(jerlang_gen_joins_mset, [first/3, beta/3]).
-include("jerlang.hrl").
-define(GEN_JOINS_MAILBOX, gen_joins_mailbox).
-define(GEN_JOINS_DUPLICATES, gen_joins_duplicates).

-spec(behaviour_info/1 :: (atom()) -> 'undefined' | behaviour()).

behaviour_info(callbacks) ->
    [{init, 1},
     {init_joins, 1},
     {handle_join, 2},
     {terminate, 0}];

behaviour_info(_Other) ->
    undefined.

% Start the joins server
start(Mod, Args, Options) ->
    gen:start(?MODULE, nolink, Mod, Args, Options).

start(Name, Mod, Args, Options) ->
    gen:start(?MODULE, nolink, Name, Mod, Args, Options).

start_link(Mod, Args, Options) ->
    gen:start(?MODULE, link, Mod, Args, Options).

start_link(Name, Mod, Args, Options) ->
    gen:start(?MODULE, link, Name, Mod, Args, Options).

%% -----------------------------------------------------------------
%% Make a call to a generic server.
%% If the server is located at another node, that node will
%% be monitored.
%% If the client is trapping exits and is linked server termination
%% is handled here (? Shall we do that here (or rely on timeouts) ?).
%% ----------------------------------------------------------------- 
call(Name, Request) ->
    case catch gen:call(Name, '$gen_call', Request) of
	{ok,Res} ->
	    Res;
	{'EXIT',Reason} ->
	    exit({Reason, {?MODULE, call, [Name, Request]}})
    end.

call(Name, Request, Timeout) ->
    case catch gen:call(Name, '$gen_call', Request, Timeout) of
	{ok,Res} ->
	    Res;
	{'EXIT',Reason} ->
	    exit({Reason, {?MODULE, call, [Name, Request, Timeout]}})
    end.

%% -----------------------------------------------------------------
%% Make a cast to a generic server.
%% -----------------------------------------------------------------
cast({global,Name}, Request) ->
    catch global:send(Name, cast_msg(Request)),
    ok;
cast({Name,Node}=Dest, Request) when is_atom(Name), is_atom(Node) -> 
    do_cast(Dest, Request);
cast(Dest, Request) when is_atom(Dest) ->
    do_cast(Dest, Request);
cast(Dest, Request) when is_pid(Dest) ->
    do_cast(Dest, Request).

do_cast(Dest, Request) -> 
    do_send(Dest, cast_msg(Request)),
    ok.

cast_msg(Request) -> {'$gen_cast',Request}.

%%%========================================================================
%%% Gen-callback functions
%%%========================================================================

%%% ---------------------------------------------------
%%% Initiate the new process.
%%% Register the name using the Rfunc function
%%% Calls the Mod:init/Args function.
%%% Finally an acknowledge is sent to Parent and the main
%%% loop is entered.
%%% ---------------------------------------------------
%%% First gather information about any joins from the Mod:init_joins
%%% function and parse it.
%%% Call to Mod:init sets the initial value for the
%%% Mod:handle_join functions.
%%% ---------------------------------------------------
init_it(Starter, self, Name, Mod, Args, Options) ->
    init_it(Starter, self(), Name, Mod, Args, Options);
init_it(Starter, Parent, Name, Mod, Args, Options) ->
    Debug = debug_options(Name, Options),
    Joins =
	case catch verify_join(Mod:init_joins(none)) of
	    {ok, JoinsDef} ->
		JoinsDef;
	    Other ->
		%io:format("Errror: ~p~n", [Other]),
		proc_lib:init_ack(Starter, {error, Other}),
		exit({error, Other})
	end,
    case catch Mod:init(Args) of
	{ok, State} ->
	    proc_lib:init_ack(Starter, {ok, self()}), 	    
	    loop(Parent, Name, State, Mod, infinity, Joins, Debug);
	{ok, State, Timeout} ->
	    proc_lib:init_ack(Starter, {ok, self()}), 	    
	    loop(Parent, Name, State, Mod, Timeout, Joins, Debug);
	{stop, Reason} ->
	    proc_lib:init_ack(Starter, {error, Reason}),
	    exit(Reason);
	ignore ->
	    proc_lib:init_ack(Starter, ignore),
	    exit(normal);
	{'EXIT', Reason} ->
	    proc_lib:init_ack(Starter, {error, Reason}),
	    exit(Reason);
	Else ->
	    Error = {bad_return_value, Else},
	    proc_lib:init_ack(Starter, {error, Error}),
	    exit(Error)
    end.

%%%========================================================================
%%% Internal functions
%%%========================================================================
%%% ---------------------------------------------------
%%% The MAIN loop.
%%% ---------------------------------------------------
loop(Parent, Name, State, Mod, hibernate, Joins, Debug) ->
    proc_lib:hibernate(?MODULE,wake_hib,
		       [Parent, Name, State, Mod, Joins, Debug]);
loop(Parent, Name, State, Mod, Time, Joins, Debug) ->
%    io:format("|R|~n", []),
    Msg = search
	      Input ->
		    Input
	  after Time ->
		  timeout
	  end,
%    io:format("Decode message: ~p~n", [Msg]),
    decode_msg(Msg, Parent, Name, State, Mod, Time, Joins, Debug, false).

%% FIXME: allow for hibernation. Compare with R12 release
%wake_hib(Parent, Name, State, Mod, Joins, Debug) ->
%    Msg = receive
%	      Input ->
%		  Input
%	  end,
%    decode_msg(Msg, Parent, Name, State, Mod, hibernate, Joins, Debug, true).

decode_msg(Msg, Parent, Name, State, Mod, Time, Joins, Debug, Hib) ->
    case Msg of
	{system, From, Req} ->
	    sys:handle_system_msg(Req, From, Parent, ?MODULE, Debug,
				  [Name, State, Mod, Time, Joins], Hib);
	{'EXIT', Parent, Reason} ->
	    terminate(Reason, Name, Msg, Mod, State, Joins, Debug);
	{internal, joins} ->
%	    io:format("Internal joins: ~p~n", [State]),
%	    {ok, Mailbox} = gen_joins_mailbox(),
%	    io:format("SIZE: ~p~n", [jerlang_dict:size(Mailbox)]),
	    handle_msg1(none, Parent, Name, State, Mod, Time, Joins, Debug);
	_Msg when Debug =:= [] ->
	    handle_msg0(Msg, Parent, Name, State, Mod, Time, Joins, Debug);
	_Msg ->
	    Debug1 = sys:handle_debug(Debug, {?MODULE, print_event}, 
				      Name, {in, Msg}),
	    handle_msg0(Msg, Parent, Name, State, Mod, Time, Joins, Debug1)
    end.

handle_msg0({'$gen_call', _, _}=Call, Parent, Name, State,
	    Mod, Time, Joins, Debug) ->
    handle_msg1(Call, Parent, Name, State,
		Mod, Time, Joins, Debug);
%% Adapting cast to common pattern
handle_msg0({'$gen_cast', Msg}, Parent, Name, State,
	    Mod, Time, Joins, Debug) ->
    handle_msg1({'$gen_cast', none, Msg}, Parent, Name, State,
		Mod, Time, Joins, Debug);
handle_msg0(_Other, _Parent, _Name, _State,
	    _Mod, _Time, _Joins, _Debug) ->
    %% FIXME: possibly just ignore?
    exit({error, unrecognized_message}).

handle_msg1(Msg, Parent, Name, State,
	    Mod, Time, Joins, Debug) ->
    %% Find any matching join
    JoinsMatching = process_join(Msg, Joins, State),
    %% Analyse result of matching
%    io:format("Analyse result~n", []),
    case JoinsMatching of
	{error, NJoins} ->
	    loop(Parent, Name, State, Mod, Time, NJoins, Debug);
	{ok, {Msgs, NJoins}} ->
	    Split = lists:map(
		      fun({Tag, From, Value}) ->
			      {{Tag, From}, Value};
			 ({Tag, Value}) ->
			      {{Tag, none}, Value}
		      end, Msgs),
	    {Tags, Values} = lists:unzip(Split),
	    JoinCall =
		try Mod:handle_join(Values, State)
		catch
		    exit:Exc -> {exit, Exc};
		    error:Exc -> {exit, Exc}
		end,
	    handle_join_result(JoinCall, Tags, Parent,
			       Name, State, Mod,
			       Time, NJoins, Debug)
    end.
    
handle_join_result({exit, Other}, _MsgTags, _Parent, _Name, _OldState,
		   _Mod, _Time, _Joins, _Debug) ->
    %% Invalid return from the handle_join call.
    %% Internal error. Closing server.
    exit({error, {internal, gen_joins_handle_join, Other}});
handle_join_result({Reply, NState}, MsgTags, Parent, Name, _OldState,
		   Mod, Time, Joins, Debug) ->
%    io:format("?: ~p || ~p || ~p~n", [MsgTags, Reply, NState]),
    ReplyTo =  lists:zip(MsgTags, Reply),
%    io:format("Join result-reply: ~p~n", [ReplyTo]),
    ok = handle_reply(ReplyTo),
%    io:format("Result from handle_join call [~p]~n", [Reply]),
    decode_msg({internal, joins}, Parent, Name,
		NState, Mod, Time, Joins, Debug, false).

handle_reply([]) ->
    ok;
handle_reply([{_, noreply} | Rest]) ->
    %% FIXME: throw warning if tag not empty
    handle_reply(Rest);
handle_reply([{{_Tag, {To, Ref}}, {reply, Reply}} | Rest]) ->
    To ! {Ref, Reply},
    handle_reply(Rest).

%handle_msg({'$gen_call', From, Msg}, Parent, Name, State, Mod, _Time, Debug) ->
%    case catch Mod:handle_call(Msg, From, State) of
%	{reply, Reply, NState} ->
%	    Debug1 = reply(Name, From, Reply, NState, Debug),
%	    loop(Parent, Name, NState, Mod, infinity, Debug1);
%	{reply, Reply, NState, Time1} ->
%	    Debug1 = reply(Name, From, Reply, NState, Debug),
%	    loop(Parent, Name, NState, Mod, Time1, Debug1);
%	{noreply, NState} ->
%	    Debug1 = sys:handle_debug(Debug, {?MODULE, print_event}, Name,
%				      {noreply, NState}),
%	    loop(Parent, Name, NState, Mod, infinity, Debug1);
%	{noreply, NState, Time1} ->
%	    Debug1 = sys:handle_debug(Debug, {?MODULE, print_event}, Name,
%				      {noreply, NState}),
%	    loop(Parent, Name, NState, Mod, Time1, Debug1);
%	{stop, Reason, Reply, NState} ->
%	    {'EXIT', R} = 
%		(catch terminate(Reason, Name, Msg, Mod, NState, Debug)),
%	    reply(Name, From, Reply, NState, Debug),
%	    exit(R);
%	Other ->
%	    handle_common_reply(Other, Parent, Name, Msg, Mod, State, Debug)
%    end;

%%% ---------------------------------------------------
%%% Send/recive functions
%%% ---------------------------------------------------
do_send(Dest, Msg) ->
    case catch erlang:send(Dest, Msg, [noconnect]) of
	noconnect ->
	    spawn(erlang, send, [Dest,Msg]);
	Other ->
	    Other
    end.

%%% ---------------------------------------------------
%%% Terminate the server.
%%% ---------------------------------------------------

terminate(Reason, _Name, _Msg, Mod, State, _Joins, _Debug) ->
    case catch Mod:terminate(Reason, State) of
	{'EXIT', R} ->
%	    error_info(R, Name, Msg, State, Debug),
	    exit(R);
	_ ->
	    case Reason of
		normal ->
		    exit(normal);
		shutdown ->
		    exit(shutdown);
		_ ->
%		    error_info(Reason, Name, Msg, State, Debug),
		    exit(Reason)
	    end
    end.

%% Misc
%% FIXME: provide support for debugging
debug_options(_, _) ->
    [].

%%% -------------------------------------
%%% Joins handling functions
%%% -------------------------------------

gen_joins_duplicates() ->
    case get(?GEN_JOINS_DUPLICATES) of
	undefined ->
%	    io:format("Init duplicates~n", []),
	    {ok, jerlang_2dict:init()};
	Mailbox ->
	    {ok, Mailbox}
    end.

store_duplicates(Mapping) ->
%    io:format("DUPLICATES: ~p~n", [Mapping]),
    put(?GEN_JOINS_DUPLICATES, Mapping).

%% -----------------------------------------------
%% The 'none' case is used when we check joins
%% as a result of the previous join being successful,
%% i.e. found match. Since State could have changed
%% we need to check if we have any further matches.
%% -----------------------------------------------

%% FIXME: remove redundant code
process_join(none, Joins, State) ->
    {ok, D} = gen_joins_duplicates(),
    process_join0(none, Joins, [], {none, {no, D}}, State);
process_join(Msg, Joins, State) ->
    {ok, D} = gen_joins_duplicates(),
    {ok, Index} = last_search_index(),
    process_join0({Index, Msg}, Joins, [], {none, {no, D}}, State).

process_join0(Msg, [], Joins, {M, {_, D}}, _) ->
%    io:format("processjoin0 first: ~p~n", [M]),
    joins_matching({error, no_match}, Msg, 
		   lists:reverse(Joins),
		   {M, D});
process_join0(none, [Join | Rest], JResult, M, State) ->
%    io:format("Process_join0-none~n", []),
    process_join1(none, [], Join, Rest, JResult, M, State);
process_join0({Id, Msg}, [Join | Rest], JResult, M, State) ->
%    io:format("Process_join0?:~n", []),
    {NJoin, Flag} = alpha_reduction({Id, Msg}, Join),
%    io:format("Call process_join1~n", []),
    process_join1({Id, Msg}, Flag, NJoin, Rest, JResult, M, State).

process_join1(Msg, AReduce, Join, RestJoins, Result, MD, State) ->
%    io:format("Process_join1~n", []),
%    io:format("ASSS~p, ~p, ~p~n", [Msg, AReduce, State]),
    NMD = update_duplicates(Msg, AReduce, MD),
%    io:format("Perform beta reduction0.0~n", []),
    {M, {_, D}} = NMD,
%    io:format("Perform beta reduction~n", []),
    Result1 = beta_reduction(Msg, AReduce, Join, {M, D}, State),
%    io:format("After beta reduction~n", []),
    case Result1 of
	{error, {not_found, NJoin}} ->
	    process_join0(Msg, RestJoins, [NJoin | Result], NMD, State);
	{ok, {MsgIds, NJoin}}  ->
%	    io:format("Found.~p~n", [Msg]),
	    joins_matching({ok, MsgIds}, Msg, 
			   {lists:reverse(Result), NJoin, RestJoins},
			   {M, D})
    end.

joins_matching({error, no_match}, _, Joins, {_, D}) ->
    store_duplicates(D),
    {error, Joins};
joins_matching({ok, MsgIds}, InitMsg,
	       {TestedJs, Join, AfterJs}, {_, D}) ->

    {RemoveIds, PIds, All} =
	propagation_ids(MsgIds, Join),
%    io:format("Remove: ~p | Save: ~p | All: ~p~n", [RemoveIds, PIds, All]),
%    io:format("Init msg: ~p~n", [InitMsg]),
    NAfterJs = propagation_update(InitMsg, PIds, AfterJs), 
    AllJoins = TestedJs ++ [Join] ++ NAfterJs,

    FinalJoins = purge_messages(AllJoins, RemoveIds),

    MatchedMsgs = remove_msgs(All, []),
    ND = jerlang_2dict:remove(D, RemoveIds),
    store_duplicates(ND),
    {ok, {MatchedMsgs, FinalJoins}}.

propagation_update({Id, Msg}, PIds, Rest) ->
    case lists:member(Id, PIds) of
	true ->
	    lists:map(
	      fun(J) ->
		      {NJ, _} = alpha_reduction(
				  {Id, Msg}, J),
		      NJ
	      end, Rest);
	false ->
	    Rest
    end;
propagation_update(_, _, Rest) ->
    Rest.

alpha_reduction({Id, {_Tag, _From, Msg}}, [Alpha | Beta]) ->
%    io:format("Alpha reduction~n", []),
    {NAlpha, Flag} = lists:mapfoldl(
      fun({PId, #pattern_joins{test=F, msgs=Msgs} = PRec} = P,
	  Acc) ->
	      case F(Msg) of
		  true ->
		      {{PId, PRec#pattern_joins{msgs=Msgs ++ [Id]}},
		       [PId | Acc]};
		  _ ->
		      {P, Acc}
	      end
      end, [], Alpha),
%    io:format("Finished alpha reduction [~p]~n", [length(Flag)]),
    {[NAlpha | Beta], Flag}.

%%  Function responsible for updating information
%%  about duplicate entries. Unfortunately one has to parse
%%  all the non-duplicates messages in order to find out
%%  groups that are equal to this message.
update_duplicates(none, _, M) ->
    M;
update_duplicates(_, [], M) ->
    M;
update_duplicates(_, _, {_, {yes, _}}=M) ->
    M;
update_duplicates({Elem, _}, _, {Mailbox, {no, Dupl}}) ->
    Update =
	jerlang_2dict:update(
	  Elem,
	  fun(Id) ->
		  erlang:search_index(Id)
	  end, Dupl),
    {Mailbox, {yes, Update}}.
    
-spec(beta_reduction/5 ::
      ({id(), msg()} | 'none', list(), join(),
       {jdict(msg()), j2dict(ref(), [id()])}, state()) ->
	     {'error', {'not_found', join()}} |
		 {'ok', {[id()], join()}}).

beta_reduction({_, _}, [], Join, _MD, _State) ->
%    io:format("No matches, beta~n", []),
    {error, {not_found, Join}};
beta_reduction(Msg0, Matches, [Alpha | Beta], {_, D}, S) ->
    Id = case Msg0 of
	     {Id0, _} -> Id0;
	     none -> none
	 end,
    MAccess = fun(Ids) ->
		      lists:map(
			fun({_, _, Val}) ->
				Val;
			   ({_, Val}) ->
				Val;
			   (Val) ->
				Val
			end,get_msgs(Ids, []))
	      end,
%    io:format("Proper Beta reduction on ~p with ~p~n", [length(Alpha), Msg0]),
    {Result, {Val1, NBeta}} = 
	beta_reduction1(Id, Matches, Alpha, Beta, [], {MAccess, D}, S),
%    io:format("Finished First beta1 with ~p~n", [Result]),
    {Result, {Val1, [Alpha | NBeta]}}.

beta_reduction1(_, _, [], [], Result, _, _) ->
%    io:format("Final Reduction ???????~n", []),
    {error, {not_found, lists:reverse(Result)}};
beta_reduction1(none, Matches,
		[{_, #pattern_joins{msgs=Msgs}}]=A, B, [], MD, S) ->
    %% Single pattern join - no new msg version.

%    io:format("betareduction 1~n", []),
%    io:format("None Reduce ~p~n", [Num]),
    beta_reduction_for(Msgs, Matches, A, B, [], MD, S);    
beta_reduction1(Id, _Matches, [_A1], [{Fun, []}]=B, [], {M, _}, S) ->
    %% Single pattern join.
%    io:format("Single pattern beta ~p~n", [Id]),
    Value = M([Id]),
    try Fun(Value, S) of
	true ->
	    {ok, {[Id], B}}
    catch
	error:function_clause ->
	    {error, {not_found, B}}
    end;
beta_reduction1(Id, Matches,
		[{_, #pattern_joins{msgs=MsgsA1}},
		 {_, #pattern_joins{msgs=MsgsA2}} | ARest],
		[{Fun, BMsgs} | BRest]=B, [],
		{M, D}, S) ->
    %% Initial Beta-reduction for first two messages.

    %% FIXME: use Matches and NumA1 and NumA2 to identify
    %% the messages faster
    Type = case ARest of
		 [] -> final;
		 _  -> partial
	     end,
%    io:format("beta reduction1 on two that is: ~p~n", [Type]),
%    io:format("Msgs: ~p:~p and ~p:~p~n", [NumA1, MsgsA1, NumA2, MsgsA2]),
    FMsgsA1 = [[X] || X <- MsgsA1],
    Seq1 =
	try beta(FMsgsA1, MsgsA2,
		 {Type, BMsgs, {Fun, S, M}, D}) of
	    {ok, []} ->
		%%  Nothing new was found
		%%  {error, {not_found, B}};
		[];
	    {ok, Seq} ->
		%  io:format("found sth ~p ~p in ~p~n", [length(BRest), Seq, Type]),
		Seq
	catch
	    error:_ ->
		%%  io:format("Erroror3 ~p~n", [Other]),
		exit({error, invalid_beta_reduction})
	end,
%    io:format("BB12: [~p] [~p]~n", [BMsgs, Seq1]),
    Seq2 = BMsgs ++ Seq1,
    case Seq2 of
	[] ->
	    %%  This beta reduction isn't satisfyable
	    %%  by any set of messages. Abort. 
	    {error, {not_found, B}};
	_ ->
	    case Type of
		final ->
		    {ok, {Seq2, B}};
		_ ->
%		    io:format("Start another reduction~n", []),
		    beta_reduction1(Id, Matches, ARest,
				    BRest, [{Fun, Seq2}],
				    {M, D}, S)
	    end
    end;
beta_reduction1(_, _, [[_]], [{_, []}], [], _, _) ->
    %%  Keep dialyzer happy
    exit({error, internal_error});
beta_reduction1(_, _Matches, [A | []],
		[{Fun, []}]=B, ResBeta,
		{M, D}, S) ->
    %%  Final beta reduction.
%    io:format("Beta reduction1 2~n", []),
    {_NumA, #pattern_joins{msgs=MsgA}} = A,
    [{_, LastB} | _] = ResBeta,
%    io:format("Msgs: ~p | ~p | ~p~n", [LastB, MsgA, Id]),
    case beta(LastB, MsgA, {final, [], {Fun, S, M}, D}) of
	{ok, []} ->
%	    io:format("Not found!~n", []),
	    {error, {not_found, lists:reverse(ResBeta) ++ B}};
	{ok, Seq} ->
	    {ok, {Seq, lists:reverse(ResBeta) ++ B}}
    end;
beta_reduction1(_, _, [_ | _], [{_, _} | _], [], _, _) ->
    %%  Keep dialyzer happy
    exit({error, internal_error});
beta_reduction1(Id, Matches, [A | ARest],
		[{Fun, BMsgs} | BRest] = B, ResBeta, {M, D}, S) ->
    %%  Partial beta reduction
%    io:format("Beta reduction1 3~n", []),
    {_NumA, #pattern_joins{msgs=MsgA}} = A,
    [{_, LastB} | _] = ResBeta,
    ResSeq =
	try beta(LastB, MsgA,
		 {partial, BMsgs, {Fun, S, M}, D}) of
	    {ok, []} ->
		[];
	    {ok, Seq} ->
		Seq
	catch
	    error:Other ->
		exit({error,
		      {internal_error,
		       invalid_beta_reduction,
		       Other}})
	end,
    
    NResBeta =  BMsgs ++ ResSeq,
    case NResBeta of
	[] ->
	    {error,
	     {not_found, lists:reverse(ResBeta) ++ B}};
	_ ->
	    beta_reduction1(Id, Matches, ARest, BRest,
			    [{Fun, NResBeta} | ResBeta],
			    {M, D}, S)
    end.

%%  Only allowed to use on single pattern join
%%  for none.
beta_reduction_for([], _, _, B, _, _, _) ->
%    io:format("Beta reduction for final~n", []),
    {error, {not_found, B}};
beta_reduction_for([Id | Rest], Matches, A, B, Res, MD, S) ->
    exit({error, for_now}),
    NRes = beta_reduction1(Id, Matches, A, B, Res, MD, S),
    case NRes of
	{error, {not_found, NB}} ->
	    beta_reduction_for(Rest, Matches, A, NB, Res, MD, S);
	_ -> NRes
    end.

purge_messages(Joins, Ids) ->
    purge_messages0(Joins, Ids, []).

purge_messages0([], _, Result) ->
    lists:reverse(Result);
purge_messages0([Join | JSRest], Ids, Result) ->
    NJoin = purge_messages1(Join, Ids),
    purge_messages0(JSRest, Ids, [NJoin | Result]).

purge_messages1([Alpha | Beta], Ids) ->
    NJoins = lists:map(
	       fun({Id, #pattern_joins{msgs=Msgs}=P}) ->
		       NMsgs = Msgs -- Ids,
		       {Id, P#pattern_joins{msgs=NMsgs}}
	       end, Alpha),
    NBeta = lists:map(
	      fun({Fun, _}) ->
		      %% FIXME: we could possibly leave some information?
%		      NBMsgs = lists:filter(
%				 fun(List) ->
%					 contains_list(Ids, List)
%				 end, BMsgs),
%		      {Fun, NBMsgs}
		      {Fun, []}
	      end, Beta),
    [NJoins | NBeta].

propagation_ids(Ids, [Alpha | _]) ->
    {A0, A1, A2} = 
	lists:foldl(
	  fun({Id,
	       {_, #pattern_joins{prop=yes}}},
	      {Acc0, Acc1, Acc2}) ->
		  {Acc0, [Id | Acc1], [{prop, Id} | Acc2]};
	     ({Id, _},
	      {Acc0, Acc1, Acc2}) ->
		  {[Id | Acc0], Acc1, [Id | Acc2]}
	  end,
	  {[], [], []},
	  lists:zip(Ids, Alpha)),
    {lists:reverse(A0),
     lists:reverse(A1),
     lists:reverse(A2)}.

verify_join({ok, Joins}) ->
    try lists:foreach(
	  fun([Alpha | Beta]) ->
		  NumA = length(Alpha),
		  NumB = length(Beta),
		  true = (NumA > 0),
		  case NumA of 
		      1 -> (1 = NumB);
		      _ -> (NumB = (NumA - 1))
		  end
	  end, Joins)
    catch
	error:_ ->
	    throw({error, joins_verification_failed})
    end,
    {ok, Joins}.

%%  ---- Misc ------
%%  ----------------

get_msgs([], Result) ->
    lists:reverse(Result);
get_msgs([Head | Rest], Result) ->
    get_msgs(Rest, [erlang:search_index(Head) | Result]).

remove_msgs([], Result) ->
    lists:reverse(Result);
remove_msgs([{prop, Id} | Rest], Result) ->
    remove_msgs(Rest, [erlang:search_index(Id) | Result]);
remove_msgs([Head | Rest], Result) ->
    {ok, Msg} = erlang:receive_index(Head),
    remove_msgs(Rest, [Msg | Result]).

-endif.
jerlang/src/jerlang_vm_core.erl0000644000175000017500000001546511220224120016470 0ustar  huberthubert-module(jerlang_vm_core).

-ifdef(use_joins_vm).

-export([test_raw/0]).
-export([loop/4]).
-import(jerlang_misc, [convert_now/1]).

-include("jerlang.hrl").

-define(CASE_TEST_GUARD, test_entry).
-define(CASE_RUN_ACTION, run_all).


-spec(loop/4 :: (fun((timeout(), ref()) -> any()),
		 [alpha()],
		 [receive_fun_test()],
		 receive_timeout()) -> {'ok', any()}).

check_invalid_timeout([{timeout, Timeout, _}])
  when (Timeout == infinity) ->
    ok;
check_invalid_timeout([{timeout, Timeout, _}])
  when (not(is_number(Timeout))) orelse (Timeout < 0) ->
    exit({error, {invalid_timeout, Timeout}});
check_invalid_timeout(_) ->
    ok.

loop(Search, Joins, Actions, Options) ->
    ok = check_invalid_timeout(Options),
%    io:format("OPTIONS: ~p~n", [Options]),
    Opt = parse_options(Options),
    search_reset(),
    receive_loop(Search, Joins, Actions, Opt).

parse_options([]) ->
    #opt{timeout=infinity,
	 t_action=none,
	 timer=disabled};
parse_options([{timeout, Timeout, TAction}]) ->
    #opt{timeout=Timeout,
	 t_action=TAction,
	 timer=disabled}.

receive_loop(Search, Joins, Actions, Opt) ->
%    io:format("Receive_loop: ~p~n", [Opt]),
    {Timeout, NOpt} = process_timeout(Opt),
%    io:format("Receive_loop2: ~p|~p~n", [Timeout, NOpt]),
    receive_with_timeout(Search, Joins, Actions,
			 NOpt, Timeout).

receive_with_timeout(_Search, _Joins, _Action,
		     #opt{t_action=TAction}, Timeout)
  when (Timeout < 0) ->
    TAction();    
receive_with_timeout(Search, Joins, Actions,
		     Opt, Timeout)
  when (Timeout >= 0) orelse (Timeout == infinity) ->

    Ref = make_ref(),
    Result = Search(Timeout,Ref),
    case Result of
	{timeout, Ref} ->
	    timeout_action(Search, Joins, Actions, Opt);
	M ->
	    {ok, Index} = last_search_index(),
	    NOpt = update_timeout(Opt),
	    message(process_join({Index, M}, Joins, Actions, []),
		    Search, Actions, NOpt)
    end.

process_timeout(#opt{timer=disabled} = Opt) ->
    {0, Opt};
process_timeout(#opt{timeout=infinity} = Opt) ->
    {infinity, Opt};
process_timeout(#opt{timeout=0} = Opt) ->
    {0, Opt};
process_timeout(#opt{timeout=Timeout} = Opt) when (Timeout < 0) ->
    {Timeout, Opt};
process_timeout(#opt{timeout=Timeout} = Opt) ->
    {Timeout, Opt#opt{s_time=(convert_now(erlang:now()))}}.

update_timeout(#opt{timer=disabled} = Opt) ->
    Opt;
update_timeout(#opt{timeout=infinity} = Opt) ->
    Opt#opt{timer=disabled};
update_timeout(#opt{s_time=Time, timeout=Limit} = Opt) ->
    Opt#opt{timeout=(Limit-(convert_now(erlang:now())-Time)),
	    timer=disabled}.

timeout_action(_, _, _, #opt{timer=enabled, t_action=TAction}) ->
    TAction();
timeout_action(Search, Joins, Actions, Opt) ->
    receive_loop(Search, Joins, Actions,
		 Opt#opt{timer=enabled}).
    

message({ok, Result}, _, _, _) ->
    Result;
message({error, NJoins}, Search, Actions, Options) ->
    receive_loop(Search, NJoins, Actions, Options).

process_join({_, _}, [], _, JoinsTests) ->
    {error, lists:reverse(JoinsTests)};
process_join({Id, Msg}, [JoinTests | JoinsRest],
	     [JoinAction | ActionsRest],
	     JoinsTests) ->

    %%  FIXME: Update variable is useless here, since always
    %%  at least one is satisfied
    {NJoin, Update} = 
	lists:mapfoldl(
		fun({PId, #pattern_joins{test=F, msgs=Msgs} = PRec} = P, S) ->
			case F(Msg) of
			    true ->
				{{PId, PRec#pattern_joins{msgs=Msgs ++ [Id]}},
				 yes};
			    _ ->
				{P, S}
			end
		end, no, JoinTests),

    Result1 = check_joins(Update, NJoin, JoinAction, Id),
    case run_joins(Result1, JoinAction, NJoin) of
	{error, _} ->
	    process_join({Id, Msg}, JoinsRest, ActionsRest,
			 [NJoin | JoinsTests]);
	Other  -> Other
    end.
    
check_joins(no, _, _, _) ->
    {error, no_match};
check_joins(yes, JoinPatterns, Action, Id) ->
    PMsgs = lists:map(
      fun({_, #pattern_joins{msgs=Msgs}}) ->
	      Msgs
      end, JoinPatterns),
    %% Either returns error or found set
    jerlang_mset:common_sets(
      PMsgs, {fun partial_run/2, Action, Id}).

partial_run(MsgIds, Action) ->
    MatchedMsgs = get_messages(MsgIds, [], fun erlang:search_index/1),
    try Action(MatchedMsgs, ?CASE_TEST_GUARD) of
	true ->
	    {ok, MsgIds, MatchedMsgs};
	false ->
	    error
    catch
	error:{badmatch, _} ->
	    error
    end.

get_messages([], Result, _) ->
    lists:reverse(Result);
get_messages([Head | Rest], Result, F) ->
    get_messages(Rest, [F(Head) | Result], F).

run_joins({ok, MsgIds, Messages}, Action, Joins) ->
    FilteredIds = propagation_filter(MsgIds, Joins, []),
    ok = purge_process_mailbox(FilteredIds),
    {ok, Action(Messages, ?CASE_RUN_ACTION)};
run_joins({error, _} = Error, _, _) ->
    Error.

purge_process_mailbox([]) ->
    ok;
purge_process_mailbox([Id | Rest]) ->
    {ok, _Msg} = erlang:receive_index(Id),
    purge_process_mailbox(Rest).

propagation_filter([], [], Result) ->
    lists:reverse(Result);
propagation_filter([Id | IdRest], [{_, #pattern_joins{prop=no}} | Rest], Result) ->
    propagation_filter(IdRest, Rest, [Id | Result]);
propagation_filter([Id | IdRest], [{_, #pattern_joins{prop=yes}} | Rest], Result) ->
    propagation_filter(IdRest, Rest, Result).

test_raw() ->
%    self() ! single,
    self() ! {one, 12},
    self() ! {two, 2},
    self() ! three,

    A = 12,

%    self() ! single,
    self() ! {four, 17},
    self() ! {five, 6},
    %%    self() ! five,
    R2 = loop(
	   fun(Timeout, Ref) ->
		   search
		       single -> single;
		       {four, SomeInt} -> {four, SomeInt};
		       {five, Int} -> {five, Int}
		   after Timeout ->
			   {timeout, Ref}
		   end
	   end,
	   [[{1, #pattern_joins{test=
			  fun(Value) ->
				  case Value of
				      single -> true;
				      _ -> false
				  end
			  end, msgs=[]}}],
	    [{2, #pattern_joins{test=
			  fun(Value) ->
				  case Value of
				      {four, SomeInt} -> true;
				      _ -> false
				  end
			  end, msgs=[]}},
	     {3, #pattern_joins{test=
			  fun(Value) ->
				  case Value of
				      {five, Int} -> true;
				      _ -> false
				  end
			  end, msgs=[]}}]],
   
    %% TODO how assignment in receive changes things?
	   [fun(Res1, Case) ->
		    [single] = Res1,
		    Ret = true,
		    case Case of
			test_entry -> Ret;
			run_all ->
			    io:format("Three !~n", []),
			    {finished, single}
		    end
	    end,
	    fun(Res2, Case) ->
		    [{four, Z}, {five, I}] = Res2,
		    Ret = is_integer(Z) andalso (Z > 15) and (I > 3),
		    case Case of
			test_entry -> Ret;
			run_all ->
			    io:format("Four !~n", []),
			    {finished_second, {Z, I}}
		    end
	    end],
	   [{timeout, 10000,
	     fun() ->
		     io:format("Timeout occured~n", []),
		     timeout_ok
	     end}]),
    io:format("Finished the second receive with: ~p~n", [R2]).

%test() ->
%    C = 15,
%    A = 12,
%    self() ! {one, 12},
%    self() ! {two, 2},
%    self() ! three,
%
%    receive
%	three ->
%	    {ok, C};
%	{one, A} and {two, B} ->
%	    {ok, {A, B}}
%    end.

-endif.
jerlang/src/jerlang_tests_vm.erl0000644000175000017500000002020511220224120016666 0ustar  huberthubert-module(jerlang_tests_vm).

-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
-endif.

-ifdef(use_joins_vm).
-export([test_suite/0]).

clear_mailbox() ->
    receive
	M -> io:format("Mailbox entry: ~p~n", [M]),
	     clear_mailbox()
    after 0 ->
	    ok
    end.

read_mailbox() ->
    search
	Z -> io:format("Search found ~p~n", [Z]),
	     read_mailbox()
    after 0 -> 
	    ok
    end.

trace_loop() ->
    receive
	{trace, _, call, X} ->
	    io:format("Call: ~p~n", [X]);
	{trace, _, return_from, Call, Ret} ->
	    io:format("Return From: ~p => ~p~n", [Call, Ret]);
	Other ->
	    io:format("Other = ~p~n", [Other])
    end,
    trace_loop().

tracer() ->
    dbg:tracer(),
    dbg:tpl(vm_tests, '_',
	    dbg:fun2ms(fun(_) ->
			        nothing end)),
    dbg:p(all, [c]).

test_suite() ->
    ok = test_simple_search_pointer(),
    ok = test_simple_search(),
    ok = test_receive_and_search(),
    ok = test_reset_search(),
    ok = test_basic(),
    ok = test_search_order(),
    ok = test_last_message(),
    ok = test_search_index(),
    ok = test_receive_index(),
    ok = test_message_indexing(),

    io:format("Finished test-suite.~n", []).

test_simple_search_pointer() ->
    io:format("Starting simple_search_pointer test...~n", []),
    clear_mailbox(),
    self() ! one,
    self() ! two,
    self() ! three,
    %% Search first fragment
    ok = search
	     one ->
		 ok
	 after 0 ->
		 error
	 end,
    %% Pointer should be set on two, since no
    %% other message was sent and pointer should
    %% have been moved to the next one
    ok = search
	     Msg ->
		 Msg = two,
		 ok
	 after 0 ->
		 error
	 end,

    %% Attempt to look for non-existing message
    ok = search
	     none ->
		 error
	 after 0 ->
		 ok
	 end,
    
    %% Pointer should be at the end of the mailbox
    %% Search for 'three' should fail
    ok = search
	     three ->
		 error
	 after 0 ->
		 ok
	 end,
    
    %% Reset search pointer
    ok = search_reset(),
    ok = search
	     three ->
		 ok
	 after 0 ->
		 error
	 end,
    
    %% Set pointer at the beginning of the mailbox
    ok = search_reset(),
    ok = search
	     Msg2 ->
		 Msg2 = one,
		 ok
	 after 0 ->
		 error
	 end,
    ok.    
 
test_last_message()->
    io:format("Starting last_message test...~n", []),
    clear_mailbox(),
    search_reset(),
    
    self() ! one,
    self() ! two,
    self() ! three,
    
    ok = search
	none ->
	    error
    after 0 ->
	    ok
    end,
    
    ok = receive
	three ->
	    ok
    after 0 ->
	    error
    end,

    self() ! four,
    self() ! five,

    ok = search
	four ->
	    ok
    after 0 ->
	    error
    end,
    self() ! six,
    ok = receive
	     six ->ok
	 after 0 ->
		 error
	 end,
    self() ! seven,
    ok = search
	     seven -> ok
	 after 0 -> error
	 end,
    ok.

test_basic() ->
    io:format("Starting basic test...~n", []),
    clear_mailbox(),
    self() ! one,
    self() ! two,
    
    ok = search
	     z -> error
	 after 0 ->
		 ok
	 end,
    clear_mailbox(),
    self() ! three,
    timer:sleep(100),
    ok = search
	three -> ok
    after 0 ->
	    error
    end,
    ok.

test_search_order() ->
    io:format("Starting search_order test...~n", []),
    clear_mailbox(),

    self() ! {one, 1},
    self() ! {two, 1},
    self() ! {one, 1},
    self() ! {one, 2},

    ok = 
	search
	    {one, 1} ->
		ok
	after 0 ->
		error
	end,
    {ok, Idx1} = last_search_index(),
    
    ok = 
	search
	    {one, 1} ->
		ok
	after 0 ->
		error
	end,
    {ok, Idx2} = last_search_index(),
    
    false = (Idx1 == Idx2),
    true = (Idx1 < Idx2),
    ok =
	search
	    {one, 2} ->
		ok
	after 0 ->
		error
	end,
    {ok, Idx3} = last_search_index(),
    true = (Idx2 < Idx3),

    ok = 
	receive
	    {one, 1} ->
		ok
	after 0 ->
		error
	end,

    undefined = erlang:search_index(Idx1),
    {one, 1}  = erlang:search_index(Idx2),
    [{messages, [{two, 1}, {one, 1}, {one, 2}]}] = 
	process_info(self(), [messages]),
    ok.

test_receive_and_search() ->
    io:format("Starting receive_and_search test...~n", []),
    clear_mailbox(),
    
    self() ! one,
    self() ! two,
    self() ! three,

    ok = search
	     two -> ok
	 after 0 ->
		 error
	 end,
    ok = receive
	     two -> ok
	 end,

    ok = search
	     three -> ok
	 after 0 ->
		 error
	 end,
    
    ok = search_reset(),
    ok = search
	     two -> error
	 after 0 ->
		 ok
	 end,
    
    ok = search_reset(),
    ok = receive
	     one -> ok
	 after 0 ->
		 ok
	 end,
    ok = search
	     Msg ->
		 Msg = three,
		 ok
	 after 0 ->
		 error
	 end,
    ok.

test_reset_search() ->
    io:format("Starting reset_search test...~n", []),
    clear_mailbox(),
    search_reset(),
    self() ! {one, 1},
    self() ! {one, 2},
    self() ! {two, 1},
    self() ! {two, 4},
    self() ! {two, 2},
    self() ! {two, 3},

    ok = search
	     {one, 2} -> ok
	 after 0 ->
		 error
	 end,

    ok = receive
	     {two, 1} -> ok
	 after 0 ->
		 error
	 end,
    ok = receive
	     {two, 4} -> ok
	 after 0 ->
		 error
	 end,
    
    ok = search
	     {two, 1} -> error;
	     {two, 4} -> error;
	     {two, 2} -> ok
	 after 0 ->
		 error
	 end,

    search_reset(),
    ok = search
	     {two, 2} -> ok
	 after 0 ->
		 error
	 end,
    ok.

test_simple_search() ->
    io:format("Starting simple_search test...~n", []),
    clear_mailbox(),

    self() ! {one, 1},
    self() ! {two, 1},
    self() ! {two, 2},
    self() ! {three, 1},

    ok = search
	     {one, _} -> ok
	 end,

    ok = search
	     {two, Z} -> 1 = Z,
			 ok
	 end,

    self() ! {two, 3},
    self() ! {two, 4},
    ok = receive
	{two, 3} -> ok
    end,
    ok = search
	     {two, 4} ->
		 ok
	 after 0 ->
		 error
	 end,

    self() ! {four, 1},
    ok = search
	     {two, 3} ->
		 error;
	     {four, 1} ->
		 ok
    after 0 ->
	    error
    end,
    ok = receive
	     M ->
		 M = {one, 1},
		 ok
	 after 0 ->
		 error
	 end,
    ok.

test_search_index() ->
    io:format("Starting search_index test...~n", []),
    clear_mailbox(),
    search_reset(),

    self() ! {one, 1},
    self() ! {two, 1},
    
    ok =
	search
	    {two, _} ->
		ok
	after 0 ->
		error
	end,
    {ok, Index} = last_search_index(),
    
    {two, 1} = erlang:search_index(Index),
    self() ! {two, 2},
    ok = 
	search
	    {two, _} ->
		ok
	after 0 ->
		error
	end,
    {ok, Index2} = last_search_index(),
    true = Index2 > Index,
    {two, 2} = erlang:search_index(Index2),
    [{messages,
      [{one, 1}, {two, 1}, {two, 2}]}] = 
	process_info(self(), [messages]),
    undefined = erlang:search_index(Index2 + 1),
    search_reset(),
    
    ok = search
	     {two, 2} ->
		 ok
	 after 0 ->
		 error
	 end,
    {ok, Index2} = last_search_index(),
    %%  search_index/1 does not depend on
    %%  on the search pointer in vm
    {one, 1} = erlang:search_index(Index - 1),
    
    ok = receive
	     {one, 1} ->
		 ok
	 after 0 ->
		 error
	 end,
    undefined = erlang:search_index(Index -1),
    ok.


test_receive_index() ->
    io:format("Starting receive_index test...~n", []),
    clear_mailbox(),

    self() ! one,
    self() ! one,
    self() ! two,
    self() ! one,
%    io:format("RECEIVE??? ~p~n", [process_info(self(), [messages])]),
    ok = 
	search
	    one ->
		ok
	after 0 ->
		error
	end,
    {ok, Idx1} = last_search_index(),

    ok =
	search
	    one ->
		ok
	after 0 ->
		error
	end,
    {ok, Idx2} = last_search_index(),

    ok = 
	search
	    one ->
		ok
	after 0 ->
		error
	end,
    {ok, Idx3} = last_search_index(),

    {ok, one} = erlang:receive_index(Idx3),

    [{messages,
      [one, one, two]}] = 
	process_info(self(), [messages]),

    ok = receive
	     one ->
		 ok
	 after 0 ->
		 error
	 end,
    [{messages,
      [one, two]}] = 
	process_info(self(), [messages]),

    undefined = erlang:receive_index(Idx1),
    {ok, one} = erlang:receive_index(Idx2),
    ok = receive
	     V ->
		 V = two,
		 ok
	 after 0 ->
		 error
	 end,

    [{messages,
      []}] = 
	process_info(self(), [messages]),   
    undefined = erlang:receive_index(Idx2),
    ok.

test_message_indexing() ->
    io:format("Starting message_indexing test...~n", []),
    clear_mailbox(),
    lists:foreach(
      fun(Elem) ->
	      undefined = erlang:search_index(Elem)
      end,
      lists:seq(0,1000)),

    ok.

-endif.
jerlang/src/jerlang_tests.erl0000644000175000017500000002752011220224120016173 0ustar  huberthubert-module(jerlang_tests).

-ifdef(use_joins_vm).
-compile({parse_transform, jerlang_vm_parse}).
-else.
-compile({parse_transform, jerlang_parse}).
-endif.

-export([test_suite/0]).

-record(test0, {a, b, c, d}).
-record(test1, {one, two}).

test_suite() ->
    ok = test_simple_receive(),
    ok = test_simple_joins(),
    ok = test_timeout(),
    ok = test_guards(),
    ok = test_deep_receive(),
    ok = test_propagation(),
    ok = test_process_info(),
    ok = test_receive_match(),
    ok = test_compiler_warnings(),
    ok = test_unbounded_variables(),
    ok = test_remote_receive(),
    ok = test_performance(),
    ok = test_no_receive(),
    io:format("Finished test_suite...~n", []),
    ok.

clear_mailbox() ->
    receive
	M -> io:format("Mailbox entry: ~p~n", [M]),
	     clear_mailbox()
    after 0 ->
	    ok
    end.

test_simple_receive() ->
    io:format("Starting simple_receive test...~n", []),
    clear_mailbox(),
    self() ! {one, 4},
    ok = receive
	     {one, 4} ->
		 ok;
	     _ ->
		 error
	 end,

    self() ! invalid,
    self() ! {two, 1},
    ok = receive
	     {A, B} ->
		 A = two,
		 B = 1,
		 ok
	 end,
    ok.

test_simple_joins() ->
    io:format("Starting simple_joins test...~n", []),
    clear_mailbox(),
    self() ! {one, 1},
    self() ! {two, 2},
    self() ! {three, 3},
    
    
    ok = receive
	     {one, A} and {three, B} ->
		 A = 1, B = 3, ok;
	     test ->
		 error
	 end,

    self() ! a,
    self() ! b,
    ok = receive
	     a and b->
		 error;
	     {two, 2} ->
		 ok
	 end,
    ok = receive
	     a and b ->
		 ok;
	     invalid2->
		 error
	 end,

    self() ! one,
    self() ! two,
    self() ! three,
    ok = receive
	     four ->
		 error;
	     one and two and three ->
		 ok
	 end,

    self() ! foo,
    self() ! foo, 
    self() ! foo,
    self() ! foo,
    ok = receive
	     foo and foo and foo and foo ->
		 ok
	 end,

    clear_mailbox(),
    self() ! {one, 1},
    self() ! {two, 3},
    Z = 4,
    A = 1,
    ok = receive
	     {two, 3} and {one, Z} ->
		 error;
	     {two, 3} and {one, A} ->
		 ok
	 end,
    self() ! {test, test1, test2},
    self() ! foo,
    ok = receive
	     _X and foo ->
		 error;
	     X ->
		 {test, _, _} = X,
		 ok
	 end,
    self() ! {test1, 10},
    self() ! {test2, 15},
    self() ! {test3, 10},
    ok = receive
	     {C, X1} and {B, X1} ->
		 try
		     C = test1,
		     B = test3,
		     ok
		 catch
		     error:{badmatch, _} ->
			 C = test3,
			 B = test1,
			 ok
		 end 
	 end,
    ok.

%%  This is partially tested by the clear_mailbox
%%  function
test_timeout() ->
    io:format("Starting timeout test...~n", []),
    clear_mailbox(),
    ok = receive
	     _ ->
		 error
	 after 0 ->
		 ok
	 end,
    
    self() ! {foo, 1},
    self() ! {foo, 2},

    ok = receive
	     {bar, _X, _Y} ->
		 error;
	     {foo, 3} ->
		 error
	 after 1000 ->
		 ok
	 end,
    B = -100,
    ok = try 
	     receive
		 _ ->
		     error
	     after B ->
		     error
	     end
	 catch
	     exit:{error, {invalid_timeout, _}} ->
		 ok
	 end,
		
    Self = self(),
    spawn(fun() ->
		  timer:sleep(1000),
		  Self ! {foo, bar, 100}
	  end),
    %% TODO: better ranges checking?
    ok = receive
	     {X, Y, Z} ->
		 X = foo, Y = bar, Z = 100, ok
	 after 3000 ->
		 error
	 end,

    self() ! unique1,
    self() ! unique2,
    self() ! unique3,
    ok = receive
	     unique1 and unique2 and unique3 ->
		 ok
	 after 0 ->
		 error
	 end,
    ok.

test_guards() ->
    io:format("Starting guards test...~n", []),
    clear_mailbox(),
    
    self() ! {foo, 12, 14},
    self() ! {bar, invalid},
    self() ! final,
    
    ok = receive
	     {foo, X1, _X2} and {bar, _}
	       when (X1 < 5) ->
		 error;
	     final ->
		 ok
	 end,

    ok = receive
	     {foo, X1, _X2} and {bar, _} when (X1 > 20) ->
		 error;
	     {foo, X1, _X2} and {bar, _} when (X1 < 20) ->
		 ok
	 end,

    self() ! {test1, 10},
    self() ! {test2, 20},
    self() ! {test3, 10},
    %%  Nondeterminism on which assignment is going to be choosen.
    %%  This actually depends on the implementation of the
    %%  oommon set algorithm
    ok = receive
	     {A, X1} and {_B, X2}
	       when (X1 == X2) andalso (A == test1) ->
		 ok;
	     {A, X1} and {_B, X2}
	       when (X1 == X2) andalso (A == test3) ->
		 ok
	 after 0 ->
		 error
	 end,

    ok.

test_deep_receive() ->
    io:format("Starting deep receive test...~n", []),
    clear_mailbox(),
   
    self() ! {foo, 1},
    self() ! {foo, 2},
    self() ! {foo, 3},
    self() ! bar,
    self() ! bar_test,
    
    ok = receive
	     {foo, _A} and {foo, _B} ->
		 receive
		     bar and {foo, 3} ->
			 ok
		 end;
	     {foo, 3} ->
		 error
	 end,

%    search_debug(on),
    self() ! {bar, 1},
    self() ! {bar, 2},
    self() ! {bar, 3},

    ok = receive
	     {bar, 1} and {bar, 2} and {bar, 3} ->
		 error;
	     bar_test and {bar, 2} ->
		 self() ! {bar, 4},
		 F = fun() ->
			     ok = receive
				 {bar, 4} ->
				     error;
				 {bar, 3} and {bar, 1} ->
				     ok
			     end,	     
			     ok
		     end,
		 F()
	 end,
    ok.

test_propagation() ->
    io:format("Starting propagation test...~n", []),
    clear_mailbox(),

    self() ! foo,
    self() ! bar,
    
    ok = receive
	     prop(foo) and prop(bar) ->
		 ok
	 end,
    ok = receive
	     foo and bar ->
		 ok
	 after 0 ->
		 error
	 end,
    ok = receive
	     foo ->
		 error;
	     bar ->
		 error
	 after 0 ->
		 ok
	 end,

    self() ! test1,
    self() ! test2,
    self() ! test3,
    ok = receive
	     test3 ->
		 error;
	     prop(test1) and test2 ->
		 ok
	 end,

    ok = receive
	     test3 ->
		 error;
	     prop(test1) ->
		 ok
	 end,

    self() ! second,
    ok = receive
	     second and test3 and test1 ->
		 ok
	 after 0 ->
		 error
	 end,

    ok.

test_process_info() ->
    io:format("Starting process_info test...~n", []),
    clear_mailbox(),
    ok.

test_receive_match() ->
    io:format("Starting receive_match test...~n", []),
    clear_mailbox(),

    %%  8 different cases
    %%  Although we check only few of them the whole
    %%  point is that they compile properly.
    ok = receive
	     _One and _Two and _Three ->
		 error
	 after 0 ->
		 ok
	 end,

    self() ! foo1,
    self() ! test1,
    self() ! test2,
    self() ! three,
    self() ! foo2,
    
    ok = receive
	     _One and _Two and Three=three ->
		 Three=three, 
		 ok
	 after 0 ->
		 error
	 end,
    clear_mailbox(),

    ok = receive
	     _One and Two=two and _Three ->
		 Two=two,
		 error
	 after 0 ->
		 ok
	 end,

    self() ! test1,
    self() ! three,
    self() ! three,
    self() ! two,
    ok = receive
	     One and Two=two and Three=three ->
		 Two=two,
		 Three=three,
		 true = (One == test1) or (One == three),
		 ok
	 after 0 ->
		 error
	 end,
    clear_mailbox(),
    ok = receive
	     _One=one and _Two and _Three ->
		 error
	 after 0 ->
		 ok
	 end,

    self() ! foo1,
    self() ! foo2,
    self() ! three,
    self() ! four,
    self() ! {one, b},
    ok = receive
	     One={one, Z} and Two and Three=three when is_atom(Z) ->
		 One={one, b},
		 Three=three,
		 true = (Two == foo1) or (Two == foo2) or (Two == four),
		 ok
	 after 0 ->
		 error
	 end,
    clear_mailbox(),
    ok = receive
	     One=one and Two=two and _Three ->
		 One=one,
		 Two=two,
		 error
	 after 0 ->
		 ok
	 end,
    self() ! foo1,
    self() ! three,
    self() ! foo2,
    self() ! one,
    self() ! foo3,
    self() ! two,
    ok = receive
	     One=one and Two=two and Three=three ->
		 One=one,
		 Two=two,
		 Three=three,
		 ok
	 after 0 ->
		 error
	 end,

    %%  More sophisticated matching
    
    clear_mailbox(),
    %%  Matching and propagation
    %%  Propagation is only allowed on the whole pattern
    %%  Including pattern. This avoids any problems that could
    %%  arise and we are consistent.
    Val1 = foo,
    self() ! {one, foo},
    self() ! one,
    self() ! foo,
    self() ! {two, foo},
    ok = receive
	     One=one and prop(Two=Val1) ->
		 One=one,
		 foo=Two,
		 ok
	 after 0 ->
		 error
	 end,
    ok.

test_compiler_warnings() ->
    io:format("Starting compiler_warnings test...~n", []),
    clear_mailbox(),
    Rec = #test0{a=1, b=2, c=3},
    #test0{b=B} = Rec,
    {_, _, A} = {foo, bar, test},
    
    ok = receive
	     A and B ->
		 A=test,
		 B=2,
		 error
	 after 0 ->
		 ok
	 end,
    ok = receive
	     %%  Expecting a single compiler warning on X
	     #test1{one=X} and #test1{two=B} ->
		 error
	 after 0 ->
		 ok
	 end,
    Bin = <<16#12345678:32/native>>,
    <<Head:10, _:10, Tail:12>> = Bin,
    Fixed = 10,
    ok = receive
	     {Head, Tail} and bar ->
		 error;
	     %%  Expecting compilation error on Test and Size
	     %%  but only once, as normally
%	     <<Head:Size/binary, 20:10>> and foo ->
	     <<Head:Fixed/binary, 20:10>> and foo ->
		 error
	 after 0 ->
		 ok
	 end,

    Val2 = bar,
    F = fun({ok, Arg1, Arg2}) ->
		%% pre: Arg1 == Arg2
		receive
		    {Arg1, Z} ->
			Arg1 = Arg2,
			receive
			    Z ->
				Z = Val2,
				ok
			end
		after 0 ->
			error
		end
	end,
    self() ! bar,
    self() ! foo,
    self() ! {foo, bar},
    ok = F({ok, foo, foo}),
    ok.

test_unbounded_variables() ->
    io:format("Starting unbounded_variables test...~n", []),
    clear_mailbox(),
    self() ! {ok, foo, bar},
    ok = receive
	     {ok, _, _} ->
		 ok
	 after 0 ->
		 error
	 end,

    self() ! {bar, 1},
    self() ! {foo, 2},
    ok = receive
	     {foo, _} and {bar, _} ->
		 ok
	 after 0->
		 error
	 end,
    %% FIXME: need to test patterns like {ok, _, _}
    %% where both '_' are different
    ok.
test_no_receive() ->
    io:format("Starting no_receive test...~n", []),
    clear_mailbox(),

    self() ! test1,
    self() ! test2,

    ok = receive
	     after 1000 ->
		     ok
	 end,
    %% FIXME: This should correctly handle the case
    %% like receive end.
    ok.

test_remote_receive() ->
    io:format("Starting remote_receive test...~n", []),
    clear_mailbox(),
    ok.

test_performance() ->
    %%  Check the behaviour of the mailbox on huge
    %%  number of messages and joins
    io:format("Starting performance test...~n", []),
    clear_mailbox(),
    ok.


%%%% How the example would normally be represented
%%%% after applying parse_transform
%    ok = receive
%        {single, B, _} when (B > 10) ->
%	    {finished, single};
%	prop({four, Z}) and {five, I} when is_integer(Z)
%	                             andalso (Z > 15)
%	                             and (I > 3)->
%	    io:format("Four !~n", []),
%	    {finished_second, {Z, I}}
%    after 10000 ->
%	    io:format("Timeout occureed~n", []),
%	    timeout
%    end,
 

%    R2 = jerlang_single_mailbox:loop(
%	   [[{1, #pattern{test=
%			  fun(Value) ->
%				  case Value of
%				      single -> true;
%				      _ -> false
%				  end
%			  end, msgs=[]}}],
%	    [{2, #pattern{test=
%			  fun(Value) ->
%				  case Value of
%				      {four, SomeInt} -> true;
%				      _ -> false
%				  end
%			  end, msgs=[]}},
%	     {3, #pattern{test=
%			  fun(Value) ->
%				  case Value of
%				      {five, Int} -> true;
%				      _ -> false
%				  end
%			  end, msgs=[]}}]],
%   
    %% TODO how assignment in receive changes things?
%	   [fun(Result0, Case0) ->
%                    [single] = Result0,
%                    Ret = true  %% none guards
%                    case Case0 of
%                        test_entry -> Ret;
%                        run_all ->
%                            io:format("Three !~n", []),
%		             {finished, single}
%                    end
%	     end
%	    fun(Result1, Case1) ->
%                    [{four, Z}, {five, I}] = Result1,
%                    Ret= is_integer(Z) andalso (Z > 15) and (I > 3),
%                    case Case1 of
%                        test_entry -> Ret;
%                        run_all ->
%                            io:format("Four !~n", []),
%		             {finished_second, {Z, I}}
%                    end
%	     end],
%	   [{timeout, 10000,
%	     fun() ->
%		     io:format("Timeout occured~n", []),
%		     timeout_ok
%	     end}]),
jerlang/src/jerlang_santa_presentation.erl0000644000175000017500000000441011220224120020723 0ustar  huberthubert-module(jerlang_santa_presentation).

-export([test_suite/0]).
-export([test_santa_claus_limited/1]).
-export([start_reindeer/0, start_elves/0, start_santa/0]).
-export([worker0/4]).
-import(jerlang_misc, [generate_seed/1, average/1]).

test_suite() ->
    jerlang_gen_joins_test_santa_parse:start(),
    start_reindeer(),
    ok.

test_santa_claus_limited(Counter) ->
    io:format("testing santa stuff limited~n", []),
    jerlang_gen_joins_test_santa_parse:start(),
    [spawn_link(?MODULE, worker0,
		[jerlang_gen_joins_test_santa_parse,
		 Counter, elf, Id]) || Id <- lists:seq(1,10)],
    [spawn_link(?MODULE, worker0,
		[jerlang_gen_joins_test_santa_parse,
		 Counter, reindeer, Id]) || Id <- lists:seq(1,9)],
    ok = jerlang_gen_joins_test_santa_parse:status({Counter, Counter}),
    %% Could use joins here ? :)
    ok =
	receive
	    {'EXIT', _, A} when (A /= normal) ->
		io:format("EXIT: ~p~n", [A]),
		error
	after 0 ->
		ok
	end.

start_santa() ->
    jerlang_gen_joins_test_santa_parse:start(),
    receive
	ok ->
	    ok
    end.

start_reindeer() ->
    Counter = 16,
        io:format("~p has ~p~n", [ok, global:registered_names()]),
    [spawn_link(?MODULE, worker0,
		[jerlang_gen_joins_test_santa_parse,
		 Counter, reindeer, Id]) || Id <- lists:seq(1,9)],
    receive
	ok ->
	    ok
    end.

start_elves() ->
    Counter = 16, 
    [spawn_link(?MODULE, worker0,
		[jerlang_gen_joins_test_santa_parse,
		 Counter, elf, Id]) || Id <- lists:seq(1,10)],
    receive
	ok ->
	    ok
    end.

worker0(Module, Num, Type, Id) ->
    generate_seed(Id),
    net_adm:ping(hubert@ciapek),
%    io:format("~p has ~p~n", [Id, global:registered_names()]),
    worker1(Module, Num, Type, Id).

worker1(_Module, 0, Type, Id) ->
    io:format("[~p ~p] finished.~n", [Type, Id]),
    ok;
worker1(Module, Num, Type, Id) ->
    receive after random:uniform(1000) -> ok end,
    io:format("[~p ~p] waiting~n", [Type, Id]),
    Res =
	try
	    ok = Module:Type(),
%	    io:format("DONE.~n", []),
	    Done = list_to_atom(atom_to_list(Type) ++ "_done"),
	    receive after random:uniform(1000) -> ok end,
	    io:format("[~p ~p] returning ~n", [Type, Id]),
	    Module:Done(),
	    ok
    catch
	_:_ ->
	    error
    end,
    case Res of
	ok ->
	    worker1(Module, Num-1, Type, Id);
	error ->
	    ok
    end.
jerlang/src/jerlang_santa_claus_sad.erl0000644000175000017500000000426611220224120020157 0ustar  huberthubert-module(jerlang_santa_claus_sad).
-export([start/0]).

-ifdef(use_joins_vm).
-compile({parse_transform, jerlang_vm_parse}).
-else.
-compile({parse_transform, jerlang_parse}).
-endif.

santa() ->
    io:format("It was a long night. Time to bed~n"),
    Group = 
	receive
	    {reindeer, Pid1} and {reindeer, Pid2} and {reindeer, Pid3} 
	      and {reindeer, Pid4} and {reindeer, Pid5} and {reindeer, Pid6}
	      and {reindeer, Pid7} and {reindeer, Pid8} and {reindeer, Pid9} ->
		io:format("Ho, ho, ho! Let's deliver presents!~n"),
		[Pid1, Pid2, Pid3, Pid4,
		 Pid5, Pid6, Pid7, Pid8, Pid9];
	    {ork, sergant, Pid1} and {ork, captain, Pid2} and {ork, sergant, Pid3} ->
		io:format("Ho, ho, ho? No presents this year. Orks destroyed the factory!~n"),
		[Pid1, Pid2, Pid3];
	    {elf, Pid1} and {elf, Pid2} and {elf, Pid3} ->
		io:format("Ho, ho, ho! Let's discuss R&D possibilites!~n"),
		[Pid1, Pid2, Pid3]
	end,
    [ Pid ! ok || Pid <- Group],
    santa().

worker(Santa, Type, Id, Action) ->
    generate_seed(Id),
    worker1(Santa, Type, Id, Action).
    
worker1(Santa, {ork, Type}, Id, Action) ->
    receive after random:uniform(8000) -> ok end,
    Santa ! {ork, Type, self()},
    io:format("~p '~p' ~p: Waiting at the gate~n", [ork, Type, Id]),
    receive ok -> ok end,
    io:format("~p '~p' ~p: ~p~n", [ork, Type, Id, Action]),
    worker1(Santa, {ork, Type}, Id, Action);
worker1(Santa, Type, Id, Action) ->
    receive after random:uniform(4000) -> ok end,
    Santa ! {Type, self()},
    io:format("~p ~p: Waiting at the gate~n", [Type, Id]),
    receive ok -> ok end,    
    io:format("~p ~p: ~p~n", [Type, Id, Action]),
    worker1(Santa, Type, Id, Action).

generate_seed(Seed) ->
    {A1, A2, A3} = now(),
    random:seed(A1+Seed, A2*Seed, A3).

start() ->
    Santa = spawn(fun() -> santa() end),
    [spawn(fun() -> worker(Santa, reindeer, I, " delivering toys.\n") end)
     || I <- lists:seq(1, 9)],
    [spawn(fun() -> worker(Santa, elf, I, " meeting in the study.\n") end)
     || I <- lists:seq(1, 10)],
    [spawn(fun() -> worker(Santa, {ork, sergant}, I, " destroying presents.\n") end)
     || I <- lists:seq(1,4)],
    spawn(fun() -> worker(Santa, {ork, captain}, 5, " making orders.\n") end).
jerlang/src/jerlang_santa_claus_minimal.erl0000644000175000017500000000433611220224120021034 0ustar  huberthubert-module(jerlang_santa_claus_minimal).
-export([start/1, time_santa_script/1]).

-ifdef(use_joins_vm).
-compile({parse_transform, jerlang_vm_parse}).
-else.
-compile({parse_transform, jerlang_parse}).
-endif.

santa(Main, Counter, Limit) ->
    io:format("It was a long night. Time to bed~n"),
    Group = 
	receive
	    {reindeer, Pid1} and {reindeer, Pid2} and 
	    {reindeer, Pid3} and {reindeer, Pid4} and
	    {reindeer, Pid5} and {reindeer, Pid6} and 
	    {reindeer, Pid7} and {reindeer, Pid8} and
	    {reindeer, Pid9} ->
		io:format("Ho, ho, ho! Let's deliver presents!~n"),
		[Pid1, Pid2, Pid3, Pid4,
		 Pid5, Pid6, Pid7, Pid8, Pid9];
	    {elf, Pid1} and {elf, Pid2} and {elf, Pid3} ->
		io:format("Ho, ho, ho! Let's discuss R&D possibilites!~n"),
		[Pid1, Pid2, Pid3]
    end,
    [ Pid ! ok || Pid <- Group],
    NCounter =
	case Counter < Limit of
	    true ->
		Counter + 1;
	    false ->
		Main ! stop,
		exit(normal)
	end,

    %% Synchronise on return of the animals
    receive
	{r, done} and {r, done} and {r, done} and
	{r, done} and {r, done} and {r, done} and
	{r, done} and {r, done} and {r, done} ->
	    ok;
	{e, done} and {e, done} and {e, done} ->
	    ok
    end,
    santa(Main, NCounter, Limit).

worker(Santa, Type, Id, Action, Ans) ->
    generate_seed(Id),
    worker1(Santa, Type, Id, Action, Ans).
    
worker1(Santa, Type, Id, Action, Ans) ->
    receive after random:uniform(1000) -> ok end,
    Santa ! {Type, self()},
    io:format("~p ~p: Waiting at the gate~n", [Type, Id]),
    receive ok -> ok end,    
    io:format("~p ~p: ~p~n", [Type, Id, Action]),
    Santa ! {Ans, done},
    worker1(Santa, Type, Id, Action, Ans).

generate_seed(Seed) ->
    {A1, A2, A3} = now(),
    random:seed(A1+Seed, A2*Seed, A3).

start(Counter) ->
    Pid = self(), 
    Santa = spawn(fun() -> santa(Pid, 0, Counter) end),
    [spawn(fun() -> worker(Santa, reindeer, I, " delivering toys.\n", r) end)
      || I <- lists:seq(1, 9)],
    [spawn(fun() -> worker(Santa, elf, I, " meeting in the study.\n", e) end)
     || I <- lists:seq(1, 10)],
    receive
	stop ->
	    ok
    end.

time_santa_script(Iter) ->
    {Time, _}
	= timer:tc(?MODULE,
		   start, [Iter]),
    
    io:format("Santa ~p took: ~p seconds~n",
	      [Iter, Time/1000000]).
jerlang/src/jerlang_santa_claus_common.erl0000644000175000017500000000444611220224120020700 0ustar  huberthubert-module(jerlang_santa_claus_common).
-export([santa/0, worker/4, secretary0/1]).
-export([start/0]).

-ifdef(use_joins_vm).
-compile({parse_transform, jerlang_vm_parse}).
-else.
-compile({parse_transform, jerlang_parse}).
-endif.


secretary0(SantaPid) ->
    self() ! {reindeers, 9},
    self() ! {elves, 3},
    secretary({[], []}, SantaPid).

secretary({Elves, Reindeers}, SantaPid) ->
    {Res, Wait} = 
	receive
	    {reindeer, Pid} and {reindeers, 1} ->
		self() ! {reindeers, 9},
		notify_santa(reindeers, SantaPid, [Pid | Reindeers]),
		{{Elves, []}, true};
	    {reindeer, Pid} and {reindeers, N} ->
		self() ! {reindeers, N - 1},
		{{Elves, [Pid | Reindeers]}, false};
	    {elf, Pid} and {elves, 1} ->
		self() ! {elves, 3},
		notify_santa(elves, SantaPid, [Pid | Elves]),
		{{[], Reindeers}, true};
	    {elf, Pid} and {elves, N} ->
		self() ! {elves, N - 1},
		{{[Pid | Elves], Reindeers}, false}
	end,
    ok = wait_for_santa(Wait),
    secretary(Res, SantaPid).

wait_for_santa(true) ->
    receive {santa, back} -> ok end;
wait_for_santa(_) ->
    ok.

notify_santa(Animal, Santa, Pids) ->
    Santa ! {wakeup, self(), Animal, Pids}.

notify(Pids) ->
    lists:foreach(
      fun(Pid) ->
	      Pid ! continue
      end, Pids).

santa() ->
    Pid = 
	receive
	    {wakeup, Secretary, Animal, Pids} ->
		santa_says(Animal),
		notify(Pids),
		Secretary
	end,
    timer:sleep(random:uniform(1000)),
    io:format("Santa is back. Going to sleep~n", []),
    Pid ! {santa, back},
    santa().

worker(Type, Secretary, Id, String) ->
    timer:sleep(random:uniform(1000)),
    Secretary ! {Type, self()},
    receive
	continue ->
	    ok
    end,
    worker(Type, Secretary, Id, String).
    

santa_says(reindeers) ->
    io:format("Ho, ho, ho! Let's deliver presents!~n", []);
santa_says(elves) ->
    io:format("Ho, ho, ho! Let's discuss R&D possibilities!~n", []).
    
start() ->
    Santa = spawn(?MODULE, santa, []),
    Secretary = spawn(?MODULE, secretary0, [Santa]), 
    [ spawn(?MODULE, worker, 
	    [elf, Secretary, X, "Elf "]) || X <- [1,3] ],
    [ spawn(?MODULE, worker,
	    [reindeer, Secretary, X, "Reindeer "]) || X <- [1,3,4,7,8,9] ],
    [ spawn(?MODULE, worker,
	    [elf, Secretary, X, "Elf "]) || X <- [2,4,5] ],
    [ spawn(?MODULE, worker,
	    [reindeer, Secretary, X, "Reindeer "]) || X <- [2,5,6] ].
jerlang/src/jerlang_santa_claus.erl0000644000175000017500000000561311220224120017325 0ustar  huberthubert-module(jerlang_santa_claus).
-export([santa/3]).
-export([start_timer/0]).
-export([start/0, start/2]).

-ifdef(use_joins_vm).
-compile({parse_transform, jerlang_vm_parse}).
-else.
-compile({parse_transform, jerlang_parse}).
-endif.

santa(Arg1, Arg2, Limits) ->
    santa(Arg1, Arg2, Limits, {0, 0}).

santa(Arg1, Arg2, Limits, {RN, EN}) ->
    %% Currently there is no way to dynamically
    %% generate patterns
    Res = receive
	{reindeer, Pid1, Ref1} and {reindeer, Pid2, Ref2} and 
	{reindeer, Pid3, Ref3} and {reindeer, Pid4, Ref4} and
	{reindeer, Pid5, Ref5} and {reindeer, Pid6, Ref6} and 
	{reindeer, Pid7, Ref7} and {reindeer, Pid8, Ref8} and
	{reindeer, Pid9, Ref9} ->
	    send_confirmation([{Pid1, Ref1}, {Pid2, Ref2},
			       {Pid3, Ref3}, {Pid4, Ref4},
			       {Pid5, Ref5}, {Pid6, Ref6},
			       {Pid7, Ref7}, {Pid8, Ref8},
			       {Pid9, Ref9}], done),
	    santa_says("Reindeers delivering presents"),
	    reindeers;
	{elf, Pid1, Ref1} and {elf, Pid2, Ref2}
	  and {elf, Pid3, Ref3} ->
	    send_confirmation([{Pid1, Ref1}, {Pid2, Ref2},
			       {Pid3, Ref3}], done),
	    santa_says("Elves discussing R&D possibilities"),
	    elves;
	{ork, _Pid}  ->
	    ork

    end,
    Counters = case Res of
	reindeers ->
	    receive
		{job_done, reindeer, Pid1, Ref1} and
		{job_done, reindeer, Pid2, Ref2} and
		{job_done, reindeer, Pid3, Ref3} and
		{job_done, reindeer, Pid4, Ref4} and
		{job_done, reindeer, Pid5, Ref5} and
		{job_done, reindeer, Pid6, Ref6} and
		{job_done, reindeer, Pid7, Ref7} and
		{job_done, reindeer, Pid8, Ref8} and
		{job_done, reindeer, Pid9, Ref9} ->
		    send_confirmation([{Pid1, Ref1}, {Pid2, Ref2},
				       {Pid3, Ref3}, {Pid4, Ref4},
				       {Pid5, Ref5}, {Pid6, Ref6},
				       {Pid7, Ref7}, {Pid8, Ref8},
				       {Pid9, Ref9}], finished),
		    {RN+1, EN}
	    end;
	elves ->
	    receive
		{job_done, elf, Pid1, Ref1} and
		{job_done, elf, Pid2, Ref2} and
		{job_done, elf, Pid3, Ref3} ->
		    send_confirmation([{Pid1, Ref1}, {Pid2, Ref2},
				       {Pid3, Ref3}], finished),
		    {RN, EN+1}
	    end;
	ork ->
	    {RN, EN}
    end,
    santa_continuation(Arg1, Arg2, Limits, Counters).

santa_continuation(Arg1, Arg2, {infinite, infinite}=L, Counters) ->
    santa_says("Going to sleep"),
    santa(Arg1, Arg2, L, Counters);
santa_continuation(_, _, {RLimit, ELimit}, {RN, EN})
  when (RLimit =< RN) and (ELimit =< EN) ->
    io:format("Simulation finished [~p | ~p] for [~p | ~p]~n",
	      [RN, EN, RLimit, ELimit]);
santa_continuation(Arg1, Arg2, Limits, Counters) ->
    santa_says("Going to sleep"),
    santa(Arg1, Arg2, Limits, Counters).
	    
send_confirmation(List, Message) ->
    [ Pid ! {Ref, Message} || {Pid, Ref} <- List].
	    
santa_says(Text) ->
    io:format("Santa: ~p~n", [Text]).

start() ->
    start(?MODULE, {infinite, infinite}).

start(Module, Args) ->
    santa_claus:start(Module, Args).

start_timer() ->
    santa_claus:start_timer(?MODULE).
jerlang/src/jerlang_philosophers2.erl0000644000175000017500000000227511220224120017632 0ustar  huberthubert-module(jerlang_philosophers2).
-export([philosopher/3,
	 waiter/2,
	 test/0]).

-compile({parse_transform, jerlang_parse}).

%% Note: probably the best solution, without
%% the waiter would be if we had distributed
%% joins

philosopher(Number, Name, Waiter) ->
    philosopher_think(Name),
    Waiter ! {order, self(), Number},
    {F1, F2} =
	receive
	    {forks, Left, Right} ->
		{Left, Right}
	end,
    philosopher_eat(Name),
    Waiter ! {fork, F1},
    Waiter ! {fork, F2},
    philosopher(Number, Name, Waiter).

philosopher_eat(Name) ->
    io:format("Philosopher ~p eats...~n", [Name]),
    timer:sleep(random:uniform(1000)).

philosopher_think(Name) ->
    io:format("Philosopher ~p thinks...~n", [Name]),
    timer:sleep(random:uniform(1000)).

waiter(Name, Size) ->
    receive
	{order, Phil, Number} and {fork, Left} and {fork, Right}
	when ((Left - 1) rem Size) == Right ->
	    Phil ! {forks, Number, (Number -1) rem Size}
    end,
    waiter(Name, Size).

test() ->
    Size = 10,
    W = spawn(?MODULE, waiter, [adam, Size]),
    [spawn(?MODULE, philosopher, [Id, Id, W]) || Id <- lists:seq(1, Size)],
    [W ! {fork, Id} || Id <- lists:seq(1, Size)],
    receive
	ok ->
	     nothing
    end.
jerlang/src/jerlang_philosophers.erl0000644000175000017500000000310411220224120017540 0ustar  huberthubert-module(jerlang_philosophers).
-export([philosopher/4,
	 fork/2,
	 waiter/2,
	 test/0]).

-compile({parse_transform, jerlang_parse}).

philosopher(Left, Right, Name, Waiter) ->
    philosopher_think(Name),
    Waiter ! {order, self(), Left, Right},
    receive
	{fork, Left} and {fork, Right} ->
	    philosopher_eat(Name)
    end,
    Waiter ! {finished, Left, Right},
    philosopher(Left, Right, Name, Waiter).

philosopher_eat(Name) ->
    io:format("Philosopher ~p eats...~n", [Name]),
    timer:sleep(random:uniform(1000)).

philosopher_think(Name) ->
    io:format("Philosopher ~p thinks...~n", [Name]),
    timer:sleep(random:uniform(1000)).

fork(Waiter, Number) ->
    receive
	{phil, Phil} ->
	    Phil ! {fork, self()}
    end,
    fork(Waiter, Number).

waiter(Name, Forks) ->
    NForks = 
	receive
	    {order, Phil, Left, Right} when lists:member(Left, Forks)
				   and lists:member(Right, Forks) ->
		Left ! {phil, Phil},
		Right ! {phil, Phil},
		Forks -- [Left, Right];
	    {initial, F} ->
		F;
	    {finished, Left, Right} ->
		Forks ++ [Left, Right]
	end,
    waiter(Name, NForks).

test() ->
    Size = 3,
    W = spawn(?MODULE, waiter, [adam, []]),
    ForksList =
	[{Id, spawn(?MODULE, fork, [W, Id])} || Id <- lists:seq(1, Size)],
    Forks = dict:from_list(ForksList),
    NForks = dict:store(0, dict:fetch(Size, Forks), Forks),
    F = lists:map(fun({_, V}) -> V end, ForksList),
    W ! {initial, F},
    [spawn(?MODULE, philosopher, [dict:fetch(Id, NForks),
				 dict:fetch(Id - 1, NForks), Id, W])
	  || Id <- lists:seq(1,Size)],
    receive
	ok ->
	     nothing
    end.
jerlang/src/jerlang_parse.erl0000644000175000017500000003563411220224120016150 0ustar  huberthubert-module(jerlang_parse).
-export([parse_transform/2]).
-import(jerlang_misc, [parse_list/2,
		       unbounded_var/1,
		       unique_atom/1]).

-define(LOCAL_PATTERN(Id, Line, UniqueVar, CaseTests, Propagation),
	{tuple, Line,[
	{integer,Line,Id},
	{record,Line,pattern_joins,
	 [{record_field,Line,
	   {atom,Line,test},
	   {'fun',Line,
	    {clauses,
	     [{clause,Line,
	       [{var,Line,UniqueVar}],
	       [],
	       [{'case',Line,
		 {var,Line,UniqueVar},
		 CaseTests
		}]
	      }]
	    }}},
	  {record_field,Line,
	   {atom,Line,msgs},
	   {nil,Line}},
	  {record_field,Line,
	   {atom,Line,prop},
	   {atom,Line,Propagation}}
	 ]}]}).

-define(JOIN_ACTION(Line, Pattern, ResArgName,
		    CaseArgName, GuardVarName, Action, GBody),
	{'fun',Line,
               {clauses,
                [{clause,Line,
                  [{var,Line,ResArgName},{var,Line,CaseArgName}],
                  [],
                  [{match, Line, Pattern, {var,Line,ResArgName}},
                   {match, Line, {var,25, GuardVarName}, GBody},
                   {'case',Line,
                    {var,Line,CaseArgName},
                    [{clause,Line,
		      [{atom,Line,test_entry}],
		      [],
		      [{var,Line,GuardVarName}]},
                     {clause,Line,
                      [{atom,Line,run_all}],
                      [],
                      Action}]}]}]}}).

-define(TIMEOUT(Time, Action, Line),
	{cons,Line,
	 {tuple,Line,
	  [{atom,Line,timeout},
	   Time,
	   {'fun',Line,
	    {clauses,
	     [{clause,Line,[],[],
	       Action}]}}]},
	 {nil,Line}}).

-define(HANDLER_MODULE, jerlang_core).
-define(HANDLER_FUNC, loop).
-define(HANDLER_RES_ARG_BASE, "ResArgName").
-define(HANDLER_CASE_ARG_BASE, "CaseArg").
-define(HANDLER_GUARD_BASE, "Guard").
-define(HANDLER_P_ARG_BASE, "Value").
-define(PATTERN_RECORD_NAME, pattern_joins).

-define(PATTERN_RECORD(PatternName, Line),
	{attribute,Line,record,
           {PatternName,
            [{record_field,Line,{atom,Line,test}},
             {record_field,Line,{atom,Line,msgs},{nil,Line}},
             {record_field,Line,{atom,Line,prop},{atom,Line,no}}]}}).

parse_transform(ASTTree, _Options) ->
    Result = parse_clause(ASTTree, []),
%    io:format("ASTTree: ~p~n", [ASTTree]),
%    io:format("Result: ~p~n", [Result]),
    Result.

parse_clause([], Ast) ->
    lists:reverse(Ast);
parse_clause([{attribute, Line, module, _}=Module | Rest], Ast) ->
    parse_clause(Rest, [?PATTERN_RECORD(pattern_joins, Line) | [ Module | Ast]]);
parse_clause([{function, L, Name, Arity, Clauses} | Rest], Ast) ->
    ParsedFunc = parse_functions(L, Name, Arity, Clauses, []),
    parse_clause(Rest, [ParsedFunc | Ast]);
parse_clause([Node | Rest], Ast) ->
    parse_clause(Rest, [Node | Ast]).

parse_functions(Line, Name, Arity, [], Result) ->
    {function, Line, Name, Arity, lists:reverse(Result)};
parse_functions(L1, Name, Arity1,
		[{clause, L2, Arity2, Guards, Body} | Rest], Result) ->
    PBody = parse_body0(Body, Arity2),
    parse_functions(L1, Name, Arity1, Rest, [{clause, L2, Arity2, Guards, PBody} | Result]).

parse_body0(Body, Arguments) ->
    {_, ArgLiveVars} = parse_body1(Arguments, sets:new(), [args]),
    {PBody, _} = parse_body1(Body, ArgLiveVars, []),
    PBody.

parse_body1(Statements, LiveVars, S) ->
    parse_body(Statements, LiveVars, [], S).

parse_body([], LiveVars, Body, _) ->
    {lists:reverse(Body), LiveVars};
parse_body([Statement | Rest], LiveVars, Body, S) ->
    {C, NLiveVars} = parse_body(Statement, LiveVars, S),
    parse_body(Rest, NLiveVars, [C | Body], S);
parse_body(Statement, LiveVars, _Body, S) ->
    parse_body(Statement, LiveVars, S).

%%  Basic clauses
parse_body({var, _Line, '_'}=Var, LiveVars, _S) ->
    {Var, LiveVars};
parse_body({var, _Line, Name} = Var, LiveVars, _S) ->
    {Var, sets:add_element(Name, LiveVars)};
parse_body({tuple, Line, PN}, LiveVars, S) ->
    {Parsed, NLiveVars} = expr_list(PN, LiveVars, S),
    {{tuple, Line, Parsed}, NLiveVars};
parse_body({nil, _Line}=Nil, LiveVars, _S) ->
    {Nil, LiveVars};
parse_body({cons, Line, P1, P2}, LiveVars, S) ->
    {Parsed1, NLiveVars1} = parse_body1(P1, LiveVars, S),
    {Parsed2, NLiveVars2} = parse_body1(P2, LiveVars, S),
    {{cons, Line, Parsed1, Parsed2},
     sets:union([NLiveVars1, NLiveVars2])};

%%  More complex constructs
parse_body({'receive', Line, Matches}, LiveVars, S) ->
    Result = parse_receive(Matches, Line, {nil, Line}, LiveVars, S),
    {Result, LiveVars};
parse_body({'receive', Line1, Matches,
	     {_, Line2, _} = Timeout, Action},
	   LiveVars, S) ->
    TimeoutOpt = ?TIMEOUT(Timeout, Action, Line2),
    P = parse_receive(Matches, Line1, TimeoutOpt, LiveVars, S),
    {P, LiveVars};
parse_body({clauses, Clauses}, LiveVars, S) ->
    {C, _NLiveVars} = parse_body1(Clauses, LiveVars, S),
    {{clauses, C}, LiveVars};
parse_body({clause, Line, Patterns, Guards, B}, LiveVars, S) ->
    {C1, NLiveVars1} = parse_body1(Patterns, LiveVars, S),
    {C2, NLiveVars2} = parse_body1(Guards, NLiveVars1, S),
    {C3, _NLiveVars3} = parse_body1(B, NLiveVars2, S),
    {{clause, Line, C1, C2, C3}, LiveVars};
parse_body({call, Line, P0, P}, LiveVars, S) ->
    {C, NLiveVars} = parse_body1(P, LiveVars, S),
    {{call, Line, P0, C}, NLiveVars};
parse_body({record, Line, Name, PM}, LiveVars, S) ->
    {PPM, NLiveVars} = expr_list(PM, LiveVars, S),
    {{record, Line, Name, PPM}, NLiveVars};
parse_body({record_field, Line, P1, P2}, LiveVars, S) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, LiveVars2} = parse_body1(P2, LiveVars1, S),
    {{record_field, Line, C1, C2}, LiveVars2};
parse_body({match, Line, P1, P2}, LiveVars, [args]) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, [args]),
    {C2, LiveVars2} = parse_body1(P2, LiveVars, [args]),
    {{match, Line, C1, C2}, sets:union(LiveVars1, LiveVars2)};
parse_body({match, Line, P1, P2}, LiveVars, S) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, _LiveVars2} = parse_body1(P2, LiveVars, S),
    {{match, Line, C1, C2}, LiveVars1};
parse_body({op, Line, Op, P1, P2}, LiveVars, S) ->
    {C1, LiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, LiveVars2} = parse_body1(P2, LiveVars, S),
    {{op, Line, Op, C1, C2}, sets:union(LiveVars1, LiveVars2)};
parse_body({Pattern, Line, P}, LiveVars, S) ->
    {C, _NLiveVars} = parse_body1(P, LiveVars, S),
    {{Pattern, Line, C}, LiveVars};
parse_body({Pattern, Line, P1, P2}, LiveVars, S) ->
    {C1, _NLiveVars1} = parse_body1(P1, LiveVars, S),
    {C2, _NLiveVars2} = parse_body1(P2, LiveVars, S),
    {{Pattern, Line, C1, C2}, LiveVars};
parse_body({Pattern, Line, P1, P2, P3, P4}, LiveVars, S) ->
    {C1, _NLiveVars1} = parse_body1(P1, LiveVars, S),
    {C4, _NLiveVars2} = parse_body1(P4, LiveVars, S),
    {{Pattern, Line, C1, P2, P3, C4}, LiveVars};
parse_body(Clause, LiveVars, _) ->
    {Clause, LiveVars}.

expr_list(List, LiveVars, S) ->
    lists:mapfoldl(
      fun(Clause, Acc) ->
	      {ParsedElem, NLiveVars} =
		  parse_body1(Clause, LiveVars, S),
	      {ParsedElem, sets:union(NLiveVars, Acc)}
      end, LiveVars, List).
	      


%%  -------   Specific parsing  ---------

parse_receive(Matches, Line, TimeoutOpt, LiveVars, S) ->
    parse_receive(Matches, Line, 1, TimeoutOpt, LiveVars, S, {[], []}).

parse_receive([], Line, _Id, TimeoutOpt, _LiveVars, _S, {Records, Functions}) ->
    FirstArg = parse_list(lists:reverse(Records), Line),
    SecondArg = parse_list(lists:reverse(Functions), Line),
    {call, Line,
     {remote, Line, {atom, Line, ?HANDLER_MODULE}, {atom, Line, ?HANDLER_FUNC}},
     [FirstArg, SecondArg, TimeoutOpt]};
parse_receive([{clause, LineC, Patterns, Guards, Action} | Rest],
	      Line, Id, TimeoutOpt, LiveVars, S, {Records, Functions}) ->
    {_, NLiveVars1} = parse_body1(Patterns, LiveVars, S),
    %%  FIXME: is the one below actually needed?
    {_, NLiveVars2} = parse_body1(Guards, NLiveVars1, S),
    {PAction, _NLiveVars3} = parse_body1(Action, NLiveVars2, S),
    {PPatterns, PPatternsRec, NId} =
	parse_patterns(Patterns, LineC, Id, LiveVars),
    ResUniqueName = unique_atom(?HANDLER_RES_ARG_BASE),
    CaseUniqueName = unique_atom(?HANDLER_CASE_ARG_BASE),
    GuardsVar = unique_atom(?HANDLER_GUARD_BASE),

    PGuardsBody
	= receive_guards(Guards, Line),
    ActGuardsFunc = ?JOIN_ACTION(Line, PPatterns, ResUniqueName,
				 CaseUniqueName, GuardsVar,
				 PAction, PGuardsBody),
    parse_receive(Rest, Line, NId, TimeoutOpt,
		  LiveVars, S,
		  {[PPatternsRec | Records],
		   [ActGuardsFunc | Functions]}).

parse_patterns(Patterns, Line, Id, LiveVars) ->
    parse_patterns(Patterns, Line, Id, {[], []}, LiveVars, true).

parse_patterns([], Line, Id, {Patterns, PatternsRecords}, _LiveVars, _) ->
    {parse_list(lists:reverse(Patterns), Line),
     parse_list(lists:reverse(PatternsRecords), Line),
     Id};
parse_patterns([Pattern | Rest], Line, Id,
	       {RetPattern0, RetPatternRec0}, LiveVars, Decode) ->
    {PPattern, Rec, NId} =
	parse_patterns(Pattern, Line, Id,
		       {[], []}, LiveVars, Decode),
    parse_patterns(Rest, Line, NId,
		   { PPattern ++ RetPattern0, Rec ++ RetPatternRec0},
		   LiveVars, true);

%%  Match is 'wrongly' recognized by the standard compiler
%%  And it brakes things horribly. We need to manually
%%  find joins and pack them together
%%  Later we reply the function again but we know that patterns
%%  are now ok, so we omit this function
parse_patterns({match, Line0, _One, _Two}=Match, Line1,
	       Id, {RetPattern, RetPatternRec},
	       LiveVars, Decode) when (Decode == true)->
    Decoded = decode_match(Match),
    JoinsEncoded = join_patterns(Decoded, Line0),
    parse_patterns(JoinsEncoded, Line1, Id,
		   {RetPattern, RetPatternRec},
		   LiveVars, false);
parse_patterns({op, Line, 'and', LPattern, RPattern},
	       _L, Id, {RetPattern,RetPatternRec},
	       LiveVars, Decode) ->
    {PLPattern, PLPatternRec, Id2} =
	parse_patterns(LPattern, Line, Id,
		       {[], []}, LiveVars, Decode),
    {PRPattern, PRPatternRec, Id3} = 
	parse_patterns(RPattern, Line, Id2,
		       {[], []}, LiveVars, Decode),
    {PRPattern ++ PLPattern ++ RetPattern,
     PRPatternRec ++ PLPatternRec ++ RetPatternRec,
     Id3};
parse_patterns(Other, Line, Id, _, LiveVars, _) ->
    parse_pattern(Other, Line, Id, LiveVars).

parse_pattern({call, _Line1, {atom, _Line2, prop}, [Pattern]},
	     Line, Id, LiveVars) ->
    {_PPattern, _Rec, _NId} =
	parse_pattern(Pattern, Line, Id, LiveVars, yes);
parse_pattern(Pattern, Line, Id, LiveVars) ->
    {_PPattern, _Rec, _NId} =
	parse_pattern(Pattern, Line, Id, LiveVars, no).

parse_pattern(Pattern, Line, Id, LiveVars, Propagate) ->
    {NPattern, Case} = unbound_pattern(Pattern, LiveVars, false),
    CaseTests = case_test_clauses(NPattern, Line, Case),
    UniqueVar = unique_atom(?HANDLER_P_ARG_BASE),
    Rec = ?LOCAL_PATTERN(Id, Line, UniqueVar, CaseTests, Propagate),
    {[Pattern], [Rec], Id + 1}.

unbound_pattern({match, Line, P1, P2}, LiveVars, Case) ->
    {R1, Case1} = unbound_pattern(P1, LiveVars, Case),
    {R2, Case2} = unbound_pattern(P2, LiveVars, Case),
    {{match, Line, R1, R2}, (Case1 or Case2)};
unbound_pattern({tuple, Line, PN}, LiveVars, _Case) ->
    RN = lists:map(
	       fun(Elem) ->
		       {R, _} = unbound_pattern(Elem, LiveVars, true),
		       R
	       end, PN),
    {{tuple, Line, RN}, true};
unbound_pattern({cons, Line, P1, P2}, LiveVars, Case) ->
    {R1, _} = unbound_pattern(P1, LiveVars, Case),
    {R2, _} = unbound_pattern(P2, LiveVars, Case),
    {{cons, Line, R1, R2}, true};
unbound_pattern({var, Line, Name} = Var, LiveVars, Case) ->
    case sets:is_element(Name, LiveVars) of
	true -> {Var, true};
	false -> {{var, Line, unbounded_var(Name)}, Case}
    end;
unbound_pattern({record, Line, Name, PN}, LiveVars, _Case) ->
    RN = lists:map(
	   fun(Elem) ->
		   {R, _} = unbound_pattern(Elem, LiveVars, true),
		   R
	   end, PN),
    {{record, Line, Name, RN}, true};
unbound_pattern({record_field, Line, P1, P2}, LiveVars, _Case) ->
    {R1, _} = unbound_pattern(P1, LiveVars, true),
    {R2, _} = unbound_pattern(P2, LiveVars, true),
    {{record_field, Line, R1, R2}, true};
unbound_pattern({bin, Line, PN}, LiveVars, _Case) ->
    RN = lists:map(
	   fun(Elem) ->
		   {R, _} = unbound_pattern(Elem, LiveVars, true),
		   R
	   end, PN),
    {{bin, Line, RN}, true};
unbound_pattern({bin_element, Line, P1, P2, P3}, LiveVars, _Case) ->
    {R1, _} = unbound_pattern(P1, LiveVars, true),
    %% P2 is the size of the bits that we take
    %% and cannot be unbounded
    %% P3 is the type of the bits we take
    %% and cannot be a variable
    {_, Case2} = unbound_pattern(P2, LiveVars, false),
    {_, Case3} = unbound_pattern(P3, LiveVars, false),
    R2 = case Case2 of
	     true -> P2;
	     false -> default
	 end,
    R3 = case Case3 of
	     true -> P3;
	     false -> default
	 end,
    {{bin_element, Line, R1, R2, R3}, true};
unbound_pattern(P, _LiveVars, _Case) ->    
    {P, true}.

case_test_clauses(Pattern, Line, false) ->
    [{clause, Line,
      [Pattern],
      [],
      [{atom, Line, true}]}];
case_test_clauses(Pattern, Line, true) ->
    [{clause, Line,
      [Pattern],
      [],
      [{atom, Line, true}]},
     {clause, Line,
      [{var, Line, '_'}],
      [],
      [{atom, Line, false}]}].

receive_guards([], Line) ->
    {atom, Line, true};
receive_guards([[Guards]], _) ->
    Guards.

decode_match({match, Line0, Left0, {match, _Line, _Left1, _Right1}=Right0}) ->
    %%  Since the code is fine we are sure that first
    %%  element is definitely not the match itself
    %% But it can be an 'and' op.

    {Pattern, Rest0} = match_r_most(Left0),
    [Head | Rest2] = decode_match(Right0),
    {MatchedPattern, Rest1} = match_l_most(Head),
    Rest0 ++ [{match, Line0, Pattern, MatchedPattern} | Rest1] ++ Rest2;
decode_match({match, Line0, Left0, {op, _, 'and', _, _}=Right0}) ->
    {Pattern, Rest0} = match_r_most(Left0),
    {MatchedPattern, Rest1} = match_l_most(Right0),
    Rest0 ++ [{match, Line0, Pattern, MatchedPattern} | Rest1];
decode_match({match, _Line0, _, {op, _, _Other, _, _}}) ->
    exit({error, invalid_join_operator});
decode_match({match, Line0, Left0, Right0}) ->
    {Pattern, Rest} = match_r_most(Left0),
    Rest ++ [{match, Line0, Pattern, Right0}].

match_r_most({op, _, 'and', Left0, Right0}) ->
    {Pattern, RestJoins} = match_r_most(Right0),
    {Pattern, [Left0 | RestJoins]};
match_r_most({op, _, Other, _, _}) ->
    exit({error, {invalid_join_operator, Other}});
match_r_most(Pattern) ->
    {Pattern, []}.

match_l_most({match, _, _, _}) ->
    exit({error, invalid_match_l_most});
match_l_most({op, _, 'and', Left0, Right0}) ->
    {Pattern, RestJoins} = match_l_most(Left0),
    {Pattern,  RestJoins ++ [Right0]};
match_l_most({op, _, Other, _, _}) ->
    exit({error, {invalid_join_operator, Other}});
match_l_most(Pattern) ->
    {Pattern, []}.

join_patterns(Patterns, Line) ->
    join_patterns1(lists:reverse(Patterns), Line).

join_patterns1([], _) ->
    [];
join_patterns1([Elem], _) ->
    Elem;
join_patterns1([Right, Left], Line) ->
    {op, Line, 'and', Left, Right};
join_patterns1([Head | Rest], Line) ->
    Result = join_patterns1(Rest, Line),
    {op, Line, 'and', Result, Head}.
jerlang/src/jerlang_mset.erl0000644000175000017500000000516311220224120016000 0ustar  huberthubert-module(jerlang_mset).

-export([common_sets/2]).
-export([test_suite/0]).

-include("jerlang.hrl").

-type(test_set_fun(B) ::
      fun (([id()], {receive_fun_param(B), jdict(_)}) ->      
		  {'ok', [id()], B} | 'error')).

-spec(common_sets/2 ::
      ([[id()]], {test_set_fun(A), any(), id()}) ->
	     {error, no_match} | {ok, [id()], A}).
-spec(test_suite/0 :: () -> 'ok' | no_return()).

common_sets(Patterns, Test) ->
    case common_sets(Patterns, [], [], Test) of
	{ok, _, _} = Result -> Result;
	{ok, _} -> {error, no_match}
    end.

%% FIXME: remove redundant code
common_sets([], Used, Result, {_, _, none}) ->
    Set = lists:reverse(Used),
    case lists:member(Set, Result) of
	true -> {no_test, Result};
	false -> {ok, [Set | Result]}
    end;
common_sets([], Used, Result, {_, _, Id}) ->
    Set  = lists:reverse(Used),
    case lists:member(Set, Result) 
	orelse (not lists:member(Id, Set)) of
	true ->  {no_test, Result};
	false -> {ok, [Set | Result]}
    end;
common_sets([Pattern | Rest], Used, Result, Test) ->
    common_sets_single(Pattern, Rest, Used, Result, Test).

common_sets_single([], _Rest, _Used, Result, _) ->
    {ok, Result};
common_sets_single([SingleElem | RestSet], Rest,
		   Used, Result, {Func, Arg, _}=Test) ->
    case lists:member(SingleElem, Used) of
	false ->
	    case common_sets(Rest, [SingleElem | Used],
					Result, Test) of
		{ok, []} ->
		    common_sets_single(RestSet, Rest, Used,
				       Result, Test);
		{ok, [Last | _] = NResult} ->
		    case Func(Last, Arg) of
			{ok, Last, FuncResult} ->
			    {ok, Last, FuncResult};
			error ->
			    common_sets_single(RestSet, Rest, Used,
					       NResult, Test);
			_ ->
			    %%  Keep Dialyzer happy.
			    %%  Otherwise complains about
			    %%  'no local return'.
			    exit({error, internal_error})
		    end;
		{no_test, Result} ->
		    common_sets_single(RestSet, Rest, Used,
				       Result, Test);
		FinalResult -> FinalResult
	    end;
	true ->
	    common_sets_single(RestSet, Rest, Used,
			       Result, Test)
    end.

test_suite() ->
    {ok, [1,2], [1,2]} = common_sets([[1,3],[2]],
				    {fun(Result, _Arg) ->
					    {ok, Result, Result}
				     end, [], 1}),
    {ok, [3,2], valid} = common_sets([[1,3],[2]],
				    {fun(Result, _Arg) ->
					     case Result of
						 [1,2] -> error;
						 _ -> {ok, Result, valid}
					     end
				     end, [], 2}),
    {ok, [3,2,1], ok} = common_sets([[1,2,3],[2,1],[1]],
				     {fun(Result, _Arg) ->
					     {ok, Result, ok}
				      end, [], 1}),
    {error, no_match} = common_sets([[1,2], [2,1], [1,2]],
			  {fun(Result, _Arg) ->
				  {ok, Result, ok}
			   end, [], 1}),
    ok.
jerlang/src/jerlang_misc.erl0000644000175000017500000000726111220224120015764 0ustar  huberthubert-module(jerlang_misc).

-compile(export_all).

-include("jerlang.hrl").

-spec(convert_now/1 :: ({byte(), byte(), byte()}) -> byte()).
-spec(unique_atom/1 :: (string()) -> atom()).
-spec(parse_list/2 ::
      (erl_term(), integer()) ->
	     {'nil', integer()} |
	     {'cons', integer(), erl_term(), erl_term()}).
-spec(unbounded_var/1 :: (atom() | string()) -> atom()).
-spec(unbounded_var_null/1 :: (integer()) -> erl_term()).
-spec(is_unbounded_var/1 :: (atom() | [byte()]) -> bool()).

merge_into_lists([], Result) ->
    Result;
merge_into_lists([{Key, Elem} | Rest], Result) ->
    Res = case lists:keytake(Key, 1, Result) of
	      {value, {Key, List}, RestResult} ->
		  [{Key, [Elem | List]} | RestResult];
	      false ->
		  [{Key, [Elem]} | Result]
    end,
    merge_into_lists(Rest, Res).

convert_now({MegaSecs,Secs,MicroSecs}) ->
    (MegaSecs*1000000 + Secs)*1000000 + MicroSecs.

unique_atom(Base) ->
    list_to_atom(Base ++ integer_to_list(convert_now(erlang:now()))).

unique_vars(Base, Length) when (is_atom(Base)) ->
    unique_vars(atom_to_list(Base), Length);
unique_vars(Base, Length) ->
    [list_to_atom(Base ++ integer_to_list(X)) || X <- lists:seq(1,Length)].

parse_list([], Line) ->
    {nil, Line};
parse_list([Elem | []], Line) ->
    {cons, Line, Elem, parse_list([], Line)};
parse_list([Elem | Rest], Line) ->
    RFirst = parse_list(Elem, Line),
    RSecond = parse_list(Rest, Line),
    {cons, Line, RFirst, RSecond};
parse_list(Elem, _Line) ->
    Elem.

unbounded_var(VarNameAtom) when is_atom(VarNameAtom) ->
    unbounded_var(atom_to_list(VarNameAtom));
unbounded_var(VarNameList) when is_list(VarNameList) ->
    case is_unbounded_var(VarNameList) of
	true -> list_to_atom(VarNameList);
	false -> list_to_atom("_" ++ VarNameList)
    end.

unbounded_var_null(Line) ->
    {var, Line, '_'}.

is_unbounded_var(VarNameAtom) when is_atom(VarNameAtom) ->
    is_unbounded_var(atom_to_list(VarNameAtom));
is_unbounded_var([95 | _]) ->
    true;
is_unbounded_var(_) ->
    false.

generate_seed(Seed) ->
    {A1, A2, A3} = now(),
    random:seed(A1+Seed, A2*Seed, A3),
    ok.

%% Statistics
average(List) ->
    round(lists:foldl(fun(X, Sum) -> X + Sum end, 0, List) / length(List)).

%%  ---------------- Parsing functions ----------------

busy_expr(Expr) ->
    busy_expr(Expr, dict:new()).

busy_expr(Expr, Vars) when is_list(Expr) ->
    busy_expr0(Expr, Vars);
busy_expr({clauses, Clauses}, Vars) ->
    busy_expr(Clauses, Vars);
busy_expr({tuple, _Line, PM}, Vars) ->
    busy_expr(PM, Vars);
busy_expr({record, _, _, PM}, Vars) ->
    busy_expr(PM, Vars);
busy_expr({record_field, _Line, P1, P2}, Vars) ->
    busy_expr0([P1,P2], Vars);
busy_expr({match, _Line, P1, P2}, Vars) ->
    busy_expr0([P1,P2], Vars);
busy_expr({op, _, _, P1, P2}, Vars) ->
    busy_expr0([P1,P2], Vars);
busy_expr({bin_element, _, P1, P2, P3}, Vars) ->
    busy_expr0([P1,P2,P3], Vars);
busy_expr({call, _, Module, Args}, Vars) ->
    busy_expr0([Module,Args], Vars);
%%
busy_expr({var, _, '_'}, Vars) ->
    Vars;
busy_expr({var, _, Name}, Vars) ->
    dict:update_counter(Name, 1, Vars);
%%
busy_expr({cons, _, P1, P2}, Vars) ->
    busy_expr0([P1, P2], Vars);
busy_expr(_, Vars) ->
    Vars.

busy_expr0(ListExpr, VarsIn) ->
    lists:foldl(fun(E, Vars) ->
			busy_expr(E, Vars)
		end, VarsIn, ListExpr).

permute(List, {Id, Fun, Order}) ->
    permute(Order, {Fun, Id}, prepare_p(List, Id, []), []).

permute([], _, _, Result) ->
    lists:reverse(Result);
permute([P | Rest], {Fun, Id}, Dict, Result) ->
    permute(Rest, {Fun, Id + 1}, Dict,
	    [Fun(Id, dict:fetch(P, Dict)) | Result]).

prepare_p([], _, Result) ->
    dict:from_list(Result);
prepare_p([P | Rest], Id, Result) ->
    prepare_p(Rest, Id + 1, [{Id, P} | Result]).
jerlang/src/jerlang_gen_joins_test_santa_parse.erl0000644000175000017500000000425011220224120022416 0ustar  huberthubert-module(jerlang_gen_joins_test_santa_parse).
-compile({parse_transform, jerlang_gen_joins_parse}).

-behaviour(jerlang_gen_joins).

-export([init/1, handle_join/2, terminate/0]).
-export([start/0, stop/0, elf/0, reindeer/0]).
-export([elf_done/0, reindeer_done/0, status/1]).

start() ->
    jerlang_gen_joins:start({global, ?MODULE}, ?MODULE, [], []).

stop() ->
    jerlang_gen_joins:call({global, ?MODULE}, stop).

terminate() ->
    ok.

init(_) ->
    {ok, {{0,0}, sleeping}}.

elf() ->
    jerlang_gen_joins:call({global, ?MODULE}, elf, infinity),
    ok.

elf_done() ->
    jerlang_gen_joins:cast({global, ?MODULE}, {done, elf}).

reindeer() ->
    jerlang_gen_joins:call({global, ?MODULE}, reindeer, infinity).

reindeer_done() ->
    jerlang_gen_joins:cast({global, ?MODULE}, {done, reindeer}).

status(Status) ->
    jerlang_gen_joins:call({global, ?MODULE}, {status, Status}, infinity).

handle_join({status, {A, B}}, {{C, D}, _}=S) when ((A =< C) and (B =< D))  ->
    io:format("I am done ~p~n", [{C, D}]),
    {[{reply, ok}], S};
handle_join(stop, _) ->
    io:format("Stopping the server~n", []),
    {stop, normal};
handle_join({done, reindeer} and {done, reindeer} and {done, reindeer} and
	    {done, reindeer} and {done, reindeer} and {done, reindeer} and
	    {done, reindeer} and {done, reindeer} and {done, reindeer},
	    {Counter, awake_reindeer}) ->
    io:format("All reindeers returned~n",[]),
    {[ noreply || _ <- lists:seq(1,9)], {Counter, sleeping}};

handle_join({done, elf} and {done, elf} and {done, elf},
	    {Counter, awake_elf}) ->
    io:format("All elves returned~n",[]),
    {[ noreply || _ <- lists:seq(1,3)], {Counter, sleeping}};

handle_join(reindeer and reindeer and reindeer and
	    reindeer and reindeer and reindeer and
	    reindeer and reindeer and reindeer,
	    {{Reindeers, Elves}, sleeping}) ->
    io:format("Ho, ho, ho! Let's deliver presents~n",[]),
    {[ {reply, ok} || _ <- lists:seq(1,9)], {{Reindeers+1, Elves}, awake_reindeer}};

handle_join(elf and elf and elf,
	    {{Reindeers, Elves}, sleeping}) ->
    io:format("Ho, ho, ho! Let's discuss R&D possibilities~n",[]),
    {[ {reply, ok} || _ <- lists:seq(1,3)], {{Reindeers, Elves+1}, awake_elf}}.
jerlang/src/jerlang_gen_joins_test_santa.erl0000644000175000017500000002134111220224120021224 0ustar  huberthubert-module(jerlang_gen_joins_test_santa).

-behaviour(jerlang_gen_joins).
-include("jerlang.hrl").

-export([init/1, handle_join/2, terminate/0]).
-export([start/0, stop/0, elf/0, reindeer/0]).
-export([elf_done/0, reindeer_done/0, status/1]).
-export([init_joins/1]).

start() ->
    jerlang_gen_joins:start({global, ?MODULE}, ?MODULE, [], []).

stop() ->
    jerlang_gen_joins:call({global, ?MODULE}, stop).

terminate() ->
    jerlang_gen_joins:call({global, ?MODULE}, stop).

init(_Args) ->
    {ok, {{0,0}, sleeping}}.

elf() ->
    jerlang_gen_joins:call({global, ?MODULE}, elf),
    ok.

elf_done() ->
    jerlang_gen_joins:cast({global, ?MODULE}, {done, elf}).


reindeer() ->
    jerlang_gen_joins:call({global, ?MODULE}, reindeer).

reindeer_done() ->
    jerlang_gen_joins:cast({global, ?MODULE}, {done, reindeer}).

status(Status) ->
    jerlang_gen_joins:call({global, ?MODULE}, {status, Status}, infinity).

init_joins(_) ->
    {ok, 
     [
      [[{1, #pattern_joins{test=fun(Value) ->
					case Value of
					    {status, _, _} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}}],
       {fun([elf, elf],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([{status, A, B}],
	    {{C, D}, _})  when ((A =< C) and (B =< D))  ->
		true
	end, []}],
      [[{1, #pattern_joins{test=fun(Value) ->
					case Value of
					    stop ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}}],
       {fun([stop],
	    _) ->
		true
	end, []}],
      [[{1, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{2, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						    false
					end
				end, msgs=[]}},
	{3, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{4, #pattern_joins{test=fun(Value) ->
					case Value of
						{done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{5, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{6, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{7, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{8, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{9, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, reindeer} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}}],
       {fun([{done, reindeer}, {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []},
       {fun([{done, reindeer}, {done, reindeer}, {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []},
       {fun([{done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []},
       {fun([{done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []},
       {fun([{done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}, {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []},
       {fun([{done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []},
       {fun([{done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []},
       {fun([{done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}, {done, reindeer}],
	    {_, awake_reindeer}) ->
		true
	end, []}],
      [[{1, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, elf} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{2, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, elf} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{3, #pattern_joins{test=fun(Value) ->
					case Value of
					    {done, elf} ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}}],
       {fun([{done, elf}, {done, elf}],
	    {_, awake_elf}) ->
		true
	end, []},
       {fun([{done, elf}, {done, elf}, {done, elf}],
	    {_, awake_elf}) ->
		true
	end, []}],
      [[{1, #pattern_joins{test=fun(Value) ->
					case Value of
					    elf ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{2, #pattern_joins{test=fun(Value) ->
					case Value of
					    elf ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{3, #pattern_joins{test=fun(Value) ->
					case Value of
					    elf ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}}],
       {fun([elf, elf],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([elf, elf, elf],
	    {_, sleeping}) ->
		true
	end, []}],
      [[{1, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{2, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{3, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{4, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{5, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{6, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{7, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{8, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}},
	{9, #pattern_joins{test=fun(Value) ->
					case Value of
					    reindeer ->
						true;
					    _ ->
						false
					end
				end, msgs=[]}}],
       {fun([reindeer, reindeer],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([reindeer, reindeer, reindeer],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([reindeer, reindeer, reindeer,
	     reindeer],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([reindeer, reindeer, reindeer,
	     reindeer, reindeer],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([reindeer, reindeer, reindeer,
	     reindeer, reindeer, reindeer],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([reindeer, reindeer, reindeer,
	     reindeer, reindeer, reindeer,
	     reindeer],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([reindeer, reindeer, reindeer,
	     reindeer, reindeer, reindeer,
	     reindeer, reindeer],
	    {_, sleeping}) ->
		true
	end, []},
       {fun([reindeer, reindeer, reindeer,
	     reindeer, reindeer, reindeer,
	     reindeer, reindeer, reindeer],
	    {_, sleeping}) ->
		true
	end, []}]
    ]}.

handle_join({status, {A, B}}, {{C, D}, _}=S) when ((A =< C) and (B =< D))  ->
    io:format("I am done ~p~n", [{C, D}]),
    {[{reply, ok}], S};
handle_join(stop, _) ->
    io:format("Stopping the server~n", []),
    {stop, normal};
handle_join([{done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}, {done, reindeer},
	     {done, reindeer}, {done, reindeer}, {done, reindeer}],
	    {Counter, awake_reindeer}) ->
    io:format("All reindeers returned~n",[]),
    {[ noreply || _ <- lists:seq(1,9)], {Counter, sleeping}};

handle_join([{done, elf}, {done, elf}, {done, elf}],
	    {Counter, awake_elf}) ->
    io:format("All elves returned~n",[]),
    {[ noreply || _ <- lists:seq(1,3)], {Counter, sleeping}};

handle_join([reindeer, reindeer, reindeer, 
	    reindeer, reindeer, reindeer, 
	    reindeer, reindeer, reindeer],
	    {{Reindeers, Elves}, sleeping}) ->
    io:format("Reindeers delivering presents~n",[]),
    {[ {reply, ok} || _ <- lists:seq(1,9)], {{Reindeers+1, Elves}, awake_reindeer}};

handle_join([elf, elf, elf],
	    {{Reindeers, Elves}, sleeping}) ->
    io:format("Elves discussing R&D possibilities~n",[]),
    {[ {reply, ok} || _ <- lists:seq(1,3)], {{Reindeers, Elves+1}, awake_elf}}.
jerlang/src/jerlang_gen_joins_test_prop_parse.erl0000644000175000017500000000227711220224120022277 0ustar  huberthubert-module(jerlang_gen_joins_test_prop_parse).
-compile({parse_transform, jerlang_gen_joins_parse}).
-behaviour(jerlang_gen_joins).

-record(test, {name, price}).

-export([init/1, handle_join/2, terminate/0]).
-export([start/0, stop/0, auth/1, enter/1, revoke/1]).

start() ->
    jerlang_gen_joins:start({local, ?MODULE}, ?MODULE, [], []).

stop() ->
    ok.

terminate() ->
    ok.

init(_Args) ->
    {ok, {status, 2}}.

auth(Name) ->
    jerlang_gen_joins:cast(?MODULE, {auth, Name}).

enter(Name) ->
    jerlang_gen_joins:call(?MODULE, {enter, Name}).

revoke(Name) ->
    jerlang_gen_joins:call(?MODULE, {revoke, Name}).

handle_join({auth, Name} and {enter, Name}, {status, Num}) when (Num > 0) ->
    io:format("*Handle Join Auth Enter~n", []),
    {[noreply, {reply, valid_pass}], {status, Num}};
handle_join({auth, Name} and {revoke, Name}, State) ->
    io:format("*Handle Join Revoke~n", []),
    {[noreply, {reply, {auth, Name}}], State};
%% FIXME: just for experimenting patterns
handle_join({value, A, F} and {value, _} and [#test{name=A, price=C} | _]
	   and {ok, size, D} and {merge, C, E, F},
	   {dict, D}) when (A < E) ->
    {[noreply, noreply, noreply, {reply, ok},
      noreply], {dict, D}}.
jerlang/src/jerlang_gen_joins_test_prop.erl0000644000175000017500000000343211220224120021077 0ustar  huberthubert-module(jerlang_gen_joins_test_prop).
-behaviour(jerlang_gen_joins).

-export([init/1, init_joins/1, handle_join/2, terminate/0]).
-export([start/0, stop/0, auth/1, enter/1, revoke/1]).

%% FIXME: this should be added by parse_transform
-include("jerlang.hrl").

start() ->
    jerlang_gen_joins:start({local, ?MODULE}, ?MODULE, [], []).

stop() ->
    ok.

terminate() ->
    ok.

init(_Args) ->
    {ok, {status, 2}}.

init_joins(_) ->
    {ok,
     [
      [[{1, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {auth, _} -> true;
				       _ -> false
				   end
			   end, msgs=[], prop=yes}},
	{2, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {enter, _} -> true;
				       _ -> false
				   end
			   end, msgs=[]}}],
       {fun([{auth, Name}, {enter, Name}], {status, Num})
	  when (Num > 0) ->
	       true
       end, []}],
      [[{3, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {auth, _} -> true;
				       _ -> false
				   end
			   end, msgs=[]}},
	{4, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {revoke, _} -> true;
				       _ -> false
				   end
			   end, msgs=[]}}],
       {fun([{auth, Name}, {revoke, Name}], _) ->
	       true
	end, []}]
      ]}.
      
auth(Name) ->
    jerlang_gen_joins:cast(?MODULE, {auth, Name}).

enter(Name) ->
    jerlang_gen_joins:call(?MODULE, {enter, Name}).

revoke(Name) ->
    jerlang_gen_joins:call(?MODULE, {revoke, Name}).

handle_join([{auth, Name}, {enter, Name}], {status, Num}) when (Num > 0) ->
    io:format("*Handle Join Auth Enter~n", []),
    {[noreply, {reply, valid_pass}], {status, Num}};
handle_join([{auth, Name}, {revoke, Name}], State) ->
    io:format("*Handle Join Revoke~n", []),
    {[noreply, {reply, {auth, Name}}], State}.
jerlang/src/jerlang_gen_joins_test_main.erl0000644000175000017500000001011211220224120021034 0ustar  huberthubert-module(jerlang_gen_joins_test_main).

-export([test_suite/0, time_santa/0]).
-export([test_santa_claus_limited/1]).
-export([time_santa_script/1]).
-export([worker0/4]).
-import(jerlang_misc, [generate_seed/1, average/1]).

test_suite() ->
    ok = test_simple(),
    ok = test_propagation(),
    ok = test_simple_parsed(),
    ok = test_add_parsed(),
    ok = test_santa_claus(),
    ok = test_santa_claus_parse().

test_simple() ->
    test_simple(jerlang_gen_joins_test_calc).

test_simple_parsed() ->
    test_simple(jerlang_gen_joins_test_calc_parse).

test_simple(Module) ->
    Module:start(),
    Num = Module:result(),
    Module:elf(elf),
    Module:add(12),
    Module:elf({elf, 12}),
    timer:sleep(2000),
    Module:elf({elf, 39}),
    Module:add(10),
    true = ((Num + 22) == Module:result()),
    ok.


test_add_parsed() ->
    jerlang_gen_joins_test_calc_parse:start(),
    jerlang_gen_joins_test_calc_parse:result(),
    jerlang_gen_joins_test_calc_parse:add(12),
    jerlang_gen_joins_test_calc_parse:add(10),
    timer:sleep(1000),
    ok.

    

test_propagation() ->
    jerlang_gen_joins_test_prop:start(),
    ok = jerlang_gen_joins_test_prop:auth(natka),
    ok = jerlang_gen_joins_test_prop:auth(hubik),
    valid_pass = jerlang_gen_joins_test_prop:enter(natka),
    {auth, natka} = jerlang_gen_joins_test_prop:revoke(natka),
    Pid = spawn_link(
	    fun() ->
		    valid_pass =
			jerlang_gen_joins_test_prop:enter(natka),
		    timer:sleep(1000)
	  end),
    valid_pass = jerlang_gen_joins_test_prop:enter(hubik),
    timer:sleep(1000),
    ok = jerlang_gen_joins_test_prop:auth(natka),
    ok = try
	     jerlang_gen_joins_test_prop:enter(nobody),
	     error
	 catch
	     exit:{timeout, _} -> ok
	 end,
    ok = receive
	     {'EXIT', Pid, normal} -> ok
	 after 0 -> error
	 end.

test_santa_claus_parse() ->
    jerlang_gen_joins_test_santa_parse:start(),
    [spawn_link(?MODULE, worker0, [jerlang_gen_joins_test_santa_parse,
			      4, elf, Id]) || Id <- lists:seq(1,10)],
    [spawn_link(?MODULE, worker0, [jerlang_gen_joins_test_santa_parse,
			      4, reindeer, Id]) || Id <- lists:seq(1,9)],
    %% Could use joins here ? :)
    ok =
	receive
	    {'EXIT', _, A} when (A /= normal) ->
		io:format("EXIT: ~p~n", [A]),
		error
	after infinity ->
		ok
	end.


test_santa_claus_limited(Counter) ->
    jerlang_gen_joins_test_santa_parse:start(),
    [spawn_link(?MODULE, worker0,
		[jerlang_gen_joins_test_santa_parse,
		 Counter, elf, Id]) || Id <- lists:seq(1,10)],
    [spawn_link(?MODULE, worker0,
		[jerlang_gen_joins_test_santa_parse,
		 Counter, reindeer, Id]) || Id <- lists:seq(1,9)],
    ok = jerlang_gen_joins_test_santa_parse:status({Counter, Counter}),
    %% Could use joins here ? :)
    ok =
	receive
	    {'EXIT', _, A} when (A /= normal) ->
		io:format("EXIT: ~p~n", [A]),
		error
	after 0 ->
		ok
	end.

test_santa_claus() ->
    io:format("testing santa stuff~n", []),
    jerlang_gen_joins_test_santa:start(),
    [spawn_link(?MODULE, worker0,
		[jerlang_gen_joins_test_santa, 2, reindeer, Id])
     || Id <- lists:seq(1,9)],
    ok = receive
	     {'EXIT', _, A} when (A /= normal) ->
		 error
	 after 5000 -> ok
	 end.

worker0(Module, Num, Type, Id) ->
    generate_seed(Id),
    worker1(Module, Num, Type).

worker1(_Module, 0, _Type) ->
    ok;
worker1(Module, Num, Type) ->
    Res =
	try
	    ok = Module:Type(),
	    Done = list_to_atom(atom_to_list(Type) ++ "_done"),
	    Module:Done(),
	    ok
    catch
	_:_ ->
	    error
    end,
    case Res of
	ok ->
	    worker1(Module, Num-1, Type);
	error ->
	    ok
    end.

time_santa() ->
    Test = [2, 4, 8, 16, 32, 64, 128, 256, 512],
    Repeat = 5,

    lists:foreach(
      fun(C) ->
	      Res = lists:map(
		      fun(_) ->
			      {Time, _}
				  = timer:tc(?MODULE,
					     test_santa_claus_limited, [C]),
			      Time
		      end, lists:seq(1, Repeat)),
	      io:format("Santa ~p took: ~p seconds~n",
			[C, average(Res)/1000000])
      end, Test).

time_santa_script(Iter) ->
    {Time, _}
	= timer:tc(?MODULE,
		   test_santa_claus_limited, [Iter]),
    
    io:format("Santa ~p took: ~p seconds~n",
	      [Iter, Time/1000000]).
    
jerlang/src/jerlang_gen_joins_test_example.erl0000644000175000017500000000314711220224120021555 0ustar  huberthubert-module(jerlang_gen_joins_test_example).
-behaviour(jerlang_gen_joins).

-compile({parse_transform, jerlang_gen_joins_parse}).

-export([init/1, handle_join/2, terminate/0]).
-export([start/0, add/1, multiply/1, divide/1, number/2]).

start() ->
    jerlang_gen_joins:start({local, ?MODULE}, ?MODULE, [], []).

terminate() ->
    jerlang_gen_joins:call(?MODULE, stop).

init(_Args) ->
    {ok, 0}.

number(Number, Id) ->
    jerlang_gen_joins:cast(?MODULE, {number, Id, Number}).

add(Id) ->
    jerlang_gen_joins:call(?MODULE, {add, Id}).

multiply(Id) ->
    jerlang_gen_joins:call(?MODULE, {multiply, Id}).

divide(Id) ->
    jerlang_gen_joins:call(?MODULE, {divide, Id}).

handle_join({number, Id, First} and {number, Id, Second}
	    and {number, Id, Third} and {add, Id}, Status) ->

    io:format("[gen_joins]: Calculate 'add' operation~n", []),
    {[noreply, noreply, {reply, First + Second + Third}],
      Status};
handle_join({number, Id, First} and {number, Id, Second}
	    and {multiply, Id}, Status) ->

    io:format("[gen_joins]: Calculate 'multiply' operation~n", []),
    {[noreply, noreply, {reply, First * Second}], Status};
handle_join({number, Id, First} and {number, Id, Second}
	    and {divide, Id}, Status) when (Second =/= 0) ->

    io:format("[gen_joins]: Calculate 'divide' operation~n", []),
    {[noreply, noreply, {reply, First / Second}],
      Status};
handle_join({number, Id, _} and {number, Id, Second}
	    and {divide, Id}, Status) when (Second =:= 0) ->
    io:format("[gen_joins]: Invalid divide operation~n", []),
    {[noreply, noreply, {reply, {error, division_by_zero}}],
      Status + 1}.
jerlang/src/jerlang_gen_joins_test_calc_parse.erl0000644000175000017500000000252111220224120022211 0ustar  huberthubert-module(jerlang_gen_joins_test_calc_parse).
-behaviour(jerlang_gen_joins).

-compile({parse_transform, jerlang_gen_joins_parse}).

-export([init/1, handle_join/2, terminate/0]).
-export([start/0, stop/0, add/1, result/0, elf/1]).

start() ->
    jerlang_gen_joins:start({local, ?MODULE}, ?MODULE, [], []).

stop() ->
    ok.

terminate() ->
    jerlang_gen_joins:call(?MODULE, stop).

init(_Args) ->
    {ok, {valid, 17}}.

add(Number) ->
    jerlang_gen_joins:cast(?MODULE, {add, Number}).

result() ->
    jerlang_gen_joins:call(?MODULE, result).

elf(Arg) ->
    jerlang_gen_joins:cast(?MODULE, Arg).

handle_join({add, One} and {add, Two}, {valid, Num}) when (One > 2) ->
    io:format("*Handle join [parse_transform]*: Adding two numbers: [~p][~p]~n", [One, Two]),
    {[noreply, noreply], {valid, Num+One+Two}};
%handle_join({add, One} and {add, One}, {ok, B} = State) when (One > 2) ->
%    io:format("*Handle join [parse_transform]*: Nothing~n",
%	      []),
%    {[noreply, noreply], noth};

handle_join(result, {valid, Res}=State) when (Res > 5) ->
    io:format("*Handle join [parse_transform]*: RESULT ~p~n",
	      [Res]),
    {[{reply, Res+10}], State};
handle_join(elf and {elf, Num} and {elf, Part}, {valid, Part}=State)
  when (Num > 5) ->
    io:format("*Handle join*: ELF MATCHES with ~p~n", [Num]),
    {[noreply, noreply, noreply], State}.
jerlang/src/jerlang_gen_joins_test_calc.erl0000644000175000017500000000505611220224120021025 0ustar  huberthubert-module(jerlang_gen_joins_test_calc).

-ifdef(use_joins_vm).
-define(GEN_JOINS, jerlang_vm_gen_joins).
-else.
-define(GEN_JOINS, jerlang_gen_joins).
-endif.
-behaviour(?GEN_JOINS).

-export([init/1, init_joins/1, handle_join/2, terminate/0]).
-export([start/0, stop/0, add/1, result/0, elf/1]).

-include("jerlang.hrl").

start() ->
    ?GEN_JOINS:start({local, ?MODULE}, ?MODULE, [], []).

stop() ->
    ok.

terminate() ->
    ?GEN_JOINS:call(?MODULE, stop).

init(_Args) ->
    {ok, {valid, 17}}.

init_joins(_) ->
    {ok,
     [
      [[{1, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {add, _One} -> true;
				       _ -> false
				   end
			   end, msgs=[]}},
	{2, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {add, _Two} -> true;
				       _ -> false
				   end
			   end, msgs=[]}}],
       {fun([{add, One}, {add, _Two}], {valid, _Num}) when (One > 2) ->
		true
	end, []}],
       %% FIXME: further reduction in 1?
       [[{3, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       result -> true;
				       _ -> false
				   end
			   end, msgs=[]}}],
       {fun([result], {valid, Res}) when (Res > 5) ->
		true
	end, []}],
       [[{4, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       elf -> true;
				       _ -> false
				   end
			   end, msgs=[]}},
	{5, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {elf, _Num} -> true;
				       _ -> false
				   end
			   end, msgs=[]}},
	{6, #pattern_joins{test=
			   fun(Value) ->
				   case Value of
				       {elf, _Part} -> true;
				       _ -> false
				   end
			   end, msgs=[]}}],
       {fun([elf, {elf, Num}], _) when (Num > 5) ->
		true
	end, []},
       {fun([elf, {elf, Num}, {elf, Part}], {valid, Part}=_State)
	   when (Num > 5) ->
		true
	end, []}]
     ]}.
      
add(Number) ->
    ?GEN_JOINS:cast(?MODULE, {add, Number}).

result() ->
    ?GEN_JOINS:call(?MODULE, result).

elf(Arg) ->
    ?GEN_JOINS:cast(?MODULE, Arg).

%handle_join({add, One} and {add, Two}, State) ->
handle_join([{add, One}, {add, Two}], {valid, Num}) when (One > 2) ->
    io:format("*Handle join*: Adding two numbers: [~p][~p]~n", [One, Two]),
    {[noreply, noreply], {valid, Num+One+Two}};
handle_join([result], {valid, Res}=State) when (Res > 5) ->
    io:format("*Handle join*: RESULT ~p~n", [Res]),
    {[{reply, Res+10}], State};
handle_join([elf, {elf, Num}, {elf, Part}], {valid, Part}=State)
  when (Num > 5) ->
    io:format("*Handle join*: ELF MATCHES with ~p~n", [Num]),
    {[noreply, noreply, noreply], State}.
jerlang/src/jerlang_gen_joins_parse.erl0000644000175000017500000004336011220224120020176 0ustar  huberthubert-module(jerlang_gen_joins_parse).
-export([parse_transform/2]).

-import(jerlang_misc, [parse_list/2,
		       unbounded_var/1,
		       is_unbounded_var/1,
		       unique_atom/1,
		       unique_vars/2,
		       busy_expr/2,
		       permute/2]).

-define(LOCAL_PATTERN(Id, Line, UniqueVar, CaseTests, Propagation),
	{tuple, Line,[
	{integer,Line,Id},
	{record,Line,pattern_joins,
	 [{record_field,Line,
	   {atom,Line,test},
	   {'fun',Line,
	    {clauses,
	     [{clause,Line,
	       [{var,Line,UniqueVar}],
	       [],
	       [{'case',Line,
		 {var,Line,UniqueVar},
		 CaseTests
		}]
	      }]
	    }}},
	  {record_field,Line,
	   {atom,Line,msgs},
	   {nil,Line}},
	  {record_field,Line,
	   {atom,Line,prop},
	   {atom,Line,Propagation}}
	 ]}]}).

-define(JOIN_GUARDS_TEST(Line, Join, State, Guards),
	{tuple, Line,
	 [{'fun',Line,
	   {clauses,
	    [{clause,Line,
	      [Join, State],
	      Guards,
	      [{atom, Line, true}]}]}},
	  {nil, Line}]}).

-define(TIMEOUT(Time, Action, Line),
	{cons,Line,
	 {tuple,Line,
	  [{atom,Line,timeout},
	   Time,
	   {'fun',Line,
	    {clauses,
	     [{clause,Line,[],[],
	       Action}]}}]},
	 {nil,Line}}).

-define(JOINS_INIT(Line, Tests),
	{function, Line, init_joins, 1,
	 [{clause, Line,
	   [{var, Line, '_'}],
	   [],
	   [{tuple, Line,
	     [{atom, Line, ok}, Tests]}]}]}).
-define(ORDERING(Initial, Line, Vars, StatusName, NewVars),
	[{match, Line,
	  {tuple, Line, Vars ++ [{var, Line, StatusName}]},
	  Initial},
	 {tuple, Line, NewVars ++ [{var, Line, StatusName}]}]).


-define(HANDLER_RES_ARG_BASE, "ResArgName").
-define(HANDLER_CASE_ARG_BASE, "CaseArg").
-define(HANDLER_GUARD_BASE, "Guard").
-define(HANDLER_P_ARG_BASE, "Value").
-define(PATTERN_RECORD_NAME, pattern_joins).

-define(PATTERN_RECORD(PatternName, Line),
	{attribute,Line,record,
           {PatternName,
            [{record_field,Line,{atom,Line,test}},
             {record_field,Line,{atom,Line,msgs},{nil,Line}},
             {record_field,Line,{atom,Line,prop},{atom,Line,no}}]}}).

-define(JOINS_EXPORT(Line),
	{attribute, Line, export,
	 [{init_joins, 1}]}).

-define(JOINS_DICT_NAME, init_joins_dict).

parse_transform(ASTTree, _Options) ->
    
    Result = parse_clause(ASTTree, []),
%    io:format("ASTTree: ~p~n", [ASTTree]),
%    ASTTree.
%    io:format("Result: ~p~n", [Result]),
    Result.

parse_clause([], [{eof, LEnd} | Ast]) ->
    %% Add the collected join information
    Init = case get(?JOINS_DICT_NAME) of
	       undefined -> [{eof, LEnd}];
	       Other     -> [{eof, LEnd}, Other]
	   end,
    Tree = Init ++ Ast,
    lists:reverse(Tree);
parse_clause([{attribute, Line, behaviour, jerlang_gen_joins}=Behaviour | Rest], Ast) ->
    parse_clause(Rest, [?JOINS_EXPORT(Line+1), Behaviour | Ast]);
parse_clause([{attribute, Line, module, _}=Module | Rest], Ast) ->
    parse_clause(Rest, [?PATTERN_RECORD(pattern_joins, Line) | [ Module | Ast]]);
parse_clause([{function, L, handle_join, 2, Clauses} | Rest], Ast) ->
    {ParsedClauses, ParsedTests} = parse_receive(Clauses, L),
    put(?JOINS_DICT_NAME,
	?JOINS_INIT(L-1, ParsedTests)),
    parse_clause(Rest,
		 [{function, L, handle_join, 2, ParsedClauses} | Ast]);
parse_clause([{function, _, handle_join, _, _} | _], _) ->
    exit({error, invalid_handle_join_arity});
parse_clause([Node | Rest], Ast) ->
    parse_clause(Rest, [Node | Ast]).

%%  -------   Specific parsing  for handle_join function ---------
parse_receive(Clauses, Line) ->
    parse_receive(Clauses, Line, 1, {[], []}).

parse_receive([], Line, _Id, {Joins, Tests}) ->
    {lists:reverse(Joins),
     parse_list(lists:reverse(Tests), Line)};
parse_receive([{clause, LineC, [Join, State], Guards, Action}| Rest],
	      Line, Id, {Joins, JoinsTests}) ->
    {RawPatterns0, PTests0, PVars, NId} = 
	parse_patterns(Join, LineC, Id, {[], []}, dict:new(), true),
    RawPatterns = lists:reverse(RawPatterns0),
    PTests = lists:reverse(PTests0),

    FOrder = get_ordering(RawPatterns, Id, {State, Guards}),

    {FPatterns,
     FPTests,
     FAction} =
	case FOrder of
		    valid ->
			{RawPatterns, PTests, Action};
		    _ ->
			Identity = fun(_, Q) -> Q end,
			OrderTest =
			    fun(Id0, {tuple, L0,
				      [{integer, L1, _} | R0]}) ->
				    {tuple, L0,
				     [{integer, L1, Id0} | R0]}
			    end,
			PPatterns =
			    permute(RawPatterns,
				    {Id, Identity, FOrder}),
			PPTests =
			    permute(PTests,
				    {Id, OrderTest, FOrder}),
			PAction =
			    permute_action(Action, Id, FOrder),
			{PPatterns, PPTests, PAction}
		end,

    BetaFunctions =
	gen_beta_functions(
	  {FPatterns, State,
	   Guards, LineC}, PVars),

    JoinResult =
	parse_list(
	  [FPTests | BetaFunctions],
	  LineC),
    
    C1 = {clause, LineC,
	  [parse_list(FPatterns, LineC), State],
	  Guards, FAction},
    parse_receive(Rest, Line, NId,
		  {[C1 | Joins],
		   [JoinResult | JoinsTests]}).

%% Ordering is disabled by default because it can
%% do unpredictable things for the user
-ifdef(use_ordering_opt).
get_ordering(RawPatterns, Id, {State, Guards}) ->
    {ok, Forder} = 
	jerlang_gen_joins_order:optimize(RawPatterns, Id,
					 {State, Guards}),
    Forder.

-else.
get_ordering(_, _, _) ->
    valid.
-endif.


gen_beta_functions({Patterns, State, Guards, LineC}, Vars0) ->
    Vars1 = busy_expr(State, Vars0),
    Vars2 = busy_expr(Guards, Vars1),
    NPatterns =
	lists:map(
	  fun(Elem) ->
		  {RPattern, _} = unbound_pattern(Elem, Vars2, true),
		  RPattern
	  end, Patterns),
    SVars = busy_expr(State, dict:new()),
    GVars = busy_expr(Guards, dict:new()),

    {NState, _} = unbound_pattern(State, Vars2, true),
    NGuards = guards_cond(Guards, GVars, Vars1),
    
    gen_beta_functions1({NPatterns, [], NState, NGuards, LineC},
			{Vars2, vars_split(SVars, GVars)},
			{false, false}, []).

%%  FIXME: need to analyze also the guard expressions.
%%  Currently we assume they are ok (i.e. contain no free,
%%  variables).
%%  FIXME: currently Cond flags are not used but
%%  we could improve the perfomance by having
%%  the state/guards only once (earliest) and not
%%  whenever they are available.
gen_beta_functions1({[], _, _, _, _}, _, _, _) ->
    exit({error, invalid_handle_join_definition});
%%  Special case for *only* two patterns in the join.
%%  Treat it only as a single beta reduction.
%%  For efficiency. There is no point in dividing this
%%  into subproblems.
gen_beta_functions1({[P1, P2 | Rest], [], State, Guards, LineC},
		    Vars, Cond, []) ->
    gen_beta_functions1({[P2 | Rest], [P1], State, Guards, LineC},
			Vars, Cond, []);
%%  Have more cases for {false, true}, etc...?
gen_beta_functions1({[Pattern], PrevP, State, Guards, LineC},
		    {VarsAll, _},
		    _, Res) ->
    {NState, _} = unbound_pattern(State, VarsAll, true),
    TransfJoin = parse_list(
		   lists:reverse(
		     [Pattern | PrevP]), LineC),
    BetaTest = ?JOIN_GUARDS_TEST(
		  LineC, TransfJoin,
		  NState, Guards),
    lists:reverse([BetaTest | Res]);
gen_beta_functions1(
  {[Pattern | Rest], PrevP, State, Guards, LineC},
  {_, {Common, SPVars, GPVars}}=Vars,
  _, Res) ->

    %%  Find out whether state and/or can be included
    %%  depending on the existence of the variables
    %%  in the Patterns
    Patterns = [Pattern | PrevP],
    PVarsDict = busy_expr(Patterns, dict:new()),
    PVars = dict:fetch_keys(PVarsDict),

    {BetaGuards, GuardsRes} =
	guards_avail({length(GPVars -- PVars) == 0,
		      Guards, []}),

    BetaState =
	state_avail(Common, GuardsRes,
		    {SPVars -- PVars, State,
		     fun jerlang_misc:unbounded_var_null/1}),
    
    NPatterns =
	p_avail(Common, {GPVars, GuardsRes},
		SPVars, PVarsDict, Patterns),
    
    BetaTest = ?JOIN_GUARDS_TEST(LineC,
				 parse_list(
				   lists:reverse(NPatterns),
				   LineC),
				 BetaState, BetaGuards),

    gen_beta_functions1(
      {Rest, [Pattern | PrevP], State, Guards, LineC},
      Vars, {false, false}, [BetaTest | Res]).

%% Ordering functions. Correctly change the targets
%% for replies
permute_action(Action, _, [_]) ->
    Action;
permute_action(Action, Id, Order) ->
    %% FIXME: should detect the situation when number
    %% of elements at the end does not match header patterns
    %% Currently it may throw a warning "no clause will match"
    {Last, ActionRest} = partition_act(Action, []),
    Line = 
	case Last of
	    [] ->
		0;
	    _ ->
		element(2, Last)
	end,	    
    UniqueVar = unique_atom("OrderAct"),
    UniqueVars =
	lists:map(fun(Name) -> {var, Line, Name} end,
		  unique_vars(UniqueVar, length(Order))),

    ResultVars =
	permute(UniqueVars,
		{Id, fun(_, Q) -> Q end, Order}),
    StatusName = unique_atom("StatusNew"),
    NLast = 
	?ORDERING(Last, Line, [parse_list(UniqueVars, Line)],
		  StatusName, [parse_list(ResultVars, Line)]),
    ActionRest ++ NLast.
    
partition_act([], _) ->
    {[], []};
partition_act([Last], Result) ->
    {Last, lists:reverse(Result)};
partition_act([E | Rest], Result) ->
    partition_act(Rest, [E | Result]).
    
%%  -------------------------------------------------
%%  Returns information collected during the parsing of
%%  Mod:handle_join arguments.
%%  {standard join represented as list of patterns,
%%   list of tests for each pattern,
%%   frequency of the variables *within* the header,
%%   ID for the next join-pattern}
%%  -------------------------------------------------

%%  Match is 'wrongly' recognized by the standard compiler
%%  And it brakes things horribly. We need to manually
%%  find joins and pack them together
%%  Later we reply the function again but we know that patterns
%%  are now ok, so we omit this function
parse_patterns({match, Line0, _One, _Two}=Match, Line1,
	       Id, {RetPattern, RetPatternRec},
	       Vars, true)->
    Decoded = decode_match(Match),
    JoinsEncoded = join_patterns(Decoded, Line0),
    parse_patterns(JoinsEncoded, Line1, Id,
		   {RetPattern, RetPatternRec},
		   Vars, false);
parse_patterns({op, Line, 'and', LPattern, RPattern},
	       _L, Id, {RetPattern,RetPatternRec},
	       Vars, Decode) ->
    {PLPattern, PLPatternRec, Vars2, Id2} =
	parse_patterns(LPattern, Line, Id,
		       {[], []}, Vars, Decode),
    {PRPattern, PRPatternRec, Vars3, Id3} = 
	parse_patterns(RPattern, Line, Id2,
		       {[], []}, Vars2, Decode),
    {PRPattern ++ PLPattern ++ RetPattern,
     PRPatternRec ++ PLPatternRec ++ RetPatternRec,
     Vars3, Id3};

parse_patterns(Other, Line, Id, _, Vars, _) ->
    parse_pattern(Other, Line, Id, Vars).

parse_pattern({call, _Line1, {atom, _Line2, prop}, [Pattern]},
	     Line, Id, Vars) ->
    {_PPattern, _Rec, _NVars, _NId} =
	parse_pattern(Pattern, Line, Id, Vars, yes);
parse_pattern(Pattern, Line, Id, Vars) ->
    {_PPattern, _Rec, _NVars, _NId} =
	parse_pattern(Pattern, Line, Id, Vars, no).

parse_pattern(Pattern, Line, Id, Vars, Propagate) ->
    {NPattern, Case} = unbound_pattern(Pattern, dict:new(), false),
    CaseTests = case_test_clauses(NPattern, Line, Case),
    UniqueVar = unique_atom(?HANDLER_P_ARG_BASE),
    Rec = ?LOCAL_PATTERN(Id, Line, UniqueVar, CaseTests, Propagate),
    NVars = busy_expr(Pattern, Vars),
    {[Pattern], [Rec], NVars, Id + 1}.

%%  -----------------------------------------------------
unbound_pattern({match, Line, P1, P2}, Vars, Case) ->
    {R1, Case1} = unbound_pattern(P1, Vars, Case),
    {R2, Case2} = unbound_pattern(P2, Vars, Case),
    {{match, Line, R1, R2}, (Case1 or Case2)};
unbound_pattern({tuple, Line, PN}, Vars, _Case) ->
    RN = lists:map(
	       fun(Elem) ->
		       {R, _} = unbound_pattern(Elem, Vars, true),
		       R
	       end, PN),
    {{tuple, Line, RN}, true};
unbound_pattern({cons, Line, P1, P2}, Vars, Case) ->
    {R1, _} = unbound_pattern(P1, Vars, Case),
    {R2, _} = unbound_pattern(P2, Vars, Case),
    {{cons, Line, R1, R2}, true};
unbound_pattern({op, Line, Op, P1, P2}, Vars, Case) ->
    {R1, _} = unbound_pattern(P1, Vars, Case),
    {R2, _} = unbound_pattern(P2, Vars, Case),
    {{op, Line, Op, R1, R2}, true};
unbound_pattern({var, Line, Name} = Var, Vars, Case) ->
    case dict:find(Name, Vars) of
	{ok, Number} when (Number > 1) ->
	    {Var, true};
	_ ->
	    {{var, Line, unbounded_var(Name)}, Case}
    end;
unbound_pattern({record, Line, Name, PN}, Vars, _Case) ->
    RN = lists:map(
	   fun(Elem) ->
		   {R, _} = unbound_pattern(Elem, Vars, true),
		   R
	   end, PN),
    {{record, Line, Name, RN}, true};
unbound_pattern({record_field, Line, P1, P2}, Vars, _Case) ->
    {R1, _} = unbound_pattern(P1, Vars, true),
    {R2, _} = unbound_pattern(P2, Vars, true),
    {{record_field, Line, R1, R2}, true};
unbound_pattern({bin, Line, PN}, Vars, _Case) ->
    RN = lists:map(
	   fun(Elem) ->
		   {R, _} = unbound_pattern(Elem, Vars, true),
		   R
	   end, PN),
    {{bin, Line, RN}, true};
unbound_pattern({bin_element, Line, P1, P2, P3}, Vars, _Case) ->
    {R1, _} = unbound_pattern(P1, Vars, true),
    %% P2 is the size of the bits that we take
    %% and cannot be unbounded
    %% P3 is the type of the bits we take
    %% and cannot be a variable
    {_, Case2} = unbound_pattern(P2, Vars, false),
    {_, Case3} = unbound_pattern(P3, Vars, false),
    R2 = case Case2 of
	     true -> P2;
	     false -> default
	 end,
    R3 = case Case3 of
	     true -> P3;
	     false -> default
	 end,
    {{bin_element, Line, R1, R2, R3}, true};
unbound_pattern([ListExpr], Vars0, Case0) ->
    {R, _} = unbound_pattern(ListExpr, Vars0, Case0),
    {[R], true};
unbound_pattern(P, _Vars, _Case) ->    
    {P, true}.


term_replace({var, Line, Name}=Var, V, N) ->
    case lists:member(Name, V) of
	true -> N(Line);
	_    -> Var
    end;
term_replace({Op, Line, E}, V, N) ->
    {Op, Line, term_replace(E, V, N)};
term_replace({Op, Line, E1, E2}, V, N) ->
    {Op, Line,
     term_replace(E1, V, N),
     term_replace(E2, V, N)};
term_replace({Op, Line, E1, E2, E3}, V, N) ->
    {Op, Line,
     term_replace(E1, V, N),
     term_replace(E2, V, N),
     term_replace(E3, V, N)};
term_replace(E, V, N) when is_list(E) ->
    lists:map(fun(Elem) -> term_replace(Elem, V, N) end, E);
term_replace(E, _, _) ->
    E.

case_test_clauses(Pattern, Line, false) ->
    [{clause, Line,
      [Pattern],
      [],
      [{atom, Line, true}]}];
case_test_clauses(Pattern, Line, true) ->
    [{clause, Line,
      [Pattern],
      [],
      [{atom, Line, true}]},
     {clause, Line,
      [{var, Line, '_'}],
      [],
      [{atom, Line, false}]}].

%%  ------------------------------------------------

%% Functions responsible for transforming
%% match to acceptable pattern structure
decode_match({match, Line0, Left0, {match, _Line, _Left1, _Right1}=Right0}) ->
    %%  Since the code is fine we are sure that first
    %%  element is definitely not the match itself
    %% But it can be an 'and' op.

    {Pattern, Rest0} = match_r_most(Left0),
    [Head | Rest2] = decode_match(Right0),
    {MatchedPattern, Rest1} = match_l_most(Head),
    Rest0 ++ [{match, Line0, Pattern, MatchedPattern} | Rest1] ++ Rest2;
decode_match({match, Line0, Left0, {op, _, 'and', _, _}=Right0}) ->
    {Pattern, Rest0} = match_r_most(Left0),
    {MatchedPattern, Rest1} = match_l_most(Right0),
    Rest0 ++ [{match, Line0, Pattern, MatchedPattern} | Rest1];
decode_match({match, _Line0, _, {op, _, _Other, _, _}}) ->
    exit({error, invalid_join_operator});
decode_match({match, Line0, Left0, Right0}) ->
    {Pattern, Rest} = match_r_most(Left0),
    Rest ++ [{match, Line0, Pattern, Right0}].

match_r_most({op, _, 'and', Left0, Right0}) ->
    {Pattern, RestJoins} = match_r_most(Right0),
    {Pattern, [Left0 | RestJoins]};
match_r_most({op, _, Other, _, _}) ->
    exit({error, {invalid_join_operator, Other}});
match_r_most(Pattern) ->
    {Pattern, []}.

match_l_most({match, _, _, _}) ->
    exit({error, invalid_match_l_most});
match_l_most({op, _, 'and', Left0, Right0}) ->
    {Pattern, RestJoins} = match_l_most(Left0),
    {Pattern,  RestJoins ++ [Right0]};
match_l_most({op, _, Other, _, _}) ->
    exit({error, {invalid_join_operator, Other}});
match_l_most(Pattern) ->
    {Pattern, []}.

join_patterns(Patterns, Line) ->
    join_patterns1(lists:reverse(Patterns), Line).

join_patterns1([], _) ->
    [];
join_patterns1([Elem], _) ->
    Elem;
join_patterns1([Right, Left], Line) ->
    {op, Line, 'and', Left, Right};
join_patterns1([Head | Rest], Line) ->
    Result = join_patterns1(Rest, Line),
    {op, Line, 'and', Result, Head}.


guards_avail({false, _, Null}) ->
    {Null, false};
guards_avail({true, Target, _}) ->
    {Target, true}.

state_avail(C, false,
	    {SVars, State, Null}) ->
    term_replace(State, C ++ SVars, Null);
state_avail(_, true,
	    {SVars, State, Null}) ->
    term_replace(State, SVars, Null).

p_avail(_, {_, false},
	SVars, PVarsDict, P) ->
    F0 = 
	dict:fetch_keys(
	  dict:filter(
	    fun(_, 1) ->
		    true;
	       (_, _) ->
		    false
	    end,PVarsDict)),
    F1 = F0 -- SVars,
    term_replace(P, F1, fun jerlang_misc:unbounded_var_null/1);
p_avail(Common, {GVars, true},
        SVars, PVarsDict, P) ->
    F0 = 
	dict:fetch_keys(
	  dict:filter(
	    fun(_, 1) ->
		    true;
	       (_, _) ->
		    false
	    end,PVarsDict)),
    F1 = F0 -- Common,
    F2 = F1 -- GVars,
    F3 = F2 -- SVars,
    term_replace(P, F3, fun jerlang_misc:unbounded_var_null/1).
	    
vars_split(Dic1, Dic2) ->
    Dic0 = dict:merge(
	     fun(_, V1, V2) -> V1 + V2 end,
	     Dic1, Dic2),
    %% Variables that are shared between
    %% state and guards
    Common = dict:fetch_keys(
	      dict:filter(
		fun(_, 1) ->
			false;
		   (_, _) ->
			true
		end, Dic0)),
    Diff = (dict:fetch_keys(Dic0) -- Common),
    {SPVars, GPVars} = lists:partition(
			 fun(Key) ->
				 dict:is_key(Key, Dic1)
			 end, Diff),
    {Common, SPVars, GPVars}.

%%  If guard contains a free variables then
%%  replace it with a neutral atom because
%%  original guard clause will complain anyway.
guards_cond(Val, GVars, AllVars) ->
    guards_cond0(Val, dict:fetch_keys(GVars) --
		dict:fetch_keys(AllVars)).

guards_cond0(Guards, []) ->
    Guards;
guards_cond0(Guards, Vars) ->
    term_replace(Guards, Vars,
		fun(Line) ->
		       {atom, Line, true}
		end).
jerlang/src/jerlang_gen_joins_order.erl0000644000175000017500000000602211220224120020171 0ustar  huberthubert-module(jerlang_gen_joins_order).

-export([optimize/3]).
-import(jerlang_misc, [busy_expr/1]).

optimize(P0, Id, {Status, Guard}) ->
    Parse = fun(Expr) ->
		    sets:from_list(
		      dict:fetch_keys(busy_expr(Expr)))
	    end,
    {P1, Initial} = init(P0, Id, Parse),
    VStatus = Parse(Status),
    VGuard = Parse(Guard),
    P2 = dependencies(P1, VStatus, VGuard),
%    io:format("This is the ranking: ~p~n", [dict:to_list(P2)]),
    Res = sort_rank(P2),
    case Res of
	Initial ->
	    {ok, valid};
	_ ->
	    {ok, generate_order(Res, [], P2, [])}
    end.

%% --- store the patterns in dict
init(P, Id0, Fun) ->
    {_, Dict} = 
	lists:foldl(
	  fun(E, {Id, S}) ->
		  {Id + 1, dict:store(Id, {Fun(E), E}, S)}
	  end, {Id0, dict:new()}, P),
    {Dict, [X || X <- lists:seq(Id0, Id0 + (length(P) -1))]}.

%% --- determine rank of each pattern
dependencies(Dict, VStatus, VGuard) ->
    dict:map(
      fun(Key, {Vars, E}) ->
	      Rank = dependency(Key, Vars, Dict),
	      %% Do we treat guards and status the same?
	      %% I guess so.
	      {Vars,
	       {Rank, has_common_set(Vars, VStatus),
		has_common_set(Vars, VGuard)},
	       E}
      end, Dict).

dependency(Id, Vars, D) ->
    dependency(Id, Vars, dict:to_list(D), []).

dependency(_, _, [], Result) ->
    lists:reverse(Result);
dependency(Id, Vars, [{Id, _} | Rest], Result) ->
    dependency(Id, Vars, Rest, Result);
dependency(Id0, Vars0, [{Id1, {Vars1, _}} | Rest], RankList) ->
    NRankList = 
	case has_common_set(Vars0, Vars1) of
	    true ->
		[Id1 | RankList];
	    _ ->
		RankList
	end,
    dependency(Id0, Vars0, Rest, NRankList).

has_common_set(Vars0, Vars1) ->
    sets:size(sets:intersection(Vars0, Vars1)) > 0.

sort_rank(Dict) ->
    L0 = dict:to_list(Dict),
    L1 = lists:keysort(1, L0),
    L2 = lists:sort(
	   fun({_, {_, Rank0, _}}, {_, {_, Rank1, _}}) ->
		   compare_rank(Rank0, Rank1)
	   end, L1),
    lists:map(
      fun({Id, _}) ->
	      Id
      end, L2).

compare_rank({L1, _, _}, {L2, _, _}) when (length(L1) > length(L2)) ->
    true;
compare_rank({L1, _, _}, {L2, _, _}) when (length(L1) < length(L2)) ->
    false;
compare_rank({_, VS1, VG1}, {_, VS2, VG2}) ->
    case compare_static(VS1, VS2) of
	{ok, L} -> L;
	error ->
	    case compare_static(VG1, VG2) of
		{ok, L} -> L;
		error -> true
	    end
    end.

compare_static(false, true) ->
    {ok, false};
compare_static(true, false) ->
    {ok, true};
compare_static(_, _) ->
    error.

generate_order([], [], _, Result) ->
    lists:reverse(Result);
generate_order(Main, [P | Rest], Dict, Result) ->
    {_, {Joined, _, _}, _} = dict:fetch(P, Dict),
    NJoined = available(Joined, Main),
    generate_order(Main -- Joined, Rest ++ NJoined,
		   Dict, [P | Result]);
generate_order([P | Rest], [], Dict, Result) ->
    {_, {Joined, _, _}, _} = dict:fetch(P, Dict),
    NJoined = available(Joined, Rest),
    generate_order(Rest -- Joined, NJoined, Dict, [P | Result]).

available(Required, All) ->
    Inter = sets:intersection(
	      sets:from_list(Required),
	      sets:from_list(All)),
    sets:to_list(Inter).
jerlang/src/jerlang_gen_joins_mset.erl0000644000175000017500000000632711220224120020036 0ustar  huberthubert-module(jerlang_gen_joins_mset).

-export([beta/3]).

-include("jerlang.hrl").


-type(fun_msg() :: fun(([id()]) -> msg())).
-type(opt() :: {status(), [id()],
		{fun_beta_test(), state(), fun_msg()},
		dupl()}).
-spec(beta/3 :: ([[id()]], [id()], opt()) ->
	    {'ok', [id()]}).

%%  -----------------------------------------
%%  Main function that runs the beta tests
%%  for Rete algorithm. Trying to find a
%%  unique set that satisfies the conditions.
%%  Can be either final or partial reduction.
%%  To improve the efficiency of the algorithm
%%  for large amounts of data, we purge branches
%%  that cannot be satisfied (for example, by
%%  removing entries that are duplicates, if they
%%  fail).
beta(Previous, Pattern, Opt) ->
    beta0(Previous, Pattern, [], Opt).

beta0(_, [], _, _) ->
    {ok, []};
beta0([], _, Res, _) ->
    {ok, lists:reverse(Res)};
beta0([P | Rest], Matches0, _,
      {final, _, _, D}=Opt) ->

    Matches1 = Matches0 -- P,
    %% No need to run purge_current in final
    %% since we are only interested in the first correct
    %% and there are no previous entries.
%    io:format("FINAL REDUCTION [~p ~p]~n", [P, Matches1]),
    Result0 = beta1(P, Matches1, [], Opt),
    case Result0 of
	[] ->
	    NRest = purge(P, Rest, D),
	    beta0(NRest, Matches0, [], Opt);
	_ ->
%	    io:format("Finalize...~n", []),
	    {ok, Result0}
    end;
beta0([P | Rest], Matches0, Res,
      {partial, Current, _, D}=Opt) ->
    Matches1 = Matches0 -- P,
    Matches2 = purge_current(Current, Matches1, D),

    Result0 = beta1(P, Matches2, [], Opt),
    NRest = purge(P, Rest, D),
    beta0(NRest, Matches0, Result0 ++ Res, Opt).

beta1(_, [], Res, _) ->
    lists:reverse(Res);
beta1(P, [E | Rest], Res,
      {Status, Current, {Fun, State, FunIds}, Dupl}=Opt) ->
    Term = P ++ [E],
    case lists:member(Term, Current) or lists:member(E, P) of
	false ->
%	    io:format("BBB2 ~p~n", [Term]),
	    Msgs = FunIds(Term),
	    try Fun(Msgs, State) of
		    true ->
		        beta_action(Term, Status,
				    {E, P, Rest, Res, Opt})
	    catch
		error:function_clause ->
		    NRest = purge(E, Rest, Dupl),
		    beta1(P, NRest, Res, Opt)
	    end;
	_ ->
%	    io:format("BBB1~n", []),
	    beta1(P, Rest, Res, Opt)
    end.

beta_action(Found, final, _) ->
    Found;
beta_action(Found, partial,
	    {Elem, LeftPartial, Right,
	     Res, {_, _, _, D}=Opt}) ->
    NRight = purge(Elem, Right, D),
    beta1(LeftPartial, NRight, [Found | Res], Opt).

purge(E, List, Duplicates) ->
    {ok, NList} = jerlang_2dict:get(E, List, Duplicates),
%    {_S1, S2} = Duplicates,
%    io:format("DUPL: ~p~n", [dict:to_list(S2)]),
%    io:format("PURGE [~p]: ~p and ~p~n", [E, List, NList]),
    NList.

%%  Remove entries from the existing matches
%%  that would produce the same results
purge_current(_, [], _) ->
    [];
purge_current([], Matches, _) ->
    Matches;
purge_current([E | Rest], Matches, D) ->
    %% FIXME: we should have a possibility of 
    %% of storing the tail somewhere?
    %% this computation will be a bottleneck,
    %% for larger number of joins
    %% (not recommended?).
    Tail = tail(E),
    Res = purge(Tail, Matches, D),
    purge_current(Rest, Res, D).    

tail([]) ->
    error;
tail([E]) ->
    E;
tail([_E | Rest]) ->
    tail(Rest).
jerlang/src/jerlang_gen_joins.erl0000644000175000017500000004724111220224120017006 0ustar  huberthubert-module(jerlang_gen_joins).

-export([start/3, start/4, start_link/3, start_link/4]).
-export([call/2, call/3, cast/2]).

%% Internal exports
-export([init_it/6, behaviour_info/1]).

-import(error_logger, [format/2]).
-import(jerlang_gen_joins_mset, [first/3, beta/3]).
-include("jerlang.hrl").
-define(GEN_JOINS_MAILBOX, gen_joins_mailbox).
-define(GEN_JOINS_DUPLICATES, gen_joins_duplicates).

-spec(behaviour_info/1 :: (atom()) -> 'undefined' | behaviour()).

behaviour_info(callbacks) ->
    [{init, 1},
     {init_joins, 1},
     {handle_join, 2},
     {terminate, 0}];

behaviour_info(_Other) ->
    undefined.

% Start the joins server
start(Mod, Args, Options) ->
    gen:start(?MODULE, nolink, Mod, Args, Options).

start(Name, Mod, Args, Options) ->
    gen:start(?MODULE, nolink, Name, Mod, Args, Options).

start_link(Mod, Args, Options) ->
    gen:start(?MODULE, link, Mod, Args, Options).

start_link(Name, Mod, Args, Options) ->
    gen:start(?MODULE, link, Name, Mod, Args, Options).

%% -----------------------------------------------------------------
%% Make a call to a generic server.
%% If the server is located at another node, that node will
%% be monitored.
%% If the client is trapping exits and is linked server termination
%% is handled here (? Shall we do that here (or rely on timeouts) ?).
%% ----------------------------------------------------------------- 
call(Name, Request) ->
    case catch gen:call(Name, '$gen_call', Request) of
	{ok,Res} ->
	    Res;
	{'EXIT',Reason} ->
	    exit({Reason, {?MODULE, call, [Name, Request]}})
    end.

call(Name, Request, Timeout) ->
    case catch gen:call(Name, '$gen_call', Request, Timeout) of
	{ok,Res} ->
	    Res;
	{'EXIT',Reason} ->
	    exit({Reason, {?MODULE, call, [Name, Request, Timeout]}})
    end.

%% -----------------------------------------------------------------
%% Make a cast to a generic server.
%% -----------------------------------------------------------------
cast({global,Name}, Request) ->
    catch global:send(Name, cast_msg(Request)),
    ok;
cast({Name,Node}=Dest, Request) when is_atom(Name), is_atom(Node) -> 
    do_cast(Dest, Request);
cast(Dest, Request) when is_atom(Dest) ->
    do_cast(Dest, Request);
cast(Dest, Request) when is_pid(Dest) ->
    do_cast(Dest, Request).

do_cast(Dest, Request) -> 
    do_send(Dest, cast_msg(Request)),
    ok.

cast_msg(Request) -> {'$gen_cast',Request}.

%%%========================================================================
%%% Gen-callback functions
%%%========================================================================

%%% ---------------------------------------------------
%%% Initiate the new process.
%%% Register the name using the Rfunc function
%%% Calls the Mod:init/Args function.
%%% Finally an acknowledge is sent to Parent and the main
%%% loop is entered.
%%% ---------------------------------------------------
%%% First gather information about any joins from the Mod:init_joins
%%% function and parse it.
%%% Call to Mod:init sets the initial value for the
%%% Mod:handle_join functions.
%%% ---------------------------------------------------
init_it(Starter, self, Name, Mod, Args, Options) ->
    init_it(Starter, self(), Name, Mod, Args, Options);
init_it(Starter, Parent, Name, Mod, Args, Options) ->
    Debug = debug_options(Name, Options),
    Joins =
	case catch verify_join(Mod:init_joins(none)) of
	    {ok, JoinsDef} ->
		JoinsDef;
	    Other ->
		%io:format("Errror: ~p~n", [Other]),
		proc_lib:init_ack(Starter, {error, Other}),
		exit({error, Other})
	end,
    case catch Mod:init(Args) of
	{ok, State} ->
	    proc_lib:init_ack(Starter, {ok, self()}), 	    
	    loop(Parent, Name, State, Mod, infinity, Joins, Debug);
	{ok, State, Timeout} ->
	    proc_lib:init_ack(Starter, {ok, self()}), 	    
	    loop(Parent, Name, State, Mod, Timeout, Joins, Debug);
	{stop, Reason} ->
	    proc_lib:init_ack(Starter, {error, Reason}),
	    exit(Reason);
	ignore ->
	    proc_lib:init_ack(Starter, ignore),
	    exit(normal);
	{'EXIT', Reason} ->
	    proc_lib:init_ack(Starter, {error, Reason}),
	    exit(Reason);
	Else ->
	    Error = {bad_return_value, Else},
	    proc_lib:init_ack(Starter, {error, Error}),
	    exit(Error)
    end.

%%%========================================================================
%%% Internal functions
%%%========================================================================
%%% ---------------------------------------------------
%%% The MAIN loop.
%%% ---------------------------------------------------
loop(Parent, Name, State, Mod, hibernate, Joins, Debug) ->
    proc_lib:hibernate(?MODULE,wake_hib,
		       [Parent, Name, State, Mod, Joins, Debug]);
loop(Parent, Name, State, Mod, Time, Joins, Debug) ->
    Msg = receive
	      Input ->
		    Input
	  after Time ->
		  timeout
	  end,
    decode_msg(Msg, Parent, Name, State, Mod, Time, Joins, Debug, false).

%% FIXME: allow for hibernation. Compare with R12 release
%wake_hib(Parent, Name, State, Mod, Joins, Debug) ->
%    Msg = receive
%	      Input ->
%		  Input
%	  end,
%    decode_msg(Msg, Parent, Name, State, Mod, hibernate, Joins, Debug, true).

decode_msg(Msg, Parent, Name, State, Mod, Time, Joins, Debug, Hib) ->
    case Msg of
	{system, From, Req} ->
	    sys:handle_system_msg(Req, From, Parent, ?MODULE, Debug,
				  [Name, State, Mod, Time, Joins], Hib);
	{'EXIT', Parent, Reason} ->
	    terminate(Reason, Name, Msg, Mod, State, Joins, Debug);
	{internal, joins} ->
	    handle_msg1(none, Parent, Name, State, Mod, Time, Joins, Debug);
	_Msg when Debug =:= [] ->
	    handle_msg0(Msg, Parent, Name, State, Mod, Time, Joins, Debug);
	_Msg ->
	    Debug1 = sys:handle_debug(Debug, {?MODULE, print_event}, 
				      Name, {in, Msg}),
	    handle_msg0(Msg, Parent, Name, State, Mod, Time, Joins, Debug1)
    end.

%check_size() ->
%    {ok, Mailbox} = gen_joins_mailbox(),
%    Size = jerlang_dict:size(Mailbox),
%    case (Size > 200) and ( (Size rem 10) == 0) of
%	true ->
%	    io:format("Size is bigger ~p~n", [Size]);
%	_ ->
%	    ok
%    end.

handle_msg0({'$gen_call', _, _}=Call, Parent, Name, State,
	    Mod, Time, Joins, Debug) ->
    handle_msg1(Call, Parent, Name, State,
		Mod, Time, Joins, Debug);
%% Adapting cast to common pattern
handle_msg0({'$gen_cast', Msg}, Parent, Name, State,
	    Mod, Time, Joins, Debug) ->
    handle_msg1({'$gen_cast', none, Msg}, Parent, Name, State,
		Mod, Time, Joins, Debug);
handle_msg0(_Other, _Parent, _Name, _State,
	    _Mod, _Time, _Joins, _Debug) ->
    %% FIXME: possibly just ignore?
    exit({error, unrecognized_message}).

handle_msg1(Msg, Parent, Name, State,
	    Mod, Time, Joins, Debug) ->
    %io:format("Handle message~n", []),
    %% Find any matching join
    JoinsMatching = process_join(Msg, Joins, State),
    %% Analyse result of matching
    case JoinsMatching of
	{error, NJoins} ->
	    loop(Parent, Name, State, Mod, Time, NJoins, Debug);
	{ok, {Msgs, NJoins}} ->
	    Split = lists:map(
		       fun({Tag, From, Value}) ->
			       {{Tag, From}, Value}
		       end, Msgs),
	    {Tags, Values} = lists:unzip(Split),
%	    io:format("Handling join ~p~n", [Values]),
	    JoinCall =
		try Mod:handle_join(Values, State)
		catch
		    exit:Exc -> {exit, Exc};
		    error:Exc -> {exit, Exc}
		end,
	    handle_join_result(JoinCall, Tags, Parent,
			       Name, State, Mod,
			       Time, NJoins, Debug)
    end.

handle_join_result({stop, Reason}, MsgTags, _Parent, Name, _OldsState,
		   Mod, _Time, _Joins, _Debug) ->
    ok = try Mod:terminate()
	 catch
	     _:_ -> %% ignore
		 ok
	 end,
    Replies = 
	lists:map(
	  fun({_, {_, _}}=Tag) ->
		  %% END FIXME
		  {Tag, {reply, {error, Reason}}};
	     ({_, _})->
		  {none, noreply}
	  end, MsgTags),
    
    ok = handle_reply(Replies),
    stop_gen_joins(Reason, Name);    
handle_join_result({exit, Other}, _MsgTags, _Parent, _Name, _OldState,
		   _Mod, _Time, _Joins, _Debug) ->
    %% Invalid return from the handle_join call.
    %% Internal error. Closing server.
    exit({error, {internal, gen_joins_handle_join, Other}});
handle_join_result({Reply, NState}, MsgTags, Parent, Name, _OldState,
		   Mod, Time, Joins, Debug) ->
    ReplyTo =  lists:zip(MsgTags, Reply),
    ok = handle_reply(ReplyTo),
    decode_msg({internal, joins}, Parent, Name,
		NState, Mod, Time, Joins, Debug, false).

handle_reply([]) ->
    ok;
handle_reply([{_, noreply} | Rest]) ->
    %% FIXME: throw warning if tag not empty
    handle_reply(Rest);
handle_reply([{{_Tag, {To, Ref}}, {reply, Reply}} | Rest]) ->
    To ! {Ref, Reply},
    handle_reply(Rest).

%handle_msg({'$gen_call', From, Msg}, Parent, Name, State, Mod, _Time, Debug) ->
%    case catch Mod:handle_call(Msg, From, State) of
%	{reply, Reply, NState} ->
%	    Debug1 = reply(Name, From, Reply, NState, Debug),
%	    loop(Parent, Name, NState, Mod, infinity, Debug1);
%	{reply, Reply, NState, Time1} ->
%	    Debug1 = reply(Name, From, Reply, NState, Debug),
%	    loop(Parent, Name, NState, Mod, Time1, Debug1);
%	{noreply, NState} ->
%	    Debug1 = sys:handle_debug(Debug, {?MODULE, print_event}, Name,
%				      {noreply, NState}),
%	    loop(Parent, Name, NState, Mod, infinity, Debug1);
%	{noreply, NState, Time1} ->
%	    Debug1 = sys:handle_debug(Debug, {?MODULE, print_event}, Name,
%				      {noreply, NState}),
%	    loop(Parent, Name, NState, Mod, Time1, Debug1);
%	{stop, Reason, Reply, NState} ->
%	    {'EXIT', R} = 
%		(catch terminate(Reason, Name, Msg, Mod, NState, Debug)),
%	    reply(Name, From, Reply, NState, Debug),
%	    exit(R);
%	Other ->
%	    handle_common_reply(Other, Parent, Name, Msg, Mod, State, Debug)
%    end;

stop_gen_joins(Reason, Name) ->
    %% FIXME: should we better handle the reason?
    unregister(Name),
    exit(Reason).

%%% ---------------------------------------------------
%%% Send/recive functions
%%% ---------------------------------------------------
do_send(Dest, Msg) ->
    case catch erlang:send(Dest, Msg, [noconnect]) of
	noconnect ->
	    spawn(erlang, send, [Dest,Msg]);
	Other ->
	    Other
    end.

%%% ---------------------------------------------------
%%% Terminate the server.
%%% ---------------------------------------------------

terminate(Reason, _Name, _Msg, Mod, State, _Joins, _Debug) ->
    case catch Mod:terminate(Reason, State) of
	{'EXIT', R} ->
%	    error_info(R, Name, Msg, State, Debug),
	    exit(R);
	_ ->
	    case Reason of
		normal ->
		    exit(normal);
		shutdown ->
		    exit(shutdown);
		_ ->
%		    error_info(Reason, Name, Msg, State, Debug),
		    exit(Reason)
	    end
    end.

%% Misc
%% FIXME: provide support for debugging
debug_options(_, _) ->
    [].

%%% -------------------------------------
%%% Joins handling functions
%%% -------------------------------------

gen_joins_mailbox() ->
    case get(?GEN_JOINS_MAILBOX) of
	undefined ->
	    {ok, jerlang_dict:init()};
	Mailbox ->
	    {ok, Mailbox}
    end.

gen_joins_duplicates() ->
    case get(?GEN_JOINS_DUPLICATES) of
	undefined ->
	    {ok, jerlang_2dict:init()};
	Mailbox ->
	    {ok, Mailbox}
    end.

store_mailbox(Mailbox) ->
    put(?GEN_JOINS_MAILBOX, Mailbox).

store_duplicates(Mapping) ->
    put(?GEN_JOINS_DUPLICATES, Mapping).

%% -----------------------------------------------
%% The 'none' case is used when we check joins
%% as a result of the previous join being successful,
%% i.e. found match. Since State could have changed
%% we need to check if we have any further matches.
%% -----------------------------------------------

%% FIXME: remove redundant code
process_join(none, Joins, State) ->
    {ok, Mailbox, D} = process_join_init(),
    process_join0(none, Joins, [], {Mailbox, {no, D}}, State);
process_join(Msg, Joins, State) ->
    {ok, Mailbox, D} = process_join_init(),
    {NMailbox, Idx} = jerlang_dict:insert(Mailbox, Msg),
    process_join0({Idx, Msg}, Joins, [], {NMailbox, {no, D}}, State).

process_join_init() ->
    {ok, Mailbox} = gen_joins_mailbox(),
    {ok, D} = gen_joins_duplicates(),
    {ok, Mailbox, D}.

process_join0(Msg, [], Joins, {M, {_, D}}, _) ->
    joins_matching({error, no_match}, Msg, 
		   lists:reverse(Joins),
		   {M, D});
process_join0(none, [Join | Rest], JResult, M, State) ->
    process_join1(none, [], Join, Rest, JResult, M, State);
process_join0({Id, Msg}, [Join | Rest], JResult, M, State) ->
    {NJoin, Flag} = alpha_reduction({Id, Msg}, Join),
    process_join1({Id, Msg}, Flag, NJoin, Rest, JResult, M, State).

process_join1(Msg, AReduce, Join, RestJoins, Result, MD, State) ->
    NMD = update_duplicates(Msg, AReduce, MD),
    {M, {_, D}} = NMD,
    Result1 = beta_reduction(Msg, AReduce, Join, {M, D}, State),
    case Result1 of
	{error, {not_found, NJoin}} ->
	    process_join0(Msg, RestJoins, [NJoin | Result], NMD, State);
	{ok, {MsgIds, NJoin}}  ->
	    joins_matching({ok, MsgIds}, Msg, 
			   {lists:reverse(Result), NJoin, RestJoins},
			   {M, D})
    end.

joins_matching({error, no_match}, _, Joins, {M, D}) ->
    store_mailbox(M),
    store_duplicates(D),
    {error, Joins};
joins_matching({ok, MsgIds}, InitMsg,
	       {TestedJs, Join, AfterJs}, {M, D}) ->

    {RemoveIds, PIds, All} =
	propagation_ids(MsgIds, Join),
    NAfterJs = propagation_update(InitMsg, PIds, AfterJs), 
    AllJoins = TestedJs ++ [Join] ++ NAfterJs,

    FinalJoins = purge_messages(AllJoins, RemoveIds),
    {NM, MatchedMsgs} = jerlang_dict:remove(M, All),
    ND = jerlang_2dict:remove(D, RemoveIds),
    store_mailbox(NM),
    store_duplicates(ND),
    {ok, {MatchedMsgs, FinalJoins}}.

propagation_update({Id, Msg}, PIds, Rest) ->
    case lists:member(Id, PIds) of
	true ->
	    lists:map(
	      fun(J) ->
		      {NJ, _} = alpha_reduction(
				  {Id, Msg}, J),
		      NJ
	      end, Rest);
	false ->
	    Rest
    end;
propagation_update(_, _, Rest) ->
    Rest.

alpha_reduction({Id, {_Tag, _From, Msg}}, [Alpha | Beta]) ->
    {NAlpha, Flag} = lists:mapfoldl(
      fun({PId, #pattern_joins{test=F, msgs=Msgs} = PRec} = P,
	  Acc) ->
	      case F(Msg) of
		  true ->
		      {{PId, PRec#pattern_joins{msgs=Msgs ++ [Id]}},
		       [PId | Acc]};
		  _ ->
		      {P, Acc}
	      end
      end, [], Alpha),
    {[NAlpha | Beta], Flag}.

%%  Function responsible for updating information
%%  about duplicate entries. Unfortunately one has to parse
%%  all the non-duplicates messages in order to find out
%%  groups that are equal to this message.
update_duplicates(none, _, M) ->
    M;
update_duplicates(_, [], M) ->
    M;
update_duplicates(_, _, {_, {yes, _}}=M) ->
    M;
update_duplicates({Elem, _}, _, {Mailbox, {no, Dupl}}) ->

    Update =
	jerlang_2dict:update(
	  Elem,
	  fun(Id) ->
		  jerlang_dict:get(Mailbox, Id)
	  end, Dupl),
    {Mailbox, {yes, Update}}.
    
-spec(beta_reduction/5 ::
      ({id(), msg()} | 'none', list(), join(),
       {jdict(msg()), j2dict(ref(), [id()])}, state()) ->
	     {'error', {'not_found', join()}} |
		 {'ok', {[id()], join()}}).

beta_reduction({_, _}, [], Join, _MD, _State) ->
    {error, {not_found, Join}};
beta_reduction(Msg0, Matches, [Alpha | Beta], {M, D}, S) ->
    Id = case Msg0 of
	     {Id0, _} -> Id0;
	     none -> none
	 end,
    MAccess = fun(Ids) ->
		      lists:map(
			fun({_, _, Val}) ->
				Val;
			   ({_, Val}) ->
				Val;
			   (Val) ->
				Val
			end,jerlang_dict:get(M, Ids))
	      end,
    {Result, {Val1, NBeta}} = 
	beta_reduction1(Id, Matches, Alpha, Beta, [], {MAccess, D}, S),
    {Result, {Val1, [Alpha | NBeta]}}.

beta_reduction1(_, _, [], [], Result, _, _) ->
    {error, {not_found, lists:reverse(Result)}};
beta_reduction1(none, Matches,
		[{_, #pattern_joins{msgs=Msgs}}]=A, B, [], MD, S) ->
    %% Single pattern join - no new msg version.

    beta_reduction_for(Msgs, Matches, A, B, [], MD, S);    
beta_reduction1(Id, _Matches, [_A1], [{Fun, []}]=B, [], {M, _}, S) ->
    %% Single pattern join.
    Value = M([Id]),
    try Fun(Value, S) of
	true ->
	    {ok, {[Id], B}}
    catch
	error:function_clause ->
	    {error, {not_found, B}}
    end;
beta_reduction1(Id, Matches,
		[{_, #pattern_joins{msgs=MsgsA1}},
		 {_, #pattern_joins{msgs=MsgsA2}} | ARest],
		[{Fun, BMsgs} | BRest]=B, [],
		{M, D}, S) ->
    %% Initial Beta-reduction for first two messages.

    Type = case ARest of
		 [] -> final;
		 _  -> partial
	     end,
    FMsgsA1 = [[X] || X <- MsgsA1],
    Seq1 =
	try beta(FMsgsA1, MsgsA2,
		 {Type, BMsgs, {Fun, S, M}, D}) of
	    {ok, []} ->
		%%  Nothing new was found
		%%  {error, {not_found, B}};
		[];
	    {ok, Seq} ->
		Seq
	catch
	    error:_ ->
		exit({error, invalid_beta_reduction})
	end,
    Seq2 = BMsgs ++ Seq1,
    case Seq2 of
	[] ->
	    %%  This beta reduction isn't satisfyable
	    %%  by any set of messages. Abort. 
	    {error, {not_found, B}};
	_ ->
	    case Type of
		final ->
		    {ok, {Seq2, B}};
		_ ->
		    beta_reduction1(Id, Matches, ARest,
				    BRest, [{Fun, Seq2}],
				    {M, D}, S)
	    end
    end;
beta_reduction1(_, _, [[_]], [{_, []}], [], _, _) ->
    %%  Keep dialyzer happy
    exit({error, internal_error});
beta_reduction1(_, _Matches, [A | []],
		[{Fun, []}]=B, ResBeta,
		{M, D}, S) ->
    %%  Final beta reduction.
    {_NumA, #pattern_joins{msgs=MsgA}} = A,
    [{_, LastB} | _] = ResBeta,
    case beta(LastB, MsgA, {final, [], {Fun, S, M}, D}) of
	{ok, []} ->
	    {error, {not_found, lists:reverse(ResBeta) ++ B}};
	{ok, Seq} ->
	    {ok, {Seq, lists:reverse(ResBeta) ++ B}}
    end;
beta_reduction1(_, _, [_ | _], [{_, _} | _], [], _, _) ->
    %%  Keep dialyzer happy
    exit({error, internal_error});
beta_reduction1(Id, Matches, [A | ARest],
		[{Fun, BMsgs} | BRest] = B, ResBeta, {M, D}, S) ->
    %%  Partial beta reduction
    {_NumA, #pattern_joins{msgs=MsgA}} = A,
    [{_, LastB} | _] = ResBeta,
    ResSeq =
	try beta(LastB, MsgA,
		 {partial, BMsgs, {Fun, S, M}, D}) of
	    {ok, []} ->
		[];
	    {ok, Seq} ->
		Seq
	catch
	    error:Other ->
		exit({error,
		      {internal_error,
		       invalid_beta_reduction,
		       Other}})
	end,
    
    NResBeta =  BMsgs ++ ResSeq,
    case NResBeta of
	[] ->
	    {error,
	     {not_found, lists:reverse(ResBeta) ++ B}};
	_ ->
	    beta_reduction1(Id, Matches, ARest, BRest,
			    [{Fun, NResBeta} | ResBeta],
			    {M, D}, S)
    end.

%%  Only allowed to use on single pattern join
%%  for none.
beta_reduction_for([], _, _, B, _, _, _) ->
    {error, {not_found, B}};
beta_reduction_for([Id | Rest], Matches, A, B, Res, MD, S) ->
    NRes = beta_reduction1(Id, Matches, A, B, Res, MD, S),
    case NRes of
	{error, {not_found, NB}} ->
	    beta_reduction_for(Rest, Matches, A, NB, Res, MD, S);
	_ -> NRes
    end.

purge_messages(Joins, Ids) ->
    purge_messages0(Joins, Ids, []).

purge_messages0([], _, Result) ->
    lists:reverse(Result);
purge_messages0([Join | JSRest], Ids, Result) ->
    NJoin = purge_messages1(Join, Ids),
    purge_messages0(JSRest, Ids, [NJoin | Result]).

purge_messages1([Alpha | Beta], Ids) ->
    NJoins = lists:map(
	       fun({Id, #pattern_joins{msgs=Msgs}=P}) ->
		       NMsgs = Msgs -- Ids,
		       {Id, P#pattern_joins{msgs=NMsgs}}
	       end, Alpha),
    NBeta = lists:map(
	      fun({Fun, _}) ->
		      %% FIXME: we could possibly leave some information?
%		      NBMsgs = lists:filter(
%				 fun(List) ->
%					 contains_list(Ids, List)
%				 end, BMsgs),
%		      {Fun, NBMsgs}
		      {Fun, []}
	      end, Beta),
    [NJoins | NBeta].

propagation_ids(Ids, [Alpha | _]) ->
    {A0, A1, A2} = 
	lists:foldl(
	  fun({Id,
	       {_, #pattern_joins{prop=yes}}},
	      {Acc0, Acc1, Acc2}) ->
		  {Acc0, [Id | Acc1], [{prop, Id} | Acc2]};
	     ({Id, _},
	      {Acc0, Acc1, Acc2}) ->
		  {[Id | Acc0], Acc1, [Id | Acc2]}
	  end,
	  {[], [], []},
	  lists:zip(Ids, Alpha)),
    {lists:reverse(A0),
     lists:reverse(A1),
     lists:reverse(A2)}.

verify_join({ok, Joins}) ->
    try lists:foreach(
	  fun([Alpha | Beta]) ->
		  NumA = length(Alpha),
		  NumB = length(Beta),
		  true = (NumA > 0),
		  case NumA of 
		      1 -> (1 = NumB);
		      _ -> (NumB = (NumA - 1))
		  end
	  end, Joins)
    catch
	error:_ ->
	    throw({error, joins_verification_failed})
    end,
    {ok, Joins}.
jerlang/src/jerlang_dict.erl0000644000175000017500000000274011220224120015751 0ustar  huberthubert-module(jerlang_dict).

-export([init/0, insert/2, get/2, remove/2, all/1]).
-export([snapshot/1, size/1]).

-include("jerlang.hrl").

-spec(init/0 :: () -> jdict(msg())).
-spec(insert/2 :: (jdict(A), A) -> jdict(A)).
-spec(get/2 :: (jdict(A), [integer()]) -> [A]).
-spec(remove/2 :: (jdict(A), [integer() | {'prop', integer()}]) ->
	     {jdict(A), [A]}).
-spec(all/1 :: (jdict(A)) -> [A]).
-spec(size/1 :: (jdict(_)) -> integer()).
-spec(snapshot/1 :: (jdict(A)) -> [A]).

init() ->
    {gb_trees:empty(), 1}.

insert({Tree, Id}, Element) ->
    {{gb_trees:enter(Id, Element, Tree), Id+1}, Id}.

get({Tree, _}, Id) when is_integer(Id) ->
    gb_trees:get(Id, Tree);
get(Tree, Ids) when is_list(Ids) ->
    get1(Tree, Ids, []).

get1(_, [], Elements) ->
    lists:reverse(Elements);
get1(Tree, [Id | Rest], Result) ->
    Value = jerlang_dict:get(Tree, Id),
    get1(Tree, Rest, [Value | Result]).

remove({Tree, Id}, RemoveList) ->
    {NTree, Result} = remove1(Tree, RemoveList, []),
    {{NTree, Id}, Result}.

remove1(Tree, [], Result) ->
    {Tree, lists:reverse(Result)};
remove1(Tree, [{prop, Id} | Rest], Result) ->
    Value = gb_trees:get(Id, Tree),
    remove1(Tree, Rest, [Value | Result]);
remove1(Tree, [Id | Rest], Result) ->
    Value = gb_trees:get(Id, Tree),
    NTree = gb_trees:delete(Id, Tree),
    remove1(NTree, Rest, [Value | Result]).

all({Tree, _}) ->
    gb_trees:to_list(Tree).

size({Tree, _}) ->
    gb_trees:size(Tree).

snapshot({Tree, _}) ->
    gb_trees:values(Tree).
jerlang/src/jerlang_core.erl0000644000175000017500000001727011220224120015762 0ustar  huberthubert-module(jerlang_core).

-export([test_raw/0]).
-export([loop/3, process_info_jerlang/1]).
-import(jerlang_misc, [convert_now/1]).

-include("jerlang.hrl").

-define(QUEUE_NAME, mailbox).
-define(CASE_TEST_GUARD, test_entry).
-define(CASE_RUN_ACTION, run_all).

-spec(process_info_jerlang/1 :: (pid()) -> 'ok' | list()).
-spec(loop/3 :: ([alpha()],
		 [receive_fun_test()],
		 nonempty_improper_list(receive_timeout(), any()))
      -> {'ok', any()}).


check_queue() ->
    case get(?QUEUE_NAME) of
	undefined ->
	    {ok, jerlang_dict:init()};
	Mailbox ->
	    {ok, Mailbox}
    end.

check_invalid_timeout([{timeout, Timeout, _}])
  when (Timeout == infinity) ->
    ok;
check_invalid_timeout([{timeout, Timeout, _}])
  when (not(is_number(Timeout))) orelse (Timeout < 0) ->
    exit({error, {invalid_timeout, Timeout}});
check_invalid_timeout(_) ->
    ok.

process_info_jerlang(Pid) when (Pid == self()) ->
    %% FIXME: join the information
    %% stored in the internal mailbox with
    %% what standard command offers
    ok;
process_info_jerlang(Pid) ->
    erlang:process_info(Pid).

loop(Joins, Actions, Options) ->
    {ok, Mailbox} = check_queue(),
    ok = check_invalid_timeout(Options),
    receive_loop0(
      process_old(Joins, Actions,
		  Mailbox, jerlang_dict:all(Mailbox)),
      Options).

receive_loop0(Result, []) ->
    receive_loop0(Result, [{timeout, infinity, none}]);


receive_loop0({ok, Result}, _) ->
    Result;
receive_loop0({error, Joins, Actions, Mailbox},
	      [{timeout, Timeout, Action}]) ->

    Opt = #opt{timeout=Timeout,
	       t_action=Action,
	       timer=disabled},
    receive_loop(Joins, Actions, Mailbox, Opt).

receive_loop(Joins, Actions, Mailbox,
	    Opt) ->
    {Timeout, NOpt} = process_timeout(Opt),
    receive_with_timeout(Joins, Actions, Mailbox, NOpt, Timeout).

receive_with_timeout(_, _, Mailbox,
		     #opt{t_action=TAction},
		     Timeout) when (Timeout < 0) ->

    put(?QUEUE_NAME, Mailbox),
    TAction();    
receive_with_timeout(Joins, Actions, Mailbox, Opt, Timeout)
  when (Timeout >= 0) or (Timeout == infinity) ->
    receive
	M ->
	    NOpt = update_timeout(Opt),
	    message(
	       process_join(M, Joins, Actions, Mailbox),
	       Actions, NOpt)
    after Timeout ->
	    timeout_action(Joins, Actions, Mailbox, Opt)
    end.

process_timeout(#opt{timer=disabled} = Opt) ->
    {0, Opt};
process_timeout(#opt{timeout=infinity} = Opt) ->
    {infinity, Opt};
process_timeout(#opt{timeout=0} = Opt) ->
    {0, Opt};
process_timeout(#opt{timeout=Timeout} = Opt) when (Timeout < 0) ->
    {Timeout, Opt};
process_timeout(#opt{timeout=Timeout} = Opt) ->
    {Timeout, Opt#opt{s_time=(convert_now(erlang:now()))}}.

update_timeout(#opt{timer=disabled} = Opt) ->
    Opt;
update_timeout(#opt{timeout=infinity} = Opt) ->
    Opt#opt{timer=disabled};
update_timeout(#opt{s_time=Time, timeout=Limit} = Opt) ->
    Opt#opt{timeout=(Limit-(convert_now(erlang:now())-Time)),
	    timer=disabled}.

timeout_action(_, _, _, #opt{timer=enabled, t_action=TAction}) ->
    TAction();
timeout_action(Joins, Actions, Mailbox, Opt) ->
    receive_loop(Joins, Actions,
		 Mailbox, Opt#opt{timer=enabled}).
    

process_old(Joins, Actions, Mailbox, []) ->
    {error, Joins, Actions, Mailbox};
process_old(Joins, Actions, Mailbox, [IdMsg | Rest]) ->
    case process_join(IdMsg, Joins, Actions, [], Mailbox) of
	{ok, Result} ->
	    {ok, Result};
	{error, NJoins, Mailbox} ->
	    process_old(NJoins, Actions, Mailbox, Rest)
    end.

message({ok, Result}, _, _) ->
    Result;
message({error, NJoins, NMailbox}, Actions, Options) ->
    receive_loop(NJoins, Actions, NMailbox, Options).

process_join(Msg, JoinsTests, Actions, Mailbox) ->
    {NMailbox, Idx} = jerlang_dict:insert(Mailbox, Msg),
    process_join({Idx, Msg}, JoinsTests, Actions, [], NMailbox).

process_join(_, [], _, JoinsTests, Mailbox) ->
    {error, lists:reverse(JoinsTests), Mailbox};
process_join({Id, Msg}, [JoinTests | JoinsRest],
	     [JoinAction | ActionsRest],
	     JoinsTests, Mailbox) ->
    {NJoin, Update} = 
	lists:mapfoldl(
		fun({PId, #pattern_joins{test=F, msgs=Msgs} = PRec} = P, S) ->
			case F(Msg) of
			    true ->
				{{PId, PRec#pattern_joins{msgs=[Id | Msgs]}},
				 yes};
			    _ ->
				{P, S}
			end
		end, no, JoinTests),

    Result1 = check_joins(Update, NJoin, JoinAction, Id, Mailbox),
    case run_joins(Result1, JoinAction, Mailbox, NJoin) of
	{error, _} ->
	    process_join({Id, Msg}, JoinsRest, ActionsRest,
			 [NJoin | JoinsTests], Mailbox);
	Other  -> Other
    end.
    
check_joins(no, _, _, _, _) ->
    {error, no_match};
check_joins(yes, JoinPatterns, Action, Id, Mailbox) ->
    PMsgs = lists:map(
      fun({_, #pattern_joins{msgs=Msgs}}) ->
	      Msgs
      end, JoinPatterns),
    %% Either returns error or found set
    jerlang_mset:common_sets(
      PMsgs, {fun test_guards/2, {Action, Mailbox}, Id}).

%%  Decision is not to use bultin func guards in the try...catch
%%  region, since there can be a function call withing the
%%  receive instruction, so this would caught wrong exception.
%%  Instead we build separate function that only handles the
%%  arguments (for example the same ones - {A, B} and {B, C})
%%  and guards are transformed into simple boolean expression.
test_guards(MsgIds, {Action, Mailbox}) ->
    MatchedMsgs = jerlang_dict:get(Mailbox, MsgIds),
    try Action(MatchedMsgs, ?CASE_TEST_GUARD) of
	true ->
	    {ok, MsgIds, none};
	false ->
	    error
    catch
	error:{badmatch, _} ->
	    error
    end.

run_joins({error, no_match}, _, _, _) ->
    {error, not_found};
run_joins({ok, MsgIds, _}, Action, Mailbox, JoinDef) ->
    %% Filter ids which really need to be removed
    PropMsgIds = propagation_filter(MsgIds, JoinDef, []),
    {NMailbox, MatchedMsgs} = jerlang_dict:remove(Mailbox, PropMsgIds),
    put(?QUEUE_NAME, NMailbox),
    {ok, Action(MatchedMsgs, ?CASE_RUN_ACTION)}.

propagation_filter([], [], Result) ->
    lists:reverse(Result);
propagation_filter([Id | IdRest],
		   [{_, #pattern_joins{prop=no}} | Rest],
		   Result) ->
    propagation_filter(IdRest, Rest, [Id | Result]);
propagation_filter([Id | IdRest],
		   [{_, #pattern_joins{prop=yes}} | Rest],
		   Result) ->
    propagation_filter(IdRest, Rest, [{prop, Id} | Result]).

test_raw() ->
%    self() ! single,
    self() ! {one, 12},
    self() ! {two, 2},
    self() ! three,

%    A = 12,
%    C = 15,
    self() ! {four, 17},
    self() ! {five, 6},
    %%    self() ! five,
    R2 = loop(
	   [[{1, #pattern_joins{test=
			  fun(Value) ->
				  case Value of
				      single -> true;
				      _ -> false
				  end
			  end, msgs=[]}}],
	    [{2, #pattern_joins{test=
			  fun(Value) ->
				  case Value of
				      {four, _SomeInt} -> true;
				      _ -> false
				  end
			  end, msgs=[]}},
	     {3, #pattern_joins{test=
			  fun(Value) ->
				  case Value of
				      {five, _Int} -> true;
				      _ -> false
				  end
			  end, msgs=[]}}]],
   
    %% TODO how assignment in receive changes things?
	   [fun(Res1, Case) ->
		    [single] = Res1,
		    Ret = true,
		    case Case of
			test_entry -> Ret;
			run_all ->
			    io:format("Three !~n", []),
			    {finished, single}
		    end
	    end,
	    fun(Res2, Case) ->
		    [{four, Z}, {five, I}] = Res2,
		    Ret = is_integer(Z) andalso (Z > 15) and (I > 3),
		    case Case of
			test_entry -> Ret;
			run_all ->
			    io:format("Four !~n", []),
			    {finished_second, {Z, I}}
		    end
	    end],
	   [{timeout, 10000,
	     fun() ->
		     io:format("Timeout occured~n", []),
		     timeout_ok
	     end}]),

    io:format("Finished the second receive with: ~p~n", [R2]),
    ok.

%test() ->
%    C = 15,
%    A = 12,
%    self() ! {one, 12},
%    self() ! {two, 2},
%    self() ! three,
%
%    receive
%	three ->
%	    {ok, C};
%	{one, A} and {two, B} ->
%	    {ok, {A, B}}
%    end.
jerlang/src/jerlang_chat_system_test.erl0000644000175000017500000000210111220224120020377 0ustar  huberthubert-module(jerlang_chat_system_test).
-export([test/0, new_user/1]).
-define(SYSTEM, jerlang_chat_system).

-define(ROOT, admin).
-define(USER1, lukasz).
-define(USER2, emilka).

test() ->
    ?SYSTEM:start(),
    spawn_link(?MODULE, new_user, [?USER1]),
    spawn_link(?MODULE, new_user, [?USER2]),
    ?SYSTEM:login(?ROOT),
    ?SYSTEM:send(?ROOT, test_msg),
    {room, Room} = ?SYSTEM:private_channel(?ROOT, ?USER1),
    ?SYSTEM:send(?ROOT, Room, test_msg_private),
    receive
	ok ->
	    ok
    end.


new_user(Name) ->
    ?SYSTEM:login(Name),
    ok = 
	receive
	    {chat, public, User, Msg} ->
		io:format("[~p]:Received message [~p] from [~p]~n",
			  [Name, Msg, User]),
		ok
	after 1000 ->
		error
	end,
    new_user0(Name).

new_user0(?USER1=User) ->
    {room, Room} = ?SYSTEM:private_channel(User, ?ROOT),
    ok =
	receive
	    {chat, private, Room, Sender, Msg} ->
		io:format("[~p]:Received '~p' on private channel from [~p]~n",
			  [User, Msg, Sender]),
		ok
	after 1000 ->
		error
	end;
new_user0(?USER2) ->
    ok = 
	receive
	    _ ->
		error
	after 1000 ->
		ok
	end.
jerlang/src/jerlang_chat_system.erl0000644000175000017500000000707011220224120017352 0ustar  huberthubert-module(jerlang_chat_system).
-compile({parse_transform, jerlang_gen_joins_parse}).

-behaviour(jerlang_gen_joins).

-export([init/1, handle_join/2, start/0, terminate/0]).
-export([login/1, logout/1, private_channel/2]).
-export([send/2, send/3, close_room/2]).

-record(user, {id, pid}).
-record(system, {users, rooms=[]}).

-define(SERVER, jerlang_gen_joins).


start() ->
    ?SERVER:start({local, ?MODULE}, ?MODULE, [], []).

terminate() ->
    ?SERVER:call(?MODULE, stop).

init(_) ->
    {ok, #system{users=dict:new(), rooms=dict:new()}}.

login(User) ->
    ?SERVER:call(?MODULE, {login, {User, self()}}).

logout(User) ->
    ?SERVER:call(?MODULE, {logout, {User, self()}}).

private_channel(User1, User2) ->
    ?SERVER:call(?MODULE, {private, {User1, self()}, User2}).

send(User, Msg) ->
    ?SERVER:cast(?MODULE, {msg, {User, self()}, Msg}).

send(User, Room, Msg) ->
    ?SERVER:cast(?MODULE, {msg, {User, self()}, Room, Msg}).

close_room(User, Room) ->
    ?SERVER:call(?MODULE, {msg, close, {User, self()}, Room}).

%% ------------------------------------------------

handle_join({login, User}, S) ->
    {NS, Result} = add_login(
		     valid_user(User, S),
		     User, S),

    {[{reply, Result}], NS};
handle_join({private, {User1, Pid1}, User2}
	    and {private, {User2, Pid2}, User1},
	    #system{rooms=Rs}=S) ->
    %% Open private channel
    {Reply, NS} = 
	case valid_user({User1, Pid1}, S)
	    and valid_user({User2, Pid2}, S) of
	    true ->
		%%  Assume unique enough
		Room = make_ref(),
		?SERVER:cast(?MODULE, {room, Room}),
		{{room, Room}, S#system{rooms=dict:store(Room,
							 [User1, User2],
							 Rs)}};
	    false ->
		{{error, invalid_authorization}, S}
	end,
    {[{reply, Reply}, {reply, Reply}], NS};
handle_join({room, Room} and {msg, close, User, Room}, S) ->
    % Determine whether the user belongs to this room
    Result = 
	case other_user(Room, User, S) of
	    {error, invalid} ->
		%% Invalid user tries to close the room
		?SERVER:cast(?MODULE, {room, Room}),
		{error, invalid_user};
	    {ok, Pid2} ->
		Pid2 ! {chat, private, Room, User, close_room_request},
		{ok, closed}
	end,
    NS = remove_room(Room, S),
    {[noreply, {reply, Result}], NS};
handle_join(prop({room, Room}) and {msg, User, Room, Msg}, S) ->
    %% Find users of the room
    case other_user(Room, User, S) of
	{ok, Pid} ->
	    Pid ! {chat, private, Room, User, Msg};
	_ ->
	    %% Ignore msg
	    ok
    end,
    {[noreply, noreply], S};
handle_join({msg, User, Msg}, S) ->
    case valid_user(User, S) of
	true ->
	    send_all(S, User, Msg);
	_ ->
	    %% Ignore msg
	    ok
    end,
    {[noreply], S}.
     

%% ------------------------------------------------
add_login(true, _, S) ->
    {S, {error, invalid_user}};
add_login(_, {User, Pid}, #system{users=Users}=S) ->
    {S#system{users=
	      dict:store(User, #user{id=User, pid=Pid}, Users)},
     valid}.

valid_user({User, Pid}, #system{users=Users}) ->
    try
	#user{pid=Pid} = dict:fetch(User, Users),
	true
    catch
	_:_ ->
	    false
    end.

send_all(#system{users=Us}, User, Msg) ->
    lists:map(
      fun({_, #user{pid=Pid}}) ->
	      Pid ! {chat, public, User, Msg}
      end, dict:to_list(Us)),
    ok.

other_user(Room, {User, _}, #system{users=Us, rooms=Rs}) ->
    case other_user0(dict:fetch(Room, Rs), User) of
	{ok, Other} ->
	    #user{pid=Pid} = dict:fetch(Other, Us),
	    {ok, Pid};
	Error ->
	    Error
    end.

other_user0([User, Other], User) ->
    {ok, Other};
other_user0([Other, User], User) ->
    {ok, Other};
other_user0(_, _) ->
    {error, invalid}.

remove_room(Room, S) ->
    dict:erase(Room, S).
jerlang/src/jerlang_2dict.erl0000644000175000017500000000544211220224120016035 0ustar  huberthubert-module(jerlang_2dict).

-export([add/3, get/3, init/0, update/3, remove/2]).
-include("jerlang.hrl").

%%  FIXME: ignore warning until OTP R13
-spec(init/0 :: () -> j2dict(ref(), [id()])).
-spec(add/3 :: (id(), 'none', j2dict(A,B)) -> j2dict(A,B);
      (id(), ref(), j2dict(A,B)) -> j2dict(A,B)).
-spec(update/3 :: (id(), fun ((id()) -> msg()) , j2dict(A,B))
      -> j2dict(A,B)).
%%  FIXME: are 'get' types ok?
-spec(get/3 :: (id () | [id()], [id()], j2dict(_, B)) -> {'ok', [B]}).
-spec(remove/2 :: (j2dict(A,B), [id()]) -> j2dict(A,B)).

%%  -----------------------------------------
%%  This data structure consists of two maps, where
%%  the first one maps every entry to a unique
%%  reference, that is a key in the second map
%%  and groups together equal entries (according
%%  to some equality operation on some data).
%%  -----------------------------------------

init() ->
    {dict:new(), dict:new()}.

add(Elem, none, {S1, S2}) ->
    Ref = make_ref(),
    NS2 = dict:store(Ref, [Elem], S2),
    NS1 = dict:store(Elem, Ref, S1),
    {NS1, NS2};
add(Elem, Ref, {S1, S2}) ->
    NS1 = dict:store(Elem, Ref, S1),
    NS2 = dict:update(Ref, fun(Old) ->
				   [Elem | Old]
			   end, [Elem], S2),
    {NS1, NS2}.

update(Elem, MFun, {_, S2}=S) ->
%    io:format("Updating value: ~p~n", [Elem]),
    Value = MFun(Elem),
%    io:format("Value: ~p~n", [Value]),
    update0(Elem, parse_msg(Value), MFun, dict:fetch_keys(S2), S).

update0(Elem, _, _, [], S) ->
    add(Elem, none, S);
update0(Elem, Value, MFun, [Key | Rest], {S1, S2}=S) ->
%    io:format("Second~n", []),
    Values = dict:fetch(Key, S2),
    case check_values(Values, Value, MFun) of
	none ->
	    update0(Elem, Value, MFun, Rest, S);
	{ok, Idx} ->
	    Ref = dict:fetch(Idx, S1),
	    add(Elem, Ref, S)
    end.

get([P], List0, S) ->
    %% Special case for the first match
    List1 = lists:flatten(List0),
    {ok, List2} = jerlang_2dict:get(P, List1, S),
    {ok, [[X] || X <- List2]};
get(Elem, List, _) when is_list(Elem) ->
    {ok, List};
get(Elem, List, {S1, S2}) ->
    Ref = dict:fetch(Elem, S1),
    Values = dict:fetch(Ref, S2),
    {ok, List -- Values}.

remove(S, []) ->
    S;
remove(S, [E | Rest]) ->
    NS = remove(S, E),
    remove(NS, Rest);
remove({S1, S2}, Elem) ->
    Ref = dict:fetch(Elem, S1),
    NS1 = dict:erase(Elem, S1),
    Value = dict:fetch(Ref, S2),
    NS2 = case Value of
	      [Elem] ->
		  dict:erase(Ref, S2);
	      _ ->
		  dict:store(Ref, Value -- [Elem], S2)
	  end,
    {NS1, NS2}.

check_values([], _, _) ->
    none;
check_values([Idx | Rest], Value0, MFun) ->
    V = MFun(Idx),
    case parse_msg(V) == Value0 of
	true ->
	    {ok, Idx};
	false ->
	    check_values(Rest, V, MFun)
    end.

parse_msg({_, _, Value}) ->
    Value;
parse_msg({_, Value}) ->
    Value;
parse_msg(Value) ->
    %%  For VM version
    Value.