static void lispStandardEvaluators() {
  // True
  
  addLispEvaluator("zivsiiacmvqrolto", main.<Lisp, Bool>f1_const(Bool.TRUE));
  
  // Not (X)
  
  addLispEvaluator("wynynoujiakixjus", new F1<Lisp,Bool>() {
    Bool get(Lisp l) {
      ret !isTrue(callLispEvaluator(l.get(0)));
    }
  });
  
  // X <> Y
  addLispEvaluator("buahjsodljsaxvaq", new F1<Lisp,Bool>() {
    Bool get(Lisp l) {
      ret l.size() == 2 && neq(l.get(0), l.get(1));
    }
  });
  
  // X > Y
  addLispEvaluator("wdbphzfoxwlrhdyl", new F1<Lisp,Bool>() {
    Bool get(Lisp l) {
      ret l.size() == 2 && eq(compareIfNotNull(lispToBigInt(l.get(0)), lispToBigInt(l.get(1))), 1);
    }
  });
  
  // I don't know if (X)
  addLispEvaluator("mzdvauejerzefagk", new F1<Lisp,Bool>() {
    Bool get(Lisp l) {
      ret l.size() == 1 && notKnownIf(l.get(0));
    }
  });
  
  // There is no statement with operator X.
  addLispEvaluator("zhoulgsatpswstfa", new F1<Lisp,Bool>() {
    Bool get(Lisp l) {
      ret l.size() == 1 && !hasTruthWithHead(l.raw(0));
    }
  });
  
  // There is no answer to (X).
  addLispEvaluator("xikyminwmeahxiws", new F1<Lisp,Bool>() {
    Bool get(Lisp l) {
      bool ok = l.size() == 1 && null == lispForward("pxavyqesoqyqbipb", l.get(0));
      print("Checking for answer to " + l.get(0) + " => " + ok);
      ret ok;
    }
  });
  
  // :- rules
  for (final Lisp rule : lispTruth2("sicrogpdrtkiptun"))
    addLispEvaluator(rule.raw(0), new F1<Lisp,Bool>() {
    Bool get(Lisp l) {
      ret l.isLeaf() && matchCondition_simple(rule.get(1));
    }
  });
}