add support for conjunctive queries.

diff --git a/Cargo.lock b/Cargo.lock
index ea28ff07c69de22cb9888443f87fa84ad72ed50d..f5be324b9eccb33c6669188988158f3a184633b2 100644 (file)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 [root]
 name = "rusty-wam"
-version = "0.6.0"
+version = "0.6.1"
 dependencies = [
  "lalrpop 0.12.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "lalrpop-util 0.12.5 (registry+https://github.com/rust-lang/crates.io-index)",

diff --git a/Cargo.toml b/Cargo.toml
index ae6ad2cf859284b5e762950e3b4494002cd5456d..736bac4ee39dd9dfa785458675aba16e91a4bd09 100644 (file)
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rusty-wam"
-version = "0.6.0"
+version = "0.6.1"
 authors = ["Mark Thom"]
 
 build = "build.rs"

diff --git a/README.md b/README.md
index 5364911ac432d2610656e4a0f770bf246da25e3c..5b1fec962c17a3b38e94c2a4dd4a999f786120ca 100644 (file)
--- a/README.md
+++ b/README.md
@@ -8,11 +8,11 @@ pure Prolog.
 
 ## Progress
 
-Prolog is implemented as a simple REPL. It is without without meta- or
+Prolog is implemented as a simple REPL. It is without meta- or
 extra-logical operators, or side effects of any kind, with the lone
 exception of cut. In terms of the tutorial pacing, the work covers in
 some form all of the WAM book, including lists, cuts, Debray
-allocation, and indexing.
+allocation, indexing, and conjunctive queries.
 
 ## Tutorial
 To enter a multi-clause predicate, the brackets ":{" and "}:" are used
@@ -76,6 +76,29 @@ Press ; to continue or . to abort.
 ;
 no
 ```
+and so do conjunctive queries:
+
+```
+prolog> ?- member([X,X],[a,b,c,[d,d],[e,d]]), member(X, [a,b,c,d,e,f,g]), member(Y, [X, a, b, c, d]).
+yes
+Y = d
+X = d
+Press ; to continue or . to abort.
+Y = a
+X = d
+Press ; to continue or . to abort.
+Y = b
+X = d
+Press ; to continue or . to abort.
+Y = c
+X = d
+Press ; to continue or . to abort.
+Y = d
+X = d
+Press ; to continue or . to abort.
+no
+prolog>
+```
 
 Note that the values of variables belonging to successful queries are
 printed out, on one line each. Uninstantiated variables are denoted by

diff --git a/src/main.rs b/src/main.rs
index 828fe381e6793902096c1578c10b76d0e80ee44d..d7b46e1fd06194ac514c68286ba0039105e886b3 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,16 +3,27 @@ mod prolog;
 
 use prolog::io::*;
 use prolog::machine::*;
+use prolog::prolog_parser::*;
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use prolog::ast::*;
+    use prolog::codegen::*;
 
-    fn submit(wam: &mut Machine, buffer: &str) -> EvalResult {
-        let result = eval(wam, buffer);
+    fn submit(wam: &mut Machine, buffer: &str) -> bool {
         wam.reset();
-        result
+
+        match parse_TopLevel(buffer.trim()) {
+            Ok(tl) =>
+                match eval(wam, &tl) {
+                    EvalResult::InitialQuerySuccess(_, _) |
+                    EvalResult::EntrySuccess |
+                    EvalResult::SubsequentQuerySuccess =>
+                        true,
+                    _ => false
+                },
+            Err(_) => panic!("Bad parse in test case!")
+        }
     }
 
     #[test]
@@ -23,28 +34,28 @@ mod tests {
         submit(&mut wam, "clouds(are, nice).");
 
         // submit returns true on failure, false on success.
-        assert_eq!(submit(&mut wam, "?- p(Z, Z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(Z, z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(Z, w).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(z, w).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(w, w).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- clouds(Z, Z).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- clouds(are, Z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- clouds(Z, nice).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(Z, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(Z, z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(Z, w)."), true);
+        assert_eq!(submit(&mut wam, "?- p(z, w)."), false);
+        assert_eq!(submit(&mut wam, "?- p(w, w)."), true);
+        assert_eq!(submit(&mut wam, "?- clouds(Z, Z)."), false);
+        assert_eq!(submit(&mut wam, "?- clouds(are, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- clouds(Z, nice)."), true);
 
-        assert_eq!(submit(&mut wam, "?- p(Z, h(Z, W), f(W)).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(Z, h(Z, W), f(W))."), false);
 
         submit(&mut wam, "p(Z, h(Z, W), f(W)).");
 
-        assert_eq!(submit(&mut wam, "?- p(z, h(z, z), f(w)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(z, h(z, w), f(w)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(z, h(z, W), f(w)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(Z, h(Z, w), f(Z)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(z, h(Z, w), f(Z)).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(z, h(z, z), f(w))."), false);
+        assert_eq!(submit(&mut wam, "?- p(z, h(z, w), f(w))."), true);
+        assert_eq!(submit(&mut wam, "?- p(z, h(z, W), f(w))."), true);
+        assert_eq!(submit(&mut wam, "?- p(Z, h(Z, w), f(Z))."), true);
+        assert_eq!(submit(&mut wam, "?- p(z, h(Z, w), f(Z))."), false);
 
         submit(&mut wam, "p(f(X), h(Y, f(a)), Y).");
 
-        assert_eq!(submit(&mut wam, "?- p(Z, h(Z, W), f(W)).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(Z, h(Z, W), f(W))."), true);
     }
 
     #[test]
@@ -55,48 +66,48 @@ mod tests {
         submit(&mut wam, "q(q, s).");
         submit(&mut wam, "r(s, t).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(q, t).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(t, q).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(q, T).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(Q, t).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(t, t).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(q, t)."), true);
+        assert_eq!(submit(&mut wam, "?- p(t, q)."), false);
+        assert_eq!(submit(&mut wam, "?- p(q, T)."), true);
+        assert_eq!(submit(&mut wam, "?- p(Q, t)."), true);
+        assert_eq!(submit(&mut wam, "?- p(t, t)."), false);
 
         submit(&mut wam, "p(X, Y) :- q(f(f(X)), R), r(S, T).");
         submit(&mut wam, "q(f(f(X)), r).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
 
         submit(&mut wam, "q(f(f(x)), r).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
 
         submit(&mut wam, "p(X, Y) :- q(X, Y), r(X, Y).");
         submit(&mut wam, "q(s, t).");
         submit(&mut wam, "r(X, Y) :- r(a).");
         submit(&mut wam, "r(a).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(t, S).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(t, s).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(s, T).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(S, t).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(t, S)."), false);
+        assert_eq!(submit(&mut wam, "?- p(t, s)."), false);
+        assert_eq!(submit(&mut wam, "?- p(s, T)."), true);
+        assert_eq!(submit(&mut wam, "?- p(S, t)."), true);
 
         submit(&mut wam, "p(f(f(a), g(b), X), g(b), h) :- q(X, Y).");
         submit(&mut wam, "q(X, Y).");
 
-        assert_eq!(submit(&mut wam, "?- p(f(X, Y, Z), g(b), h).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(f(X, g(Y), Z), g(Z), X).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(f(X, g(Y), Z), g(Z), h).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(Z, Y, X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(f(X, Y, Z), Y, h).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(f(X, Y, Z), g(b), h)."), true);
+        assert_eq!(submit(&mut wam, "?- p(f(X, g(Y), Z), g(Z), X)."), false);
+        assert_eq!(submit(&mut wam, "?- p(f(X, g(Y), Z), g(Z), h)."), true);
+        assert_eq!(submit(&mut wam, "?- p(Z, Y, X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(f(X, Y, Z), Y, h)."), true);
 
         submit(&mut wam, "p(_, f(_, Y, _)) :- h(Y).");
         submit(&mut wam, "h(y).");
 
-        assert_eq!(submit(&mut wam, "?- p(_, f(_, Y, _)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(_, f(_, y, _)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(_, f(_, z, _)).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(_, f(_, Y, _))."), true);
+        assert_eq!(submit(&mut wam, "?- p(_, f(_, y, _))."), true);
+        assert_eq!(submit(&mut wam, "?- p(_, f(_, z, _))."), false);
     }
 
     #[test]
@@ -105,55 +116,55 @@ mod tests {
 
         submit(&mut wam, "p(X, a). p(b, X).");
 
-        assert_eq!(submit(&mut wam, "?- p(x, Y).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b, X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b, a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(a, b).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(x, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b, X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b, a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(a, b)."), false);
 
         submit(&mut wam, "p(X, Y, a). p(X, a, Y). p(X, Y, a).");
 
-        assert_eq!(submit(&mut wam, "?- p(c, d, X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(a, a, a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b, c, d).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(c, d, X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(a, a, a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b, c, d)."), false);
 
         submit(&mut wam, "p(X, a). p(X, Y) :- q(Z), p(X, X).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(x, a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, b).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(x, a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, b)."), false);
 
         submit(&mut wam, "q(z).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, b).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(x, a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(X, b)."), true);
+        assert_eq!(submit(&mut wam, "?- p(x, a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
 
         submit(&mut wam, "p(X, a). p(X, Y) :- q(Y), p(X, X).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, b).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, b)."), false);
 
         submit(&mut wam, "p(a, z). p(X, Y) :- q(Y), p(X, Y).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(a, z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(a, X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b, a).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(a, z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(a, X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b, a)."), false);
 
         submit(&mut wam, "p(X, Y, Z) :- q(X), r(Y), s(Z).
-                        p(a, b, Z) :- q(Z).");
+                          p(a, b, Z) :- q(Z).");
 
         submit(&mut wam, "q(x).");
         submit(&mut wam, "r(y).");
         submit(&mut wam, "s(z).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y, Z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(a, b, c).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(a, b, C).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(X, Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(a, b, c)."), false);
+        assert_eq!(submit(&mut wam, "?- p(a, b, C)."), true);
 
         submit(&mut wam, "p(X) :- q(X). p(X) :- r(X).");
         submit(&mut wam, "q(X) :- a.");
@@ -162,10 +173,10 @@ mod tests {
         submit(&mut wam, "s(x, t).");
         submit(&mut wam, "t(y, u).");
 
-        assert_eq!(submit(&mut wam, "?- p(X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(x).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(y).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(z).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(x)."), true);
+        assert_eq!(submit(&mut wam, "?- p(y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(z)."), false);
 
         submit(&mut wam, "p(f(f(X)), h(W), Y) :- g(W), h(W), f(X).
                           p(X, Y, Z) :- h(Y), g(W), z(Z).");
@@ -174,24 +185,24 @@ mod tests {
         submit(&mut wam, "f(s).");
         submit(&mut wam, "z(Z).");
 
-        assert_eq!(submit(&mut wam, "?- p(X, Y, Z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, X, Z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(f(f(Z)), Y, Z).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, X, X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(X, Y, X).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(f(f(X)), h(f(X)), Y).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, X, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(f(f(Z)), Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, X, X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y, X)."), true);
+        assert_eq!(submit(&mut wam, "?- p(f(f(X)), h(f(X)), Y)."), false);
 
         submit(&mut wam, "p(X) :- f(Y), g(Y), i(X, Y).");
         submit(&mut wam, "g(f(a)). g(f(b)). g(f(c)).");
         submit(&mut wam, "f(f(a)). f(f(b)). f(f(c)).");
         submit(&mut wam, "i(X, X).");
 
-        assert_eq!(submit(&mut wam, "?- p(X).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(X)."), true);
 
         submit(&mut wam, "p(X) :- f(f(Y)), g(Y, f(Y)), i(X, f(Y)).");
         submit(&mut wam, "g(Y, f(Y)) :- g(f(Y)).");
 
-        assert_eq!(submit(&mut wam, "?- p(X).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p(X)."), true);
     }
 
     #[test]
@@ -202,123 +213,123 @@ mod tests {
         submit(&mut wam, "memberchk(X, [X|_]) :- !.
                           memberchk(X, [_|Xs]) :- memberchk(X, Xs).");
 
-        assert_eq!(submit(&mut wam, "?- memberchk(X, [a,b,c]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- memberchk([X,X], [a,b,c,[d,e],[d,d]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- memberchk([X,X], [a,b,c,[D,d],[e,e]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- memberchk([X,X], [a,b,c,[e,d],[f,e]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- memberchk([X,X,Y], [a,b,c,[e,d],[f,e]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- memberchk([X,X,Y], [a,b,c,[e,e,d],[f,e]]).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- memberchk(X, [a,b,c])."), true);
+        assert_eq!(submit(&mut wam, "?- memberchk([X,X], [a,b,c,[d,e],[d,d]])."), true);
+        assert_eq!(submit(&mut wam, "?- memberchk([X,X], [a,b,c,[D,d],[e,e]])."), true);
+        assert_eq!(submit(&mut wam, "?- memberchk([X,X], [a,b,c,[e,d],[f,e]])."), false);
+        assert_eq!(submit(&mut wam, "?- memberchk([X,X,Y], [a,b,c,[e,d],[f,e]])."), false);
+        assert_eq!(submit(&mut wam, "?- memberchk([X,X,Y], [a,b,c,[e,e,d],[f,e]])."), true);
 
         // test deep cuts.
-        submit(&mut wam, "commit :- a, !.");        
+        submit(&mut wam, "commit :- a, !.");
+
+        assert_eq!(submit(&mut wam, "?- commit."), false);
 
-        assert_eq!(submit(&mut wam, "?- commit.").failed_query(), true);
-        
         submit(&mut wam, "a.");
 
-        assert_eq!(submit(&mut wam, "?- commit.").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- commit."), true);
 
         submit(&mut wam, "commit(X) :- a(X), !.");
 
-        assert_eq!(submit(&mut wam, "?- commit(X).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- commit(X)."), false);
 
         submit(&mut wam, "a(x).");
 
-        assert_eq!(submit(&mut wam, "?- commit(X).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- commit(X)."), true);
 
         submit(&mut wam, "a :- b, !, c. a :- d.");
 
-        assert_eq!(submit(&mut wam, "?- a.").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- a."), false);
 
         submit(&mut wam, "b.");
 
-        assert_eq!(submit(&mut wam, "?- a.").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- a."), false);
 
         submit(&mut wam, "d.");
 
         // we've committed to the first clause since the query on b
         // succeeds, so we expect failure here.
-        assert_eq!(submit(&mut wam, "?- a.").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- a."), false);
 
         submit(&mut wam, "c.");
 
-        assert_eq!(submit(&mut wam, "?- a.").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- a."), true);
 
         submit(&mut wam, "a(X) :- b, !, c(X). a(X) :- d(X).");
 
-        assert_eq!(submit(&mut wam, "?- a(X).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- a(X)."), false);
 
         submit(&mut wam, "c(c).");
         submit(&mut wam, "d(d).");
 
-        assert_eq!(submit(&mut wam, "?- a(X).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- a(X)."), true);
 
         submit(&mut wam, "b.");
 
-        assert_eq!(submit(&mut wam, "?- a(X).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- a(X)."), true);
 
         wam.clear();
 
-        assert_eq!(submit(&mut wam, "?- c(X).").failed_query(), true);
-        
+        assert_eq!(submit(&mut wam, "?- c(X)."), false);
+
         submit(&mut wam, "a(X) :- b, c(X), !. a(X) :- d(X).");
         submit(&mut wam, "b.");
 
-        assert_eq!(submit(&mut wam, "?- a(X).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- a(X)."), false);
 
         submit(&mut wam, "d(d).");
 
-        assert_eq!(submit(&mut wam, "?- a(X).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- a(X)."), true);
 
         submit(&mut wam, "c(c).");
-        
-        assert_eq!(submit(&mut wam, "?- a(X).").failed_query(), false);
+
+        assert_eq!(submit(&mut wam, "?- a(X)."), true);
     }
-    
+
     #[test]
     fn test_queries_on_lists() {
         let mut wam = Machine::new();
 
         submit(&mut wam, "p([Z, W]).");
 
-        assert_eq!(submit(&mut wam, "?- p([Z, Z]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z, W, Y]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([Z | W]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z | [Z]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z | [W]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z | []]).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p([Z, Z])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z, W, Y])."), false);
+        assert_eq!(submit(&mut wam, "?- p([Z | W])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z | [Z]])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z | [W]])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z | []])."), false);
 
         submit(&mut wam, "p([Z, Z]).");
 
-        assert_eq!(submit(&mut wam, "?- p([Z, Z]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z, W, Y]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([Z | W]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z | [Z]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z | [W]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z | []]).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p([Z, Z])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z, W, Y])."), false);
+        assert_eq!(submit(&mut wam, "?- p([Z | W])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z | [Z]])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z | [W]])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z | []])."), false);
 
         submit(&mut wam, "p([Z]).");
 
-        assert_eq!(submit(&mut wam, "?- p([Z, Z]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([Z, W, Y]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([Z | W]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Z | [Z]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([Z | [W]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([Z | []]).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- p([Z, Z])."), false);
+        assert_eq!(submit(&mut wam, "?- p([Z, W, Y])."), false);
+        assert_eq!(submit(&mut wam, "?- p([Z | W])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Z | [Z]])."), false);
+        assert_eq!(submit(&mut wam, "?- p([Z | [W]])."), false);
+        assert_eq!(submit(&mut wam, "?- p([Z | []])."), true);
 
         submit(&mut wam, "member(X, [X|Xs]).
                           member(X, [Y|Xs]) :- member(X, Xs).");
 
-        assert_eq!(submit(&mut wam, "?- member(a, [c, [X, Y]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- member(c, [a, [X, Y]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- member(a, [a, [X, Y]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- member(a, [X, Y, Z]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- member([X, X], [a, [X, Y]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- member([X, X], [a, [b, c], [b, b], [Z, x], [d, f]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- member([X, X], [a, [b, c], [b, d], [foo, x], [d, f]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- member([X, Y], [a, [b, c], [b, b], [Z, x], [d, f]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- member([X, Y, Y], [a, [b, c], [b, b], [Z, x], [d, f]]).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- member([X, Y, Z], [a, [b, c], [b, b], [Z, x], [d, f]]).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- member(a, [c, [X, Y]])."), false);
+        assert_eq!(submit(&mut wam, "?- member(c, [a, [X, Y]])."), false);
+        assert_eq!(submit(&mut wam, "?- member(a, [a, [X, Y]])."), true);
+        assert_eq!(submit(&mut wam, "?- member(a, [X, Y, Z])."), true);
+        assert_eq!(submit(&mut wam, "?- member([X, X], [a, [X, Y]])."), true);
+        assert_eq!(submit(&mut wam, "?- member([X, X], [a, [b, c], [b, b], [Z, x], [d, f]])."), true);
+        assert_eq!(submit(&mut wam, "?- member([X, X], [a, [b, c], [b, d], [foo, x], [d, f]])."), false);
+        assert_eq!(submit(&mut wam, "?- member([X, Y], [a, [b, c], [b, b], [Z, x], [d, f]])."), true);
+        assert_eq!(submit(&mut wam, "?- member([X, Y, Y], [a, [b, c], [b, b], [Z, x], [d, f]])."), false);
+        assert_eq!(submit(&mut wam, "?- member([X, Y, Z], [a, [b, c], [b, b], [Z, x], [d, f]])."), false);
     }
 
     #[test]
@@ -336,92 +347,92 @@ mod tests {
                           p(X) :- x.
                           p([c, d, e]).");
 
-        assert_eq!(submit(&mut wam, "?- p(a).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(b).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(c).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(f(a)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(g(b, X)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, X)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, c)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(g(b)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d, e]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d | X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]]).").failed_query(), false);        
+        assert_eq!(submit(&mut wam, "?- p(a)."), false);
+        assert_eq!(submit(&mut wam, "?- p(b)."), false);
+        assert_eq!(submit(&mut wam, "?- p(c)."), false);
+        assert_eq!(submit(&mut wam, "?- p(f(a))."), false);
+        assert_eq!(submit(&mut wam, "?- p(g(b, X))."), false);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, X))."), false);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, c))."), false);
+        assert_eq!(submit(&mut wam, "?- p(g(b))."), false);
+        assert_eq!(submit(&mut wam, "?- p([])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d, e])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d | X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]])."), true);
 
         submit(&mut wam, "a.");
-        
-        assert_eq!(submit(&mut wam, "?- p(a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(c).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(f(a)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(b, X)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, X)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, c)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(g(b)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p([]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d, e]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d | X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]]).").failed_query(), false);        
+
+        assert_eq!(submit(&mut wam, "?- p(a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b)."), false);
+        assert_eq!(submit(&mut wam, "?- p(c)."), false);
+        assert_eq!(submit(&mut wam, "?- p(f(a))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(b, X))."), false);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, X))."), false);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, c))."), false);
+        assert_eq!(submit(&mut wam, "?- p(g(b))."), false);
+        assert_eq!(submit(&mut wam, "?- p([])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d, e])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d | X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]])."), true);
 
         submit(&mut wam, "b.");
         submit(&mut wam, "f(x).");
-        
-        assert_eq!(submit(&mut wam, "?- p(a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(c).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- p(f(a)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(b, X)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, X)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, c)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(b)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d, e]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d | X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]]).").failed_query(), false);
+
+        assert_eq!(submit(&mut wam, "?- p(a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b)."), true);
+        assert_eq!(submit(&mut wam, "?- p(c)."), false);
+        assert_eq!(submit(&mut wam, "?- p(f(a))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(b, X))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, X))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, c))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(b))."), true);
+        assert_eq!(submit(&mut wam, "?- p([])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d, e])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d | X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]])."), true);
 
         submit(&mut wam, "c.");
         submit(&mut wam, "g(X).");
 
-        assert_eq!(submit(&mut wam, "?- p(a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(c).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(f(a)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(b, X)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, X)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, c)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(b)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d, e]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d | X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(blah).").failed_query(), true);
+        assert_eq!(submit(&mut wam, "?- p(a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b)."), true);
+        assert_eq!(submit(&mut wam, "?- p(c)."), true);
+        assert_eq!(submit(&mut wam, "?- p(f(a))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(b, X))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, X))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, c))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(b))."), true);
+        assert_eq!(submit(&mut wam, "?- p([])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d, e])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d | X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]])."), true);
+        assert_eq!(submit(&mut wam, "?- p(blah)."), false);
 
         submit(&mut wam, "x.");
-       
-        assert_eq!(submit(&mut wam, "?- p(a).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(b).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(c).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(f(a)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(b, X)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, X)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(Y, c)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(g(b)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d, e]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c, d | X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([c|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|X]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]]).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- p(blah).").failed_query(), false);
+
+        assert_eq!(submit(&mut wam, "?- p(a)."), true);
+        assert_eq!(submit(&mut wam, "?- p(b)."), true);
+        assert_eq!(submit(&mut wam, "?- p(c)."), true);
+        assert_eq!(submit(&mut wam, "?- p(true(a))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(b, X))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, X))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(Y, c))."), true);
+        assert_eq!(submit(&mut wam, "?- p(g(b))."), true);
+        assert_eq!(submit(&mut wam, "?- p([])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d, e])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c, d | X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([c|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|X])."), true);
+        assert_eq!(submit(&mut wam, "?- p([Y|[d|Xs]])."), true);
+        assert_eq!(submit(&mut wam, "?- p(blah)."), true);
 
         submit(&mut wam, "call(or(X, Y)) :- call(X).
                           call(trace) :- trace.
@@ -433,43 +444,118 @@ mod tests {
                           call(call(X)) :- call(X).
                           call(repeat).
                           call(repeat) :- call(repeat).
-                          call(true).");
-
-        assert_eq!(submit(&mut wam, "?- call(repeat).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(true).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(call(repeat)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(call(true)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(notrace).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- call(nl).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- call(builtin(X)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- call(extern(X)).").failed_query(), true);
-        
+                          call(false).");
+
+        assert_eq!(submit(&mut wam, "?- call(repeat)."), true);
+        assert_eq!(submit(&mut wam, "?- call(false)."), true);
+        assert_eq!(submit(&mut wam, "?- call(call(repeat))."), true);
+        assert_eq!(submit(&mut wam, "?- call(call(false))."), true);
+        assert_eq!(submit(&mut wam, "?- call(notrace)."), false);
+        assert_eq!(submit(&mut wam, "?- call(nl)."), false);
+        assert_eq!(submit(&mut wam, "?- call(builtin(X))."), false);
+        assert_eq!(submit(&mut wam, "?- call(extern(X))."), false);
+
         submit(&mut wam, "notrace.");
         submit(&mut wam, "nl.");
-        
-        assert_eq!(submit(&mut wam, "?- call(repeat).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(true).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(call(repeat)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(call(true)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(notrace).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(nl).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(builtin(X)).").failed_query(), true);
-        assert_eq!(submit(&mut wam, "?- call(extern(X)).").failed_query(), true);        
-        
+
+        assert_eq!(submit(&mut wam, "?- call(repeat)."), true);
+        assert_eq!(submit(&mut wam, "?- call(false)."), true);
+        assert_eq!(submit(&mut wam, "?- call(call(repeat))."), true);
+        assert_eq!(submit(&mut wam, "?- call(call(false))."), true);
+        assert_eq!(submit(&mut wam, "?- call(notrace)."), true);
+        assert_eq!(submit(&mut wam, "?- call(nl)."), true);
+        assert_eq!(submit(&mut wam, "?- call(builtin(X))."), false);
+        assert_eq!(submit(&mut wam, "?- call(extern(X))."), false);
+
         submit(&mut wam, "builtin(X).");
         submit(&mut wam, "extern(x).");
 
-        assert_eq!(submit(&mut wam, "?- call(repeat).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(true).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(call(repeat)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(call(true)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(notrace).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(nl).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(builtin(X)).").failed_query(), false);
-        assert_eq!(submit(&mut wam, "?- call(extern(X)).").failed_query(), false);
+        assert_eq!(submit(&mut wam, "?- call(repeat)."), true);
+        assert_eq!(submit(&mut wam, "?- call(false)."), true);
+        assert_eq!(submit(&mut wam, "?- call(call(repeat))."), true);
+        assert_eq!(submit(&mut wam, "?- call(call(false))."), true);
+        assert_eq!(submit(&mut wam, "?- call(notrace)."), true);
+        assert_eq!(submit(&mut wam, "?- call(nl)."), true);
+        assert_eq!(submit(&mut wam, "?- call(builtin(X))."), true);
+        assert_eq!(submit(&mut wam, "?- call(extern(X))."), true);
+    }
+
+    #[test]
+    fn test_queries_on_conjuctive_queries() {
+        let mut wam = Machine::new();
+
+        submit(&mut wam, "p(a, b).");
+        submit(&mut wam, "q(b, c).");
+
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, X)."), false);
+
+        submit(&mut wam, "p(a, [f(g(X))]).");
+        submit(&mut wam, "q(Y, c).");
+
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, X)."), false);
+
+        submit(&mut wam, "member(X, [X|_]).
+                          member(X, [_|Xs]) :- member(X, Xs).");
+
+        assert_eq!(submit(&mut wam, "?- member(X, [a,b,c]), member(X, [a,b,c])."), true);
+        assert_eq!(submit(&mut wam, "?- member(X, [a,b,c]), member(X, [b,c])."), true);
+        assert_eq!(submit(&mut wam, "?- member(X, [a,c]), member(X, [b,c])."), true);
+        assert_eq!(submit(&mut wam, "?- member(X, [a,b,c,d]), !, member(X, [a,d])."), true);
+        assert_eq!(submit(&mut wam, "?- member(X, [a,b,c,d]), !, member(X, [e])."), false);
+        assert_eq!(submit(&mut wam, "?- member([X,X],[a,b,c,[d,d],[e,d]]),
+                                        member(X, [a,b,c,d,e,f,g]), 
+                                        member(Y, [X, a, b, c, d])."),
+                          true);
+        assert_eq!(submit(&mut wam, "?- member([X,X],[a,b,c,[d,d],[e,d]]),
+                                        member(X, [a,b,c,d,e,f,g]), 
+                                        !,
+                                        member(Y, [X, a, b, c, d])."),
+                          true);
+        
+        submit(&mut wam, "p(a, [f(g(X))]).");
+        submit(&mut wam, "q(Y, c).");
+
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, X)."), false);
+
+        submit(&mut wam, "p(a, [f(g(X))]). p(X, c) :- c.");
+        submit(&mut wam, "c.");
+        submit(&mut wam, "q(Y, c).");
+
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), !, q(Y, Z)."), true);
+
+        submit(&mut wam, "q([f(g(x))], Z). q([f(g(y))], Y). q([f(g(z))], a).");
+
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), !, q(Y, Z)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), !, q(Y, X)."), true);
+
+        submit(&mut wam, "p(X, [f(g(x))]). p(X, [f(g(y))]). p(X, [f(g(z))]).");
+
+        assert_eq!(submit(&mut wam, "?- q(f(X), Y), p(X, Y)."), false);
+        assert_eq!(submit(&mut wam, "?- q(X, Y), p(X, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(X, Y)."), true);
+        assert_eq!(submit(&mut wam, "?- p(X, Y), q(Y, X)."), true);
+        assert_eq!(submit(&mut wam, "?- q(X, Y), p(Y, X)."), true);
     }
 }
 
+fn process_buffer(wam: &mut Machine, buffer: &str)
+{
+    match parse_TopLevel(buffer.trim()) {
+        Ok(tl) => {
+            let result = eval(wam, &tl);
+            print(wam, result);
+        },
+        Err(_) => {
+            println!("Grammatical error of some kind!");
+        }
+    };
+}
+
 fn prolog_repl() {
     let mut wam = Machine::new();
 
@@ -481,13 +567,11 @@ fn prolog_repl() {
         if buffer == "quit\n" {
             break;
         } else if buffer == "clear\n" {
-            wam = Machine::new();
+            wam.clear();
             continue;
         }
 
-        let result = eval(&mut wam, buffer.trim());
-        print(&mut wam, result);
-
+        process_buffer(&mut wam, buffer.trim());
         wam.reset();
     }
 }

diff --git a/src/prolog/allocator.rs b/src/prolog/allocator.rs
new file mode 100644 (file)
index 0000000..047b35e
--- /dev/null
+++ b/src/prolog/allocator.rs
@@ -0,0 +1,58 @@
+use prolog::ast::*;
+use prolog::fixtures::*;
+use prolog::targets::*;
+
+use std::cell::Cell;
+
+pub trait Allocator<'a>
+{
+    fn new() -> Self;
+    
+    fn mark_anon_var<Target>(&mut self, Level, &mut Vec<Target>)
+        where Target: CompilationTarget<'a>;
+    fn mark_non_var<Target>(&mut self, Level, GenContext, &'a Cell<RegType>, &mut Vec<Target>)
+        where Target: CompilationTarget<'a>;
+    fn mark_var<Target>(&mut self, &'a Var, Level, &'a Cell<VarReg>, GenContext, &mut Vec<Target>)
+        where Target: CompilationTarget<'a>;    
+    
+    fn reset(&mut self);
+    fn reset_contents(&mut self) {}
+
+    fn advance(&mut self, GenContext, &'a Term);
+    fn advance_arg(&mut self);
+
+    fn bindings(&self) -> &AllocVarDict<'a>;
+    fn bindings_mut(&mut self) -> &mut AllocVarDict<'a>;
+
+    fn take_bindings(self) -> AllocVarDict<'a>;
+    
+    fn drain_var_data(&mut self, vs: VariableFixtures<'a>) -> VariableFixtures<'a>
+    {
+        let mut perm_vs = VariableFixtures::new();
+
+        for (var, (var_status, cells)) in vs.into_iter() {
+            match var_status {
+                VarStatus::Temp(chunk_num, tvd) => {
+                    self.bindings_mut().insert(var, VarData::Temp(chunk_num, 0, tvd));
+                },
+                VarStatus::Perm(_) => {
+                    self.bindings_mut().insert(var, VarData::Perm(0));
+                    perm_vs.insert(var, (var_status, cells));
+                }
+            };
+        }
+
+        perm_vs
+    }
+    
+    fn get(&self, var: &'a Var) -> RegType {
+        self.bindings().get(var).unwrap().as_reg_type()
+    }    
+    
+    fn record_register(&mut self, var: &'a Var, r: RegType) {
+        match self.bindings_mut().get_mut(var).unwrap() {
+            &mut VarData::Temp(_, ref mut s, _) => *s = r.reg_num(),
+            &mut VarData::Perm(ref mut s) => *s = r.reg_num()
+        }
+    }
+}

diff --git a/src/prolog/ast.rs b/src/prolog/ast.rs
index cd302ff59247d58951e74b50fefb2c5c4a7416f9..6674f261051a968e40c21439045089347fd3027c 100644 (file)
--- a/src/prolog/ast.rs
+++ b/src/prolog/ast.rs
@@ -1,4 +1,5 @@
 use std::cell::Cell;
+use std::cmp::Ordering;
 use std::collections::{HashMap, VecDeque};
 use std::ops::{Add, AddAssign};
 use std::vec::Vec;
@@ -43,7 +44,7 @@ impl PredicateClause {
 pub enum TopLevel {
     Fact(Term),
     Predicate(Vec<PredicateClause>),
-    Query(Term),
+    Query(Vec<TermOrCut>),
     Rule(Rule)
 }
 
@@ -70,7 +71,7 @@ impl RegType {
             RegType::Perm(reg_num) | RegType::Temp(reg_num) => reg_num
         }
     }
-    
+
     pub fn is_perm(self) -> bool {
         match self {
             RegType::Perm(_) => true,
@@ -90,7 +91,7 @@ impl VarReg {
         match self {
             VarReg::ArgAndNorm(reg, _) | VarReg::Norm(reg) => reg
         }
-    }   
+    }
 }
 
 impl Default for VarReg {
@@ -266,17 +267,6 @@ pub enum Line {
     Query(CompiledQuery)
 }
 
-pub enum LineOrCodeOffset<'a> {
-    Instruction(&'a Line),
-    Offset(usize)
-}
-
-impl<'a> From<&'a Line> for LineOrCodeOffset<'a> {
-    fn from(line: &'a Line) -> Self {
-        LineOrCodeOffset::Instruction(line)
-    }
-}
-
 pub type ThirdLevelIndex = Vec<IndexedChoiceInstruction>;
 
 pub type Code = Vec<Line>;
@@ -369,15 +359,29 @@ impl HeapCellValue {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq)]
 pub enum CodePtr {
     DirEntry(usize),
-    TopLevel
+    TopLevel(usize, usize, usize) // chunk_num, e, offset.
+}
+
+impl PartialOrd<CodePtr> for CodePtr {
+    fn partial_cmp(&self, other: &CodePtr) -> Option<Ordering> {
+        match (self, other) {
+            (&CodePtr::DirEntry(p1), &CodePtr::DirEntry(ref p2)) =>
+                p1.partial_cmp(p2),
+            (&CodePtr::DirEntry(_), &CodePtr::TopLevel(_, _, _)) =>
+                Some(Ordering::Less),
+            (&CodePtr::TopLevel(_, _, p1), &CodePtr::TopLevel(_, _, ref p2)) =>
+                p1.partial_cmp(p2),
+            _ => Some(Ordering::Greater)
+        }
+    }
 }
 
 impl Default for CodePtr {
     fn default() -> Self {
-        CodePtr::TopLevel
+        CodePtr::TopLevel(0, 0, 0)
     }
 }
 
@@ -387,7 +391,7 @@ impl Add<usize> for CodePtr {
     fn add(self, rhs: usize) -> Self::Output {
         match self {
             CodePtr::DirEntry(p) => CodePtr::DirEntry(p + rhs),
-            CodePtr::TopLevel => CodePtr::TopLevel
+            CodePtr::TopLevel(cn, e, p) => CodePtr::TopLevel(cn, e, p + rhs)
         }
     }
 }
@@ -395,8 +399,8 @@ impl Add<usize> for CodePtr {
 impl AddAssign<usize> for CodePtr {
     fn add_assign(&mut self, rhs: usize) {
         match self {
-            &mut CodePtr::DirEntry(ref mut p) => *p += rhs,
-            _ => {}
+            &mut CodePtr::DirEntry(ref mut p) |
+            &mut CodePtr::TopLevel(_, _, ref mut p) => *p += rhs
         }
     }
 }
@@ -430,6 +434,13 @@ impl Term {
         }
     }
 
+    pub fn subterms(&self) -> usize {
+        match self {
+            &Term::Clause(_, _, ref terms) => terms.len(),
+            _ => 1
+        }
+    }
+
     pub fn name(&self) -> Option<&Atom> {
         match self {
             &Term::Constant(_, Constant::Atom(ref atom))
@@ -445,24 +456,3 @@ impl Term {
         }
     }
 }
-
-pub type HeapVarDict = HashMap<Var, Addr>;
-
-pub enum EvalResult {
-    EntryFailure,
-    EntrySuccess,
-    InitialQuerySuccess(HeapVarDict),
-    QueryFailure,
-    SubsequentQuerySuccess,
-}
-
-impl EvalResult {
-    #[allow(dead_code)]
-    pub fn failed_query(&self) -> bool {
-        if let &EvalResult::QueryFailure = self {
-            true
-        } else {
-            false
-        }
-    }
-}

diff --git a/src/prolog/codegen.rs b/src/prolog/codegen.rs
index 1dbbb439336a8dd9f6eb07d0b4e4c56f9205de70..25e0f248047230f28cde45c2199c620bfd78dd5f 100644 (file)
--- a/src/prolog/codegen.rs
+++ b/src/prolog/codegen.rs
@@ -1,5 +1,5 @@
+use prolog::allocator::*;
 use prolog::ast::*;
-use prolog::debray_allocator::*;
 use prolog::fixtures::*;
 use prolog::indexing::*;
 use prolog::iterators::*;
@@ -9,21 +9,40 @@ use std::cell::Cell;
 use std::collections::HashMap;
 use std::vec::Vec;
 
-pub struct CodeGenerator<'a> {
-    marker: TermMarker<'a>,
+pub struct CodeGenerator<'a, TermMarker> {
+    marker: TermMarker,
     var_count: HashMap<&'a Var, usize>
 }
 
-impl<'a> CodeGenerator<'a> {
+pub enum EvalResult<'a> {
+    EntryFailure,
+    EntrySuccess,
+    InitialQuerySuccess(AllocVarDict<'a>, HeapVarDict<'a>),
+    QueryFailure,
+    SubsequentQuerySuccess,
+}
+
+impl<'a> EvalResult<'a> {
+    #[allow(dead_code)]
+    pub fn failed_query(&self) -> bool {
+        if let &EvalResult::QueryFailure = self {
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl<'a, TermMarker: Allocator<'a>> CodeGenerator<'a, TermMarker> {
     pub fn new() -> Self {
-        CodeGenerator { marker: TermMarker::new(),
+        CodeGenerator { marker: Allocator::new(),
                         var_count: HashMap::new() }
     }
 
-    pub fn vars(&self) -> &HashMap<&Var, VarData> {
-        &self.marker.bindings
+    pub fn take_vars(self) -> AllocVarDict<'a> {
+        self.marker.take_bindings()
     }
-
+    
     fn update_var_count<Iter>(&mut self, iter: Iter)
         where Iter : Iterator<Item=TermRef<'a>>
     {
@@ -98,7 +117,7 @@ impl<'a> CodeGenerator<'a> {
 
     fn add_or_increment_void_instr<Target>(target: &mut Vec<Target>)
         where Target: CompilationTarget<'a>
-    {        
+    {
         if let Some(ref mut instr) = target.last_mut() {
             if Target::is_void_instr(&*instr) {
                 Target::incr_void_instr(instr);
@@ -232,38 +251,72 @@ impl<'a> CodeGenerator<'a> {
         }
     }
 
-    fn lco(body: &mut Code, rule: &'a Rule) -> usize
+    fn lco(body: &mut Code, toc: &TermOrCut) -> usize
     {
-        let last_arity = rule.last_clause().arity();
+        let last_arity = toc.arity();
         let mut dealloc_index = body.len() - 1;
 
-        match rule.last_clause() {
-              &TermOrCut::Term(Term::Clause(_, ref name, _))
-            | &TermOrCut::Term(Term::Constant(_, Constant::Atom(ref name))) => {
-                if let &mut Line::Control(ref mut ctrl) = body.last_mut().unwrap() {
-                    *ctrl = ControlInstruction::Execute(name.clone(), last_arity);
-                }
-            },
+        match toc {
+            &TermOrCut::Term(Term::Clause(_, ref name, _))
+                | &TermOrCut::Term(Term::Constant(_, Constant::Atom(ref name))) => {
+                    if let &mut Line::Control(ref mut ctrl) = body.last_mut().unwrap() {
+                        *ctrl = ControlInstruction::Execute(name.clone(), last_arity);
+                    }
+                },
             _ => dealloc_index = body.len()
         };
 
         dealloc_index
     }
 
-    pub fn compile_rule(&mut self, rule: &'a Rule) -> Code
+    fn compile_seq(&mut self,
+                   clauses: &'a [TermOrCut],
+                   vs: &VariableFixtures<'a>,
+                   body: &mut Code,
+                   is_exposed: bool)
     {
-        let iter = ChunkedIterator::from_rule(rule);
-        let (mut vs, deep_cuts) = self.collect_var_data(iter);
-        vs = self.marker.drain_var_data(vs);
+        let iter = ChunkedIterator::from_term_sequence(clauses);
 
-        let &Rule { head: (ref p0, ref p1), ref clauses } = rule;
+        for (chunk_num, (_, terms)) in iter.enumerate() {
+            self.marker.reset_contents();
+
+            for (i, term) in terms.iter().enumerate() {
+                let mut body_appendage = match term {
+                    &TermOrCutRef::Cut if i + 1 < terms.len() =>
+                        vec![Line::Cut(CutInstruction::Cut(Terminal::Non))],
+                    &TermOrCutRef::Cut =>
+                        vec![Line::Cut(CutInstruction::Cut(Terminal::Terminal))],
+                    &TermOrCutRef::Term(term) if i + 1 < terms.len() => {
+                        let num_vars = vs.vars_above_threshold(i + 1);
+                        self.compile_internal_query(term,
+                                                    GenContext::Mid(chunk_num),
+                                                    num_vars,
+                                                    is_exposed)
+                    },
+                    &TermOrCutRef::Term(term) => {
+                        let num_vars = vs.vars_above_threshold(i + 1);
+                        self.compile_internal_query(term,
+                                                    GenContext::Last(chunk_num),
+                                                    num_vars,
+                                                    is_exposed)
+                    }
+                };
 
-        self.marker.advance(p0);
+                body.append(&mut body_appendage);
+            }
+        }
+    }
 
+    fn compile_seq_prelude(&mut self,
+                           num_clauses: usize,
+                           vs: &VariableFixtures<'a>,
+                           deep_cuts: bool,
+                           body: &mut Code)
+                           -> usize
+    {
         let perm_vars = vs.vars_above_threshold(0) + deep_cuts as usize;
-        let mut body  = Vec::new();
 
-        if clauses.len() > 0 {
+        if num_clauses > 0 {
             body.push(Line::Control(ControlInstruction::Allocate(perm_vars)));
 
             if deep_cuts {
@@ -271,10 +324,16 @@ impl<'a> CodeGenerator<'a> {
             }
         }
 
-        if p0.is_clause() {
-            body.push(Line::Fact(self.compile_target(p0, GenContext::Head, false)));
-        }
+        perm_vars
+    }
 
+    fn compile_neck_cut_or(&mut self,
+                           p1: &'a TermOrCut,
+                           clauses: &'a [TermOrCut],
+                           body: &mut Code,
+                           perm_vars: usize,
+                           is_exposed: bool)
+    {
         match p1 {
             &TermOrCut::Cut => {
                 let term = if clauses.is_empty() {
@@ -286,7 +345,7 @@ impl<'a> CodeGenerator<'a> {
                 body.push(Line::Cut(CutInstruction::NeckCut(term)));
             },
             &TermOrCut::Term(ref p1) => {
-                self.marker.advance(p1);
+                self.marker.advance(GenContext::Head, p1);
 
                 if p1.is_clause() {
                     let term_loc = if p1.is_callable() {
@@ -295,38 +354,49 @@ impl<'a> CodeGenerator<'a> {
                         GenContext::Mid(0)
                     };
 
-                    body.push(Line::Query(self.compile_target(p1, term_loc, false)));
+                    body.push(Line::Query(self.compile_target(p1, term_loc, is_exposed)));
                 }
 
-                Self::add_conditional_call(&mut body, p1, perm_vars);
+                Self::add_conditional_call(body, p1, perm_vars);
             }
         };
+    }
 
-        let iter = ChunkedIterator::from_term_sequence(clauses);
+    fn compile_cleanup(body: &mut Code, num_clauses: usize, toc: &TermOrCut)
+    {
+        let dealloc_index = Self::lco(body, toc);
 
-        for (chunk_num, (_, terms)) in iter.enumerate() {
-            self.marker.reset_contents();
+        if num_clauses > 0 {
+            body.insert(dealloc_index, Line::Control(ControlInstruction::Deallocate));
+        }
+    }
 
-            for (i, term) in terms.iter().enumerate() {
-                let mut body_appendage = match term {
-                    &TermOrCutRef::Cut if i + 1 < terms.len() =>
-                        vec![Line::Cut(CutInstruction::Cut(Terminal::Non))],
-                    &TermOrCutRef::Cut =>
-                        vec![Line::Cut(CutInstruction::Cut(Terminal::Terminal))],
-                    &TermOrCutRef::Term(term) if i + 1 < terms.len() => {
-                        let num_vars = vs.vars_above_threshold(i + 1);
-                        self.compile_internal_query(term, GenContext::Mid(chunk_num), num_vars)
-                    },
-                    &TermOrCutRef::Term(term) => {
-                        let num_vars = vs.vars_above_threshold(i + 1);
-                        self.compile_internal_query(term, GenContext::Last(chunk_num), num_vars)
-                    }
-                };
+    pub fn compile_rule<'b: 'a>(&mut self, rule: &'b Rule) -> Code
+    {
+        let iter = ChunkedIterator::from_rule(rule);
+        let (mut vs, deep_cuts) = self.collect_var_data(iter);
+        vs = self.marker.drain_var_data(vs);
 
-                body.append(&mut body_appendage);
-            }
+        let &Rule { head: (ref p0, ref p1), ref clauses } = rule;
+        let mut body = Vec::new();
+
+        self.marker.advance(GenContext::Head, p0);
+
+        let perm_vars = self.compile_seq_prelude(clauses.len(), &vs, deep_cuts, &mut body);
+
+        if p0.is_clause() {
+            body.push(Line::Fact(self.compile_target(p0, GenContext::Head, false)));
         }
 
+        let clauses_slice = if clauses.len() > 1 {
+            &clauses[1 .. ]
+        } else {
+            &[]
+        };
+
+        self.compile_neck_cut_or(p1, clauses_slice, &mut body, perm_vars, false);
+        self.compile_seq(clauses, &vs, &mut body, false);
+
         if clauses.len() > 0 {
             let mut index = body.len() - 1;
 
@@ -335,15 +405,11 @@ impl<'a> CodeGenerator<'a> {
             }
 
             if let &mut Line::Query(ref mut query) = &mut body[index] {
-                vs.mark_unsafe_query_vars(p0, query);
+                vs.mark_unsafe_vars_in_rule(p0, query);
             }
         }
 
-        let dealloc_index = Self::lco(&mut body, &rule);
-
-        if clauses.len() > 0 {
-            body.insert(dealloc_index, Line::Control(ControlInstruction::Deallocate));
-        }
+        Self::compile_cleanup(&mut body, clauses.len(), rule.last_clause());
 
         body
     }
@@ -352,7 +418,7 @@ impl<'a> CodeGenerator<'a> {
     {
         let mut unsafe_vars = HashMap::new();
 
-        for var_status in self.marker.bindings.values() {
+        for var_status in self.marker.bindings().values() {
             unsafe_vars.insert(var_status.as_reg_type(), false);
         }
 
@@ -375,13 +441,13 @@ impl<'a> CodeGenerator<'a> {
         }
     }
 
-    pub fn compile_fact(&mut self, term: &'a Term) -> Code
+    pub fn compile_fact<'b: 'a>(&mut self, term: &'b Term) -> Code
     {
         let iter = ChunkedIterator::from_term(term, true);
         let (vs, _) = self.collect_var_data(iter);
         self.marker.drain_var_data(vs);
 
-        self.marker.advance(term);
+        self.marker.advance(GenContext::Head, term);
 
         let mut code = Vec::new();
 
@@ -397,14 +463,19 @@ impl<'a> CodeGenerator<'a> {
         code
     }
 
-    fn compile_internal_query(&mut self, term: &'a Term, term_loc: GenContext, index: usize) -> Code
+    fn compile_internal_query(&mut self,
+                              term: &'a Term,
+                              term_loc: GenContext,
+                              index: usize,
+                              is_exposed: bool)
+                              -> Code
     {
-        self.marker.advance(term);
+        self.marker.advance(term_loc, term);
 
         let mut code = Vec::new();
 
         if term.is_clause() {
-            let compiled_query = Line::Query(self.compile_target(term, term_loc, false));
+            let compiled_query = Line::Query(self.compile_target(term, term_loc, is_exposed));
             code.push(compiled_query);
         }
 
@@ -413,23 +484,39 @@ impl<'a> CodeGenerator<'a> {
         code
     }
 
-    pub fn compile_query(&mut self, term: &'a Term) -> Code
+    pub fn compile_query(&mut self, query: &'a Vec<TermOrCut>) -> Code
     {
-        let iter = ChunkedIterator::from_term(term, true);
-        let (vs, _) = self.collect_var_data(iter);
+        let iter = ChunkedIterator::from_term_sequence(query);
+        let (mut vs, deep_cuts) = self.collect_var_data(iter);
+        let p1 = query.first().unwrap();
 
-        self.marker.drain_var_data(vs);
-        self.marker.advance(term);
+        vs = self.marker.drain_var_data(vs);
 
-        let mut code = Vec::new();
+        let mut code  = Vec::new();
+        let perm_vars = self.compile_seq_prelude(query.len() - 1,
+                                                 &vs,
+                                                 deep_cuts,
+                                                 &mut code);
 
-        if term.is_clause() {
-            let compiled_query = self.compile_target(term, GenContext::Last(0), true);
-            code.push(Line::Query(compiled_query));
-        }
+        let query_slice = if query.len() > 1 {
+            &query[1 .. ]
+        } else {
+            &[]
+        };
 
-        Self::add_conditional_call(&mut code, term, 0);
+        self.compile_neck_cut_or(p1, query_slice, &mut code, perm_vars, true);
+        self.compile_seq(query_slice, &vs, &mut code, true);
 
+        for line in code.iter_mut() {
+            match line {
+                &mut Line::Query(ref mut query) =>
+                    vs.mark_unsafe_vars_in_query(query),
+                _ => {}
+            };
+        }
+        
+        Self::compile_cleanup(&mut code, query.len() - 1, query.last().unwrap());        
+        
         code
     }
 
@@ -456,12 +543,12 @@ impl<'a> CodeGenerator<'a> {
         subseqs
     }
 
-    fn compile_pred_subseq(&mut self, clauses: &'a [PredicateClause]) -> Code
+    fn compile_pred_subseq<'b: 'a>(&mut self, clauses: &'b [PredicateClause]) -> Code
     {
         let mut code_body = Vec::new();
         let mut code_offsets = CodeOffsets::new();
 
-        let multi_clause = clauses.len() > 1;
+        let num_clauses  = clauses.len();
 
         for (i, clause) in clauses.iter().enumerate() {
             self.marker.reset();
@@ -473,10 +560,10 @@ impl<'a> CodeGenerator<'a> {
                     self.compile_rule(rule)
             };
 
-            if multi_clause {
+            if num_clauses > 1 {
                 let choice = match i {
                     0 => ChoiceInstruction::TryMeElse(clause_code.len() + 1),
-                    _ if i == clauses.len() - 1 => ChoiceInstruction::TrustMe,
+                    _ if i == num_clauses - 1 => ChoiceInstruction::TrustMe,
                     _ => ChoiceInstruction::RetryMeElse(clause_code.len() + 1)
                 };
 
@@ -497,10 +584,10 @@ impl<'a> CodeGenerator<'a> {
         code
     }
 
-    pub fn compile_predicate(&mut self, clauses: &'a Vec<PredicateClause>) -> Code
+    pub fn compile_predicate<'b: 'a>(&mut self, clauses: &'b Vec<PredicateClause>) -> Code
     {
         let mut code   = Vec::new();
-        let split_pred = Self::split_predicate(clauses);
+        let split_pred = Self::split_predicate(&clauses);
         let multi_seq  = split_pred.len() > 1;
 
         for (l, r) in split_pred {

diff --git a/src/prolog/debray_allocator.rs b/src/prolog/debray_allocator.rs
index 1f2be910d64726fc5b4fab0e8ae7f7eb5f41e7c6..29c5f1c7fcd5fe835a439740bcf1c79956d4e225 100644 (file)
--- a/src/prolog/debray_allocator.rs
+++ b/src/prolog/debray_allocator.rs
@@ -1,3 +1,4 @@
+use prolog::allocator::*;
 use prolog::ast::*;
 use prolog::fixtures::*;
 use prolog::targets::*;
@@ -5,25 +6,15 @@ use prolog::targets::*;
 use std::cell::Cell;
 use std::collections::{BTreeSet, HashMap};
 
-pub struct TermMarker<'a> {
-    pub bindings: HashMap<&'a Var, VarData>,
+pub struct DebrayAllocator<'a> {
+    bindings: HashMap<&'a Var, VarData>,
     arg_c:    usize,
     temp_lb:  usize,
     contents: HashMap<usize, &'a Var>,
     in_use:   BTreeSet<usize>,
 }
 
-impl<'a> TermMarker<'a> {
-    pub fn new() -> TermMarker<'a> {
-        TermMarker {
-            arg_c:   1,
-            temp_lb: 1,
-            bindings: HashMap::new(),
-            contents: HashMap::new(),
-            in_use: BTreeSet::new()
-        }
-    }
-
+impl<'a> DebrayAllocator<'a> {    
     fn occurs_shallowly_in_head(&self, var: &'a Var, r: usize) -> bool
     {
         match self.bindings.get(var).unwrap() {
@@ -33,25 +24,6 @@ impl<'a> TermMarker<'a> {
         }
     }
 
-    pub fn drain_var_data(&mut self, vs: VariableFixtures<'a>) -> VariableFixtures<'a>
-    {
-        let mut perm_vs = VariableFixtures::new();
-
-        for (var, (var_status, cells)) in vs.into_iter() {
-            match var_status {
-                VarStatus::Temp(chunk_num, tvd) => {
-                    self.bindings.insert(var, VarData::Temp(chunk_num, 0, tvd));
-                },
-                VarStatus::Perm(_) => {
-                    self.bindings.insert(var, VarData::Perm(0));
-                    perm_vs.insert(var, (var_status, cells));
-                }
-            };
-        }
-
-        perm_vs
-    }
-
     fn alloc_with_cr(&self, var: &'a Var) -> usize
     {
         match self.bindings.get(var) {
@@ -186,59 +158,67 @@ impl<'a> TermMarker<'a> {
         }
     }
 
-    fn get(&self, var: &'a Var) -> RegType {
-        self.bindings.get(var).unwrap().as_reg_type()
+    fn alloc_reg_to_non_var(&mut self) -> usize
+    {
+        let mut final_index = 0;
+
+        for index in self.temp_lb .. {
+            if !self.in_use.contains(&index) {
+                final_index = index;
+                break;
+            }
+        }
+
+        self.temp_lb = final_index + 1;
+
+        final_index
     }
 
     fn in_place(&self, var: &'a Var, term_loc: GenContext, r: RegType, k: usize) -> bool
     {
         match term_loc {
             GenContext::Head if !r.is_perm() => r.reg_num() == k,
-            _ => match self.bindings.get(var).unwrap() {
+            _ => match self.bindings().get(var).unwrap() {
                      &VarData::Temp(_, o, _) if r.reg_num() == k => o == k,
                      _ => false
                  }
         }
+    }    
+}
+
+impl<'a> Allocator<'a> for DebrayAllocator<'a>
+{
+    fn new() -> DebrayAllocator<'a> {
+        DebrayAllocator {
+            arg_c:   1,
+            temp_lb: 1,
+            bindings: HashMap::new(),
+            contents: HashMap::new(),
+            in_use: BTreeSet::new()
+        }
     }
     
-    pub fn mark_anon_var<Target>(&mut self, lvl: Level, target: &mut Vec<Target>)
+    fn mark_anon_var<Target>(&mut self, lvl: Level, target: &mut Vec<Target>)
         where Target: CompilationTarget<'a>
     {
         let r = RegType::Temp(self.alloc_reg_to_non_var());
 
         match lvl {
+            Level::Deep => target.push(Target::subterm_to_variable(r)),
             Level::Shallow => {
                 let k = self.arg_c;
                 self.arg_c += 1;
 
                 target.push(Target::argument_to_variable(r, k));
-            },
-            Level::Deep =>
-                target.push(Target::subterm_to_variable(r))
-        };
-    }
-
-    fn alloc_reg_to_non_var(&mut self) -> usize
-    {
-        let mut final_index = 0;
-
-        for index in self.temp_lb .. {
-            if !self.in_use.contains(&index) {
-                final_index = index;
-                break;
             }
-        }
-
-        self.temp_lb = final_index + 1;
-
-        final_index
+        };
     }
 
-    pub fn mark_non_var<Target>(&mut self,
-                                lvl: Level,
-                                term_loc: GenContext,
-                                cell: &Cell<RegType>,
-                                target: &mut Vec<Target>)
+    fn mark_non_var<Target>(&mut self,
+                            lvl: Level,
+                            term_loc: GenContext,
+                            cell: &Cell<RegType>,
+                            target: &mut Vec<Target>)
         where Target: CompilationTarget<'a>
     {
         let r = cell.get();
@@ -262,12 +242,12 @@ impl<'a> TermMarker<'a> {
         }
     }
 
-    pub fn mark_var<Target>(&mut self,
-                            var: &'a Var,
-                            lvl: Level,
-                            cell: &'a Cell<VarReg>,
-                            term_loc: GenContext,
-                            target: &mut Vec<Target>)
+    fn mark_var<Target>(&mut self,
+                        var: &'a Var,
+                        lvl: Level,
+                        cell: &'a Cell<VarReg>,
+                        term_loc: GenContext,
+                        target: &mut Vec<Target>)
         where Target: CompilationTarget<'a>
     {
         let (r, is_new_var) = match self.get(var) {
@@ -311,7 +291,7 @@ impl<'a> TermMarker<'a> {
                     }
                 } else {
                     target.push(Target::subterm_to_variable(r));
-                },                    
+                },
             Level::Deep =>
                 target.push(Target::subterm_to_value(r))
         };
@@ -325,30 +305,35 @@ impl<'a> TermMarker<'a> {
         }
     }
 
-    fn record_register(&mut self, var: &'a Var, r: RegType) {
-        match self.bindings.get_mut(var).unwrap() {
-            &mut VarData::Temp(_, ref mut s, _) => *s = r.reg_num(),
-            &mut VarData::Perm(ref mut s) => *s = r.reg_num()
-        }
+    fn reset(&mut self) {
+        self.bindings.clear();
+        self.contents.clear();
+        self.in_use.clear();
     }
 
-    pub fn advance_arg(&mut self) {
+    fn reset_contents(&mut self) {
+        self.contents.clear();
+        self.in_use.clear();
+    }
+    
+    fn advance_arg(&mut self) {
         self.arg_c += 1;
     }
 
-    pub fn advance(&mut self, term: &'a Term) {
-        self.arg_c = 1;
-        self.temp_lb = term.arity() + 1;
+    fn bindings(&self) -> &AllocVarDict<'a> {
+        &self.bindings
     }
-
-    pub fn reset(&mut self) {
-        self.bindings.clear();
-        self.contents.clear();
-        self.in_use.clear();
+    
+    fn bindings_mut(&mut self) -> &mut AllocVarDict<'a> {
+        &mut self.bindings
     }
 
-    pub fn reset_contents(&mut self) {
-        self.contents.clear();
-        self.in_use.clear();
+    fn take_bindings(self) -> AllocVarDict<'a> {
+        self.bindings
+    }
+    
+    fn advance(&mut self, _: GenContext, term: &'a Term) {
+        self.arg_c   = 1;
+        self.temp_lb = term.arity() + 1;
     }
 }

diff --git a/src/prolog/fixtures.rs b/src/prolog/fixtures.rs
index beebd27b1c3733df883fda867f20075f0d37262c..ea0fd831c7071db0c8eeefe4beb6dbcb5e1182ca 100644 (file)
--- a/src/prolog/fixtures.rs
+++ b/src/prolog/fixtures.rs
@@ -8,6 +8,9 @@ use std::vec::Vec;
 
 pub type OccurrenceSet = BTreeSet<(GenContext, usize)>;
 
+pub type HeapVarDict<'a>  = HashMap<&'a Var, Addr>;
+pub type AllocVarDict<'a> = HashMap<&'a Var, VarData>;
+
 pub struct TempVarData {
     last_term_arity: usize,
     pub use_set: OccurrenceSet,
@@ -232,26 +235,8 @@ impl<'a> VariableFixtures<'a>
         }
     }
 
-    pub fn mark_unsafe_query_vars(&self, head: &Term, query: &mut CompiledQuery)
+    fn mark_unsafe_vars(&self, unsafe_vars: &mut HashMap<RegType, bool>, query: &mut CompiledQuery)
     {
-        let mut unsafe_vars = HashMap::new();
-
-        for &(_, ref cb) in self.values() {
-            if !cb.is_empty() {
-                let index = cb.first().unwrap().get().norm();
-                unsafe_vars.insert(index, false);
-            }
-        }
-
-        for term_ref in head.breadth_first_iter() {
-            match term_ref {
-                TermRef::Var(_, cell, _) => {
-                    unsafe_vars.remove(&cell.get().norm());
-                },
-                _ => {}
-            };
-        }
-
         for query_instr in query.iter_mut() {
             match query_instr {
                 &mut QueryInstruction::PutValue(RegType::Perm(i), arg) =>
@@ -262,7 +247,7 @@ impl<'a> VariableFixtures<'a>
                         }
                     },
                 &mut QueryInstruction::SetVariable(reg)
-                    | &mut QueryInstruction::PutVariable(reg, _) =>
+              | &mut QueryInstruction::PutVariable(reg, _) =>
                     if let Some(found) = unsafe_vars.get_mut(&reg) {
                         *found = true;
                     },
@@ -277,4 +262,43 @@ impl<'a> VariableFixtures<'a>
             };
         }
     }
+
+    fn record_unsafe_vars(&self, unsafe_vars: &mut HashMap<RegType, bool>) {        
+        for &(_, ref cb) in self.values() {
+            match cb.first() {
+                Some(index) => {
+                    unsafe_vars.insert(index.get().norm(), false);
+                },
+                None => {}
+            };
+        }
+    }
+    
+    fn mark_head_vars_as_safe(&self, head: &Term, unsafe_vars: &mut HashMap<RegType, bool>)
+    {                
+        for term_ref in head.breadth_first_iter() {
+            match term_ref {
+                TermRef::Var(_, cell, _) => {
+                    unsafe_vars.remove(&cell.get().norm());
+                },
+                _ => {}
+            };
+        }
+    }
+
+    pub fn mark_unsafe_vars_in_query(&self, query: &mut CompiledQuery) {
+        let mut unsafe_vars = HashMap::new();
+
+        self.record_unsafe_vars(&mut unsafe_vars);
+        self.mark_unsafe_vars(&mut unsafe_vars, query);
+    }
+    
+    pub fn mark_unsafe_vars_in_rule(&self, head: &Term, query: &mut CompiledQuery)
+    {
+        let mut unsafe_vars = HashMap::new();
+
+        self.record_unsafe_vars(&mut unsafe_vars);        
+        self.mark_head_vars_as_safe(head, &mut unsafe_vars);
+        self.mark_unsafe_vars(&mut unsafe_vars, query);
+    }
 }

diff --git a/src/prolog/heapview.rs b/src/prolog/heapview.rs
index b1a11e21ba6f501a8a3f682b54221e935eabdbc2..c11103db4ab23396d34c6326482d76013450870d 100644 (file)
--- a/src/prolog/heapview.rs
+++ b/src/prolog/heapview.rs
@@ -30,6 +30,7 @@ impl TToken {
 
 #[derive(Clone, Copy)]
 enum CellRef<'a> {
+    Lis(usize),
     View(CellView<'a>),
     Redirect(usize),
     TToken(TToken)
@@ -56,7 +57,9 @@ impl<'a> HeapCellViewer<'a> {
             match focus {
                 &Addr::Con(ref c) =>
                     return CellRef::View(CellView::Con(c)),
-                &Addr::Lis(hc) | &Addr::HeapCell(hc) | &Addr::Str(hc) =>
+                &Addr::Lis(hc) =>
+                    return CellRef::Lis(hc),
+                &Addr::HeapCell(hc) | &Addr::Str(hc) =>
                     return CellRef::Redirect(hc),
                 &Addr::StackCell(fr, sc) => {
                     match &self.and_stack[fr][sc] {
@@ -108,22 +111,25 @@ impl<'a> HeapCellViewer<'a> {
         }
     }
 
+    fn handle_list(&mut self, focus: usize) -> CellView<'a> {
+        self.state_stack.push(CellRef::TToken(TToken::RSBracket));
+
+        self.state_stack.push(CellRef::Redirect(focus + 1));
+        self.state_stack.push(CellRef::TToken(TToken::Bar));
+        self.state_stack.push(CellRef::Redirect(focus));
+
+        let len = self.state_stack.len() - 4;
+
+        return CellView::TToken(TToken::LSBracket(len));
+    }
+    
     fn from_heap(&mut self, mut focus: usize) -> CellView<'a> {
         loop {
             match &self.heap[focus] {
                 &HeapCellValue::Con(ref c) =>
                     return CellView::Con(c),
-                &HeapCellValue::Lis(a) => {
-                    self.state_stack.push(CellRef::TToken(TToken::RSBracket));
-
-                    self.state_stack.push(CellRef::Redirect(a + 1));
-                    self.state_stack.push(CellRef::TToken(TToken::Bar));
-                    self.state_stack.push(CellRef::Redirect(a));
-
-                    let len = self.state_stack.len() - 4;
-
-                    return CellView::TToken(TToken::LSBracket(len));
-                },
+                &HeapCellValue::Lis(a) =>
+                    return self.handle_list(a),                
                 &HeapCellValue::NamedStr(arity, ref name) => {
                     self.state_stack.push(CellRef::TToken(TToken::RRBracket));
 
@@ -146,6 +152,7 @@ impl<'a> HeapCellViewer<'a> {
                 },
                 &HeapCellValue::Ref(Ref::StackCell(fr, sc)) => {
                     match self.cell_ref_from_addr(&self.and_stack[fr][sc]) {
+                        CellRef::Lis(hc)         => return self.handle_list(hc),
                         CellRef::View(cell_view) => return cell_view,
                         CellRef::Redirect(hc)    => focus = hc,
                         CellRef::TToken(token)   => return CellView::TToken(token)
@@ -160,6 +167,8 @@ impl<'a> HeapCellViewer<'a> {
     fn follow(&mut self, cell_ref: CellRef<'a>) -> CellView<'a>
     {
         match cell_ref {
+            CellRef::Lis(hc) =>
+                self.handle_list(hc),
             CellRef::Redirect(hc) =>
                 self.from_heap(hc),
             CellRef::View(cell_view) =>

diff --git a/src/prolog/io.rs b/src/prolog/io.rs
index 9a3c82079a281be4df3d74309881d3e700ca30f3..37c872ba6a07e27838e815b75dda81100c6a48d6 100644 (file)
--- a/src/prolog/io.rs
+++ b/src/prolog/io.rs
@@ -1,6 +1,6 @@
 use prolog::ast::*;
 use prolog::codegen::*;
-use prolog::prolog_parser::*;
+use prolog::debray_allocator::*;
 use prolog::machine::*;
 
 use termion::raw::IntoRawMode;
@@ -257,13 +257,12 @@ pub fn read() -> String {
     result
 }
 
-pub fn eval(wam: &mut Machine, buffer: &str) -> EvalResult
+pub fn eval<'a, 'b: 'a>(wam: &'a mut Machine, tl: &'b TopLevel) -> EvalResult<'b>
 {
-    let result = parse_TopLevel(buffer);
-    let mut cg = CodeGenerator::new();
+    match tl {
+        &TopLevel::Predicate(ref clauses) => {
+            let mut cg = CodeGenerator::<DebrayAllocator>::new();
 
-    match &result {
-        &Ok(TopLevel::Predicate(ref clauses)) => {
             if is_consistent(clauses) {
                 let compiled_pred = cg.compile_predicate(clauses);
                 wam.add_predicate(clauses, compiled_pred);
@@ -277,30 +276,34 @@ Each predicate must have the same name and arity.";
                 EvalResult::EntryFailure
             }
         },
-        &Ok(TopLevel::Fact(ref fact)) => {
-            let compiled_fact = cg.compile_fact(&fact);
-            wam.add_fact(fact, compiled_fact);            
+        &TopLevel::Fact(ref fact) => {
+            let mut cg = CodeGenerator::<DebrayAllocator>::new();
+
+            let compiled_fact = cg.compile_fact(fact);
+            wam.add_fact(fact, compiled_fact);
+
             EvalResult::EntrySuccess
         },
-        &Ok(TopLevel::Rule(ref rule)) => {
-            let compiled_rule = cg.compile_rule(&rule);
-            wam.add_rule(rule, compiled_rule);            
+        &TopLevel::Rule(ref rule) => {
+            let mut cg = CodeGenerator::<DebrayAllocator>::new();
+
+            let compiled_rule = cg.compile_rule(rule);
+            wam.add_rule(rule, compiled_rule);
+
             EvalResult::EntrySuccess
         },
-        &Ok(TopLevel::Query(ref query)) => {
-            let compiled_query = cg.compile_query(&query);
-            wam.run_query(compiled_query, &cg)
-        },
-        &Err(_) => {
-            println!("Grammatical error of some kind!");
-            EvalResult::EntryFailure
+        &TopLevel::Query(ref query) => {
+            let mut cg = CodeGenerator::<DebrayAllocator>::new();
+
+            let compiled_query = cg.compile_query(query);
+            wam.submit_query(compiled_query, cg.take_vars())
         }
     }
 }
 
 pub fn print(wam: &mut Machine, result: EvalResult) {
     match result {
-        EvalResult::InitialQuerySuccess(heap_locs) => {
+        EvalResult::InitialQuerySuccess(alloc_locs, mut heap_locs) => {
             println!("yes");
 
             if heap_locs.is_empty() {
@@ -324,14 +327,14 @@ pub fn print(wam: &mut Machine, result: EvalResult) {
                     for c in stdin.keys() {
                         match c.unwrap() {
                             Key::Char(';') => {
-                                result = wam.continue_query();
+                                result = wam.continue_query(&alloc_locs, &mut heap_locs);
                                 break;
                             },
                             Key::Char('.') =>
                                 break 'outer,
                             _ => {}
                         }
-                    };
+                    }
 
                     if let &EvalResult::QueryFailure = &result {
                         write!(stdout, "no\n\r").unwrap();

diff --git a/src/prolog/iterators.rs b/src/prolog/iterators.rs
index b8ca6a3cb1fe52b5cd04cb365112582e7a08b6f8..d7d673656a892b89ed3de8752f1b7579092a14f6 100644 (file)
--- a/src/prolog/iterators.rs
+++ b/src/prolog/iterators.rs
@@ -230,7 +230,7 @@ impl<'a> ChunkedIterator<'a>
         }
     }
 
-    pub fn from_term_sequence(terms: &'a Vec<TermOrCut>) -> Self
+    pub fn from_term_sequence(terms: &'a [TermOrCut]) -> Self
     {
         let iter = terms.iter().map(|c| {
             match c {

diff --git a/src/prolog/machine.rs b/src/prolog/machine.rs
index 3abb42f9626c9cc6c9cff069b808ecfa59604f1f..4af0fdc43e8c7089b0a533ec81089402c23890f0 100644 (file)
--- a/src/prolog/machine.rs
+++ b/src/prolog/machine.rs
@@ -3,6 +3,7 @@ use prolog::codegen::*;
 use prolog::heapview::*;
 use prolog::and_stack::*;
 use prolog::or_stack::*;
+use prolog::fixtures::*;
 
 use std::collections::HashMap;
 use std::ops::{Index, IndexMut};
@@ -31,7 +32,7 @@ struct MachineState {
     registers: Registers,
     trail: Vec<Ref>,
     tr: usize,
-    hb: usize
+    hb: usize,
 }
 
 type CodeDir = HashMap<(Atom, usize), usize>;
@@ -39,7 +40,8 @@ type CodeDir = HashMap<(Atom, usize), usize>;
 pub struct Machine {
     ms: MachineState,
     code: Code,
-    code_dir: CodeDir
+    code_dir: CodeDir,
+    cached_query: Option<Code>
 }
 
 impl Index<RegType> for MachineState {
@@ -68,12 +70,29 @@ impl IndexMut<RegType> for MachineState {
     }
 }
 
+impl Index<CodePtr> for Machine {
+    type Output = Line;
+
+    fn index(&self, ptr: CodePtr) -> &Self::Output {
+        match ptr {
+            CodePtr::TopLevel(_, _, p) => {
+                match &self.cached_query {
+                    &Some(ref cq) => &cq[p],
+                    &None => panic!("Out-of-bounds top level index.")
+                }
+            },
+            CodePtr::DirEntry(p) => &self.code[p]
+        }
+    }
+}
+
 impl Machine {
     pub fn new() -> Self {
         Machine {
             ms: MachineState::new(),
             code: Vec::new(),
-            code_dir: HashMap::new()
+            code_dir: HashMap::new(),
+            cached_query: None
         }
     }
 
@@ -84,105 +103,239 @@ impl Machine {
     pub fn add_fact(&mut self, fact: &Term, mut code: Code) {
         if let Some(name) = fact.name() {
             let p = self.code.len();
+
+            let name  = name.clone();
             let arity = fact.arity();
 
             self.code.append(&mut code);
-            self.code_dir.insert((name.clone(), arity), p);
+            self.code_dir.insert((name, arity), p);
         }
     }
 
     pub fn add_rule(&mut self, rule: &Rule, mut code: Code) {
         if let Some(name) = rule.head.0.name() {
             let p = self.code.len();
+
+            let name  = name.clone();
             let arity = rule.head.0.arity();
 
             self.code.append(&mut code);
-            self.code_dir.insert((name.clone(), arity), p);
+            self.code_dir.insert((name, arity), p);
         }
     }
 
-    pub fn add_predicate(&mut self, pred: &Vec<PredicateClause>, mut code: Code)
+    pub fn add_predicate(&mut self, clauses: &Vec<PredicateClause>, mut code: Code)
     {
         let p = self.code.len();
-        let name  = pred.first().unwrap().name().clone();
-        let arity = pred.first().unwrap().arity();
+
+        let arity = clauses.first().unwrap().arity();
+        let name  = clauses.first().unwrap().name().clone();
 
         self.code.append(&mut code);
         self.code_dir.insert((name, arity), p);
     }
 
-    fn execute_instr<'a>(&mut self, instr_src: LineOrCodeOffset<'a>) -> bool
+    fn cached_query_size(&self) -> usize {
+        match &self.cached_query {
+            &Some(ref query) => query.len(),
+            _ => 0
+        }
+    }
+
+    fn execute_instr(&mut self, ptr: CodePtr)
     {
-        let mut instr = match instr_src {
-            LineOrCodeOffset::Instruction(instr) => instr,
-            LineOrCodeOffset::Offset(p) => &self.code[p]
+        // can't use self[ptr] or self.index(ptr) to set the value of
+        // instr! instr is then typed as Line, not &Line. WHY????
+        // This is a compiler bug. Has to be.
+        let instr = match ptr {
+            CodePtr::TopLevel(_, _, p) => {
+                match &self.cached_query {
+                    &Some(ref cq) => &cq[p],
+                    &None => return
+                }
+            },
+            CodePtr::DirEntry(p) => &self.code[p]
         };
 
-        loop {
-            match instr {
-                &Line::Choice(ref choice_instr) =>
-                    self.ms.execute_choice_instr(choice_instr),
-                &Line::Cut(ref cut_instr) =>
-                    self.ms.execute_cut_instr(cut_instr),
-                &Line::Control(ref control_instr) =>
-                    self.ms.execute_ctrl_instr(&self.code_dir, control_instr),
-                &Line::Fact(ref fact) => {
-                    for fact_instr in fact {
-                        if self.failed() {
-                            break;
-                        }
-
-                        self.ms.execute_fact_instr(&fact_instr);
+        match instr {
+            &Line::Choice(ref choice_instr) =>
+                self.ms.execute_choice_instr(choice_instr),
+            &Line::Cut(ref cut_instr) =>
+                self.ms.execute_cut_instr(cut_instr),
+            &Line::Control(ref control_instr) =>
+                self.ms.execute_ctrl_instr(&self.code_dir, control_instr),
+            &Line::Fact(ref fact) => {
+                for fact_instr in fact {
+                    if self.failed() {
+                        break;
                     }
-                    self.ms.p += 1;
-                },
-                &Line::Indexing(ref indexing_instr) =>
-                    self.ms.execute_indexing_instr(&indexing_instr),
-                &Line::IndexedChoice(ref choice_instr) =>
-                    self.ms.execute_indexed_choice_instr(choice_instr),
-                &Line::Query(ref query) => {
-                    for query_instr in query {
-                        if self.failed() {
-                            break;
-                        }
 
-                        self.ms.execute_query_instr(&query_instr);
+                    self.ms.execute_fact_instr(&fact_instr);
+                }
+                self.ms.p += 1;
+            },
+            &Line::Indexing(ref indexing_instr) =>
+                self.ms.execute_indexing_instr(&indexing_instr),
+            &Line::IndexedChoice(ref choice_instr) =>
+                self.ms.execute_indexed_choice_instr(choice_instr),
+            &Line::Query(ref query) => {
+                for query_instr in query {
+                    if self.failed() {
+                        break;
                     }
-                    self.ms.p += 1;
+
+                    self.ms.execute_query_instr(&query_instr);
                 }
+                self.ms.p += 1;
             }
+        }
+    }
 
-            if self.failed() {
-                let b0 = self.ms
-                    .or_stack
-                    .top()
-                    .map(|fr| fr.b0)
-                    .unwrap_or(0);
-                
-                let p = if self.ms.b > 0 {
-                    let b = self.ms.b - 1;
-                    self.ms.or_stack[b].bp
-                } else {
-                    CodePtr::TopLevel
-                };
+    fn backtrack(&mut self)
+    {
+        let b0 = self.ms
+            .or_stack
+            .top()
+            .map(|fr| fr.b0)
+            .unwrap_or(0);
 
-                if let CodePtr::TopLevel = p {
-                    return false;
-                } else {
-                    self.ms.fail = false;
-                    self.ms.p = p;
-                    self.ms.b0 = b0;
-                }
+        let p = if self.ms.b > 0 {
+            let b = self.ms.b - 1;
+            self.ms.or_stack[b].bp
+        } else {
+            self.ms.p = CodePtr::TopLevel(0, 0, 0);
+            return;
+        };
+
+        self.ms.p = p;
+
+        if let CodePtr::TopLevel(_, _, p) = p {
+            self.ms.fail = p == 0;
+            self.ms.b0 = b0;
+
+            return;
+        } else {
+            self.ms.fail = false;
+        }
+    }
+
+    fn query_stepper<'a>(&mut self, mut ptr: CodePtr)
+    {
+        loop
+        {
+            self.execute_instr(ptr);
+
+            if self.failed() {
+                self.backtrack();
             }
 
             match self.ms.p {
                 CodePtr::DirEntry(p) if p < self.code.len() =>
-                    instr = &self.code[p],
+                    ptr = self.ms.p,
                 _ => break
+            };
+        }
+    }
+
+    fn record_var_places<'a>(&self,
+                             chunk_num: usize,
+                             e: usize,
+                             alloc_locs: &AllocVarDict<'a>,
+                             heap_locs: &mut HeapVarDict<'a>)
+    {
+        for (var, var_data) in alloc_locs {
+            match var_data {
+                &VarData::Perm(_) => {
+                    let r = var_data.as_reg_type().reg_num();
+                    let addr = self.ms.and_stack[e][r].clone();
+
+                    heap_locs.insert(var, addr);
+                },
+                &VarData::Temp(cn, _, _) if cn == chunk_num => {
+                    let r = var_data.as_reg_type();
+                    let addr = self.ms[r].clone();
+
+                    heap_locs.insert(var, addr);
+                },
+                _ => {}
             }
         }
+    }
+
+    fn run_query<'a>(&mut self, alloc_locs: &AllocVarDict<'a>, heap_locs: &mut HeapVarDict<'a>)
+    {
+        let end_ptr    = CodePtr::TopLevel(0, 0, self.cached_query_size());
+        let mut tl_ptr = self.ms.p;
+
+        while tl_ptr < end_ptr {
+            self.query_stepper(tl_ptr);
+
+            tl_ptr = self.ms.p;
+
+            if let &mut CodePtr::TopLevel(ref mut cn, ref mut e, p) = &mut tl_ptr {
+                if p == 0 {
+                    break;
+                }
+
+                match &self[CodePtr::TopLevel(*cn, *e, p)] {
+                    &Line::Control(ControlInstruction::Call(_, _, _))
+                  | &Line::Control(ControlInstruction::Execute(_, _)) => {
+                      self.record_var_places(*cn, *e, alloc_locs, heap_locs);
+                      *cn += 1;
+                  },
+                    &Line::Control(ControlInstruction::Allocate(_)) =>
+                        *e = self.ms.e,
+                    _ => {}
+                };
+
+                self.ms.p = CodePtr::TopLevel(*cn, *e, p);
+            } else {
+                break;
+            }
+        }
+    }
+
+    pub fn submit_query<'a>(&mut self, code: Code, alloc_locs: AllocVarDict<'a>) -> EvalResult<'a>
+    {
+        let mut heap_locs = HashMap::new();
+        self.cached_query = Some(code);
+
+        self.run_query(&alloc_locs, &mut heap_locs);
+
+        if self.failed() {
+            EvalResult::QueryFailure
+        } else {
+            EvalResult::InitialQuerySuccess(alloc_locs, heap_locs)
+        }
+    }
+
+    pub fn continue_query<'a>(&mut self,
+                              alloc_locs: &AllocVarDict<'a>,
+                              heap_locs: &mut HeapVarDict<'a>)
+                              -> EvalResult
+    {
+        if !self.or_stack_is_empty() {
+            if self.ms.b == 0 {
+                return EvalResult::QueryFailure;
+            }
+
+            let b = self.ms.b - 1;
+            self.ms.p = self.ms.or_stack[b].bp;
 
-        true
+            if let CodePtr::TopLevel(_, _, 0) = self.ms.p {
+                return EvalResult::QueryFailure
+            }
+
+            self.run_query(alloc_locs, heap_locs);
+
+            if self.failed() {
+                EvalResult::QueryFailure
+            } else {
+                EvalResult::SubsequentQuerySuccess
+            }
+        } else {
+            EvalResult::QueryFailure
+        }
     }
 
     pub fn heap_view(&self, var_dir: &HeapVarDict) -> String {
@@ -241,75 +394,16 @@ impl Machine {
         result
     }
 
-    pub fn run_query(&mut self, code: Code, cg: &CodeGenerator) -> EvalResult
-    {
-        let mut succeeded = true;
-        let mut heap_locs = HashMap::new();
-
-        for instr in code.iter().take(1) {
-            succeeded = self.execute_instr(LineOrCodeOffset::from(instr));
-        }
-
-        if succeeded {
-            for (var, var_data) in cg.vars() {
-                let r = var_data.as_reg_type();
-                
-                let addr = self.ms[r].clone();
-                heap_locs.insert((*var).clone(), addr);
-            }
-
-            for instr in code.iter().skip(1) {
-                succeeded = self.execute_instr(LineOrCodeOffset::from(instr));
-                if !succeeded {
-                    break;
-                }
-            }
-        }
-
-        if succeeded {
-            EvalResult::InitialQuerySuccess(heap_locs)
-        } else {
-            EvalResult::QueryFailure
-        }
-    }
-
     pub fn or_stack_is_empty(&self) -> bool {
         self.ms.or_stack.is_empty()
     }
 
-    pub fn continue_query(&mut self) -> EvalResult
-    {
-        if !self.or_stack_is_empty() {
-            if self.ms.b == 0 {
-                return EvalResult::QueryFailure;
-            }
-
-            let b = self.ms.b - 1;
-            self.ms.p = self.ms.or_stack[b].bp;
-
-            let succeeded = if let CodePtr::DirEntry(p) = self.ms.p {
-                self.execute_instr(LineOrCodeOffset::Offset(p))
-            } else {
-                false
-            };
-
-            if succeeded {
-                EvalResult::SubsequentQuerySuccess
-            } else {
-                EvalResult::QueryFailure
-            }
-        } else {
-            EvalResult::QueryFailure
-        }
-    }
-
-    #[allow(dead_code)]
     pub fn clear(&mut self) {
         self.reset();
         self.code.clear();
         self.code_dir.clear();
     }
-    
+
     pub fn reset(&mut self) {
         self.ms.reset();
     }
@@ -319,12 +413,12 @@ impl MachineState {
     fn new() -> MachineState {
         MachineState { h: 0,
                        s: 0,
-                       p: CodePtr::TopLevel,
+                       p: CodePtr::default(),
                        b: 0,
                        b0: 0,
                        e: 0,
                        num_of_args: 0,
-                       cp: CodePtr::TopLevel,
+                       cp: CodePtr::default(),
                        fail: false,
                        heap: Vec::with_capacity(256),
                        mode: MachineMode::Write,
@@ -815,7 +909,7 @@ impl MachineState {
                 match norm {
                     RegType::Perm(n) => {
                         let e = self.e;
-                        
+
                         self[norm] = Addr::StackCell(e, n);
                         self.registers[arg] = self[norm].clone();
                     },
@@ -1112,7 +1206,7 @@ impl MachineState {
                 }
 
                 if let &Terminal::Terminal = term {
-                    self.p = CodePtr::TopLevel;
+                    self.p = CodePtr::default();
                 } else {
                     self.p += 1;
                 }
@@ -1132,9 +1226,9 @@ impl MachineState {
                     self.b = b0;
                     self.tidy_trail();
                 }
-                
+
                 if let &Terminal::Terminal = term {
-                    self.p = CodePtr::TopLevel;
+                    self.p = CodePtr::default();
                 } else {
                     self.p += 1;
                 }
@@ -1150,8 +1244,8 @@ impl MachineState {
         self.b0 = 0;
         self.s = 0;
         self.tr = 0;
-        self.p = CodePtr::TopLevel;
-        self.cp = CodePtr::TopLevel;
+        self.p = CodePtr::default();
+        self.cp = CodePtr::default();
         self.num_of_args = 0;
 
         self.fail = false;
@@ -1161,5 +1255,5 @@ impl MachineState {
         self.and_stack.clear();
         self.or_stack.clear();
         self.registers = vec![Addr::HeapCell(0); 64];
-    }    
+    }
 }

diff --git a/src/prolog/mod.rs b/src/prolog/mod.rs
index dd2d771eb31e9b70666209767309904a21343c3a..98634a7d33e334266a1e3870dee045a1ce3f539e 100644 (file)
--- a/src/prolog/mod.rs
+++ b/src/prolog/mod.rs
@@ -1,3 +1,4 @@
+pub mod allocator;
 pub mod and_stack;
 pub mod ast;
 pub mod codegen;
@@ -7,6 +8,7 @@ pub mod heapview;
 pub mod indexing;
 pub mod io;
 pub mod iterators;
+pub mod naive_allocator;
 pub mod prolog_parser;
 pub mod machine;
 pub mod or_stack;

diff --git a/src/prolog/naive_allocator.rs b/src/prolog/naive_allocator.rs
index aefdfd72b9426b35b667dfbe16741e1ec1cefa4e..21c2c674551b7f77d5fee6f44447cd0f425eea27 100644 (file)
--- a/src/prolog/naive_allocator.rs
+++ b/src/prolog/naive_allocator.rs
@@ -1,163 +1,157 @@
+use prolog::allocator::*;
 use prolog::ast::*;
 use prolog::fixtures::*;
+use prolog::targets::*;
 
 use std::cell::Cell;
 use std::cmp::max;
-use std::collections::{BTreeSet, HashMap};
+use std::collections::HashMap;
 
-pub struct TermMarker<'a> {    
-    pub bindings: HashMap<&'a Var, VarData>,
+pub struct NaiveAllocator<'a> {    
+    bindings: AllocVarDict<'a>,
     arg_c:    usize,
     temp_c:   usize,
-    contents: HashMap<usize, &'a Var>,
-    in_use:   BTreeSet<usize>,
 }
-
-impl<'a> TermMarker<'a> {
-    pub fn new() -> TermMarker<'a> {
-        TermMarker {
+    
+impl<'a> Allocator<'a> for NaiveAllocator<'a>
+{
+    fn new() -> Self {
+        NaiveAllocator {
             arg_c:    1,
             temp_c:   1,
             bindings: HashMap::new(),
-            contents: HashMap::new(),
-            in_use: BTreeSet::new()
         }
     }
-
-    pub fn drain_var_data(&mut self, vs: VariableFixtures<'a>) -> VariableFixtures<'a>
+    
+    fn mark_anon_var<Target>(&mut self, lvl: Level, target: &mut Vec<Target>)
+        where Target: CompilationTarget<'a>
     {
-        let mut perm_vs = VariableFixtures::new();
-
-        for (var, (var_status, cells)) in vs.into_iter() {
-            match var_status {
-                VarStatus::Temp(chunk_num, tvd) => {
-                    self.bindings.insert(var, VarData::Temp(chunk_num, 0, tvd));
-                },
-                VarStatus::Perm(_) => {
-                    self.bindings.insert(var, VarData::Perm(0));
-                    perm_vs.insert(var, (var_status, cells));
-                }
-            };
-        }
-
-        perm_vs
-    }
-
-    fn get(&self, var: &'a Var) -> RegType {
-        self.bindings.get(var).unwrap().as_reg_type()
-    }
-
-    pub fn contains_var(&self, var: &'a Var) -> bool {
-        self.bindings.contains_key(var)
-    }
+        let r = {
+            let temp = self.temp_c;
+            self.temp_c += 1;
+            RegType::Temp(temp)
+        };
 
-    pub fn marked_var(&self, var: &'a Var) -> bool {
-        self.get(var).reg_num() != 0
-    }
+        match lvl {
+            Level::Deep => target.push(Target::subterm_to_variable(r)),
+            Level::Shallow => {
+                let k = self.arg_c;
+                self.arg_c += 1;
 
-    fn record_register(&mut self, var: &'a Var, r: RegType) {
-        match self.bindings.get_mut(var).unwrap() {
-            &mut VarData::Temp(_, ref mut s, _) => *s = r.reg_num(),
-            &mut VarData::Perm(ref mut s) => *s = r.reg_num()
+                target.push(Target::argument_to_variable(r, k));
+            }
         }
     }
 
-    pub fn mark_non_var(&mut self, lvl: Level, cell: &Cell<RegType>) {
-        let reg_type = cell.get();
+    fn mark_non_var<Target>(&mut self,
+                            lvl: Level,
+                            _: GenContext,
+                            cell: &Cell<RegType>,
+                            _: &mut Vec<Target>)
+        where Target: CompilationTarget<'a>
+    {
+        let r = cell.get();
 
-        if reg_type.reg_num() == 0 {
-            match lvl {
-                Level::Deep if !reg_type.is_perm() => {
-                    let temp = self.temp_c;
-                    self.temp_c += 1;
-                    cell.set(RegType::Temp(temp));
-                },
-                Level::Shallow if !reg_type.is_perm() => {
-                    let arg = self.arg_c;
+        if r.reg_num() == 0 {
+            let r = match lvl {                
+                Level::Shallow => {
+                    let k = self.arg_c;
                     self.arg_c += 1;
-                    cell.set(RegType::Temp(arg));
+                    
+                    RegType::Temp(k)
                 },
-                _ => {}
+                _ => {
+                    let temp = self.temp_c;
+                    self.temp_c += 1;
+                    
+                    RegType::Temp(temp)
+                }
             };
-        }
-    }
-
-    pub fn mark_old_var(&mut self, lvl: Level, var: &'a Var) -> VarReg
-    {
-        let inner_reg = self.get(var);
 
-        match lvl {
-            Level::Deep => VarReg::Norm(inner_reg),
-            Level::Shallow => {
-                let reg = VarReg::ArgAndNorm(inner_reg, self.arg_c);
-                self.arg_c += 1;
-                reg
-            }
+            cell.set(r);
         }
-    }
-
-    pub fn mark_new_var(&mut self, lvl: Level, var: &'a Var, reg: RegType) -> VarReg
+    }    
+
+    fn mark_var<Target>(&mut self,
+                        var: &'a Var,
+                        lvl: Level,
+                        cell: &'a Cell<VarReg>,
+                        _: GenContext,
+                        target: &mut Vec<Target>)
+        where Target: CompilationTarget<'a>
     {
-        let inner_reg = if !reg.is_perm() {
-            let temp = self.temp_c;
-            self.temp_c += 1;
-            RegType::Temp(temp)
-        } else {
-            reg
+        let (r, is_new_var) = match self.get(var) {
+            RegType::Temp(0) => {
+                let o = self.temp_c;
+                self.temp_c += 1;
+                
+                (RegType::Temp(o), true)
+            },
+            RegType::Perm(0) => {
+                let pr = cell.get().norm();
+                self.record_register(var, pr);
+                
+                (pr, true)
+            },
+            r => (r, false)
         };
-
-        let reg = match lvl {
-            Level::Deep => VarReg::Norm(inner_reg),
+        
+        match lvl {            
             Level::Shallow => {
-                let reg = VarReg::ArgAndNorm(inner_reg, self.arg_c);
-                self.arg_c += 1;
-                reg
+                let k = self.arg_c;                
+                self.arg_c += 1;                               
+
+                cell.set(VarReg::ArgAndNorm(r, k));
+                
+                if is_new_var {
+                    target.push(Target::argument_to_variable(r, k));
+                } else {
+                    target.push(Target::argument_to_value(r, k));
+                }                
+            },
+            Level::Deep => {
+                cell.set(VarReg::Norm(r));
+
+                if is_new_var {
+                    target.push(Target::subterm_to_variable(r));
+                } else {
+                    target.push(Target::subterm_to_value(r));
+                }
             }
         };
 
-        self.record_register(var, inner_reg);
-        reg
+        if !r.is_perm() {
+            self.record_register(var, r);
+        }
     }
-
-    pub fn mark_anon_var(&mut self, lvl: Level) -> VarReg {
-        let inner_reg = {
-            let temp = self.temp_c;
-            self.temp_c += 1;
-            RegType::Temp(temp)
-        };
-
-        match lvl {
-            Level::Deep => VarReg::Norm(inner_reg),
-            Level::Shallow => {
-                let reg = VarReg::ArgAndNorm(inner_reg, self.arg_c);
-                self.arg_c += 1;
-                reg
-            }
+    
+    fn reset(&mut self) {
+        self.bindings.clear();
+    }
+    
+    fn advance(&mut self, term_loc: GenContext, term: &'a Term) {
+        if let GenContext::Head = term_loc {
+            self.arg_c  = 1;
+            self.temp_c = max(term.subterms() + 1, self.temp_c);
+        } else {
+            self.arg_c  = 1;
+            self.temp_c = term.subterms() + 1;
         }
     }
 
-    pub fn advance_arg(&mut self) {
+    fn advance_arg(&mut self) {
         self.arg_c += 1;
     }
 
-    pub fn advance_at_head(&mut self, term: &'a Term) {
-        self.arg_c  = 1;
-        self.temp_c = max(term.subterms() + 1, self.temp_c);
-    }
-
-    pub fn advance(&mut self, term: &'a Term) {
-        self.arg_c  = 1;
-        self.temp_c = term.subterms() + 1;
+    fn bindings(&self) -> &AllocVarDict<'a> {
+        &self.bindings
     }
-
-    pub fn reset(&mut self) {
-        self.bindings.clear();
-        self.contents.clear();
-        self.in_use.clear();
+    
+    fn bindings_mut(&mut self) -> &mut AllocVarDict<'a> {
+        &mut self.bindings
     }
-
-    pub fn reset_contents(&mut self) {
-        self.contents.clear();
-        self.in_use.clear();
+    
+    fn take_bindings(self) -> AllocVarDict<'a> {
+        self.bindings
     }
 }

diff --git a/src/prolog/prolog_parser.lalrpop b/src/prolog/prolog_parser.lalrpop
index fc0d6ffbd30bb2fa3e3e6cf82cfc1be83656cf5e..12a59ce54db5b728175588215bdcac8c6a89caee 100644 (file)
--- a/src/prolog/prolog_parser.lalrpop
+++ b/src/prolog/prolog_parser.lalrpop
@@ -5,7 +5,7 @@ use std::cell::Cell;
 grammar;
 
 pub TopLevel: TopLevel = {
-    "?-" <t:Term> "." => TopLevel::Query(t),
+    "?-" <q:Query> "." => TopLevel::Query(q),
     <Predicate> => TopLevel::Predicate(<>),
     <Rule>  "." => TopLevel::Rule(<>),
     <Term>  "." => TopLevel::Fact(<>)
@@ -56,6 +56,14 @@ PredicateClause : PredicateClause = {
     <Term> "." => PredicateClause::Fact(<>)
 };
 
+Query : Vec<TermOrCut> = {
+    <tcs: (<TermOrCut> ",")*> <tc: TermOrCut> => {
+        let mut tcs = tcs;
+        tcs.push(tc);
+        tcs
+    }        
+};
+
 Rule : Rule = {
     <c:Clause> ":-" <h:TermOrCut> <cs: ("," <TermOrCut>)*> =>
         Rule { head: (c, h), clauses: cs },

diff --git a/src/prolog/prolog_parser.rs b/src/prolog/prolog_parser.rs
index 39cc865c3df44a2739f094f4091b11867f5bd5b9..c3909323a8d7a05d63639d10cd0c9ce5edf93526 100644 (file)
--- a/src/prolog/prolog_parser.rs
+++ b/src/prolog/prolog_parser.rs
@@ -33,6 +33,9 @@ mod __parse__TopLevel {
         Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2b(::std::vec::Vec<Box<Term>>),
         Nt_28_3cPredicateClause_3e_29(PredicateClause),
         Nt_28_3cPredicateClause_3e_29_2b(::std::vec::Vec<PredicateClause>),
+        Nt_28_3cTermOrCut_3e_20_22_2c_22_29(TermOrCut),
+        Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2a(::std::vec::Vec<TermOrCut>),
+        Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b(::std::vec::Vec<TermOrCut>),
         NtAtom(Atom),
         NtBoxedTerm(Box<Term>),
         NtClause(Term),
@@ -40,6 +43,7 @@ mod __parse__TopLevel {
         NtListInternals(Term),
         NtPredicate(Vec<PredicateClause>),
         NtPredicateClause(PredicateClause),
+        NtQuery(Vec<TermOrCut>),
         NtRule(Rule),
         NtTerm(Term),
         NtTermOrCut(TermOrCut),
@@ -53,11 +57,11 @@ mod __parse__TopLevel {
         // State 1
         0, 0, 0, 0, 0, 0, 0, 13, 14, 0, 15, 0, 16, 17, 0,
         // State 2
-        0, 21, 0, 0, -30, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 21, 0, 0, -37, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 3
-        0, 0, 0, 0, -31, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, -38, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 4
-        0, 0, 0, 0, -32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 5
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 6
@@ -69,251 +73,243 @@ mod __parse__TopLevel {
         // State 9
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 10
-        0, 0, 0, 0, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 11
-        0, 0, 0, 0, 0, 0, 0, 13, 14, 0, 15, 0, 16, 29, 0,
+        34, 0, 0, 0, 0, 0, 0, 35, 36, 0, 37, 0, 38, 39, 0,
         // State 12
-        0, 0, 0, 0, 0, 0, 0, 37, 38, 0, 39, 0, 40, 41, 0,
+        0, 0, 0, 0, 0, 0, 0, 47, 48, 0, 49, 0, 50, 51, 0,
         // State 13
-        0, 0, 0, 0, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 14
-        0, 0, 0, 0, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 15
         0, 0, 0, 0, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 15
+        0, 0, 0, 0, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 16
-        0, -14, 0, 0, -14, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, -19, 0, 0, -19, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 17
         0, 0, 0, 0, 0, 0, 0, -13, -13, 0, -13, 0, -13, -13, 0,
         // State 18
-        0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 19
-        0, 0, 0, 0, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 20
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 21
-        62, 0, 0, 0, 0, 0, 0, 63, 64, 0, 65, 0, 66, 67, 0,
+        34, 0, 0, 0, 0, 0, 0, 35, 36, 0, 37, 0, 38, 39, 0,
         // State 22
-        62, 0, 0, 0, 0, 0, 0, 63, 64, 0, 65, 0, 66, 67, 0,
+        34, 0, 0, 0, 0, 0, 0, 35, 36, 0, 37, 0, 38, 39, 0,
         // State 23
-        0, 0, 0, 0, 0, 0, 0, -24, -24, 0, -24, 0, -24, -24, 0,
+        0, 0, 0, 0, 0, 0, 0, -29, -29, 0, -29, 0, -29, -29, 0,
         // State 24
-        0, 0, 0, 0, 0, 0, 0, -25, -25, 0, -25, 0, -25, -25, 0,
+        0, 0, 0, 0, 0, 0, 0, -30, -30, 0, -30, 0, -30, -30, 0,
         // State 25
-        0, 69, 0, 0, -30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        34, 0, 0, 0, 0, 0, 0, 35, 36, 0, 37, 0, 38, 39, 0,
         // State 26
-        0, 0, 0, 0, -31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 69, 0, -37, -37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 27
-        0, 0, 0, 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -38, -38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 28
-        0, -14, 0, 0, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -39, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 29
-        0, 71, 0, -30, 0, 0, 0, 0, 0, -30, 0, -30, 0, 0, 0,
+        0, 0, 0, 0, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 30
-        0, 0, 0, 72, 0, 0, 0, 0, 0, -20, 0, 73, 0, 0, 0,
+        0, 0, 0, -43, -43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 31
-        0, 0, 0, -31, 0, 0, 0, 0, 0, -31, 0, -31, 0, 0, 0,
+        0, 0, 0, 71, -31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 32
-        0, 0, 0, -32, 0, 0, 0, 0, 0, -32, 0, -32, 0, 0, 0,
+        0, 0, 0, -40, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 33
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 0, 0, 0, 0, 0,
+        0, 0, 0, -42, -42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 34
-        0, 0, 0, -15, 0, 0, 0, 0, 0, -15, 0, -15, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 47, 48, 0, 49, 0, 50, 51, 0,
         // State 35
-        0, 0, 0, -33, 0, 0, 0, 0, 0, -33, 0, -33, 0, 0, 0,
+        0, 0, 0, -23, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 36
-        0, 0, 0, 0, 0, 0, 0, 37, 38, 0, 39, 0, 40, 41, 0,
+        0, 0, 0, -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 37
-        0, 0, 0, -18, 0, 0, 0, 0, 0, -18, 0, -18, 0, 0, 0,
+        0, 0, 0, -48, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 38
-        0, 0, 0, -34, 0, 0, 0, 0, 0, -34, 0, -34, 0, 0, 0,
+        0, -19, 0, -19, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 39
-        0, 0, 0, -41, 0, 0, 0, 0, 0, -41, 0, -41, 0, 0, 0,
+        0, 73, 0, -37, 0, 0, 0, 0, 0, -37, 0, -37, 0, 0, 0,
         // State 40
-        0, -14, 0, -14, 0, 0, 0, 0, 0, -14, 0, -14, 0, 0, 0,
+        0, 0, 0, 74, 0, 0, 0, 0, 0, -25, 0, 75, 0, 0, 0,
         // State 41
-        0, 0, 0, 0, 0, 0, 0, -24, -24, 0, -24, 0, -24, -24, 0,
+        0, 0, 0, -38, 0, 0, 0, 0, 0, -38, 0, -38, 0, 0, 0,
         // State 42
-        0, 0, 0, 0, 0, 0, 0, -25, -25, 0, -25, 0, -25, -25, 0,
+        0, 0, 0, -39, 0, 0, 0, 0, 0, -39, 0, -39, 0, 0, 0,
         // State 43
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 76, 0, 0, 0, 0, 0,
         // State 44
-        0, 77, -30, -30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -20, 0, 0, 0, 0, 0, -20, 0, -20, 0, 0, 0,
         // State 45
-        0, 0, 78, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -40, 0, 0, 0, 0, 0, -40, 0, -40, 0, 0, 0,
         // State 46
-        0, 0, -31, -31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 47, 48, 0, 49, 0, 50, 51, 0,
         // State 47
-        0, 0, -32, -32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -23, 0, 0, 0, 0, 0, -23, 0, -23, 0, 0, 0,
         // State 48
-        0, 0, -15, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -41, 0, 0, 0, 0, 0, -41, 0, -41, 0, 0, 0,
         // State 49
-        0, 0, -33, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -48, 0, 0, 0, 0, 0, -48, 0, -48, 0, 0, 0,
         // State 50
-        0, 0, 0, 0, 0, 0, 0, 37, 38, 0, 39, 0, 40, 41, 0,
+        0, -19, 0, -19, 0, 0, 0, 0, 0, -19, 0, -19, 0, 0, 0,
         // State 51
-        0, 0, -18, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, -29, -29, 0, -29, 0, -29, -29, 0,
         // State 52
-        0, 0, -34, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, -30, -30, 0, -30, 0, -30, -30, 0,
         // State 53
-        0, 0, -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 54
-        0, -14, -14, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 79, -37, -37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 55
-        0, 81, 0, -30, -30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 80, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 56
-        0, 0, 0, -31, -31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -38, -38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 57
-        0, 0, 0, -32, -32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -39, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 58
-        0, 0, 0, -36, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -20, -20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 59
-        0, 0, 0, 83, -28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -40, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 60
-        0, 0, 0, -33, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 47, 48, 0, 49, 0, 50, 51, 0,
         // State 61
-        0, 0, 0, -35, -35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -23, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 62
-        0, 0, 0, 0, 0, 0, 0, 37, 38, 0, 39, 0, 40, 41, 0,
+        0, 0, -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 63
-        0, 0, 0, -18, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -48, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 64
-        0, 0, 0, -34, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, -19, -19, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 65
-        0, 0, 0, -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 84, -35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 66
-        0, -14, 0, -14, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 84, -33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 67
-        0, 0, 0, 83, -26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 86, -32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 68
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 69
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 70
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        -17, 0, 0, 0, 0, 0, 0, -17, -17, 0, -17, 0, -17, -17, 0,
         // State 71
-        0, 0, 0, 0, 0, 0, 0, 37, 38, 0, 39, 0, 40, 41, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 0,
         // State 72
-        0, 0, 0, 0, 0, 0, 0, 97, 98, 0, 99, 0, 100, 101, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 73
-        0, 0, 0, 0, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 47, 48, 0, 49, 0, 50, 51, 0,
         // State 74
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 102, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 99, 100, 0, 101, 0, 102, 103, 0,
         // State 75
-        0, 0, 103, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 76
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 104, 0, 0, 0, 0, 0,
         // State 77
-        0, 0, 0, 0, -16, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 105, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 78
-        0, 0, 0, 0, 0, 0, 0, -9, -9, 0, -9, 0, -9, -9, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 79
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 107, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, -21, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 80
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 0, 0, 0, 0, 0, -9, -9, 0, -9, 0, -9, -9, 0,
         // State 81
-        0, 0, 0, 110, -29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 0, 0, 0, 0, 0,
         // State 82
-        62, 0, 0, 0, 0, 0, 0, 63, 64, 0, 65, 0, 66, 67, 0,
+        0, 0, 0, 110, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 83
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0,
+        34, 0, 0, 0, 0, 0, 0, 35, 36, 0, 37, 0, 38, 39, 0,
         // State 84
-        0, 0, 0, 110, -27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 110, -34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 85
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        -18, 0, 0, 0, 0, 0, 0, -18, -18, 0, -18, 0, -18, -18, 0,
         // State 86
-        0, 0, 114, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 87
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 113, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 88
-        0, 0, 116, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -24, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 89
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -21, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 90
-        0, 117, 0, 0, 0, 0, 0, 0, 0, -30, 0, 0, 0, 0, 0,
+        0, 0, 115, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 91
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -22, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -26, 0, 0, 0, 0, 0,
         // State 92
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -31, 0, 0, 0, 0, 0,
+        0, 116, 0, 0, 0, 0, 0, 0, 0, -37, 0, 0, 0, 0, 0,
         // State 93
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -32, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -27, 0, 0, 0, 0, 0,
         // State 94
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -15, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -38, 0, 0, 0, 0, 0,
         // State 95
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -33, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -39, 0, 0, 0, 0, 0,
         // State 96
-        0, 0, 0, 0, 0, 0, 0, 37, 38, 0, 39, 0, 40, 41, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -20, 0, 0, 0, 0, 0,
         // State 97
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -18, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -40, 0, 0, 0, 0, 0,
         // State 98
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -34, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 47, 48, 0, 49, 0, 50, 51, 0,
         // State 99
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -41, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -23, 0, 0, 0, 0, 0,
         // State 100
-        0, -14, 0, 0, 0, 0, 0, 0, 0, -14, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -41, 0, 0, 0, 0, 0,
         // State 101
-        0, 0, 0, -19, 0, 0, 0, 0, 0, -19, 0, -19, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -48, 0, 0, 0, 0, 0,
         // State 102
-        0, 0, 0, 0, -17, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, -19, 0, 0, 0, 0, 0, 0, 0, -19, 0, 0, 0, 0, 0,
         // State 103
-        0, 0, 0, 0, 0, 0, 0, -10, -10, 0, -10, 0, -10, -10, 0,
+        0, 0, 0, -24, 0, 0, 0, 0, 0, -24, 0, -24, 0, 0, 0,
         // State 104
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 0, 0, -22, -22, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 105
-        0, 0, 120, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, -10, -10, 0, -10, 0, -10, -10, 0,
         // State 106
-        0, 0, -19, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 107
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 119, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 108
-        0, 0, 122, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -24, -24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 109
-        62, 0, 0, 0, 0, 0, 0, 63, 64, 0, 65, 0, 66, 67, 0,
+        34, 0, 0, 0, 0, 0, 0, 35, 36, 0, 37, 0, 38, 39, 0,
         // State 110
         0, 0, 0, -4, -4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 111
-        0, 0, 0, -19, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 121, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 112
-        0, 0, 124, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -21, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 113
-        0, 0, 0, 0, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 122, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 114
-        0, 0, 125, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -21, 0, 0, 0, 0, 0, -21, 0, -21, 0, 0, 0,
         // State 115
-        0, 0, 0, -16, 0, 0, 0, 0, 0, -16, 0, -16, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 116
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 125, 0, 0, 0, 0, 0,
         // State 117
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0,
+        0, 0, 126, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 118
-        0, 0, 129, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, -21, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 119
-        0, 0, -16, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -5, -5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 120
-        0, 0, 130, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -22, -22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 121
-        0, 0, 0, -16, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, -22, 0, 0, 0, 0, 0, -22, 0, -22, 0, 0, 0,
         // State 122
-        0, 0, 0, -5, -5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 61, 62, 0, 63, 0, 64, 65, 0,
         // State 123
-        0, 0, 0, 0, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 128, 81, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 124
-        0, 0, 0, -17, 0, 0, 0, 0, 0, -17, 0, -17, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -24, 0, 0, 0, 0, 0,
         // State 125
-        0, 0, 0, 0, 0, 0, 0, 51, 52, 0, 53, 0, 54, 55, 0,
+        0, 0, -22, -22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 126
-        0, 0, 132, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 129, 106, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 127
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -19, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -21, 0, 0, 0, 0, 0,
         // State 128
-        0, 0, -17, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 129
-        0, 0, 0, -17, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 130
-        0, 0, 133, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 131
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -16, 0, 0, 0, 0, 0,
-        // State 132
-        0, 0, 0, 0, 0, 0, 0, 0, 0, -17, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, -22, 0, 0, 0, 0, 0,
     ];
     const __EOF_ACTION: &'static [i32] = &[
         0,
@@ -321,11 +317,11 @@ mod __parse__TopLevel {
         0,
         0,
         0,
-        -38,
+        -45,
         0,
         0,
         0,
-        -42,
+        -49,
         0,
         0,
         0,
@@ -333,14 +329,14 @@ mod __parse__TopLevel {
         0,
         0,
         0,
-        -23,
+        -28,
         0,
         0,
         0,
         0,
         0,
-        -39,
-        -40,
+        -46,
+        -47,
         0,
         0,
         0,
@@ -357,8 +353,6 @@ mod __parse__TopLevel {
         0,
         0,
         0,
-        -24,
-        -25,
         0,
         0,
         0,
@@ -369,6 +363,8 @@ mod __parse__TopLevel {
         0,
         0,
         0,
+        -29,
+        -30,
         0,
         0,
         0,
@@ -385,11 +381,7 @@ mod __parse__TopLevel {
         0,
         0,
         0,
-        -37,
-        0,
-        0,
-        0,
-        0,
+        -44,
         0,
         0,
         0,
@@ -452,271 +444,263 @@ mod __parse__TopLevel {
     ];
     const __GOTO: &'static [i32] = &[
         // State 0
-        0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 4, 5, 0, 6, 7, 8, 9, 0, 10, 11, 0,
+        0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 4, 5, 0, 6, 7, 0, 8, 9, 0, 10, 11, 0,
         // State 1
-        0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 5, 0, 0, 18, 19, 20, 0, 0, 11, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 5, 0, 0, 18, 0, 19, 20, 0, 0, 11, 0,
         // State 2
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 3
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 4
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 5
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 6
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 7
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 8
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 9
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 10
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 11
-        0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 27, 5, 0, 0, 0, 0, 28, 0, 0, 11, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, 0, 28, 29, 0, 0, 0, 30, 0, 31, 32, 0, 33, 0,
         // State 12
-        0, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 33, 34, 0, 0, 0, 35, 0, 0, 36, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 42, 43, 44, 0, 0, 0, 0, 45, 0, 0, 46, 0,
         // State 13
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 14
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 15
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 16
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 17
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 18
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 19
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 20
-        0, 0, 0, 0, 0, 44, 0, 0, 45, 46, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 54, 0, 0, 0, 0, 0, 55, 56, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 21
-        0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 57, 58, 0, 0, 0, 0, 59, 60, 0, 61, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 28, 29, 0, 0, 0, 0, 0, 31, 66, 0, 33, 0,
         // State 22
-        0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 57, 58, 0, 0, 0, 0, 59, 68, 0, 61, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 28, 29, 0, 0, 0, 0, 0, 31, 67, 0, 33, 0,
         // State 23
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 24
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 25
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 28, 29, 0, 0, 0, 0, 0, 31, 68, 0, 33, 0,
         // State 26
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 27
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 28
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 29
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 30
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 31
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 32
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 33
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 34
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 42, 43, 72, 0, 0, 0, 0, 45, 0, 0, 46, 0,
         // State 35
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 36
-        0, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 33, 75, 0, 0, 0, 35, 0, 0, 36, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 37
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 38
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 39
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 40
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 41
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 42
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 43
-        0, 0, 0, 0, 0, 0, 0, 0, 45, 76, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 44
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 45
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 46
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 42, 43, 77, 0, 0, 0, 0, 45, 0, 0, 46, 0,
         // State 47
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 48
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 49
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 50
-        0, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 33, 80, 0, 0, 0, 35, 0, 0, 36, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 51
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 52
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 53
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 78, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 54
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 55
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 56
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 57
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 58
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 59
-        0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 60
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 42, 43, 82, 0, 0, 0, 0, 45, 0, 0, 46, 0,
         // State 61
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 62
-        0, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 33, 84, 0, 0, 0, 35, 0, 0, 36, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 63
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 64
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 65
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 66
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 67
-        0, 0, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 68
-        0, 0, 0, 0, 0, 86, 0, 0, 45, 87, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 87, 0, 0, 0, 0, 0, 55, 88, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 69
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 70
-        0, 0, 0, 0, 0, 88, 0, 0, 45, 89, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 71
-        0, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 33, 90, 0, 0, 0, 35, 0, 0, 36, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 72
-        0, 0, 0, 0, 0, 0, 0, 0, 91, 92, 93, 94, 0, 0, 0, 0, 95, 0, 0, 96, 0,
+        0, 0, 0, 0, 0, 90, 0, 0, 0, 0, 0, 55, 91, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 73
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 42, 43, 92, 0, 0, 0, 0, 45, 0, 0, 46, 0,
         // State 74
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93, 94, 95, 96, 0, 0, 0, 0, 0, 97, 0, 0, 98, 0,
         // State 75
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 76
-        0, 0, 0, 0, 0, 105, 0, 0, 45, 106, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 77
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 78
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 107, 0, 0, 0, 0, 0, 55, 108, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 79
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 80
-        0, 0, 0, 0, 0, 108, 0, 0, 45, 109, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 81
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 82
-        0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 57, 58, 0, 0, 0, 0, 59, 111, 0, 61, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 83
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 28, 29, 0, 0, 0, 0, 0, 31, 111, 0, 33, 0,
         // State 84
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 85
-        0, 0, 0, 0, 0, 0, 0, 0, 45, 113, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 86
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 112, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 87
-        0, 0, 0, 0, 0, 0, 0, 0, 45, 115, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 88
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 89
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 114, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 90
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 91
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 92
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 93
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 94
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 95
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 96
-        0, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 33, 118, 0, 0, 0, 35, 0, 0, 36, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 97
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 98
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 42, 43, 117, 0, 0, 0, 0, 45, 0, 0, 46, 0,
         // State 99
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 100
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 101
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 102
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 103
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 104
-        0, 0, 0, 0, 0, 0, 0, 0, 45, 119, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 105
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 106
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 118, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 107
-        0, 0, 0, 0, 0, 0, 0, 0, 45, 121, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 108
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 109
-        0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 57, 58, 0, 0, 0, 0, 59, 123, 0, 61, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 28, 29, 0, 0, 0, 0, 0, 31, 120, 0, 33, 0,
         // State 110
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 111
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 112
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 113
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 114
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 115
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 123, 0, 0, 0, 0, 0, 55, 124, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 116
-        0, 0, 0, 0, 0, 126, 0, 0, 45, 127, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 117
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 118
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 119
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 120
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 121
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 122
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 127, 57, 58, 0, 0, 0, 0, 0, 59, 0, 0, 60, 0,
         // State 123
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 124
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 125
-        0, 0, 0, 0, 0, 0, 0, 0, 45, 131, 47, 48, 0, 0, 0, 0, 49, 0, 0, 50, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 126
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 127
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 128
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 129
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 130
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 131
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 132
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
     fn __expected_tokens(__state: usize) -> Vec<::std::string::String> {
         const __TERMINAL: &'static [&'static str] = &[
@@ -896,156 +880,214 @@ mod __parse__TopLevel {
     {
         let __nonterminal = match -__action {
             1 => {
-                // ("," <TermOrCut>) = ",", TermOrCut => ActionFn(28);
+                // ("," <TermOrCut>) = ",", TermOrCut => ActionFn(29);
                 let __sym1 = __pop_NtTermOrCut(__symbols);
                 let __sym0 = __pop_Term_22_2c_22(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym1.2.clone();
-                let __nt = super::__action28::<>(input, __sym0, __sym1);
+                let __nt = super::__action29::<>(input, __sym0, __sym1);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::Nt_28_22_2c_22_20_3cTermOrCut_3e_29(__nt), __end));
                 0
             }
             2 => {
-                // ("," <TermOrCut>)* =  => ActionFn(26);
+                // ("," <TermOrCut>)* =  => ActionFn(27);
                 let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
                 let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
-                let __nt = super::__action26::<>(input, &__start, &__end);
+                let __nt = super::__action27::<>(input, &__start, &__end);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 0);
                 __symbols.push((__start, __Symbol::Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2a(__nt), __end));
                 1
             }
             3 => {
-                // ("," <TermOrCut>)* = ("," <TermOrCut>)+ => ActionFn(27);
+                // ("," <TermOrCut>)* = ("," <TermOrCut>)+ => ActionFn(28);
                 let __sym0 = __pop_Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2b(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action27::<>(input, __sym0);
+                let __nt = super::__action28::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2a(__nt), __end));
                 1
             }
             4 => {
-                // ("," <TermOrCut>)+ = ",", TermOrCut => ActionFn(39);
+                // ("," <TermOrCut>)+ = ",", TermOrCut => ActionFn(45);
                 let __sym1 = __pop_NtTermOrCut(__symbols);
                 let __sym0 = __pop_Term_22_2c_22(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym1.2.clone();
-                let __nt = super::__action39::<>(input, __sym0, __sym1);
+                let __nt = super::__action45::<>(input, __sym0, __sym1);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2b(__nt), __end));
                 2
             }
             5 => {
-                // ("," <TermOrCut>)+ = ("," <TermOrCut>)+, ",", TermOrCut => ActionFn(40);
+                // ("," <TermOrCut>)+ = ("," <TermOrCut>)+, ",", TermOrCut => ActionFn(46);
                 let __sym2 = __pop_NtTermOrCut(__symbols);
                 let __sym1 = __pop_Term_22_2c_22(__symbols);
                 let __sym0 = __pop_Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2b(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym2.2.clone();
-                let __nt = super::__action40::<>(input, __sym0, __sym1, __sym2);
+                let __nt = super::__action46::<>(input, __sym0, __sym1, __sym2);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2b(__nt), __end));
                 2
             }
             6 => {
-                // (<BoxedTerm> ",") = BoxedTerm, "," => ActionFn(34);
+                // (<BoxedTerm> ",") = BoxedTerm, "," => ActionFn(38);
                 let __sym1 = __pop_Term_22_2c_22(__symbols);
                 let __sym0 = __pop_NtBoxedTerm(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym1.2.clone();
-                let __nt = super::__action34::<>(input, __sym0, __sym1);
+                let __nt = super::__action38::<>(input, __sym0, __sym1);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::Nt_28_3cBoxedTerm_3e_20_22_2c_22_29(__nt), __end));
                 3
             }
             7 => {
-                // (<BoxedTerm> ",")* =  => ActionFn(32);
+                // (<BoxedTerm> ",")* =  => ActionFn(36);
                 let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
                 let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
-                let __nt = super::__action32::<>(input, &__start, &__end);
+                let __nt = super::__action36::<>(input, &__start, &__end);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 0);
                 __symbols.push((__start, __Symbol::Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2a(__nt), __end));
                 4
             }
             8 => {
-                // (<BoxedTerm> ",")* = (<BoxedTerm> ",")+ => ActionFn(33);
+                // (<BoxedTerm> ",")* = (<BoxedTerm> ",")+ => ActionFn(37);
                 let __sym0 = __pop_Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2b(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action33::<>(input, __sym0);
+                let __nt = super::__action37::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2a(__nt), __end));
                 4
             }
             9 => {
-                // (<BoxedTerm> ",")+ = BoxedTerm, "," => ActionFn(45);
+                // (<BoxedTerm> ",")+ = BoxedTerm, "," => ActionFn(51);
                 let __sym1 = __pop_Term_22_2c_22(__symbols);
                 let __sym0 = __pop_NtBoxedTerm(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym1.2.clone();
-                let __nt = super::__action45::<>(input, __sym0, __sym1);
+                let __nt = super::__action51::<>(input, __sym0, __sym1);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2b(__nt), __end));
                 5
             }
             10 => {
-                // (<BoxedTerm> ",")+ = (<BoxedTerm> ",")+, BoxedTerm, "," => ActionFn(46);
+                // (<BoxedTerm> ",")+ = (<BoxedTerm> ",")+, BoxedTerm, "," => ActionFn(52);
                 let __sym2 = __pop_Term_22_2c_22(__symbols);
                 let __sym1 = __pop_NtBoxedTerm(__symbols);
                 let __sym0 = __pop_Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2b(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym2.2.clone();
-                let __nt = super::__action46::<>(input, __sym0, __sym1, __sym2);
+                let __nt = super::__action52::<>(input, __sym0, __sym1, __sym2);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2b(__nt), __end));
                 5
             }
             11 => {
-                // (<PredicateClause>) = PredicateClause => ActionFn(31);
+                // (<PredicateClause>) = PredicateClause => ActionFn(35);
                 let __sym0 = __pop_NtPredicateClause(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action31::<>(input, __sym0);
+                let __nt = super::__action35::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::Nt_28_3cPredicateClause_3e_29(__nt), __end));
                 6
             }
             12 => {
-                // (<PredicateClause>)+ = PredicateClause => ActionFn(49);
+                // (<PredicateClause>)+ = PredicateClause => ActionFn(55);
                 let __sym0 = __pop_NtPredicateClause(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action49::<>(input, __sym0);
+                let __nt = super::__action55::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::Nt_28_3cPredicateClause_3e_29_2b(__nt), __end));
                 7
             }
             13 => {
-                // (<PredicateClause>)+ = (<PredicateClause>)+, PredicateClause => ActionFn(50);
+                // (<PredicateClause>)+ = (<PredicateClause>)+, PredicateClause => ActionFn(56);
                 let __sym1 = __pop_NtPredicateClause(__symbols);
                 let __sym0 = __pop_Nt_28_3cPredicateClause_3e_29_2b(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym1.2.clone();
-                let __nt = super::__action50::<>(input, __sym0, __sym1);
+                let __nt = super::__action56::<>(input, __sym0, __sym1);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::Nt_28_3cPredicateClause_3e_29_2b(__nt), __end));
                 7
             }
             14 => {
+                // (<TermOrCut> ",") = TermOrCut, "," => ActionFn(32);
+                let __sym1 = __pop_Term_22_2c_22(__symbols);
+                let __sym0 = __pop_NtTermOrCut(__symbols);
+                let __start = __sym0.0.clone();
+                let __end = __sym1.2.clone();
+                let __nt = super::__action32::<>(input, __sym0, __sym1);
+                let __states_len = __states.len();
+                __states.truncate(__states_len - 2);
+                __symbols.push((__start, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29(__nt), __end));
+                8
+            }
+            15 => {
+                // (<TermOrCut> ",")* =  => ActionFn(30);
+                let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
+                let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
+                let __nt = super::__action30::<>(input, &__start, &__end);
+                let __states_len = __states.len();
+                __states.truncate(__states_len - 0);
+                __symbols.push((__start, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2a(__nt), __end));
+                9
+            }
+            16 => {
+                // (<TermOrCut> ",")* = (<TermOrCut> ",")+ => ActionFn(31);
+                let __sym0 = __pop_Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b(__symbols);
+                let __start = __sym0.0.clone();
+                let __end = __sym0.2.clone();
+                let __nt = super::__action31::<>(input, __sym0);
+                let __states_len = __states.len();
+                __states.truncate(__states_len - 1);
+                __symbols.push((__start, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2a(__nt), __end));
+                9
+            }
+            17 => {
+                // (<TermOrCut> ",")+ = TermOrCut, "," => ActionFn(57);
+                let __sym1 = __pop_Term_22_2c_22(__symbols);
+                let __sym0 = __pop_NtTermOrCut(__symbols);
+                let __start = __sym0.0.clone();
+                let __end = __sym1.2.clone();
+                let __nt = super::__action57::<>(input, __sym0, __sym1);
+                let __states_len = __states.len();
+                __states.truncate(__states_len - 2);
+                __symbols.push((__start, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b(__nt), __end));
+                10
+            }
+            18 => {
+                // (<TermOrCut> ",")+ = (<TermOrCut> ",")+, TermOrCut, "," => ActionFn(58);
+                let __sym2 = __pop_Term_22_2c_22(__symbols);
+                let __sym1 = __pop_NtTermOrCut(__symbols);
+                let __sym0 = __pop_Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b(__symbols);
+                let __start = __sym0.0.clone();
+                let __end = __sym2.2.clone();
+                let __nt = super::__action58::<>(input, __sym0, __sym1, __sym2);
+                let __states_len = __states.len();
+                __states.truncate(__states_len - 3);
+                __symbols.push((__start, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b(__nt), __end));
+                10
+            }
+            19 => {
                 // Atom = r#"[a-z][A-Za-z0-9_]*"# => ActionFn(5);
                 let __sym0 = __pop_Termr_23_22_5ba_2dz_5d_5bA_2dZa_2dz0_2d9___5d_2a_22_23(__symbols);
                 let __start = __sym0.0.clone();
@@ -1054,9 +1096,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtAtom(__nt), __end));
-                8
+                11
             }
-            15 => {
+            20 => {
                 // BoxedTerm = Term => ActionFn(6);
                 let __sym0 = __pop_NtTerm(__symbols);
                 let __start = __sym0.0.clone();
@@ -1065,24 +1107,24 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtBoxedTerm(__nt), __end));
-                9
+                12
             }
-            16 => {
-                // Clause = Atom, "(", BoxedTerm, ")" => ActionFn(47);
+            21 => {
+                // Clause = Atom, "(", BoxedTerm, ")" => ActionFn(53);
                 let __sym3 = __pop_Term_22_29_22(__symbols);
                 let __sym2 = __pop_NtBoxedTerm(__symbols);
                 let __sym1 = __pop_Term_22_28_22(__symbols);
                 let __sym0 = __pop_NtAtom(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym3.2.clone();
-                let __nt = super::__action47::<>(input, __sym0, __sym1, __sym2, __sym3);
+                let __nt = super::__action53::<>(input, __sym0, __sym1, __sym2, __sym3);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 4);
                 __symbols.push((__start, __Symbol::NtClause(__nt), __end));
-                10
+                13
             }
-            17 => {
-                // Clause = Atom, "(", (<BoxedTerm> ",")+, BoxedTerm, ")" => ActionFn(48);
+            22 => {
+                // Clause = Atom, "(", (<BoxedTerm> ",")+, BoxedTerm, ")" => ActionFn(54);
                 let __sym4 = __pop_Term_22_29_22(__symbols);
                 let __sym3 = __pop_NtBoxedTerm(__symbols);
                 let __sym2 = __pop_Nt_28_3cBoxedTerm_3e_20_22_2c_22_29_2b(__symbols);
@@ -1090,13 +1132,13 @@ mod __parse__TopLevel {
                 let __sym0 = __pop_NtAtom(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym4.2.clone();
-                let __nt = super::__action48::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4);
+                let __nt = super::__action54::<>(input, __sym0, __sym1, __sym2, __sym3, __sym4);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 5);
                 __symbols.push((__start, __Symbol::NtClause(__nt), __end));
-                10
+                13
             }
-            18 => {
+            23 => {
                 // List = "[]" => ActionFn(8);
                 let __sym0 = __pop_Term_22_5b_5d_22(__symbols);
                 let __start = __sym0.0.clone();
@@ -1105,9 +1147,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtList(__nt), __end));
-                11
+                14
             }
-            19 => {
+            24 => {
                 // List = "[", ListInternals, "]" => ActionFn(9);
                 let __sym2 = __pop_Term_22_5d_22(__symbols);
                 let __sym1 = __pop_NtListInternals(__symbols);
@@ -1118,9 +1160,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::NtList(__nt), __end));
-                11
+                14
             }
-            20 => {
+            25 => {
                 // ListInternals = BoxedTerm => ActionFn(10);
                 let __sym0 = __pop_NtBoxedTerm(__symbols);
                 let __start = __sym0.0.clone();
@@ -1129,9 +1171,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtListInternals(__nt), __end));
-                12
+                15
             }
-            21 => {
+            26 => {
                 // ListInternals = BoxedTerm, ",", ListInternals => ActionFn(11);
                 let __sym2 = __pop_NtListInternals(__symbols);
                 let __sym1 = __pop_Term_22_2c_22(__symbols);
@@ -1142,9 +1184,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::NtListInternals(__nt), __end));
-                12
+                15
             }
-            22 => {
+            27 => {
                 // ListInternals = BoxedTerm, "|", BoxedTerm => ActionFn(12);
                 let __sym2 = __pop_NtBoxedTerm(__symbols);
                 let __sym1 = __pop_Term_22_7c_22(__symbols);
@@ -1155,9 +1197,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::NtListInternals(__nt), __end));
-                12
+                15
             }
-            23 => {
+            28 => {
                 // Predicate = (<PredicateClause>)+, PredicateClause => ActionFn(13);
                 let __sym1 = __pop_NtPredicateClause(__symbols);
                 let __sym0 = __pop_Nt_28_3cPredicateClause_3e_29_2b(__symbols);
@@ -1167,9 +1209,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::NtPredicate(__nt), __end));
-                13
+                16
             }
-            24 => {
+            29 => {
                 // PredicateClause = Rule, "." => ActionFn(14);
                 let __sym1 = __pop_Term_22_2e_22(__symbols);
                 let __sym0 = __pop_NtRule(__symbols);
@@ -1179,9 +1221,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::NtPredicateClause(__nt), __end));
-                14
+                17
             }
-            25 => {
+            30 => {
                 // PredicateClause = Term, "." => ActionFn(15);
                 let __sym1 = __pop_Term_22_2e_22(__symbols);
                 let __sym0 = __pop_NtTerm(__symbols);
@@ -1191,143 +1233,166 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::NtPredicateClause(__nt), __end));
-                14
+                17
             }
-            26 => {
-                // Rule = Clause, ":-", TermOrCut => ActionFn(41);
+            31 => {
+                // Query = TermOrCut => ActionFn(59);
+                let __sym0 = __pop_NtTermOrCut(__symbols);
+                let __start = __sym0.0.clone();
+                let __end = __sym0.2.clone();
+                let __nt = super::__action59::<>(input, __sym0);
+                let __states_len = __states.len();
+                __states.truncate(__states_len - 1);
+                __symbols.push((__start, __Symbol::NtQuery(__nt), __end));
+                18
+            }
+            32 => {
+                // Query = (<TermOrCut> ",")+, TermOrCut => ActionFn(60);
+                let __sym1 = __pop_NtTermOrCut(__symbols);
+                let __sym0 = __pop_Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b(__symbols);
+                let __start = __sym0.0.clone();
+                let __end = __sym1.2.clone();
+                let __nt = super::__action60::<>(input, __sym0, __sym1);
+                let __states_len = __states.len();
+                __states.truncate(__states_len - 2);
+                __symbols.push((__start, __Symbol::NtQuery(__nt), __end));
+                18
+            }
+            33 => {
+                // Rule = Clause, ":-", TermOrCut => ActionFn(47);
                 let __sym2 = __pop_NtTermOrCut(__symbols);
                 let __sym1 = __pop_Term_22_3a_2d_22(__symbols);
                 let __sym0 = __pop_NtClause(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym2.2.clone();
-                let __nt = super::__action41::<>(input, __sym0, __sym1, __sym2);
+                let __nt = super::__action47::<>(input, __sym0, __sym1, __sym2);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::NtRule(__nt), __end));
-                15
+                19
             }
-            27 => {
-                // Rule = Clause, ":-", TermOrCut, ("," <TermOrCut>)+ => ActionFn(42);
+            34 => {
+                // Rule = Clause, ":-", TermOrCut, ("," <TermOrCut>)+ => ActionFn(48);
                 let __sym3 = __pop_Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2b(__symbols);
                 let __sym2 = __pop_NtTermOrCut(__symbols);
                 let __sym1 = __pop_Term_22_3a_2d_22(__symbols);
                 let __sym0 = __pop_NtClause(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym3.2.clone();
-                let __nt = super::__action42::<>(input, __sym0, __sym1, __sym2, __sym3);
+                let __nt = super::__action48::<>(input, __sym0, __sym1, __sym2, __sym3);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 4);
                 __symbols.push((__start, __Symbol::NtRule(__nt), __end));
-                15
+                19
             }
-            28 => {
-                // Rule = Atom, ":-", TermOrCut => ActionFn(43);
+            35 => {
+                // Rule = Atom, ":-", TermOrCut => ActionFn(49);
                 let __sym2 = __pop_NtTermOrCut(__symbols);
                 let __sym1 = __pop_Term_22_3a_2d_22(__symbols);
                 let __sym0 = __pop_NtAtom(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym2.2.clone();
-                let __nt = super::__action43::<>(input, __sym0, __sym1, __sym2);
+                let __nt = super::__action49::<>(input, __sym0, __sym1, __sym2);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::NtRule(__nt), __end));
-                15
+                19
             }
-            29 => {
-                // Rule = Atom, ":-", TermOrCut, ("," <TermOrCut>)+ => ActionFn(44);
+            36 => {
+                // Rule = Atom, ":-", TermOrCut, ("," <TermOrCut>)+ => ActionFn(50);
                 let __sym3 = __pop_Nt_28_22_2c_22_20_3cTermOrCut_3e_29_2b(__symbols);
                 let __sym2 = __pop_NtTermOrCut(__symbols);
                 let __sym1 = __pop_Term_22_3a_2d_22(__symbols);
                 let __sym0 = __pop_NtAtom(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym3.2.clone();
-                let __nt = super::__action44::<>(input, __sym0, __sym1, __sym2, __sym3);
+                let __nt = super::__action50::<>(input, __sym0, __sym1, __sym2, __sym3);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 4);
                 __symbols.push((__start, __Symbol::NtRule(__nt), __end));
-                15
+                19
             }
-            30 => {
-                // Term = Atom => ActionFn(20);
+            37 => {
+                // Term = Atom => ActionFn(21);
                 let __sym0 = __pop_NtAtom(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action20::<>(input, __sym0);
+                let __nt = super::__action21::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTerm(__nt), __end));
-                16
+                20
             }
-            31 => {
-                // Term = Clause => ActionFn(21);
+            38 => {
+                // Term = Clause => ActionFn(22);
                 let __sym0 = __pop_NtClause(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action21::<>(input, __sym0);
+                let __nt = super::__action22::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTerm(__nt), __end));
-                16
+                20
             }
-            32 => {
-                // Term = List => ActionFn(22);
+            39 => {
+                // Term = List => ActionFn(23);
                 let __sym0 = __pop_NtList(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action22::<>(input, __sym0);
+                let __nt = super::__action23::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTerm(__nt), __end));
-                16
+                20
             }
-            33 => {
-                // Term = Var => ActionFn(23);
+            40 => {
+                // Term = Var => ActionFn(24);
                 let __sym0 = __pop_NtVar(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action23::<>(input, __sym0);
+                let __nt = super::__action24::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTerm(__nt), __end));
-                16
+                20
             }
-            34 => {
-                // Term = "_" => ActionFn(24);
+            41 => {
+                // Term = "_" => ActionFn(25);
                 let __sym0 = __pop_Term_22___22(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action24::<>(input, __sym0);
+                let __nt = super::__action25::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTerm(__nt), __end));
-                16
+                20
             }
-            35 => {
-                // TermOrCut = "!" => ActionFn(18);
+            42 => {
+                // TermOrCut = "!" => ActionFn(19);
                 let __sym0 = __pop_Term_22_21_22(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action18::<>(input, __sym0);
+                let __nt = super::__action19::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTermOrCut(__nt), __end));
-                17
+                21
             }
-            36 => {
-                // TermOrCut = Term => ActionFn(19);
+            43 => {
+                // TermOrCut = Term => ActionFn(20);
                 let __sym0 = __pop_NtTerm(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action19::<>(input, __sym0);
+                let __nt = super::__action20::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTermOrCut(__nt), __end));
-                17
+                21
             }
-            37 => {
-                // TopLevel = "?-", Term, "." => ActionFn(1);
+            44 => {
+                // TopLevel = "?-", Query, "." => ActionFn(1);
                 let __sym2 = __pop_Term_22_2e_22(__symbols);
-                let __sym1 = __pop_NtTerm(__symbols);
+                let __sym1 = __pop_NtQuery(__symbols);
                 let __sym0 = __pop_Term_22_3f_2d_22(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym2.2.clone();
@@ -1335,9 +1400,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 3);
                 __symbols.push((__start, __Symbol::NtTopLevel(__nt), __end));
-                18
+                22
             }
-            38 => {
+            45 => {
                 // TopLevel = Predicate => ActionFn(2);
                 let __sym0 = __pop_NtPredicate(__symbols);
                 let __start = __sym0.0.clone();
@@ -1346,9 +1411,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtTopLevel(__nt), __end));
-                18
+                22
             }
-            39 => {
+            46 => {
                 // TopLevel = Rule, "." => ActionFn(3);
                 let __sym1 = __pop_Term_22_2e_22(__symbols);
                 let __sym0 = __pop_NtRule(__symbols);
@@ -1358,9 +1423,9 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::NtTopLevel(__nt), __end));
-                18
+                22
             }
-            40 => {
+            47 => {
                 // TopLevel = Term, "." => ActionFn(4);
                 let __sym1 = __pop_Term_22_2e_22(__symbols);
                 let __sym0 = __pop_NtTerm(__symbols);
@@ -1370,20 +1435,20 @@ mod __parse__TopLevel {
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 2);
                 __symbols.push((__start, __Symbol::NtTopLevel(__nt), __end));
-                18
+                22
             }
-            41 => {
-                // Var = r#"[A-Z][A-Za-z0-9_]*"# => ActionFn(25);
+            48 => {
+                // Var = r#"[A-Z][A-Za-z0-9_]*"# => ActionFn(26);
                 let __sym0 = __pop_Termr_23_22_5bA_2dZ_5d_5bA_2dZa_2dz0_2d9___5d_2a_22_23(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
-                let __nt = super::__action25::<>(input, __sym0);
+                let __nt = super::__action26::<>(input, __sym0);
                 let __states_len = __states.len();
                 __states.truncate(__states_len - 1);
                 __symbols.push((__start, __Symbol::NtVar(__nt), __end));
-                19
+                23
             }
-            42 => {
+            49 => {
                 // __TopLevel = TopLevel => ActionFn(0);
                 let __sym0 = __pop_NtTopLevel(__symbols);
                 let __start = __sym0.0.clone();
@@ -1394,7 +1459,7 @@ mod __parse__TopLevel {
             _ => panic!("invalid action code {}", __action)
         };
         let __state = *__states.last().unwrap() as usize;
-        let __next_state = __GOTO[__state * 21 + __nonterminal] - 1;
+        let __next_state = __GOTO[__state * 25 + __nonterminal] - 1;
         __states.push(__next_state);
         None
     }
@@ -1628,6 +1693,36 @@ mod __parse__TopLevel {
             _ => panic!("symbol type mismatch")
         }
     }
+    fn __pop_Nt_28_3cTermOrCut_3e_20_22_2c_22_29<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, TermOrCut, usize) {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2a<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, ::std::vec::Vec<TermOrCut>, usize) {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2a(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, ::std::vec::Vec<TermOrCut>, usize) {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Nt_28_3cTermOrCut_3e_20_22_2c_22_29_2b(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
     fn __pop_NtAtom<
       'input,
     >(
@@ -1698,6 +1793,16 @@ mod __parse__TopLevel {
             _ => panic!("symbol type mismatch")
         }
     }
+    fn __pop_NtQuery<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, Vec<TermOrCut>, usize) {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::NtQuery(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
     fn __pop_NtRule<
       'input,
     >(
@@ -2149,11 +2254,11 @@ pub fn __action1<
 >(
     input: &'input str,
     (_, _, _): (usize, &'input str, usize),
-    (_, t, _): (usize, Term, usize),
+    (_, q, _): (usize, Vec<TermOrCut>, usize),
     (_, _, _): (usize, &'input str, usize),
 ) -> TopLevel
 {
-    TopLevel::Query(t)
+    TopLevel::Query(q)
 }
 
 #[allow(unused_variables)]
@@ -2341,6 +2446,22 @@ pub fn __action15<
 #[allow(unused_variables)]
 pub fn __action16<
     'input,
+>(
+    input: &'input str,
+    (_, tcs, _): (usize, ::std::vec::Vec<TermOrCut>, usize),
+    (_, tc, _): (usize, TermOrCut, usize),
+) -> Vec<TermOrCut>
+{
+    {
+        let mut tcs = tcs;
+        tcs.push(tc);
+        tcs
+    }
+}
+
+#[allow(unused_variables)]
+pub fn __action17<
+    'input,
 >(
     input: &'input str,
     (_, c, _): (usize, Term, usize),
@@ -2353,7 +2474,7 @@ pub fn __action16<
 }
 
 #[allow(unused_variables)]
-pub fn __action17<
+pub fn __action18<
     'input,
 >(
     input: &'input str,
@@ -2369,7 +2490,7 @@ pub fn __action17<
 }
 
 #[allow(unused_variables)]
-pub fn __action18<
+pub fn __action19<
     'input,
 >(
     input: &'input str,
@@ -2380,7 +2501,7 @@ pub fn __action18<
 }
 
 #[allow(unused_variables)]
-pub fn __action19<
+pub fn __action20<
     'input,
 >(
     input: &'input str,
@@ -2391,7 +2512,7 @@ pub fn __action19<
 }
 
 #[allow(unused_variables)]
-pub fn __action20<
+pub fn __action21<
     'input,
 >(
     input: &'input str,
@@ -2402,7 +2523,7 @@ pub fn __action20<
 }
 
 #[allow(unused_variables)]
-pub fn __action21<
+pub fn __action22<
     'input,
 >(
     input: &'input str,
@@ -2413,7 +2534,7 @@ pub fn __action21<
 }
 
 #[allow(unused_variables)]
-pub fn __action22<
+pub fn __action23<
     'input,
 >(
     input: &'input str,
@@ -2424,7 +2545,7 @@ pub fn __action22<
 }
 
 #[allow(unused_variables)]
-pub fn __action23<
+pub fn __action24<
     'input,
 >(
     input: &'input str,
@@ -2435,7 +2556,7 @@ pub fn __action23<
 }
 
 #[allow(unused_variables)]
-pub fn __action24<
+pub fn __action25<
     'input,
 >(
     input: &'input str,
@@ -2446,7 +2567,7 @@ pub fn __action24<
 }
 
 #[allow(unused_variables)]
-pub fn __action25<
+pub fn __action26<
     'input,
 >(
     input: &'input str,
@@ -2457,7 +2578,7 @@ pub fn __action25<
 }
 
 #[allow(unused_variables)]
-pub fn __action26<
+pub fn __action27<
     'input,
 >(
     input: &'input str,
@@ -2469,7 +2590,7 @@ pub fn __action26<
 }
 
 #[allow(unused_variables)]
-pub fn __action27<
+pub fn __action28<
     'input,
 >(
     input: &'input str,
@@ -2480,7 +2601,7 @@ pub fn __action27<
 }
 
 #[allow(unused_variables)]
-pub fn __action28<
+pub fn __action29<
     'input,
 >(
     input: &'input str,
@@ -2492,7 +2613,42 @@ pub fn __action28<
 }
 
 #[allow(unused_variables)]
-pub fn __action29<
+pub fn __action30<
+    'input,
+>(
+    input: &'input str,
+    __lookbehind: &usize,
+    __lookahead: &usize,
+) -> ::std::vec::Vec<TermOrCut>
+{
+    vec![]
+}
+
+#[allow(unused_variables)]
+pub fn __action31<
+    'input,
+>(
+    input: &'input str,
+    (_, v, _): (usize, ::std::vec::Vec<TermOrCut>, usize),
+) -> ::std::vec::Vec<TermOrCut>
+{
+    v
+}
+
+#[allow(unused_variables)]
+pub fn __action32<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, TermOrCut, usize),
+    (_, _, _): (usize, &'input str, usize),
+) -> TermOrCut
+{
+    (__0)
+}
+
+#[allow(unused_variables)]
+pub fn __action33<
     'input,
 >(
     input: &'input str,
@@ -2503,7 +2659,7 @@ pub fn __action29<
 }
 
 #[allow(unused_variables)]
-pub fn __action30<
+pub fn __action34<
     'input,
 >(
     input: &'input str,
@@ -2515,7 +2671,7 @@ pub fn __action30<
 }
 
 #[allow(unused_variables)]
-pub fn __action31<
+pub fn __action35<
     'input,
 >(
     input: &'input str,
@@ -2526,7 +2682,7 @@ pub fn __action31<
 }
 
 #[allow(unused_variables)]
-pub fn __action32<
+pub fn __action36<
     'input,
 >(
     input: &'input str,
@@ -2538,7 +2694,7 @@ pub fn __action32<
 }
 
 #[allow(unused_variables)]
-pub fn __action33<
+pub fn __action37<
     'input,
 >(
     input: &'input str,
@@ -2549,7 +2705,7 @@ pub fn __action33<
 }
 
 #[allow(unused_variables)]
-pub fn __action34<
+pub fn __action38<
     'input,
 >(
     input: &'input str,
@@ -2561,7 +2717,7 @@ pub fn __action34<
 }
 
 #[allow(unused_variables)]
-pub fn __action35<
+pub fn __action39<
     'input,
 >(
     input: &'input str,
@@ -2572,7 +2728,7 @@ pub fn __action35<
 }
 
 #[allow(unused_variables)]
-pub fn __action36<
+pub fn __action40<
     'input,
 >(
     input: &'input str,
@@ -2584,7 +2740,7 @@ pub fn __action36<
 }
 
 #[allow(unused_variables)]
-pub fn __action37<
+pub fn __action41<
     'input,
 >(
     input: &'input str,
@@ -2595,7 +2751,7 @@ pub fn __action37<
 }
 
 #[allow(unused_variables)]
-pub fn __action38<
+pub fn __action42<
     'input,
 >(
     input: &'input str,
@@ -2607,7 +2763,30 @@ pub fn __action38<
 }
 
 #[allow(unused_variables)]
-pub fn __action39<
+pub fn __action43<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, TermOrCut, usize),
+) -> ::std::vec::Vec<TermOrCut>
+{
+    vec![__0]
+}
+
+#[allow(unused_variables)]
+pub fn __action44<
+    'input,
+>(
+    input: &'input str,
+    (_, v, _): (usize, ::std::vec::Vec<TermOrCut>, usize),
+    (_, e, _): (usize, TermOrCut, usize),
+) -> ::std::vec::Vec<TermOrCut>
+{
+    { let mut v = v; v.push(e); v }
+}
+
+#[allow(unused_variables)]
+pub fn __action45<
     'input,
 >(
     input: &'input str,
@@ -2617,20 +2796,20 @@ pub fn __action39<
 {
     let __start0 = __0.0.clone();
     let __end0 = __1.2.clone();
-    let __temp0 = __action28(
+    let __temp0 = __action29(
         input,
         __0,
         __1,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action37(
+    __action43(
         input,
         __temp0,
     )
 }
 
 #[allow(unused_variables)]
-pub fn __action40<
+pub fn __action46<
     'input,
 >(
     input: &'input str,
@@ -2641,13 +2820,13 @@ pub fn __action40<
 {
     let __start0 = __1.0.clone();
     let __end0 = __2.2.clone();
-    let __temp0 = __action28(
+    let __temp0 = __action29(
         input,
         __1,
         __2,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action38(
+    __action44(
         input,
         __0,
         __temp0,
@@ -2655,7 +2834,7 @@ pub fn __action40<
 }
 
 #[allow(unused_variables)]
-pub fn __action41<
+pub fn __action47<
     'input,
 >(
     input: &'input str,
@@ -2666,13 +2845,13 @@ pub fn __action41<
 {
     let __start0 = __2.2.clone();
     let __end0 = __2.2.clone();
-    let __temp0 = __action26(
+    let __temp0 = __action27(
         input,
         &__start0,
         &__end0,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action16(
+    __action17(
         input,
         __0,
         __1,
@@ -2682,7 +2861,7 @@ pub fn __action41<
 }
 
 #[allow(unused_variables)]
-pub fn __action42<
+pub fn __action48<
     'input,
 >(
     input: &'input str,
@@ -2694,12 +2873,12 @@ pub fn __action42<
 {
     let __start0 = __3.0.clone();
     let __end0 = __3.2.clone();
-    let __temp0 = __action27(
+    let __temp0 = __action28(
         input,
         __3,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action16(
+    __action17(
         input,
         __0,
         __1,
@@ -2709,7 +2888,7 @@ pub fn __action42<
 }
 
 #[allow(unused_variables)]
-pub fn __action43<
+pub fn __action49<
     'input,
 >(
     input: &'input str,
@@ -2720,13 +2899,13 @@ pub fn __action43<
 {
     let __start0 = __2.2.clone();
     let __end0 = __2.2.clone();
-    let __temp0 = __action26(
+    let __temp0 = __action27(
         input,
         &__start0,
         &__end0,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action17(
+    __action18(
         input,
         __0,
         __1,
@@ -2736,7 +2915,7 @@ pub fn __action43<
 }
 
 #[allow(unused_variables)]
-pub fn __action44<
+pub fn __action50<
     'input,
 >(
     input: &'input str,
@@ -2748,12 +2927,12 @@ pub fn __action44<
 {
     let __start0 = __3.0.clone();
     let __end0 = __3.2.clone();
-    let __temp0 = __action27(
+    let __temp0 = __action28(
         input,
         __3,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action17(
+    __action18(
         input,
         __0,
         __1,
@@ -2763,7 +2942,7 @@ pub fn __action44<
 }
 
 #[allow(unused_variables)]
-pub fn __action45<
+pub fn __action51<
     'input,
 >(
     input: &'input str,
@@ -2773,20 +2952,20 @@ pub fn __action45<
 {
     let __start0 = __0.0.clone();
     let __end0 = __1.2.clone();
-    let __temp0 = __action34(
+    let __temp0 = __action38(
         input,
         __0,
         __1,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action35(
+    __action39(
         input,
         __temp0,
     )
 }
 
 #[allow(unused_variables)]
-pub fn __action46<
+pub fn __action52<
     'input,
 >(
     input: &'input str,
@@ -2797,13 +2976,13 @@ pub fn __action46<
 {
     let __start0 = __1.0.clone();
     let __end0 = __2.2.clone();
-    let __temp0 = __action34(
+    let __temp0 = __action38(
         input,
         __1,
         __2,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action36(
+    __action40(
         input,
         __0,
         __temp0,
@@ -2811,7 +2990,7 @@ pub fn __action46<
 }
 
 #[allow(unused_variables)]
-pub fn __action47<
+pub fn __action53<
     'input,
 >(
     input: &'input str,
@@ -2823,7 +3002,7 @@ pub fn __action47<
 {
     let __start0 = __1.2.clone();
     let __end0 = __2.0.clone();
-    let __temp0 = __action32(
+    let __temp0 = __action36(
         input,
         &__start0,
         &__end0,
@@ -2840,7 +3019,7 @@ pub fn __action47<
 }
 
 #[allow(unused_variables)]
-pub fn __action48<
+pub fn __action54<
     'input,
 >(
     input: &'input str,
@@ -2853,7 +3032,7 @@ pub fn __action48<
 {
     let __start0 = __2.0.clone();
     let __end0 = __2.2.clone();
-    let __temp0 = __action33(
+    let __temp0 = __action37(
         input,
         __2,
     );
@@ -2869,7 +3048,7 @@ pub fn __action48<
 }
 
 #[allow(unused_variables)]
-pub fn __action49<
+pub fn __action55<
     'input,
 >(
     input: &'input str,
@@ -2878,19 +3057,19 @@ pub fn __action49<
 {
     let __start0 = __0.0.clone();
     let __end0 = __0.2.clone();
-    let __temp0 = __action31(
+    let __temp0 = __action35(
         input,
         __0,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action29(
+    __action33(
         input,
         __temp0,
     )
 }
 
 #[allow(unused_variables)]
-pub fn __action50<
+pub fn __action56<
     'input,
 >(
     input: &'input str,
@@ -2900,18 +3079,112 @@ pub fn __action50<
 {
     let __start0 = __1.0.clone();
     let __end0 = __1.2.clone();
-    let __temp0 = __action31(
+    let __temp0 = __action35(
         input,
         __1,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action30(
+    __action34(
+        input,
+        __0,
+        __temp0,
+    )
+}
+
+#[allow(unused_variables)]
+pub fn __action57<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, TermOrCut, usize),
+    __1: (usize, &'input str, usize),
+) -> ::std::vec::Vec<TermOrCut>
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action32(
         input,
         __0,
+        __1,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action41(
+        input,
         __temp0,
     )
 }
 
+#[allow(unused_variables)]
+pub fn __action58<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, ::std::vec::Vec<TermOrCut>, usize),
+    __1: (usize, TermOrCut, usize),
+    __2: (usize, &'input str, usize),
+) -> ::std::vec::Vec<TermOrCut>
+{
+    let __start0 = __1.0.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action32(
+        input,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action42(
+        input,
+        __0,
+        __temp0,
+    )
+}
+
+#[allow(unused_variables)]
+pub fn __action59<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, TermOrCut, usize),
+) -> Vec<TermOrCut>
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action30(
+        input,
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action16(
+        input,
+        __temp0,
+        __0,
+    )
+}
+
+#[allow(unused_variables)]
+pub fn __action60<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, ::std::vec::Vec<TermOrCut>, usize),
+    __1: (usize, TermOrCut, usize),
+) -> Vec<TermOrCut>
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action31(
+        input,
+        __0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action16(
+        input,
+        __temp0,
+        __1,
+    )
+}
+
 pub trait __ToTriple<'input, > {
     type Error;
     fn to_triple(value: Self) -> Result<(usize,(usize, &'input str),usize),Self::Error>;