static class EvalTransform {

  int varCount;

  Exception exception;

  boolean recurse = true;

  Lisp newVar() {

    ret lisp("$e" + (++varCount));

  }

  Lisp transformEval(Lisp tree, L<Lisp> out) {

    if (tree.is("[]", 2) && tree.get(0).is("eval", 0) && tree.get(1).is("()", 1)) {

      Lisp exp = tree.get(1).get(0);

      if (recurse)

        exp = transformEval(exp, out);

      Lisp var = newVar();

      out.add(lisp("[]", var, "=").addAll(nlUnroll(exp)));

      ret var;

    }

    // recurse

    Lisp n = new Lisp(tree.head);

    for (Lisp t : tree)

      n.add(transformEval(t, out));

    ret n;

  }

  Lisp evalTransformRule(Lisp rule) {

    try {

      L<Lisp> ops = snlSplitOps(rule);

      // expand unconditional rule

      if (ops == null || ops.isEmpty() || !ops.get(0).is("if *", 1))

        ops = litlist(lisp("then *", rule));

      for (int i = 0; i < l(ops); i++) {

        Lisp op = ops.get(i).get(0);

        new L<Lisp> out;

        Lisp op2 = transformEval(op, out);

        if (out.isEmpty()) continue;

        for (Lisp l : out) {

          ops.add(i, lisp(i == 0 ? "if *" : "and *", l));

          ++i;

        }

        ops.set(i, lisp(i == l(ops)-1 ? "then *" : "and *", op2));

      }

      ret snlJoinOps(ops);

    } catch (Exception e) {

      exception = e;

      ret rule;

    }

  }

  Lisp evalTransformQuestion(Lisp question) {

    try {

      new L<Lisp> out;

      Lisp tree = transformEval(question, out);

      for (int i = l(out)-1; i >= 0; i--)

        tree = lisp("[]", out.get(i), "and", tree);

      ret tree;

    } catch (Exception e) {

      exception = e;

      ret question;

    }

  }

}