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);
  }