diff -r b51d34113d47 -r 73f990bc6843 lex_blex_Frankensteined.scala
--- a/lex_blex_Frankensteined.scala	Thu May 07 11:36:15 2020 +0100
+++ b/lex_blex_Frankensteined.scala	Wed May 27 22:23:52 2020 +0100
@@ -1,9 +1,13 @@
-package RexpRelated
+
+import Element.elem
 import scala.language.implicitConversions    
 import scala.language.reflectiveCalls
 import scala.annotation.tailrec   
 import scala.util.Try
 
+
+package RexpRelated
+{
 abstract class Bit
 case object Z extends Bit
 case object S extends Bit
@@ -31,6 +35,10 @@
   def AALT(bs: Bits, r1: ARexp, r2: ARexp) = AALTS(bs, List(r1, r2))
 
 
+
+
+
+
   def distinctBy[B, C](xs: List[B], f: B => C, acc: List[C] = Nil): List[B] = xs match {
     case Nil => Nil
     case (x::xs) => {
@@ -661,6 +669,10 @@
           case Sequ(v1small, v2small) => Sequ(vunsimp(r1, v1)(v1small), vunsimp(r2, v2)(v2small))
           case _ => {
             println(vsmall) ;
+            println(aregex_simple_print(r1))
+            println(v1)
+            println(aregex_simple_print( r2))
+            println(v2)
             throw new Exception("bad arguments sequ")
           }
           //(ASEQ(bs1, r1s, r2s),  Sequ(v1s, v2s))
@@ -828,11 +840,11 @@
   }
   def deunify(rs_length: Int, v: Val): Val = v match{
     case Position(i, v0) => {
-      if(i <0) {println(rs_length, v); throw new Exception("deunify minus")} 
-      else if(rs_length == 1) {println(v); v}
-      else if(rs_length - 1 == i) coat(v0, i) 
-      else coat(Left(v0), i)
-      }
+      if(i <0) {throw new Exception("deunify minus")} 
+      else if(rs_length == 1) { v0}
+      else if(rs_length - 1 == i) {coat(v0, i)} 
+      else {coat(Left(v0), i)}
+    }
     case _ => throw new Exception("deunify error")
   }
   def flats2(front: List[ARexp], i: Int, rs: List[ARexp], v: Val): (List[ARexp], Val) = v match {
@@ -856,15 +868,16 @@
     }
     case _ => throw new Exception("flats2 error")
   }
-  def distinctBy2[B, C](v: Val, xs: List[B], f: B => C, acc: List[C] = Nil, res: List[B] = Nil): (List[B], Val) = xs match {
+  def distinctBy2[B, C](j: Int, v: Val, xs: List[B], f: B => C, acc: List[C] = Nil, res: List[B] = Nil): (List[B], Val) = xs match {
     case Nil => (res, v)
     case (x::xs) => {
       val re = f(x)
       if (acc.contains(re)) v match { 
-        case Position(i, v0) => distinctBy2(Position(i - 1, v0), xs, f, acc, res)  
+        case Position(i, v0) => if(j > 0) distinctBy2(j - 1, Position(i - 1, v0), xs, f, acc, res)  
+        else if(j < 0)distinctBy2(j - 1, Position(i, v0), xs, f, acc, res) else throw new Exception("Value not POSIX")
         case _ => throw new Exception("dB2")
       }
-      else distinctBy2(v, xs, f, re::acc, x::res)
+      else distinctBy2(j - 1, v, xs, f, re::acc, x::res)
     }
   }
    def bsimp2(r: ARexp, v: Val): (ARexp, Val) = (r,v) match{
@@ -875,14 +888,21 @@
         case ((r1s, v1s), (r2s, v2s)) => (ASEQ(bs1, r1s, r2s),  Sequ(v1s, v2s))
     }
     case (AALTS(bs1, rs), v) => {
+      println("Entry into AALTS")
+      rs.map(println(aregex_simple_print()))
       val vlist = unify(rs, v)
       vlist match {
         case Position(i, v0) => {
           val v_simp = bsimp2(rs(i), v0)._2
+          println("map on bsimp")
           val rs_simp = rs.map(bsimp)
           val flat_res = flats2( Nil, i, rs_simp, Position(i, v_simp) )
-          val dist_res = distinctBy2(flat_res._2, flat_res._1, erase)
+          println("list after flats2")
+          flat_res._1.map(println(aregex_simple_print(_)))
+          val dist_res = distinctBy2(i, flat_res._2, flat_res._1, erase)
+          println("list after distinctBy2")
           val rs_new = dist_res._1
+          rs_new.map(println(aregex_simple_print(_)))
           val v_new = deunify(rs_new.length, dist_res._2)
           rs_new match {
             case Nil => (AZERO, undefined)
@@ -1283,7 +1303,48 @@
 
 
   //--------------------------------------------------------------------------------------------------------END OF NON-BITCODE PART (TESTING)
+  def bstostick(bs: List[Bit]): Element = bs match {
+    //case b::Nil => elem(b.toString)
+    case b::bs1 => elem(b.toString) beside bstostick(bs1)
+    case Nil => elem(' ', 1, 1)
+  }
 
+  def aregex_simple_print(r: ARexp): Element = r match {
+    case AALTS(bs,rs) => {
+      val bitstick = bstostick(bs)
+      rs match {
+        case r::rs1 =>  
+        rs1.foldLeft( 
+        ((elem("(") left_align bitstick) beside 
+        aregex_simple_print(r))  )( (acc, r2) => acc beside ((elem(" + ") above elem("   ")) beside aregex_simple_print(r2) )) beside
+        elem(")")
+        case Nil => elem(' ', 1, 1)
+      }
+    }
+    case ASEQ(bs, r1, r2) => {
+      ((elem("[") left_align bstostick(bs)) beside  aregex_simple_print(r1) beside elem("~") beside aregex_simple_print(r2) beside (elem("]") above elem(" "))) 
+    }
+    case ASTAR(bs, r) => {
+      r match {
+        case AONE(_) | AZERO | ACHAR(_, _) => {
+          (elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*")) 
+        }
+        case _ => {
+          (elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*")) 
+        }
+      }
+    }
+    case AONE(bs) => {
+      elem("1") left_align bstostick(bs)
+    }
+    case ACHAR(bs, c) => {
+      elem(c, 1, 1) left_align bstostick(bs)
+    }
+    case AZERO =>
+    {
+      elem ("0") above elem(" ")
+    }
+  }
 
 
   def clear() = {
@@ -1345,6 +1406,8 @@
 
 }
 
+
+
 import Rexp.Bits
 abstract class ARexp 
 case object AZERO extends ARexp
@@ -1368,3 +1431,4 @@
 case object undefined extends Val
 //case class Pos(i: Int, v: Val) extends Val
 case object Prd extends Val
+}