import java.util.*;

import java.util.zip.*;

import java.util.List;

import java.util.regex.*;

import java.util.concurrent.*;

import java.util.concurrent.atomic.*;

import java.util.concurrent.locks.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.text.*;

import javax.swing.table.*;

import java.io.*;

import java.net.*;

import java.lang.reflect.*;

import java.lang.ref.*;

import java.lang.management.*;

import java.security.*;

import java.security.spec.*;

import java.awt.*;

import java.awt.event.*;

import java.awt.image.*;

import javax.imageio.*;

import java.math.*;

// We don't use #1006722 anymore

//   (but it's still listed in #7!?)

// TODO: deprecate (remove) the "f <id>" syntax

// TODO: skip ifclass blocks in findFunctionInvocations.

//       after main loop completes (including standard functions+

//       classes), run tok_ifclass and if any change, run main loop

//       again.

//       This will allow clean handling of functions like "unnull"

//       which right now _always_ include Symbol (because unnull

//       references emptySymbol inside an ifclass Symbol block).

// Note: Before editing this, transpile #7

// Use 'Very fresh' (R-transpile doesn't seem to work) or Q/M if you haven't screwed yourself currently

// by making your transpiler unable to transpile itself... or

// something

// Note: Don't try hijackPrint, it doesn't seem to work in here

// (because of the way it is called by e.g. transpileForServer_returnPair?)

/* functions to possibly edit when creating/changing JavaX constructs:

  tok_pingify

*/

// new JavaParser includes

import com.github.javaparser.*;

import com.github.javaparser.ast.CompilationUnit;

import com.github.javaparser.ast.Node;

import com.github.javaparser.ast.body.*;

import com.github.javaparser.ast.visitor.*;

import com.github.javaparser.Problem;

import com.github.javaparser.ast.NodeList;

import com.github.javaparser.ast.body.MethodDeclaration;

import com.github.javaparser.ast.body.EnumDeclaration;

import com.github.javaparser.ast.stmt.LocalClassDeclarationStmt;

import com.github.javaparser.printer.*;

import java.text.DecimalFormat;

import java.text.SimpleDateFormat;

import java.text.NumberFormat;

import java.nio.charset.Charset;

import javax.imageio.metadata.*;

import javax.imageio.stream.*;

import static x30_pkg.x30_util.DynamicObject;

import java.nio.file.Files;

import java.nio.file.Path;

class main {

 // JavaParser

static CompilationUnit javaParseCompilationUnit(String java) { return javaParseCompilationUnit(java, false); }

static CompilationUnit javaParseCompilationUnit(String java, boolean withComments) {

  JavaParser p = new JavaParser();

  p.getParserConfiguration().setAttributeComments(withComments);

  ParseResult<CompilationUnit> r = p.parse(java);

  if (!r.isSuccessful())

    throw fail(str(r));

  return r.getResult().get();

}

static String javaParser_makeAllPublic(String src, Object... __) {

  CompilationUnit cu = javaParseCompilationUnit(src);

  PrettyPrinterConfiguration ppconf = new PrettyPrinterConfiguration();

  ppconf.setIndentSize(2);

  ppconf.setIndentType(PrettyPrinterConfiguration.IndentType.SPACES);

  ppconf.setPrintComments(false);

  javaParser_makeAllPublic_Visitor visitor = new javaParser_makeAllPublic_Visitor();

  visitor.notTopLevelClassDecl = boolOptPar("notTopLevelClassDecl", __);

  visitor.visit(cu, null);

  return cu.toString(ppconf);

}

static class javaParser_makeAllPublic_Visitor extends VoidVisitorAdapter {

  boolean notTopLevelClassDecl = false; // don't make top-level class declaration public

  void makePublic(NodeList<com.github.javaparser.ast.Modifier> modifiers) {

    // XXX: does this work?

    modifiers.remove(com.github.javaparser.ast.Modifier.privateModifier());

    modifiers.remove(com.github.javaparser.ast.Modifier.protectedModifier());

    if (!modifiers.contains(com.github.javaparser.ast.Modifier.publicModifier()))

      modifiers.add(com.github.javaparser.ast.Modifier.publicModifier());

  }

  public void visit(ClassOrInterfaceDeclaration n, Object arg) {

    Node parent = n.getParentNode().get();

    if (!(parent instanceof LocalClassDeclarationStmt

      || parent instanceof CompilationUnit && neq(n.getName().asString(), "main")))

      if (notTopLevelClassDecl)

        notTopLevelClassDecl = false;

      else

        makePublic(n.getModifiers());

    super.visit(n, arg);

  }

  public void visit(FieldDeclaration n, Object arg) {

    makePublic(n.getModifiers());

    super.visit(n, arg);

  }

  public void visit(ConstructorDeclaration n, Object arg) {

    Node parent = n.getParentNode().get();

    if (!(parent instanceof EnumDeclaration))

      makePublic(n.getModifiers());

    super.visit(n, arg);

  }

  public void visit(MethodDeclaration n, Object arg) {

    NodeList<com.github.javaparser.ast.Modifier> m = n.getModifiers();

    //print("Method found: " + n.getName() + " with modifiers: " + m + ", position: " + n.getRange()->begin);

    if (m.contains(com.github.javaparser.ast.Modifier.privateModifier()) && !m.contains(com.github.javaparser.ast.Modifier.staticModifier()) && !m.contains(com.github.javaparser.ast.Modifier.finalModifier()))

      m.add(com.github.javaparser.ast.Modifier.finalModifier());

    makePublic(m);

    super.visit(n, arg);

  }

}

static String javaParser_reparse_keepComments(String src) {

  CompilationUnit cu = javaParseCompilationUnit(src, true);

  PrettyPrinterConfiguration ppconf = new PrettyPrinterConfiguration();

  ppconf.setPrintComments(true);

  ppconf.setIndentSize(2);

  ppconf.setIndentType(PrettyPrinterConfiguration.IndentType.SPACES);

  return cu.toString(ppconf);

}

static String javaParser_makeAllPublic_keepComments(String src) {

  CompilationUnit cu = javaParseCompilationUnit(src);

  PrettyPrinterConfiguration ppconf = new PrettyPrinterConfiguration();

  ppconf.setPrintComments(true);

  ppconf.setIndentSize(2);

  ppconf.setIndentType(PrettyPrinterConfiguration.IndentType.SPACES);

  new javaParser_makeAllPublic_Visitor().visit(cu, null);

  return cu.toString(ppconf);

}

static int findCodeTokens(List<String> tok, String... tokens) {

  return findCodeTokens(tok, 1, false, tokens);

}

static int findCodeTokens(List<String> tok, boolean ignoreCase, String... tokens) {

  return findCodeTokens(tok, 1, ignoreCase, tokens);

}

static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String... tokens) {

  return findCodeTokens(tok, startIdx, ignoreCase, tokens, null);

}

