bool debug;

  bool imagineMode;

  bool collectCheckingLog = true;

  new LinkedHashSet<S> imaginedFacts;

  LS checkingLog;

  long processingTime;

  new L<IfThen> activeTempRules;

  visualize {

    ret withCenteredButtons(super.visualize(),

      "Checking Log", r { showText("Checking Log", lines(checkingLog)) });

  }

  S evalExp(Exp e, NLLogicChecker_v2.Matching m) {

    S code = nlLogic_text(e);

    print("Eval'ing: " + code);

    temp tempAdd(hotwire_copyOver_after, voidfunc(Class c) {

      copyFields(mc(), c, 'telegram_msg_tl, 'telegram_recentHistory_tl)

    });

    S result = str(evalWithDollarVars(code, m.matches));

    print("Result: " + shorten(result, 100));

    ret result;

  }

  void thinkAbout(S s) {

    time "Processing Time For Message"{

      thinkAbout_impl(s);

    }

    processingTime = lastTiming();

  }

  void thinkAbout_impl(S input) {

    new Thinking().thinkAbout_impl(input);

  }

  void _postMessage(S s) { postMessage(s); }

  class Thinking {

    long cancelTime = now()+20000;

    new Map<S, Int> ruleScores;

    new LinkedHashSet<S> rewrittenInputs;

    new LinkedHashSet<S> newRewrittenInputs;

    bool posted;

    void postMessage(S s) {

      _postMessage(s);

      posted = true;

    }

    void thinkAbout_impl(S input) {

      if (eq(input, "!initiative")) {

        L<IfThen> rules = mL_parsedNLRulesWithoutIDs("Initiative rules");

        for (IfThen rule : shuffledIterator(rules)) {

          Pair<Exp> p = nlLogic_extractFirstCondition(rule.in);

          if (p == null) continue;

          if (nlLogic_isFunc(p.a, 'initiative)) {

            postMessage(nlLogic_text(((Func) p.a).arg));

            IfThen temp = IfThen(p.b, rule.out);

            temp.globalID = aGlobalID();

            print("Have temp rule: " + sfu(temp));

            activeTempRules.add(temp);

            ret;

          }

        }

        ret;

      }

      ai_tg_collectRuleFeedback(ruleScores, null);

      newRewrittenInputs.add(input);

      final Map msg = telegram_msg();

      NLLogicChecker_v3 c = new NLLogicChecker_v3 {

        bool checkExpression_impl(Exp e, Matching m) {

          if (e instanceof Literal) {

            // TEXT CONDITIONS

            S text = nlLogic_text(e);

            if (eq(text, "authorized"))

              ret telegram_amIAuthorized();

            else if(eq(text, "imagineMode"))

              ret imagineMode;

          }

          ret super.checkExpression_impl(e, m);

        }

      };

      c.evaluator = func(Exp e, NLLogicChecker_v2.Matching m) -> S { evalExp(e, m) };

      if (collectCheckingLog) {

        checkingLog = new L;

        nlLogic_collectCheckingLog(c, checkingLog);

      }

      Pair<L<IfThen>, LS> rulesAndFacts = getRulesAndFacts();

      c.facts = reversed(rulesAndFacts.b);

      L<IfThen> rules = concatLists_conservative(activeTempRules, reversed(rulesAndFacts.a)); // latest rules first!

      activeTempRules.clear();

      while (!posted && now() < cancelTime && nempty(newRewrittenInputs)) {

        fS s = first(newRewrittenInputs);

        rewrittenInputs.add(s);

        newRewrittenInputs.remove(s);

        c.input = s;

        c.recentHistory = recentHistory;

        final new L<RuleWithParams> battleSpace;

        applyNLLogicFacts_v4_verbose.set(debug);

        applyNLLogicFacts_v4(c, voidfunc(IfThen rule, NLLogicChecker_v2.Matching m) {

          // Rule fired!

          battleSpace.add(new RuleWithParams(rule, m.matches));

        }, rules);

        print("Have " + n2(battleSpace, "possible rule"));

        nlLogic_battleItOut(battleSpace, c.facts);

        L<RuleWithParams> winners = nlLogic_highestScore(battleSpace, ruleScores);

        fS msgGlobalID = getString(msg, 'globalID);

        //print("msgGlobalID=" + msgGlobalID);

        for (RuleWithParams r : winners) {

          print("Firing rule " + r.rule.globalID);

          // Save rule fire

          if (nempty(msgGlobalID) && nempty(r.rule.globalID)) {

            S fact = format("Rule * fired on message * at *", r.rule.globalID, msgGlobalID, localDateWithMilliseconds());

             if (nempty(r.matches))

               fact += " with vars " + dropPrefix("lhm", struct(r.matches));

            print("Saving rule fire. Mech mode: " + mechMode());

            print(addToMechList("Telegram Rule Fires", print(fact)));

          }

          executeRule(c, r);

        }

        if (collectCheckingLog)

          print("Checking log length: " + l(checkingLog));

      }

    }

    void executeRule(NLLogicChecker_v3 c, RuleWithParams r) {

      // Execute rule

      for (Exp e : nlLogic_unrollAnd(r.rule.out)) {

        e = c.apply(e, r.matches);

        if (e cast Func) {

          S name = e.name;

          if (eqOneOf(name, 'output, 'say))

            postMessage(nlLogic_text(e.arg));

          else if (eq(name, 'fact)) {

            S fact = nlLogic_text(e.arg);

            if (imagineMode) {

              if (!containsNL(imaginedFacts, fact)) {

                imaginedFacts.add(fact);

                postMessage("Storing imaginary fact: " + fact);

              }

            } else if (!ai_isQuestion_2(fact) && ai_storeActualFact(fact))

              postMessage("Storing fact: " + fact);

          } else if (eq(name, 'storeRule)) {

            S rule = nlLogic_text(e.arg);

            if (!telegram_authorizedToStoreRule(rule)) continue;

            rule = nlLogic_addGlobalID(rule);

            if (mech_changed(appendToMechList_noUniq("NL Logic Examples", "\n" + rule)))

              postMessage("Rule stored");

          } else if (eq(name, 'imagineMode)) {

            imagineMode = match("true", nlLogic_text(e.arg));

            if (!imagineMode) imaginedFacts.clear();

          } else if (eq(name, 'input)) {

            S x = nlLogic_text(e.arg);

            if (!rewrittenInputs.contains(x) && newRewrittenInputs.add(x))

              print("New rewritten input: " + x);

          } else

            ret with print("Skipping rule with unknown RHS func: " + e.name);

        } else

          ret with print("Skipping rule with unknown RHS element: " + e);

      }

    }

  } // end class Thinking

  Pair<L<IfThen>, LS> getRulesAndFacts() { 

    ret ai_activeRulesAndFacts(imagineMode ? asList(imaginedFacts) : null);

  }