diff --git a/fungll.krak b/fungll.krak
index d59953b..a42c264 100644
--- a/fungll.krak
+++ b/fungll.krak
@@ -8,26 +8,34 @@ import str:*
 // nonterminals are negative, terminals are positive
 obj Grammer (Object) {
     var nonterminals: vec<vec<vec<int>>>
+    var nonterminal_names: vec<str>
     var terminals: vec<char>
     fun construct(): *Grammer {
         nonterminals.construct()
+        nonterminal_names.construct()
         terminals.construct()
         return this
     }
     fun copy_construct(old: *Grammer): void {
         nonterminals.copy_construct(&old->nonterminals)
+        nonterminal_names.copy_construct(&old->nonterminal_names)
         terminals.copy_construct(&old->terminals)
     }
     fun destruct(): void {
         nonterminals.destruct()
+        nonterminal_names.destruct()
         terminals.destruct()
     }
     fun operator=(other:ref Grammer):void {
         destruct()
         copy_construct(&other)
     }
-    fun add_new_nonterminal(rule: ref vec<int>): int {
+    fun add_new_nonterminal(name: *char, rule: ref vec<int>): int {
+        return add_new_nonterminal(str(name), rule)
+    }
+    fun add_new_nonterminal(name: ref str, rule: ref vec<int>): int {
         nonterminals.add(vec(rule))
+        nonterminal_names.add(name)
         return -1*nonterminals.size
     }
     fun add_to_nonterminal(nonterminal: int, rule: ref vec<int>) {
@@ -46,6 +54,24 @@ obj Grammer (Object) {
     fun is_terminal(x: int): bool {
         return x > 0
     }
+    fun to_string(it: BS): str {
+        var rule_str = str()
+        for (var i = 0; i < nonterminals[(-1*it.nonterminal)-1][it.rule_idx].size; i++;) {
+            if i == it.idx_into_rule {
+                rule_str += "*"
+            }
+            var erminal = nonterminals[(-1*it.nonterminal)-1][it.rule_idx][i]
+            if erminal < 0 {
+                rule_str += nonterminal_names[(-1*erminal)-1]
+            } else {
+                rule_str += terminals[erminal-1]
+            }
+        }
+        if it.idx_into_rule == nonterminals[(-1*it.nonterminal)-1][it.rule_idx].size {
+            rule_str += "*"
+        }
+        return str("<") + nonterminal_names[(-1*it.nonterminal)-1] + " ::= " + rule_str + ", "  + it.left + ", " + it.pivot + ", " + it.right + ">"
+    }
 }
 obj Pending (Object) {
     var nonterminal: int
@@ -161,36 +187,18 @@ fun bs(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: in
     var to_ret.construct(nonterminal, rule_idx, idx_into_rule, left, pivot, right): BS
     return to_ret
 }
-/*fun complete_parser_for(grammer: ref Grammer, start_symbol, input: ref str): set<BS> {*/
-    /*return fungll(grammer, input, start_symbol).second*/
-/*}*/
-/*fun fungll(grammer: ref Grammer, input: ref str, start_symbol: int): set<BS> {*/
-/*fun fungll(grammer: ref Grammer, input: ref str): <, set<BS>> {*/
 fun fungll(grammer: ref Grammer, input: ref str): set<BS> {
-    /*loop(grammer, input, descend(grammer, 0 [>start_symbol<], 0), set(), set(), set(), set())*/
     return loop(grammer, input, descend(grammer, -1 /*start_symbol*/, 0), set<Descriptor>(), map<pair<int, int>, set<Pending>>(), map<pair<int,int>, set<int>>(), set<BS>())
 }
 fun descend(grammer: ref Grammer, symbol: int, l: int): set<Descriptor> {
-    /*grammer.get_nonterminal_rules(symbol).map(fun(rhs): descriptor { <X::=.rhs,l,l> })*/
-    /*return grammer.get_nonterminal_rules(symbol).map(fun(rhs: int): Descriptor { return descriptor(symbol, rhs, 0, l, l); })*/
     var to_ret = set<Descriptor>()
     for (var rhs = 0; rhs < grammer.get_nonterminal_rules(symbol).size; rhs++;)
         to_ret.add(descriptor(symbol, rhs, 0, l, l))
     return to_ret
 }
 fun loop(grammer: ref Grammer, input: ref str, R: set<Descriptor>, U: set<Descriptor>, G: map<pair<int, int>, set<Pending>>, P: map<pair<int,int>, set<int>>, Y: set<BS>): set<BS> {
-    /*if R.size() == 0 {*/
-        /*return <U,Y>*/
-    /*} else {*/
-        /*var d = R.pop()*/
-        /*var <<R',Y'>,G',P'> = process(grammer, input, d, G, P)*/
-        /*var U_with_d = U.union(set(d));*/
-        /*var R'' = (R.union(R') - U_with_d*/
-        /*return loop(grammer, input, R'', U_with_d, G.union(G'), P.union(P'), Y.union(Y'))*/
-    /*}*/
     while R.size() != 0 {
         var d = R.pop()
-        /*var <<Rp,Yp>,Gp,Pp> = process(grammer, input, d, G, P)*/
         var it = process(grammer, input, d, G, P)
         var Rp = it.first.first
         var Yp = it.first.second
@@ -201,7 +209,6 @@ fun loop(grammer: ref Grammer, input: ref str, R: set<Descriptor>, U: set<Descri
         var nextR = R.union(Rp) - U_with_d
         R = nextR
         U = U_with_d
-        /*G += Gp*/
         for (var i = 0; i < Gp.keys.size; i++;) {
             if G.contains_key(Gp.keys[i]) {
                 G[Gp.keys[i]].add(Gp.values[i])
@@ -209,7 +216,6 @@ fun loop(grammer: ref Grammer, input: ref str, R: set<Descriptor>, U: set<Descri
                 G[Gp.keys[i]] = Gp.values[i]
             }
         }
-        /*P += Pp*/
         for (var i = 0; i < Pp.keys.size; i++;) {
             if P.contains_key(Pp.keys[i]) {
                 P[Pp.keys[i]].add(Pp.values[i])
@@ -221,18 +227,14 @@ fun loop(grammer: ref Grammer, input: ref str, R: set<Descriptor>, U: set<Descri
     }
     return Y
 }
-/*fun process(grammer: ref Grammer, input: ref str, <X:=a.b,l,k>, G, P): {*/
 fun process(grammer: ref Grammer, input: ref str, descript: Descriptor, G: map<pair<int, int>, set<Pending>>, P: map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, set<Pending>>, map<pair<int,int>, set<int>>> {
-    /*if is_e(b) {*/
+    // if at end / end is emptystr
     if descript.idx_into_rule == grammer.get_nonterminal_rules(descript.nonterminal)[descript.rule_idx].size {
-        /*return process_e(<X::=a.,l,k>, G, P)*/
         return process_e(grammer, descript, G, P)
     } else {
-        /*return process_symbol(grammer, input, <X::=a.sb',l,k>, G, P) // b=sb'*/
         return process_symbol(grammer, input, descript, G, P)
     }
 }
-/*fun process_e(<X::=a.,l,k>, G, P) {*/
 fun process_e(grammer: ref Grammer, descript: Descriptor, G: ref map<pair<int, int>, set<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, set<Pending>>, map<pair<int,int>, set<int>>> {
     var nonterminal: int
     var rule_idx: int
@@ -241,44 +243,30 @@ fun process_e(grammer: ref Grammer, descript: Descriptor, G: ref map<pair<int, i
     var X = descript.nonterminal
     var l = descript.left;
     var k = descript.pivot;
-    /*var K = { <g,l'> | <<X,l>,<g,l'>> in G }*/
     var K = G.get(make_pair(X,l))
-    /*var <R,Y> = ascend(l,K,k)*/
     var it = ascend(l,K,k)
     var R = it.first
     var Y = it.second
-    /*var Y' = { <X::=.,l,l,l> | is_e(a) }*/
     if grammer.get_nonterminal_rules(X)[descript.rule_idx].size == 0 {
         Y.add(bs(X,descript.rule_idx, 0, l, l, l))
     }
-    /*return <<R,Y.union(Y')>,set(),set(<<X,l>,k>)>*/
     return make_triple(make_pair(R,Y), map<pair<int, int>, set<Pending>>(), map(make_pair(X,l), set(k)))
 }
-/*fun process_symbol(grammer: ref Grammer, input: ref str, <X::=a.sb',l,k>, G, P) {*/
 fun process_symbol(grammer: ref Grammer, input: ref str, descript: Descriptor, G: ref map<pair<int, int>, set<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, set<Pending>>, map<pair<int,int>, set<int>>> {
     var s = grammer.get_nonterminal_rules(descript.nonterminal)[descript.rule_idx][descript.idx_into_rule]
     var k = descript.pivot
-    /*R = { r | <<s,k>,r> in P }*/
     var R = P.get_with_default(make_pair(s,k), set<int>())
-    /*G' = {<<s,k>, <X::=as.b',l>>}*/
     var Gp = map(make_pair(s,k), set(pending(descript.nonterminal, descript.rule_idx, descript.idx_into_rule+1, descript.left)))
     if grammer.is_terminal(s) {
-        /*return <match(input,<X::=a.sb',l,k>),set(),set()>*/
-        /*return make_triple(match(input,descript), map<pair<int,int>, vec<Pending>>(), map<pair<int,int>, set<int>>())*/
         return make_triple(matc(grammer,input,descript), map<pair<int,int>, set<Pending>>(), map<pair<int,int>, set<int>>())
     } else if R.size() == 0 { // s in N
-        /*return <<descend(grammer,s,k), set()>, G', set()>*/
         return make_triple(make_pair(descend(grammer,s,k), set<BS>()), Gp, map<pair<int,int>, set<int>>())
     } else { // s in N and R != set()
-        /*return <skip(k,<X::=as.b',l> R), G', set()>*/
         return make_triple(skip(k,pending(descript.nonterminal, descript.rule_idx, descript.idx_into_rule+1, descript.left), R), Gp, map<pair<int,int>, set<int>>())
     }
 }
-/*fun match(input: ref str, <X::=a.sb',l,k>): <discriptor_set, set<BS>> {*/
 fun matc(grammer: ref Grammer, input: ref str, descript: Descriptor): pair<set<Descriptor>, set<BS>> {
-    /*if input[k] == grammer.get_terminal(s) {*/
     if descript.pivot < input.length() && input[descript.pivot] == grammer.get_terminal(grammer.get_nonterminal_rules(descript.nonterminal)[descript.rule_idx][descript.idx_into_rule]) {
-        /*return <set(X::=as.b',l,k+1>), set(<X::=as.b',l,k,k+1)>*/
         return make_pair(set(descriptor(descript.nonterminal, descript.rule_idx, descript.idx_into_rule+1, descript.left, descript.pivot+1)), set(bs(descript.nonterminal, descript.rule_idx, descript.idx_into_rule+1, descript.left, descript.pivot, descript.pivot+1)))
     } else {
         return make_pair(set<Descriptor>(), set<BS>())
@@ -287,14 +275,10 @@ fun matc(grammer: ref Grammer, input: ref str, descript: Descriptor): pair<set<D
 fun skip(k: int, c: Pending, R: ref set<int>): pair<set<Descriptor>, set<BS>> { return nmatch(k, set(c), R); }
 fun ascend(k:int, K: ref set<Pending>, r: int): pair<set<Descriptor>, set<BS>> { return nmatch(k, K, set(r)); }
 fun nmatch(k:int, K: ref set<Pending>, R: ref set<int>): pair<set<Descriptor>, set<BS>> {
-    /*var R = { <g,l,r> | <g,l> in K, r in R }*/
-    /*var Y = { <g,l,k,r> | <g,l> in K, r in R }*/
     var Rp = set<Descriptor>()
     var Y = set<BS>()
-    /*for pending in K {*/
     for (var i = 0; i < K.data.size; i++;) {
         var pending = K.data[i]
-        /*for r in R {*/
         for (var j = 0; j < R.data.size; j++;) {
             var r = R.data[j]
             Rp.add(descriptor(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, r))
@@ -303,18 +287,10 @@ fun nmatch(k:int, K: ref set<Pending>, R: ref set<int>): pair<set<Descriptor>, s
     }
     return make_pair(Rp,Y)
 }
-
 fun main(argc: int, argv: **char): int {
     var grammer.construct(): Grammer
-    /*add_new_nonterminal(rule: ref vec<int>): int {*/
-    /*add_to_nonterminal(nonterminal: int, rule: ref vec<int>) {*/
-    /*add_terminal(c: char): int {*/
-
-    /*fungll(grammer: ref Grammer, input: ref str): set<BS> {*/
-
-
     var one = grammer.add_terminal('1')
-    var E = grammer.add_new_nonterminal(vec<int>())
+    var E = grammer.add_new_nonterminal("E", vec<int>())
     grammer.add_to_nonterminal(E, vec(one))
     grammer.add_to_nonterminal(E, vec(E,E,E))
 
@@ -322,7 +298,8 @@ fun main(argc: int, argv: **char): int {
     println(str("length of BSR is: ") + BSR.size())
     for (var i = 0; i < BSR.data.size; i++;) {
         var BS = BSR.data[i]
-        println(str() + i + ": " + BSR.data[i].to_string())
+        /*println(str() + i + ": " + grammer.to_string(BSR.data[i]) + "\t\t" + BSR.data[i].to_string())*/
+        println(str() + i + ": " + grammer.to_string(BSR.data[i]))
     }
 
     return 0