static HashSet<String> findCodeTokens_specials = lithashset("*", "<quoted>", "<id>", "<int>", "\\*");

static int findCodeTokens_bails, findCodeTokens_nonbails;

static interface findCodeTokens_Matcher {

  boolean get(String token);

}

static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String[] tokens, Object condition) {

  int end = tok.size()-tokens.length*2+2, nTokens = tokens.length;

  int i = startIdx | 1;

  findCodeTokens_Matcher[] matchers = new findCodeTokens_Matcher[nTokens];

  IContentsIndexedList2 indexedList = tok instanceof IContentsIndexedList2 ? (IContentsIndexedList2) tok : null;

  TreeSet<HasIndex> indices = null;

  int indicesOfs = 0;

  for (int j = 0; j < nTokens; j++) {

    String p = tokens[j];

    findCodeTokens_Matcher matcher;

    if (p.equals("*"))

      matcher = t -> true;

    else if (p.equals("<quoted>"))

      matcher = t -> isQuoted(t);

    else if (p.equals("<id>"))

      matcher = t -> isIdentifier(t);

    else if (p.equals("<int>"))

      matcher = t -> isInteger(t);

    else if (p.equals("\\*"))

      matcher = t -> t.equals("*");

    else if (ignoreCase)

      matcher = t -> eqic(p, t);

    else {

      matcher = t -> t.equals(p);

      if (indexedList != null) {

        TreeSet<HasIndex> indices2 = indexedList.indicesOf_treeSetOfHasIndex(p);

        if (indices2 == null) return -1;

        if (indices == null || indices2.size() < indices.size()) {

          // found shorter list

          indices = indices2;

          indicesOfs = j;

        }

      }

    }

    matchers[j] = matcher;

  }

  // go over shortest index

  if (indices != null) {

    int min = i+indicesOfs*2;

    SortedSet<HasIndex> tailSet = min == 1 ? indices : indices.tailSet(new HasIndex(min));

    outer: for (HasIndex h : tailSet) {

      int idx = h.idx-indicesOfs*2;

      if (idx >= end) break;

      for (int j = 0; j < nTokens; j++) try {

        if (!matchers[j].get(tok.get(idx+j*2)))

          continue outer;

      } catch (IndexOutOfBoundsException e) {

        print("fct indicesOfs=" + indicesOfs + ", h=" + h + ", idx=" + idx);

        throw e;

      }

      if (condition == null || checkTokCondition(condition, tok, idx-1))

        return idx;

    }

    return -1;

  }

  outer: for (; i < end; i += 2) {

    for (int j = 0; j < nTokens; j++)

      if (!matchers[j].get(tok.get(i+j*2)))

        continue outer;

    if (condition == null || checkTokCondition(condition, tok, i-1)) // pass N index

      return i;

  }

  return -1;

}

static boolean autoQuine = true;

static int maxQuineLength = 80;

static boolean assumeTriple = true;

static boolean quickInstanceOfEnabled = false; // interferes with things

static boolean debug_jreplace = false;

// _registerThread usually costs nothing because we need

// the registerWeakHashMap mechanism anyway for ping().

// Anyway - no forced functions for now :)

static List<String> functionsToAlwaysInclude = ll(

  //"_registerThread",

  //"asRuntimeException"

);

// classes with two type parameters that can written with just one

// e.g. Pair<S> => Pair<S, S>

static Set<String> pairClasses = lithashset("Pair", "Either", "Map", "AbstractMap", "HashMap", "TreeMap", "LinkedHashMap", "MultiMap", "CompactHashMap", "WrappedMap", "F1", "IF1", "AllOnAll", "AllOnAllWithUpdates", "MultiSetMap", "AutoMap", "ValueOnDemandMap", "NavigableMap", "SortedMap");

// classes with 3 type parameters that can written with just one

// e.g. T3<S> => T3<S, S, S>

static Set<String> tripleClasses = lithashset("T3", "IF2", "F2", "IVF3", "VF3");

static String transpilingSnippetID;

//static new AtomicInteger varCount;

static ThreadLocal<AtomicInteger> varCountByThread = new ThreadLocal();

static Map<String, String> snippetCache = syncMap();

static boolean useIndexedList2 = false, useTokenIndexedList = true;

static boolean opt_javaTok = true;

static boolean cacheStdFunctions = true, cacheStdClasses = true;

static HashMap<Long, CachedInclude> cachedIncludes = new HashMap();

static ExecutorService executor;

static List lclasses;

static long startTime, lastPrint;

// These variables have to be cleared manually for each transpilation

static HashSet<Long> included = new HashSet();

static NavigableSet<String> definitions = ciSet();

static HashMap<String, String> rewrites = new HashMap();

static HashSet<String> shouldNotIncludeFunction = new HashSet(); // this verifies after the fact that the function was not included

static HashSet<String> shouldNotIncludeClass = new HashSet();

static HashSet<String> doNotIncludeFunction = new HashSet(); // this actually prevents the function from being included

static Map<String, String> functionToPackage = new HashMap();

static HashSet<String> doNotIncludeClass = new HashSet();

static HashSet<String> needLatest = new HashSet(); // this forces a function to be included

static HashSet<String> addedFunctions = new HashSet();

static HashSet<String> addedClasses = new HashSet();

static HashSet<String> hardFunctionReferences = new HashSet();

static HashSet<String> mapLikeFunctions = new HashSet();

static HashSet<String> lambdaMapLikeFunctions = new HashSet();

static HashSet<String> curry1LikeFunctions = new HashSet();

static HashSet<String> mapMethodLikeFunctions = new HashSet();

static HashSet<String> nuLikeFunctions = new HashSet();

static HashSet<String> getLikeFunctions = new HashSet(); // name is slightly misleading. this turns a pre-argument into a fieldLambda

static HashSet<String> lambdaMethod0LikeFunctions = new HashSet(); // we're getting better again with the names (maybe)

static HashSet<String> lambda0LikeFunctions = new HashSet();

static Map<String, String> extraStandardFunctions;

static boolean quickmainDone1, quickmainDone2;

static TreeSet<String> libs = new TreeSet();

static String mainBaseClass, mainPackage, mainClassName;

