bool debug;

  bool imagineMode;

  bool collectCheckingLog = true;

  new LinkedHashSet<S> imaginedFacts;

  LS checkingLog;

  long processingTime;

  new L<IfThen> activeTempRules;

  int evalTimeout = 20000;

  bool useIterate; // full iterate mode for normal rule checking

  O standardGrouper; // grouping function for all input

  *() {

    please include function parse3_cachedPattern.

    please include function parse3_cachedInput.

    setMaxSizeOfMRUCache(parse3_cachedPattern_cache, 10000);

    setMaxSizeOfMRUCache(parse3_cachedInput_cache, 10000);

  }

  void thinkAbout(S s) {

    time "Processing Time For Message"{

      thinkAbout_impl(s);

    }

    processingTime = lastTiming();

  }

  void thinkAbout_impl(fS input) {

    final new Thinking t;

    final Map<S, O> tl = getMCThreadLocals(ai_staticVars());

    /*Thread thread = startThread("Think!", r {

      setMCThreadLocals(tl);*/

      t.thinkAbout(input);

    /*});*/

    int n = 0;

    do {

      while (l(t.output) > n)

        postMessage(t.output.get(n++));

      //joinThread(thread, 50);

    } while (!t.done);

    activeTempRules.clear();

  }

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

  class Thinking {

    long cancelTime = now()+20000;

    new Map<S, Int> ruleScores;

    volatile bool posted, done;

    new L<IfThen> rules;

    replace Plan with PlanInMotion.

    new Plan<Runnable> plan;

    new HashSet<S> outputSet;

    LS output = synchroList();

    void postMessage(S s) {

      //_postMessage(s);

      if (outputSet.add(s))

        output.add(s);

      posted = true;

    }

    void done() { done = true; }

    void thinkAbout(S input) {

      try {

        thinkAbout_impl(input);

      } finally {

        done();

      }

    }

    void thinkAbout_impl(fS input0) {

      fS input1 = unixLineBreaks(input0);

      plan.add(r "!initiative" {

        if (!eq(input1, "!initiative")) ret;

        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 with done();

          }

        }

        ret with done();

      });

      plan.add(r "!step" {

        new Matches mm;

        if (!startsWith_trim(input1, "!step ", mm)) ret;

        // TODO

      });

      runPlanWithCheck(plan, func -> bool { !done });

      if (done) ret;

      stdCommands(input1);

      S input2 = input1;

      final new LS options;

      if (startsWith(input2, "[")) {

        addAll(options, leadingSquareBracketOptions(input2));

        input2 = dropLeadingSquareBracketStuff(input2);

      }

      fS input = callFOrKeep(standardGrouper, input2);

      ai_tg_collectRuleFeedback(ruleScores, null);

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

        }

      };

      if (collectCheckingLog) {

        checkingLog = new L;

        nlLogic_collectCheckingLog(c, checkingLog);

      }

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

      NLLogic_MultiThreadedEngine engine = new(rulesAndFacts);

      engine.unsafeEvals = true; // TODO: make sure we don't eval deep into some weird computation

      engine.showFailed = false;

      engine.makeLogicChecker = func -> NLLogicChecker_v2 {

        new NLLogicChecker_v2 c;

        c.recentHistory = recentHistory;

        c.useIterate = useIterate;

        ret c;

      };

      engine.seedInput(input);

      engine.fullRun();

      ExecutedRule winner = first(engine.executedRules());

      if (winner != null)

        fireRule(assertNotNull("logic checker", winner.logicChecker), winner.rule);

      if (collectCheckingLog)

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

    }

    void fireRule(NLLogicChecker_v2 c, RuleWithParams r) {

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

      // Save rule fire

      fS msgGlobalID = getString(telegram_msg(), 'globalID);

      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, this);

    }

  } // end class Thinking

  void executeRule(NLLogicChecker_v2 c, RuleWithParams r, Thinking t) {

    // Execute rule

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

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

      if (e cast Func) {

        S name = e.name, arg = nlLogic_text(e.arg);

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

          t.postMessage(arg);

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

          S fact = arg;

          if (imagineMode) {

            if (!containsNL(imaginedFacts, fact)) {

              imaginedFacts.add(fact);

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

            }

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

            t.postMessage("Storing fact: " + fact);

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

          S rule = arg;

          if (!telegram_authorizedToStoreRule(rule)) continue;

          rule = nlLogic_addGlobalID(rule);

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

            t.postMessage("Rule stored");

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

          imagineMode = match("true", arg);

          if (!imagineMode) imaginedFacts.clear();

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

          S x = arg;

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

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

        } */ else if (c.checkHelper(e, ai_matchingWrapping(r.matches))) {

        } else

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

      } else

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

    }

  }

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

    Pair<L<IfThen>, LS> p = ai_activeRulesAndFacts(imagineMode ? asList(imaginedFacts) : null);

    if (debug)

      print("getRulesAndFacts: " + n2(p.a, "rule"));

    ret p;

  }

  void stdCommands(S s) {

    s = trim(s);

    final new Matches m;

    S procedure = nlLookup(mechMap("Telegram Procedures"), s, m);

    if (procedure != null) {

      procedure = expandDollarRefsToMatches(procedure, m, true);

      print(">> " + procedure);

      postMessage(strOrNull(javaEvalOrInterpret(procedure)));

    }

    print("s=" + s);

    S language = 'english;

    if (swic_trim(s, "!german ", m)) {

      language = 'german;

      s = m.rest();

      print("s=" + s);

    }

    ai_setLanguage(language);

    if (swic_trim(s, "!say ", m))

      postMessage(m.rest());

    if (eq(s, "!gac"))

      postMessage(random_gac36k());

    if (swic_trim(s, "!parse ", m))

      postMessage(ai_renderCulledParseTree(ai_parseToTreeWithGuessing(m.rest())));

    if (swic_trim(s, "!simplify ", m))

      postMessage(lines(ai_parseTree_simplifiedTexts(ai_parseToTreeWithGuessing(m.rest()))));

    if (swicOneOf_trim(s, m, "!factsFrom ", "!factsFrom\n")) {

      S x = m.rest();

      ai_deriveFacts_debug = leadingSquareBracketOptions(x).contains("debug");

      temp tempSet(NLLogicChecker_v2, staticVerbose := ai_deriveFacts_debug);

      fS _x = dropActuallyLeadingSquareBracketStuff(x);

      postMessage(or2(evalWithTimeout_text(evalTimeout, func {

        lines(ai_factsFromNewFacts(tlft(_x)))

      }), "No new facts found"));

    }

    if (swic_trim(s, "!askBack ", m)) {

      NLLogicChecker_v2 c = nlLogicCheckerWithRulesAndFacts(getRulesAndFacts());

      c.input = m.rest();

      askBack(c);

    }

    if (swic_trim(s, "!askBackAboutFact ", m)) {

      NLLogicChecker_v2 c = nlLogicCheckerWithRulesAndFacts(getRulesAndFacts());

      c.facts = listPlus_inFront(c.facts, m.rest());

      askBack(c);

    }

    /*if (telegram_amIAuthorized())*/ {

      if (telegram_amIFullyAuthorized()) {

        if (eq(s, "!reload")) {

          if (!hasFunctionNamed(mc(), 'dm_reloadMe))

            postMessage("Not a module");

          else {

            postMessage("OK, reloading.");

            doAfter(1000, 'dm_reloadMe);

            ret;

          }

        }

        bool freshMe = swic_trim(s, "!fresh ", m);

        if (freshMe || eq(s, "!fresh")) { dm_refreshTranspiler(); if (!freshMe) postMessage("OK"); }

        if (swic_trim(s, "!eval ", m))

          postMessage(pcallOrExceptionText(func { strOrNull(javaEvalOrInterpret(m.rest())) }));

        if (freshMe || swic_trim(s, "!real-eval ", m))

          postMessage(evalWithTimeout_text(evalTimeout, func {

            javaEval(m.rest())

          }));

      }

      if (swic_trim(s, "!rule ", m)) {

        S rule = m.rest();

        if (!telegram_authorizedToStoreRule(rule)) ret;

        LS rules = trimAll(ai_unparsedTalkRules());

        if (!contains(rules, rule)) { // TODO: ignore global IDs

          rule = nlLogic_addGlobalID(rule);

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

          postMessage("Rule saved as " + leadingSquareBracketOptions_id(rule) + ". Have " + n2(l(rules)+1, "rule") + ".");

        }

      }

      if (swic_trim(s, "!fact ", m)) {

        S fact = m.rest();

        LS facts = mL("Random facts");

        if (!contains(facts, fact)) {

          appendToMechList_noUniq("Random facts", fact);

          postMessage("Fact saved. Have " + n2(l(facts)+1, "fact") + ".");

        }

      }

      if (eqic(s, "!deriveFacts"))

        postMessage("Got " + n2(ai_applyFactToFactRules(), "fact") + ". Total: " + l(mL("Derived facts")));

      if (eqic(s, "!groupFacts"))

        if (standardGrouper != null) {

          appendToMechList("Derived facts", map(standardGrouper, ai_facts()));

          postMessage("OK");

        }

      if (eqic(s, "!imaginaryFacts")) {

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

        LS facts = reversed(rulesAndFacts.b);

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

        final Set<S> toDrop = asHashSet(matchAll_first("$x is not a general chat rule", facts));

        rules = [IfThen r : rules | !toDrop.contains(r.globalID)

          && !ai_ruleAccessesInput(r)];

        print("Deriving from " + n2(rules, "rule") + " and " + n2(facts, "fact"));

        set ai_deriveFacts_debug;

        Set<S> newFacts = ai_deriveFacts(rules, facts);

        newFacts = setMinusSet(newFacts, facts);

        imaginedFacts.addAll(newFacts);

        postMessage("Got " + n2(newFacts, "imaginary fact") + ". Total: " + l(imaginedFacts));

      }

      // end of authorized functions

    }

  }

  void askBack(NLLogicChecker_v2 c) {  

    L<RuleFailInfo> fails = nlLogic_sortedRuleFails(nlLogic_ruleFails(c, c.rules));

    print("Have " + n2(fails, "fail"));

    //pnl(fails);

    postMessage(lines(nlLogic_unresolvedFactsToQuestions(fails)));

  }