diff --git a/fungll.krak b/fungll.krak
index 4d6a31a..524c50b 100644
--- a/fungll.krak
+++ b/fungll.krak
@@ -7,7 +7,7 @@ import str:*
 
 // nonterminals are negative, terminals are positive
 obj Grammer (Object) {
-    var nonterminals: vec<vec<int>>
+    var nonterminals: vec<vec<vec<int>>>
     var terminals: vec<char>
     fun construct(): *Grammer {
         nonterminals.construct()
@@ -28,27 +28,33 @@ obj Grammer (Object) {
     }
     fun add_new_nonterminal(rule: ref vec<int>): int {
         nonterminals.add(vec(rule))
-        return -1*nonterminal.size
+        return -1*nonterminals.size
     }
     fun add_to_nonterminal(nonterminal: int, rule: ref vec<int>) {
         nonterminals[(-1*nonterminal)-1].add(rule)
     }
     fun add_terminal(c: char): int {
-        terminals.add(rule)
+        terminals.add(c)
         return terminals.size
     }
-    fun get_nonterminal_rules(nonterminal: int): ref vec<int> {
+    fun get_nonterminal_rules(nonterminal: int): ref vec<vec<int>> {
         return nonterminals[(-1*nonterminal)-1]
     }
     fun get_terminal(terminal: int): char {
         return terminals[terminal-1]
     }
+    fun is_terminal(x: int): bool {
+        return x > 0
+    }
 }
 obj Pending (Object) {
     var nonterminal: int
     var rule_idx: int
     var idx_into_rule: int
     var left: int
+    fun construct(): *Pending {
+        return this->construct(0,0,0,0)
+    }
     fun construct(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int): *Pending {
         this->nonterminal = nonterminal;
         this->rule_idx = rule_idx;
@@ -67,6 +73,9 @@ obj Pending (Object) {
         destruct()
         copy_construct(&other)
     }
+    fun operator==(rhs: ref Pending): bool {
+        return nonterminal == rhs.nonterminal && rule_idx == rhs.rule_idx && idx_into_rule == rhs.idx_into_rule && left == rhs.left
+    }
 }
 fun pending(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int): Pending {
     var to_ret.construct(nonterminal, rule_idx, idx_into_rule, left): Pending
@@ -78,6 +87,9 @@ obj Descriptor (Object) {
     var idx_into_rule: int
     var left: int
     var pivot: int
+    fun construct(): *Descriptor {
+        return this->construct(0,0,0,0,0)
+    }
     fun construct(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int): *Descriptor {
         this->nonterminal = nonterminal;
         this->rule_idx = rule_idx;
@@ -98,6 +110,9 @@ obj Descriptor (Object) {
         destruct()
         copy_construct(&other)
     }
+    fun operator==(rhs: ref Descriptor): bool {
+        return nonterminal == rhs.nonterminal && rule_idx == rhs.rule_idx && idx_into_rule == rhs.idx_into_rule && left == rhs.left && pivot == rhs.pivot
+    }
 }
 fun descriptor(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int): Descriptor {
     var to_ret.construct(nonterminal, rule_idx, idx_into_rule, left, pivot): Descriptor
@@ -110,6 +125,9 @@ obj BS (Object) {
     var left: int
     var pivot: int
     var right: int
+    fun construct(): *BS {
+        return this->construct(0,0,0,0,0,0)
+    }
     fun construct(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int, right: int): *BS {
         this->nonterminal = nonterminal;
         this->rule_idx = rule_idx;
@@ -135,6 +153,9 @@ obj BS (Object) {
     fun to_string(): str {
         return str() + nonterminal + " " + rule_idx + " " + idx_into_rule + " " + left + " " + pivot + " " + right
     }
+    fun operator==(rhs: ref BS): bool {
+        return nonterminal == rhs.nonterminal && rule_idx == rhs.rule_idx && idx_into_rule == rhs.idx_into_rule && left == rhs.left && pivot == rhs.pivot && right == rhs.right
+    }
 }
 fun bs(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: int, right: int): BS {
     var to_ret.construct(nonterminal, rule_idx, idx_into_rule, left, pivot, right): BS
@@ -146,14 +167,18 @@ fun bs(nonterminal: int, rule_idx: int, idx_into_rule: int, left: int, pivot: in
 /*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, decend(grammer, 0 [>start_symbol<], 0), set(), set(), set(), set())*/
-    loop(grammer, input, decend(grammer, 0 /*start_symbol*/, 0), set(), map<pair<int, int>, vec<Pending>>(), set(), set<BS>())
+    /*loop(grammer, input, descend(grammer, 0 [>start_symbol<], 0), set(), set(), set(), set())*/
+    loop(grammer, input, descend(grammer, 0 /*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); })
+    /*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>, vec<Pending>>, P: map<pair<int,int>, set<int>>, Y: set<BS>): set<BS> {
+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 {*/
@@ -176,31 +201,46 @@ 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
-        P += Pp
+        /*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])
+            } else {
+                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])
+            } else {
+                P[Pp.keys[i]] = Pp.values[i]
+            }
+        }
         Y += Yp
     }
     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, discript: Descriptor, G: map<pair<int, int>, vec<Pending>>, P: map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, Pending>, map<pair<int,int>, set<int>>> {
+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 descript.idx_into_rule == grammer.get_nonterminal_rules(discript.nonterminal)[descript.rule_idx].size {
+    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(descript, 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(descript: Descriptor, G: ref map<pair<int, int>, vec<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, Pending>, map<pair<int,int>, set<int>>> {
+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
     var left: int
     var pivot: int
     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)*/
@@ -212,20 +252,20 @@ fun process_e(descript: Descriptor, G: ref map<pair<int, int>, vec<Pending>>, P:
         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>, Pending>(), map(make_pair(X,l), set(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>, vec<Pending>>, P: ref map<pair<int,int>, set<int>>): triple<pair<set<Descriptor>, set<BS>>, map<pair<int, int>, Pending>, map<pair<int,int>, set<int>>> {
+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 }*/
-    R = P.get(make_pair(s,k))
+    var R = P.get(make_pair(s,k))
     /*G' = {<<s,k>, <X::=as.b',l>>}*/
-    var Gp = map(make_pair(s,k), pending(descript.nonterminal, descript.rule_idx, descript.idx_into_rule, descript.left))
+    var Gp = map(make_pair(s,k), set(pending(descript.nonterminal, descript.rule_idx, descript.idx_into_rule, 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(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>>())
@@ -235,9 +275,9 @@ fun process_symbol(grammer: ref Grammer, input: ref str, descript: Descriptor, G
     }
 }
 /*fun match(input: ref str, <X::=a.sb',l,k>): <discriptor_set, set<BS>> {*/
-fun matc(input: ref str, descript: Descriptor): pair<set<Descriptor>, 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 input[descript.piviot] == grammer.get_terminal(s) {
+    if input[descript.pivot] == grammer.get_terminal(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 {
@@ -249,7 +289,7 @@ fun ascend(k:int, K: ref set<Pending>, r: int): pair<set<Descriptor>, set<BS>> {
 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 R = set<Descriptor>()
+    var Rp = set<Descriptor>()
     var Y = set<BS>()
     /*for pending in K {*/
     for (var i = 0; i < K.data.size; i++;) {
@@ -257,11 +297,11 @@ fun nmatch(k:int, K: ref set<Pending>, R: ref set<int>): pair<set<Descriptor>, s
         /*for r in R {*/
         for (var j = 0; j < R.data.size; j++;) {
             var r = R.data[j]
-            R.push(descriptor(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, r))
-            Y.push(bs(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, k, r))
+            Rp.add(descriptor(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, r))
+            Y.add(bs(pending.nonterminal, pending.rule_idx, pending.idx_into_rule, pending.left, k, r))
         }
     }
-    return make_pair(R,Y)
+    return make_pair(Rp,Y)
 }
 
 fun main(argc: int, argv: **char): int {