static boolean localStuffOnly = false; // for transpiling a fragment

static boolean asInclude = false; // for transpiling an include (auto-close scopes, enable all standard class ifclass [todo])

static boolean allowMetaCode = false; // run any embedded meta code

static List<String> metaPostBlocks, metaTransformers;

static boolean dontPrintSource = false;

static boolean dontLoadCachedIncludesFromVM = false; // for benchmarking

static HashSet<String> haveClasses = new HashSet();

static class CachedInclude {

  String javax;

  Future<String> java;

  String realJava;

  long snippetID;

  CachedInclude() {}

  CachedInclude(long snippetID) {

  this.snippetID = snippetID;}

  String java() {

    return realJava != null ? realJava : getFuture(java);

  }

  Future<String> javaFuture() {

    return realJava != null ? nowFuture(realJava) : java;

  }

  void clean() {

    if (java != null) {

      realJava = getFuture(java);

      java = null;

    }

  }

}

public static void main(final String[] args) throws Exception {

  startTime = lastPrint = sysNow();

  try {

    if (!dontLoadCachedIncludesFromVM)

      vmKeepWithProgramMD5_get("cachedIncludes");

  } catch (Throwable __e) { _handleException(__e); }

  executor = Executors.newFixedThreadPool(numberOfCores());

  transpilingSnippetID = or(getThreadLocal((ThreadLocal<String>) getOpt(javax(), "transpilingSnippetID")), transpilingSnippetID);

  //print(+transpilingSnippetID);

  transpileRaw_dontCopyFromCreator = true;

  final Object oldPrint = or(print_byThread().get(), "print_raw");

   AutoCloseable __17 = tempInterceptPrint(new F1<String, Boolean>() {

    Boolean get(String s) {

      long now = sysNow();

      long time = now-lastPrint; // -startTime;

      lastPrint = now;

      callF(oldPrint, "[" + formatInt(time/1000, 2) + ":" + formatInt(time % 1000, 3) + "] " + s);

      return false;

    }

  }); try {

  try {

    _main();

  } finally {

    interceptPrintInThisThread(oldPrint);

    if (executor != null) executor.shutdown();

    executor = null;

    localStuffOnly = false;

    asInclude = false;

  }

} finally { _close(__17); }}

static void _main() { try {

  if (sameSnippetID(programID(), defaultJavaXTranslatorID())) setDefaultJavaXTranslatorID("#7");

  //reTok_modify_check = true;

  //if (useIndexedList) findCodeTokens_debug = true;

  javaTok_opt = opt_javaTok;

  //findCodeTokens_indexed = findCodeTokens_unindexed = 0;

  findCodeTokens_bails = findCodeTokens_nonbails = 0;

  javaTok_n = javaTok_elements = 0;

  String in = loadMainJava();

  print("759 STARTING " + identityHashCode(main.class));

  // clear things

  includeInMainLoaded_magicComment = null;

  included.clear();

  definitions.clear();

  rewrites.clear();

  // XXX definitions.add("SymbolAsString");

  shouldNotIncludeFunction.clear();

  shouldNotIncludeClass.clear();

  doNotIncludeFunction.clear();

  functionToPackage.clear();

  needLatest.clear();

  doNotIncludeClass.clear();

  addedFunctions.clear();

  addedClasses.clear();

  hardFunctionReferences.clear();

  mapLikeFunctions = cloneHashSet(tok_mapLikeFunctions());

  lambdaMapLikeFunctions = new HashSet();

  curry1LikeFunctions = new HashSet();

  mapMethodLikeFunctions = cloneHashSet(tok_mapMethodLikeFunctions());

  nuLikeFunctions.clear();

  getLikeFunctions.clear();

  lambdaMethod0LikeFunctions.clear();

  lambda0LikeFunctions.clear();

  extraStandardFunctions = new HashMap();

  libs.clear();

  mainBaseClass = mainPackage = mainClassName = null;

  varCountByThread.set(null);

  quickmainDone1 = quickmainDone2 = false;

  metaPostBlocks = new ArrayList();

  metaTransformers = new ArrayList();

  dontPrintSource = false;

  defaultMaxQuineLength_value = defaultMaxQuineLength_defaultValue;

  debug_jreplace = false;

  haveClasses.clear();

  //L ts = findTranslators(toLines(join(tok)));

  //print("Translators in source at start: " + structure(ts));

  List<String> tok = jtok(in);

  try {

    tok_definitions(tok);

    // add m { }

    if (!localStuffOnly && !hasCodeTokens(tok, "m", "{") && !hasCodeTokens(tok, "main", "{") && !hasCodeTokens(tok, "class", "main")) {

      if (l(tok) == 1) tok = singlePlusList(first(tok), dropFirst(javaTok("m {}")));

      else {

        replaceTokens_reTok(tok, 1, 2, "m {\n\n" + unnull(get(tok, 1)));

        replaceTokens_reTok(tok, l(tok)-2, l(tok)-1, unnull(get(tok, l(tok)-2)) + "}");

      }

      tok_moveImportsUp(tok);

    }

    // standard translate

    //ts = findTranslators(toLines(join(tok)));

    //print("Translators in source: " + structure(ts));

    if (tok_hasTranslators(tok))

      tok = jtok(defaultTranslate(join(tok)));

    //print("end of default translate");

    //print(join(tok));

    //tok_autoCloseBrackets(tok);    

    tok_metaTransformNow(tok);

    tok_processEarlyIncludes(tok);

    tok_earlyGeneralStuff(tok);

    tok = tok_processIncludes(tok); // before standard functions

    if (processConceptsDot(tok))

      tok = tok_processIncludes(tok);

    tok = localStuff1(tok);

   if (!localStuffOnly) {

    int safety = 0;

    boolean same = false;

    do { // BIG LOOP

      ping();

      List<String> before = cloneList(tok);

      // do the non-local stuff (flags and rewrites, things that correlate across includes like tok_selfType)

      // to allow crazy stuff like "nonStatic !include #someStaticClass"

      tok_processEarlyIncludes(tok);

      jreplace(tok, "nonStatic static", "");

      tok_selfType(tok);

      tok_mainClassNameAndPackage(tok);

      tok_definitions(tok);

      tok_ifndef(tok);

      tok_ifdef(tok);

      defineMapLikes(tok);

      defineLambdaMapLikes(tok);

      defineCurry1Likes(tok);

      defineMapMethodLikes(tok);

      defineNuLikes(tok);

      defineXLikes(tok, "getLike", getLikeFunctions);

      defineXLikes(tok, "lambdaMethod0Like", lambdaMethod0LikeFunctions);

      defineXLikes(tok, "lambda0Like", lambda0LikeFunctions);

      if (tok_applyAllXLikeFunctions(tok)) {

        functionReferences(tok);

        lambdaReferences(tok);

      }

      tok_dropExtraCommas(tok); // from e.g. tok_applyMapMethodLikeFunctions

      tok_delegateTo(tok);

      tok_replaceWith(tok);

      tok_findAndClearRewrites(tok);

      tok_processRewrites(tok);

      tok_multiTypeArguments_v2(tok);

      // main bla(...) => mainClassName.bla(...)

      // or main ClassName => main.ClassName

      //jreplace(tok, "main <id>(", mainClassName() + ".$2(");

      grabImportedStaticFunctions(tok);

      jreplace_dyn_allowNull(tok, "main <id>", (_tok, cIdx, end) -> {

        String fname = _tok.get(cIdx+2);

        boolean isClass = haveClasses.contains(fname);

        printVars("expandMainRef", "fname", fname, "isClass", isClass);

        if (isClass || eqGet(_tok, cIdx+4, "(")) {

          String pkg = functionToPackage.get(fname);

          printVars("expandMainRef", "pkg", pkg);

          String call = "." + fname;

          return or(pkg, mainClassName()) + call;

        }

        return null;

      });

      try {

        if (safety == 0) tok = quickmain(tok);

      } catch (Throwable e) {

        printSources(tok);

        rethrow(e);

      }

      tok_collectMetaPostBlocks(tok, metaPostBlocks);

      tok_collectTransformers(tok, metaTransformers);

      tok_metaTransformNow(tok);

      // Hack to allow DynModule to reimplement _registerThread

      /*if (tok.contains("DynModule") && !addedClasses.contains("DynModule"))

        addStandardClasses_v2(tok);*/

      defineExtraSF(tok);

      tok = standardFunctions(tok);

      tok = stdstuff(tok); // all the keywords, standard

      String diff;

      long startTime = now();

      //diff = unidiff(before, join(tok));

      //print("unidiff: " + (now()-startTime) + " ms");

      //same = eq(diff, "");

      same = eq(tok, before);

      if (!same) {

        print("Not same " + safety + ".");

        //print(indent(2, diff));

      }

      if (safety++ >= 10) {

        //print(unidiff(before, join(tok)));

        printSources(tok);

        throw fail("safety 10 error!");

      }

    } while (!same); // END OF BIG LOOP

    print("Post.");

    if (mainBaseClass != null) {

      jreplace1(tok, "class main", "class main extends " + mainBaseClass);

      mainBaseClass = null;

    }

    print("moveImportsUp"); tok_moveImportsUp(tok);

    print("Indexing"); tok = indexTokenList(tok);

    // POST-PROCESSING after stdstuff loop

    if (transpilingSnippetID != null)

      jreplace_dyn(tok, "class whatever", 

        new F2<List<String>, Integer, String>() { public String get(List<String> tok, Integer cIndex) { try { 

          try { return "class " + stringToLegalIdentifier(getSnippetTitle(transpilingSnippetID)); } catch (Throwable __e) { _handleException(__e); }

          return "class Whatever";

         } catch (Exception __e) { throw rethrow(__e); } }

  public String toString() { return "pcall { ret \"class \" + stringToLegalIdentifier(getSnippetTitle(transpilingSni..."; }});

    //print("Type<A, A>"); // Type<A> to Type<A, A>

    print("extendClasses"); tok = extendClasses(tok);

    print("libs"); libs(tok);

    print("sourceCodeLine"); sourceCodeLine(tok);

    tok_overridableFunctionDefs(tok, null);

    // escaping for lambdas

    //jreplace(tok, "-=>", "->");

    // Stuff that depends on the list of inner classes (haveClasses)

    haveClasses = haveClasses_actual(tok);

    print("innerClassesVar"); innerClassesVar(tok, haveClasses);

    fillVar_transpilationDate(tok);

    haveClasses_addImported(tok, haveClasses);

    print("ifclass"); tok_ifclass(tok, haveClasses);

    print("slashCasts"); slashCasts(tok, haveClasses);

    print("newWithoutNew"); newWithoutNew(tok, haveClasses);

    if (!assumeTriple) {

      print("Triple");

      if (tok.contains("Triple") && !haveClasses.contains("Triple")) {

        jreplace(tok, "Triple", "T3");

        haveClasses.remove("Triple");

        haveClasses.add("T3");

        slashCasts(tok, lithashset("T3"));

        tok_quickInstanceOf(tok, lithashset("T3"));

      }

    }

    if (hasDef("SymbolAsString"))

      jreplace(tok, "Symbol", "String");

    // using non-lazy version now for cleanImports

    print("classReferences"); expandClassReferences/*_lazy*/(tok, haveClasses);

    if (metaCodeAllowed()) runMetaPostBlocks(tok);

    // Error-checking

    print("Error-checking"); 

    Set<String> functions = new HashSet(findFunctions(tok));

    for (String f : hardFunctionReferences)

      if (!functions.contains(f))

        throw fail("Function " + f + " requested, but not supplied");

    print("autoImports"); tok = autoImports(tok); // faster to do it at the end

    if (hasDef("cleanImports"))

      tok_cleanImports(tok);

    if (includeInMainLoaded_magicComment != null) {

      int i = lastIndexOfStartingWith(tok, includeInMainLoaded_magicComment);

      if (i >= 0) tok.set(i, dropPrefix(includeInMainLoaded_magicComment, tok.get(i)));

    }

    print("definitions=" + sfu(definitions));

    if (containsOneOf(definitions, "allpublic", "reparse", "PublicExceptTopClass")) {

      // Fire up the Java parser & pretty printer!

      print(containsIC(definitions, "allpublic")? "Making all public." : "Reparsing.");

      //try {

        String src = join(tok);

        try {

          if (containsIC(definitions, "allpublic"))

            src = javaParser_makeAllPublic(src);

          else if (containsIC(definitions, "PublicExceptTopClass"))

            src = javaParser_makeAllPublic(src, "notTopLevelClassDecl" , true);

          else if (containsIC(definitions, "keepComments"))

            src = javaParser_makeAllPublic_keepComments(src);

          else {

            print("javaParser_reparse_keepComments. size=" + l(src));

            src = javaParser_reparse_keepComments(src);

            print("size=" + l(src));

          }

        } catch (Throwable e) {

          String _src = src;

          String errorContext = extractAndPrintJavaParseError(_src, e);

          File f = transpilerErrorSourceFile();

          saveTextFileVerbose(f, src);

          dontPrintSource = true;

          throw fail("Java parsing error:" + errorContext + innerMessage(e)); // drop the long nested parser stacktraces

        }

        tok = jtok(src);

      /*} catch e {

        S src = join(tok);

        if (!dontPrintSource)

          print(src);

        print(f2s(saveProgramTextFile("error.java", src)));

        throw rethrow(e);

      }*/

    }

    // Do this after JavaParser (because it doesn't like package after class)

    if (mainPackage != null) {

      print("mainPackage");

      tokPrepend(tok, 1, "package " + mainPackage + ";\n");

      reTok(tok, 1, 2);

    }

    if (mainClassName != null) {

      print("mainClassName");

      jreplace(tok, "class main", "class " + mainClassName);

      jreplace(tok, "main.class", mainClassName + ".class");

      //tokPrepend(tok, 1, "class main {}\n"); // so main.class is generated and compiler sanity checks succeed. we can later skip it in the JavaXClassLoader

    }

    if (nempty(libs)) {

      print("Adding libs: " + libs);

      tok.add(concatMap_strings(new F1<String, String>() { public String get(String s) { try {  return "\n!" + s;  } catch (Exception __e) { throw rethrow(__e); } }

  public String toString() { return "\"\\n!\" + s"; }}, libs));

    }

   } // if (!localStuffOnly)

  } catch (Throwable e) {

    if (!dontPrintSource)

      printSources(tok);

    String src = join(tok);

    print(f2s(saveProgramTextFile("error.java", src)));

    throw rethrow(e);

  }

  /*if (useIndexedList)

    print("Indexed/unindexed lookups: " + findCodeTokens_indexed + "/" + findCodeTokens_unindexed + ", lists made: " + IndexedList2.instances);

  print("findCodeToken bails: " + findCodeTokens_bails + "/" + findCodeTokens_nonbails);

  print("javaToks: " + javaTok_n + "/" + javaTok_elements);*/

  print("Saving.");

  // for dexcompile.php

  if (mainClassName != null)

    tokPrepend(tok, 0, "//FILENAME: " 

      + (mainPackage != null ? mainPackage.replace(".", "/") + "/" : "") + mainClassName + ".java\n");

  if (mainJava != null)

    mainJava = join(tok);

  else if (tok.contains("package"))

    splitJavaFiles(tok);

  else

    saveMainJava(tok);

} catch (Exception __e) { throw rethrow(__e); } }

static List<String> localStuff1(List<String> tok) {

  int safety = 0, i;

  boolean same = false;

  tok = indexTokenList(tok);

  tok_scopes(tok, "autoCloseScopes" , true);

  do {

    ping();

    List<String> before = cloneList(tok);

    //print("localStuff loop " + safety);

    earlyStuff(tok);

    // EARLY local stuff goes here

    tok_dropMetaComments(tok);

    tok_earlyGeneralStuff(tok);

    conceptDeclarations(tok);

    tok_recordDecls(tok);

    tok = multilineStrings(tok);

    tok_singleQuoteIdentifiersToStringConstants(tok);

    tok_inStringEvals(tok);

    tok_listComprehensions(tok);

    tok_eventFunctions(tok);

    tok_for_single(tok);

    tok_for_unpair(tok); // Do this...

    //tok_doubleFor_v2(tok);

    tok_doubleFor_v3(tok); // ...before this

    tok_forUnnull(tok);

    tok_ifCast(tok);

    forPing(tok);

    tok_directSnippetRefs(tok);

    quicknu(tok);

    //tok_juxtaposeCalls(tok);

    jreplace(tok, "LLS", "L<LS>");

    jreplace(tok, "LS", "L<S>");

    jreplace(tok, "ES", "Ext<S>");

    jreplace(tok, "ExtS", "Ext<S>");

    jreplace(tok, "WeakRef", "WeakReference");

    jreplace(tok, "dispose <id>;", "{ cleanUp($2); $2 = null; }");

    tok_doPing(tok);

    replaceKeywordBlock(tok,

      "swing",

      "{ swing(r {",

      "}); }");

    replaceKeywordBlock(tok,

      "androidUI",

      "{ androidUI(r {",

      "}); }");

    replaceKeywordBlock(tok,

      "withDBLock",

      "{ withDBLock(r {",

      "}); }");

    replaceKeywordBlock(tok, "afterwards", "temp tempAfterwards(r {", "});");

    for (String keyword : ll("tokcondition", "tokCondition"))

      replaceKeywordBlock(tok,

        keyword,

        "new TokCondition { public bool get(final L<S> tok, final int i) {",

        "}}");

    jreplace(tok, "synced <id>", "synchronized $2");

    jreplace(tok, "sync <id>", "synchronized $2");

    jreplace(tok, "synchronized {", "synchronized(this) {");

    replaceKeywordBlock(tok, "answer",

      "static S answer(S s) {\nfinal new Matches m;\n",

      "\nret null;\n}");

    replaceKeywordBlock(tok, "static-pcall",

      "static { pcall {",

      "}}");

    replaceKeywordBlock(tok, "loading",

      "{ temp tempShowLoadingAnimation(); ",

      "}");

    replaceKeywordPlusQuotedBlock(tok, "loading",

      new Object() { String[] get(List<String> tok, int i) {

        String text = tok.get(i+2);

        return new String[] {

          "{ temp tempShowLoadingAnimation(" + text + "); ",

          "}" };

      }});

    while ((i = jfind(tok, "visualize as")) >= 0) {

      int j = tok_findEndOfStatement(tok, i); // expression, rather

      tok.set(i+2, "{ ret");

      tok.set(j-1, "; }");

      reTok(tok, i, j);

    }

    for (String pat : ll("visual {", "visualize {"))

      jreplace(tok, pat, "public JComponent visualize() {", tokCondition_beginningOfMethodDeclaration());

    jreplace(tok, "visualize2 {", "JComponent visualize2() {", tokCondition_beginningOfMethodDeclaration());

    replaceKeywordBlock(tok, "start-thread-printDone", "start-thread {", "printDone(); }");

    replaceKeywordBlock(tok, "start-thread", "start { thread \"Start\" { temp enter(); pcall {", "}}}");

    jreplace(tok, "start {", "void start() ctex { super.start();", tokCondition_beginningOfMethodDeclaration());

    var notVoidMethod = new TokCondition() { public boolean get(final List<String> tok, final int i) {

      return neqGet(tok, i-1, "void");

    }};

    // run { ... } => public void run() { ... }

    // same with close

    jreplace(tok, "run {", "public void run() {", notVoidMethod);

    jreplace(tok, "close {", "public void close() {", notVoidMethod);

    replaceKeywordBlock(tok, "html",

      "static O html(S uri, fMap<S, S> params) ctex " + "{\n", "}");

    replaceKeywordBlock(tok, "afterVisualize",

      "visualize { JComponent _c = super.visualize();",

      "ret _c; }");

    replaceKeywordBlock(tok, "enhanceFrame",

      "void enhanceFrame(Container f) { super.enhanceFrame(f);",

      "}");

    if (assumeTriple)

      jreplace(tok, "Triple", "T3");

    tok_shortFinals(tok);

    tok_moduleClassDecls(tok);

    jreplace(tok, "static sync", "static synchronized");

    jreplace(tok, "sclass", "static class");

    jreplace(tok, "fclass", "final class");

    jreplace(tok, "fsclass", "final static class");

    jreplace(tok, "srecord", "static record");

    jreplace(tok, "strecord", "static transformable record");

    jreplace(tok, "record noeq", "noeq record");

    jreplace(tok, "asclass", "abstract static class");

    jreplace(tok, "sinterface", "static interface");

    jreplace(tok, "ssynchronized", "static synchronized");

    jreplace(tok, "ssvoid", "static synchronized void");

    jreplace(tok, "sbool", "static bool");

    jreplace(tok, "fbool", "final bool");

    jreplace(tok, "sint", "static int");

    jreplace(tok, "snew", "static new");

    jreplace(tok, "sv <id>", "static void $2");

    jreplace(tok, "pvoid", "public void");

    // "sS" => static S

    jreplace(tok, "sS", "static S");

    // "sO" => static O

    jreplace(tok, "sO", "static O");

    // "sL" => static L

    jreplace(tok, "sL", "static L");

    // "toString {" => "public S toString() {"

    jreplace(tok, "toString {", "public S toString() {");

    jreplace(tok, "Int", "Integer");

    jreplace(tok, "Bool", "Boolean");

    jreplace(tok, "BigInt", "BigInteger");

    jreplace(tok, "Char", "Character");

    jreplace(tok, "Sym", "Symbol");

    jreplace(tok, "SymSym", "SymbolSymbol");

    jreplace(tok, "SS", "Map<S>");

    jreplace(tok, "SymbolSymbol", "Map<Symbol>");

    jreplace(tok, "MapSO", "Map<S, O>");

    jreplace(tok, "ByName<", "IF1<S, ");

    jreplace(tok, "ITransform<<id>>", "IF1<$3>");

    jreplace(tok, "ITransform", "IF1");

    jreplace(tok, "PairS", "Pair<S>");

    jreplace(tok, "LPairS", "L<Pair<S>>");

    jreplace(tok, "T3S", "T3<S>");

    jreplace(tok, "F1S", "F1<S>");

    jreplace(tok, "ItIt", "IterableIterator");

    jreplace(tok, "CloseableItIt", "CloseableIterableIterator");

    jreplace(tok, "class <id> > <id>", "class $2 extends $4", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      String t = _get(tok, i+1+4*2);

      return eq(t, "{") || isIdentifier(t);

    }});

    jreplace(tok, "class <id> > <id><<id>> {", "class $2 extends $4  $5 $6 $7 {");

    jreplace(tok, "ISegmenter", "IF1<BufferedImage, L<Rect>>");

    // IPred<A, B> => IF2<A, B, Bool>

    jreplace(tok, "IPred<<id>, <id>>", "IF2<$3, $5, Bool>");

    // IPred<A> => IF1<A, Bool>

    jreplace(tok, "IPred<<id>>", "IF1<$3, Bool>");

    jreplace(tok, "IPred<<id>[]>", "IF1<$3[], Bool>");

    // Proposition => WithReasoning<S> (should we really define this?)

    jreplace(tok, "Proposition", "WithReasoning<S>");

    replaceKeywordBlock(tok, "print exceptions",

      "{ try {",

      "} on fail __e { printStackTrace(__e); } }");

    // "on fail {" => "catch (Throwable _e) { ... rethrow(_e); }"

    replaceKeywordBlock(tok, "on fail",

      "catch (Throwable _e) {",

      "\nthrow rethrow(_e); }");

    // "on fail e {" => "catch (Throwable e) { ... rethrow(e); }"

    replaceKeywordBlock_dyn2_legacy(tok, "on fail <id>", new Object() {

      String[] get(List<String> tok, int iOpening, int iClosing) {

        String var = tok.get(iOpening-2);

        return new String[] {

          "catch (Throwable " + var + ") {",

          "\nthrow rethrow(" + var + "); }"

        };

      }

    });

    // "on fail Type e {" => "catch (Type e) { ... rethrow(e); }"

    replaceKeywordBlock_dyn2_legacy(tok, "on fail <id> <id>", new Object() {

      String[] get(List<String> tok, int iOpening, int iClosing) {

        String type = tok.get(iOpening-4);

        String var = tok.get(iOpening-2);

        return new String[] {

          "catch (" + type + " " + var + ") {",

          "\nthrow " + var + "; }"

        };

      }

    });

    // "catch {" => "catch (Throwable _e) {"

    jreplace(tok, "catch {", "catch (Throwable _e) {");

    // "catch print e {" => "catch e { _handleException(e); "

    jreplace(tok, "catch print <id> {", "catch $3 { _handleException($3);");

    // "catch print short e {" => "catch e { printExceptionShort(e); "

    jreplace(tok, "catch print short <id> {", "catch $4 { printExceptionShort($4);");

    // "catch X e {" => "catch (X e) {"

    jreplace(tok, "catch <id> <id> {", "catch ($2 $3) {");

    // "catch e {" => "catch (Throwable e) {" (if e is lowercase)

    jreplace(tok, "catch <id> {", "catch (Throwable $2) {", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      String word = tok.get(i+3);

      return startsWithLowerCaseOrUnderscore(word);

    }});

    jreplace(tok, "+ +", "+", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      //printStructure("++: ", subList(tok, i-1, i+6));

      if (empty(_get(tok, i+2))) return false; // no space between the pluses

      if (empty(_get(tok, i)) && eq("+", _get(tok, i-1))) return false;  // an actual "++" at the left

      if (empty(_get(tok, i+4)) && eq("+", _get(tok, i+5))) return false;  // an actual "++" at the right

      //print("doing it");

      return true;

    }});

    // single underscore (not allowed in Java anymore) to double underscore

    jreplace(tok, "_", "__");

    // [stdEq] -> implementation of equals() and hashCode()

    jreplace(tok, "[stdEq]",

      "public bool equals(O o) { ret stdEq2(this, o); }\n" +

      "public int hashCode() { ret stdHash2(this); }");

    // [stdToString] -> toString { ret stdToString(this); }

    jreplace(tok, "[stdToString]",

      "toString { ret stdToString(this); }");

    // [concepts] "concept.field!" for dereferencing references

    // "<id>!", "?!" etc.

    jreplace(tok, "*!", "$1.get()", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      String l = tok.get(i+1);

      if (!(isIdentifier(l) || eqOneOf(l, ")", "?"))) return false;

      if (tok.get(i+2).contains("\n")) return false; // no line break between <id> and !

      if (nempty(tok.get(i+4))) return true; // space after = ok

      String t = _get(tok, i+5);

      if (t == null) return false;

      if (isIdentifier(t) || eqOneOf(t, "=", "(")) return false;

      return true;

    }});

    jreplace(tok, "for (<id> :", "for (var $3 :");

    jreplace(tok, "for (<id> <id>)", "for ($3 $4 : list($3))");

    jreplace(tok, "for (final <id> <id>)", "for (final $4 $5 : list($4))");

    jreplace(tok, "ret", "return", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      if (eqGetOneOf(tok, i-1, "int", "return")) return false;

      String next = _get(tok, i+3);

      if (eq(next, ".")) return isInteger(_get(tok, i+5)); // e.g. "ret .1", but not "ret.bla"

      return !eqOneOf(next, "=", ")");

    }});

    // "continue unless", "break unless"

    for (String phrase : ll("continue unless", "break unless"))

      while ((i = jfind(tok, phrase)) >= 0) {

        String keyword = tok.get(i);

        int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");

        replaceTokens(tok, i, i+4, "{ if (!(");

        tok.set(j, ")) " + keyword + "; }");

        reTok(tok, i, j+1);

      }

    // S s = bla(), return if null; => S s = bla(); if (s == null) return;

    // same with continue, break

    while ((i = jfind(tok, ", <id> if null;", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      return eqOneOf(tok.get(i+3), "return", "ret", "continue", "break");

    }})) >= 0) {

      String cmd = tok.get(i+2);

      int j = tok_findBeginningOfStatement(tok, i);

      print("Found statement " + j + "/" + i + " - " + joinSubList(tok, j-1, i+5*2-1));

      String var = getVarDeclarationName(subList(tok, j-1, i));

      replaceTokens_reTok(tok, i, i+5*2-1, "; if (" + var + " == null) " + cmd + ";");

    }

    // S s = bla(), return false if null; => S s = bla(); if (s == null) return false;

    // (with false being any identifier)

    while ((i = jfind(tok, ", return <id> if null;")) >= 0) {

      String returnValue = tok.get(i+4);

      int j = tok_findBeginningOfStatement(tok, i);

      String var = getVarDeclarationName(subList(tok, j-1, i));

      replaceTokens_reTok(tok, i, i+6*2-1, "; if (" + var + " == null) return " + returnValue + ";");

    }

    // "continue if", "break if"

    for (String phrase : ll("continue if", "break if"))

      while ((i = jfind(tok, phrase)) >= 0) {

        String keyword = tok.get(i);

        int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");

        replaceTokens(tok, i, i+4, "{ if (");

        tok.set(j, ") " + keyword + "; }");

        reTok(tok, i, j+1);

      }

    // return unless set <var>; => { if (var) return; set var; }

    jreplace(tok, "return unless set <id>;", "{ if ($4) return; set $4; }");

    // set x; => x = true;

    // yeah it doesn't save many characters, but I like it

    jreplace(tok, "set <id>;", "$2 = true;", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      return !eqGet(tok, i-1, "unless");

    }});

    // set !x; => x = false; (did this one day and thought yes it makes sense in a way)

    jreplace(tok, "set !<id>;", "$3 = false;");

    // unset x; => x = false;

    jreplace(tok, "unset <id>;", "$2 = false;");

    // "return if"

    while ((i = jfind(tok, "return if")) >= 0) {

      int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");

      replaceTokens(tok, i, i+4, "{ if (");

      tok.set(j, ") return; }");

      reTok(tok, i, j+1);

    }

    // "return unless"

    while ((i = jfind(tok, "return unless")) >= 0) {

      int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");

      replaceTokens(tok, i, i+4, "{ if (!(");

      tok.set(j, ")) return; }");

      reTok(tok, i, j+1);

    }

    tok_ifNullAssign(tok);

    // "return <id> if"

    // "return with <statement>" / "continue with <statement>" / "break with <statement>"

    while ((i = jfind(tok, "<id> with", new TokCondition() { public boolean get(final List<String> tok, final int i) { return eqOneOf(tok.get(i+1), "return", "continue", "break"); }})) >= 0) {

      // XXX int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");

      int j = tok_findEndOfStatement(tok, i+4)-1;

      //print("Found statement: " + joinSubList(tok, i+4, j+1));

      tok.set(j, "; " + tok.get(i) + "; }");

      replaceTokens(tok, i, i+3, "{");

      reTok(tok, i, j+1);

    }

    while ((i = jfind(tok, "return <id> if")) >= 0) {

      int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");

      tok.set(j, ") return " + tok.get(i+2) + "; }");

      replaceTokens(tok, i, i+6, "{ if (");

      reTok(tok, i, j+1);

    }

    // return "bla" with <statement>

    while ((i = jfindOneOf(tok,

      "return <quoted> with", "return <id> with")) >= 0) {

      String result = tok.get(i+2);

      int j = scanOverExpression(tok, getBracketMap(tok), i+6, ";");

      replaceTokens(tok, i, i+5, "{");

      tok.set(j, "; return " + result + "; }");

      reTok(tok, i, j+1);

    }

    tok_debugStatements(tok);

    // while not null (...) / if not null (...)

    while ((i = jfind_check("not", tok, "<id> not null (", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      return eqOneOf(_get(tok, i+1), "if", "while");

    }})) >= 0) {

      int closingBracket = findEndOfBracketPart(tok, i+6)-1;

      replaceTokens(tok, i+2, i+6, "(");

      tok.set(closingBracket, ") != null)");

      reTok(tok, i, closingBracket+1);

    }

    // while null (...) / if null (...)

    while ((i = jfind_check("null", tok, "<id> null (", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      return eqOneOf(_get(tok, i+1), "if", "while");

    }})) >= 0) {

      int closingBracket = findEndOfBracketPart(tok, i+4)-1;

      replaceTokens(tok, i+2, i+4, "(");

      tok.set(closingBracket, ") == null)");

      reTok(tok, i, closingBracket+1);

    }

    // Replace $1 with m.unq(0) etc. - caveat: this blocks identifiers $1, $2, ...

    for (i = 1; i < l(tok); i += 2) {

      String s = tok.get(i);

      if (s.startsWith("$")) {

        s = substring(s, 1);

        if (isInteger(s)) {

          tok.set(i, "m.unq(" + (parseInt(s)-1) + ")");

          reTok(tok, i);

        }

      }

    }

    // instanceof trickery

    jreplace(tok, "is a <id>", "instanceof $3");

    jreplace(tok, "!<id> instanceof <id>.<id>", "!($2 instanceof $4.$6)");

    jreplace(tok, "!<id> instanceof <id>", "!($2 instanceof $4)");

    jreplace(tok, "<id> !instanceof <id>", "!($1 instanceof $4)");

    // map func1 func2 func3(...) => mapFGH(f func1, f func2, f func3, ...)

    jreplace(tok, "map <id> <id> <id>(", "mapFGH(f $2, f $3, f $4,");

    // map func1 func2(...) => mapFG(f func1, f func2, ...)

    jreplace(tok, "map <id> <id>(", "mapFG(f $2, f $3,");

    // "ref->bla" for dereferencing Concept.Ref or ThreadLocal or other

    // For lambdas, use SPACES on the left or right of the arrow!

    //jreplace(tok, "<id> ->", "$1.get().");

    jreplace(tok, "->", ".get().", new TokCondition() { public boolean get(final List<String> tok, final int i) {

      return empty(tok.get(i)) // no space on left of arrow

        && empty(tok.get(i+2)) // no space inside of arrow

        && empty(tok.get(i+4)) // no space on right of arrow

        && !eq(_get(tok, i-1), "-"); // i-->0;

    }});

    // shortened subconcept declaration (before star constructors!)

    shortenedSubconcepts(tok);

    tok_beaConceptDecls(tok);

    // "case" as a variable name ( => _case)

    caseAsVariableName(tok);

    // "do" as a function name ( => dO)

    tok_doAsMethodName(tok);

    // "continue" as a function name ( => _continue)

    continueAsFunctionName(tok);

    tok_extend(tok);

    jreplace(tok, "pn {", "p-noconsole {");

    // Do these BEFORE awt replacement! ("p-awt" contains "awt" token)

    replaceKeywordBlock(tok, "r-awt", "r { awt {", "}}");

    if (hasCodeTokens(tok, "p", "-")) tok_p_old(tok);

    replaceKeywordBlock(tok, "awt-messagebox", "awt { pcall-messagebox {", "}}");

    replaceKeywordBlock(tok, "awt", "swingLater(r {", "});");

    jreplace(tok, "p-android {", "set flag Android. p {");

    unswing(tok);

    lockBlocks(tok);

    tok_switchTo(tok);

    // trim x;

    jreplace(tok, "trim <id>;", "$2 = trim($2);");

    // iterate with index

    jreplace (tok, "for <id> over <id>:", "for (int $2 = 0; $2 < l($4); $2++)");

    jreplace (tok, "for <id> backwards over <id>:", "for (int $2 = l($5)-1; $2 >= 0; $2--)");

    jreplace (tok, "for <id>, <id> <id> over <id>: {", "for (int $2 = 0; $2 < l($7); $2++) { $4 $5 = $7.get($2);");

    jreplace (tok, "for <id>, <id> <id> backwards over <id>: {", "for (int $2 = l($8)-1; $2 >= 0; $2--) { $4 $5 = $8.get($2);");

    jreplace (tok, "for <id> to <id>:", "for (int $2 = 0; $2 < $4; $2++)");

    jreplace (tok, "for <id> to <int>:", "for (int $2 = 0; $2 < $4; $2++)");

    tok = expandShortTypes(tok);

    tok_equalsCast(tok);

    tok_equalsOptCast(tok);

    replaceKeywordBlock(tok, "r-thread-messagebox", "r-thread { pcall-messagebox {", "}}");

    replaceKeywordBlock(tok, "thread-messagebox", "thread { pcall-messagebox {", "}}");

    jreplace(tok, "rThread {", "r-thread {");

    jreplace(tok, "rEnterThread {", "rThreadEnter {");

    jreplace(tok, "rThreadEnter {", "r-thread { temp enter(); ");

    replaceKeywordBlock(tok, "r-thread", "runnableThread(r {", "})");

    rNamedThread(tok);

    // only works in the scope of a DynModule

    jreplace(tok, "rEnter {", "r { temp enter(); ");

    replaceKeywordBlock(tok, "r-pcall", "r { pcall {", "}}");

    replaceKeywordBlock(tok, "r-messagebox", "r { pcall-messagebox {", "}}");

    jreplace(tok, "r <id> + r <id>", "r { $2(); $5(); }");

    // runnable and r - now also with automatic toString if enabled

    for (String keyword : ll("runnable", "r")) {

      while ((i = jfind(tok, keyword + " {")) >= 0) {

        int idx = findCodeTokens(tok, i, false, "{");

        int j = findEndOfBracketPart(tok, idx);

        List<String> contents = subList(tok, idx+1, j-1);

        replaceTokens(tok, i, j+1, "new Runnable {"

          + "  public void run() ctex { " + tok_addSemicolon(contents) + "\n}"

          + (autoQuine ? tok_autoQuineFunc(contents) : "")

          + "}");

        reTok(tok, i, j+1);

      }

      while ((i = jfind(tok, keyword + " <quoted> {")) >= 0) {

        int idx = findCodeTokens(tok, i, false, "{");

        int j = findEndOfBracketPart(tok, idx);

        List<String> contents = subList(tok, idx+1, j-1);

        replaceTokens(tok, i, j+1, "new Runnable {"

          + "  public void run() ctex { " + tok_addSemicolon(contents) + "\n}"

          + "  toString { ret " + tok.get(i+2) + "; }"

          + (autoQuine ? tok_autoQuineFunc(contents, "_shortenedSourceCode") : "")

          + "}");

        reTok(tok, i, j+1);

      }

    }

    replaceKeywordBlock(tok,

      "expectException",